# Introduction Obscura is an open-source headless browser engine written in Rust. It runs JavaScript via V8, speaks the Chrome DevTools Protocol, and works as a drop-in replacement for headless Chrome with Puppeteer and Playwright. ### Versus headless Chrome | Metric | Obscura | Headless Chrome | | ----------- | -------- | --------------- | | Memory | 30 MB | 200+ MB | | Binary size | 70 MB | 300+ MB | | Startup | Instant | \~2s | | Page load | 85 ms | \~500 ms | | Anti-detect | Built-in | None | | Puppeteer | Yes | Yes | | Playwright | Yes | Yes | Rendering and stealth are both first-class capabilities. Release builds support screenshots, scroll-aware layout, activity-driven CDP screencasting, and raster PDF export; stealth builds retain all of those surfaces while adding the wreq/BoringSSL transport and browser-identity protections. ### Quickstart * [Installation](/quickstart/installation) * [Your first fetch](/quickstart/your-first-fetch) * [Extract data](/quickstart/extract-data) * [Connect Puppeteer or Playwright](/quickstart/connect-puppeteer-or-playwright) ### Guides * [Build from source](/guides/build-from-source) * [Configure stealth and proxies](/guides/configure-stealth-and-proxies) * [Markdown extraction](/guides/markdown-extraction) * [Use with Puppeteer](/guides/use-with-puppeteer) * [Use with Playwright](/guides/use-with-playwright) * [Use the MCP server](/guides/use-the-mcp-server) * [Use as a Rust library](/guides/use-as-a-rust-library) * [Persist cookies and storage](/guides/persist-cookies-and-storage) * [Intercept and modify requests](/guides/intercept-and-modify-requests) * [Run in production at scale](/guides/run-in-production-at-scale) ### Reference * [CLI reference](/reference/cli-reference) * [Environment variables](/reference/environment-variables) ### Contributing * [Architecture overview](/contributing/architecture-overview) * [Adding a CDP method or Web API](/contributing/adding-a-cdp-method-or-web-api) * [Testing and debugging](/contributing/testing-and-debugging) ### Links * Source: * Releases: * Issues: License: Apache-2.0. # Installation ### Linux x86\_64 ```bash curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-x86_64-linux.tar.gz tar xzf obscura-x86_64-linux.tar.gz ./obscura --version ``` ### Linux ARM64 ```bash curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-aarch64-linux.tar.gz tar xzf obscura-aarch64-linux.tar.gz ./obscura --version ``` Linux builds target Ubuntu 22.04 and require glibc 2.35+. ### macOS Apple Silicon ```bash curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-aarch64-macos.tar.gz tar xzf obscura-aarch64-macos.tar.gz ./obscura --version ``` ### macOS Intel ```bash curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-x86_64-macos.tar.gz tar xzf obscura-x86_64-macos.tar.gz ./obscura --version ``` ### Windows Download the `.zip` from [Releases](https://github.com/h4ckf0r0day/obscura/releases), extract, run `obscura.exe --version`. ### Arch Linux (AUR) ```bash yay -S obscura-browser ``` ### Docker ```bash docker run -d --name obscura -p 127.0.0.1:9222:9222 h4ckf0r0day/obscura ``` Image: [h4ckf0r0day/obscura](https://hub.docker.com/r/h4ckf0r0day/obscura). Built on `distroless/cc:nonroot`, with no shell or package manager in the runtime image, running as uid 65532. Note the `-p 127.0.0.1:...` above: it publishes the port to host loopback only. A mounted `--storage-dir` must be writable by uid 65532 — see [Run in production at scale](/guides/run-in-production-at-scale#the-container-does-not-run-as-root). Official archives and the Docker image include the rendering engine. Source builders must pass `--features render`; see [Build from source](/guides/build-from-source). ### From source See [Build from source](/guides/build-from-source). ### What's in the archive * `obscura`: CLI and CDP server. * `obscura-worker`: helper for the parallel `scrape` command. Keep both in the same directory. Archive suffixes identify the feature set: no suffix includes rendering, `-stealth` includes rendering and stealth, `-no-render` includes neither, and `-no-render-stealth` includes stealth without rendering. ### Smoke test ```bash ./obscura fetch https://example.com --eval "document.title" ./obscura fetch https://example.com --screenshot smoke.png ``` Expected output: `"Example Domain"`, followed by a nonempty PNG at `smoke.png`. ### Troubleshooting `cannot execute binary file`: wrong arch. Check `uname -m`. `GLIBC_2.35 not found`: distro is older than Ubuntu 22.04. Use Docker or build from source. macOS Gatekeeper warning: `xattr -d com.apple.quarantine ./obscura`. # Your first fetch `obscura fetch` loads a URL, runs its JavaScript, and prints the result. ### Load a page ```bash obscura fetch https://example.com ``` Prints the rendered HTML. ### Run JavaScript with `--eval` ```bash obscura fetch https://example.com --eval "document.title" ``` ``` "Example Domain" ``` Returns JSON: ```bash obscura fetch https://news.ycombinator.com \ --eval "Array.from(document.querySelectorAll('.titleline a')).slice(0, 5).map(a => a.textContent)" ``` ### Multi-statement eval `--eval` evaluates one expression. For multiple statements, wrap in an IIFE: ```bash obscura fetch https://example.com --eval "(function(){ const links = document.querySelectorAll('a'); return Array.from(links).map(a => a.href); })()" ``` A bare block starting with `const` or `let` returns `null` because V8 gives top-level declarations an empty completion value. ### Wait for the right moment CLI default is `load`. For faster returns on slow sites: ```bash obscura fetch https://my-spa.example --wait-until domcontentloaded --eval "document.title" ``` | Level | Returns when | | ------------------ | --------------------------------------- | | `domcontentloaded` | HTML parsed, scripts ran | | `load` | All subresources finished (default) | | `networkidle2` | ≤2 network connections active for 500ms | | `networkidle0` | 0 network connections active for 500ms | (When driving obscura via Puppeteer or Playwright the default is `domcontentloaded` to match client expectations.) ### Common flags ``` --user-agent "..." Override the User-Agent --timeout 30 Navigation timeout in seconds (default 30) --wait 5 Extra wait after the page settles, in seconds (default 5) --selector ".main" CSS selector to narrow output to --proxy http://host:port Route through a proxy --stealth Stealth client (TLS fingerprint, tracker blocking) -o, --output file.html Write output to a file -q, --quiet Suppress info logging ``` Full list: [CLI reference](/reference/cli-reference). # Extract data `--dump` formats the page output without writing JavaScript. ```bash obscura fetch https://example.com --dump html obscura fetch https://example.com --dump text obscura fetch https://example.com --dump markdown obscura fetch https://example.com --dump links obscura fetch https://example.com --dump assets obscura fetch https://example.com --dump original obscura fetch https://example.com --dump cookies ``` ### `html` Rendered HTML after JavaScript runs. Default. ```bash obscura fetch https://news.ycombinator.com --dump html > hn.html ``` ### `text` Plain text. No markup. ```bash obscura fetch https://en.wikipedia.org/wiki/Rust_(programming_language) --dump text ``` ### `markdown` Markdown conversion: headings, lists, links, code blocks, images. ```bash obscura fetch https://docs.example.com/page --dump markdown > page.md ``` ### `links` Every `` on the page, one per line. ```bash obscura fetch https://example.com --dump links ``` ### `assets` Every external resource (stylesheets, scripts, images, fonts, iframes), plus the URLs the page requested through `fetch()`/XHR, one JSON object per line. ```bash obscura fetch https://example.com --dump assets ``` ### `original` The raw HTML the server sent, before JavaScript ran. ```bash obscura fetch https://my-spa.example --dump original > before.html obscura fetch https://my-spa.example --dump html > after.html diff before.html after.html ``` ### `cookies` Every cookie in the jar as a JSON array, including HttpOnly cookies that `document.cookie` cannot see. Useful for capturing session tokens set by anti-bot challenges. ```bash obscura fetch https://example.com --dump cookies ``` ### With `--wait-until` `--dump` runs after the wait condition: ```bash obscura fetch https://my-spa.example --wait-until load --dump markdown ``` ### Pipe and redirect ```bash obscura fetch https://example.com --dump markdown > example.md obscura fetch https://example.com --dump text --quiet | wc -w ``` # Connect Puppeteer or Playwright Obscura speaks the Chrome DevTools Protocol over WebSocket. Puppeteer and Playwright can connect to its CDP endpoint for the supported workflows below. ### Start the server ```bash obscura serve --port 9222 ``` ``` obscura listening on ws://127.0.0.1:9222 ``` ### Puppeteer ```bash npm install puppeteer-core ``` ```js const puppeteer = require('puppeteer-core'); const browser = await puppeteer.connect({ browserWSEndpoint: 'ws://127.0.0.1:9222', }); const page = await browser.newPage(); await page.goto('https://example.com'); console.log(await page.title()); // "Example Domain" await browser.disconnect(); ``` Use `puppeteer-core`, not `puppeteer`. The `puppeteer` package bundles a Chrome download. ### Playwright ```bash npm install playwright ``` ```js const { chromium } = require('playwright'); const browser = await chromium.connectOverCDP('ws://127.0.0.1:9222'); const context = browser.contexts()[0] || await browser.newContext(); const page = await context.newPage(); await page.goto('https://example.com'); console.log(await page.title()); await browser.close(); ``` Use `connectOverCDP`, not `connect`. Playwright's `connect` speaks Playwright's own protocol, which obscura does not implement. ### `waitUntil` Default is `domcontentloaded`. For full subresource load: ```js await page.goto('https://example.com', { waitUntil: 'load' }); ``` | Value | Returns when | | ------------------ | --------------------------------------- | | `domcontentloaded` | HTML parsed, scripts ran (default) | | `load` | All subresources finished | | `networkidle2` | ≤2 network connections active for 500ms | | `networkidle0` | 0 network connections active for 500ms | ### Supported * `page.goto`, `page.reload`, `page.goBack`, `page.goForward` * `page.evaluate`, `page.evaluateHandle` * `page.click`, `page.type`, `page.fill`, `page.focus` * `page.waitForSelector`, `page.waitForFunction`, `page.waitForNavigation` * `page.cookies`, `page.setCookie`, `context.cookies` * `page.setRequestInterception`, block / modify * `page.exposeFunction` * `page.content`, `page.title`, `page.url` * `page.screenshot` for viewport, clipped, and full-page capture * `page.pdf` for raster-backed print output * raw CDP `Page.startScreencast` with frame acknowledgements (`page.createCDPSession()` in Puppeteer; `context.newCDPSession(page)` in Playwright) DOM-agent frameworks such as browser-use also connect: obscura implements `DOMSnapshot.captureSnapshot` and `Target.targetInfoChanged` for perception, and `DOM.focus` so a focused field receives `Input.dispatchKeyEvent` keystrokes. ### Capture example ```js await page.setViewport({ width: 1440, height: 1000 }); await page.screenshot({ path: 'viewport.png' }); await page.screenshot({ path: 'full-page.png', fullPage: true }); await page.pdf({ path: 'page.pdf', format: 'A4', printBackground: true }); ``` Rendering is included in official binaries and requires `--features render` for source builds. The client-specific guides cover scrolling, raw CDP screencasting, and current output limits. ### Current limits * Pages share one V8 isolate. CPU-bound JavaScript on one page can delay others. * PDF output is raster-backed; text is not selectable and tagged PDF, headers/footers, outlines, and full CSS paged media are not implemented. * Service workers, native media playback, some Web APIs, and long-tail CSS or compositor effects are still incomplete relative to Chromium. # Build from source ### Requirements * Rust 1.75+ ([rustup.rs](https://rustup.rs)) * C compiler (gcc or clang) * \~5 GB free disk space (V8 compiles from source on first build) First build takes about 5 minutes. Incremental builds are seconds. ### Build ```bash git clone https://github.com/h4ckf0r0day/obscura.git cd obscura cargo build --release -p obscura-cli --bins --features render ``` Binary is at `./target/release/obscura`. This produces the release binary with geometry, screenshots, screencasting, and PDF export. ### Rendering and stealth ```bash cargo build --release -p obscura-cli --bins --features render,stealth ``` This is the complete rendering build with the stealth wreq/BoringSSL transport, TLS fingerprint randomization, browser-identity protections, and tracker blocklist. See [Configure stealth and proxies](/guides/configure-stealth-and-proxies). ### Without rendering ```bash cargo build --release -p obscura-cli --bins --no-default-features cargo build --release -p obscura-cli --bins --no-default-features --features stealth ``` The second command keeps stealth while excluding layout, screenshots, screencasting, and PDF export. The stealth feature builds BoringSSL and generates Rust bindings. In addition to the default requirements, install CMake, Clang, and the libclang/LLVM development libraries. On Ubuntu/Debian: ```bash sudo apt-get install build-essential cmake clang libclang-dev llvm-dev ``` On macOS, install the Xcode Command Line Tools and CMake. On Windows, install the Visual Studio C++ Build Tools, CMake, and LLVM/Clang. Ensure the directory containing `libclang` is available through `LIBCLANG_PATH` if bindgen cannot locate it automatically. On macOS 26 with the standalone Command Line Tools, Apple Clang may not find libc++ while compiling BoringSSL. Use the active SDK for that build: ```bash SDK_PATH="$(xcrun --show-sdk-path)" SDKROOT="$SDK_PATH" CXXFLAGS="-isystem $SDK_PATH/usr/include/c++/v1" \ cargo build --release -p obscura-cli --bins --features render,stealth ``` ### OpenSSL on older systems If the build fails on the vendored OpenSSL with an AVX-512 assembler error (common on older VPS hosts): ```bash OPENSSL_NO_VENDOR=1 cargo build --release -p obscura-cli --bins --features render ``` Uses the system OpenSSL instead. ### Run from the build ```bash ./target/release/obscura --version ./target/release/obscura fetch https://example.com --eval "document.title" ``` Install system-wide: ```bash cargo install --path crates/obscura-cli --features render ``` ### Tests ```bash cargo nextest run --release --features render --no-fail-fast ``` Integration suite: ```bash python3 tests/test_all.py ``` Use `cargo nextest`, not `cargo test`: runtime tests require process isolation because the engine owns a single V8 isolate per process. # Configure stealth and proxies ### Stealth mode ```bash obscura fetch https://example.com --stealth obscura serve --stealth obscura scrape url1 url2 --stealth obscura mcp --stealth ``` `--stealth` is a global flag, so it works before or after the subcommand and applies to `fetch`, `serve`, `scrape`, and `mcp`. In a `scrape` run each worker inherits it. What `--stealth` changes: * Uses the wreq HTTP client with browser-matching TLS fingerprints (ClientHello, ALPN, cipher order). * Loads a tracker blocklist that drops requests to known analytics and fingerprinting endpoints. * Bundles webpki roots instead of relying on the system store. Requires a build that includes the stealth feature. Use a `-stealth` archive with rendering or a `-no-render-stealth` archive without it. To build the rendering variant yourself: ```bash cargo build --release -p obscura-cli --bins --features render,stealth ``` Omit rendering with `cargo build --release -p obscura-cli --bins --no-default-features --features stealth`. ### What stealth handles * Basic bot detection that checks TLS fingerprint or User-Agent. * Sites that rely on third-party analytics being reachable. ### What stealth does not handle * Cloudflare interactive challenges. * Datadome and Akamai bot manager active challenges. * CAPTCHAs. * IP-based rate limiting (use proxies). ### Proxies HTTP proxy: ```bash obscura fetch https://example.com --proxy http://proxy.example.com:8080 obscura serve --proxy http://proxy.example.com:8080 ``` With auth: ```bash obscura fetch https://example.com --proxy http://user:pass@proxy.example.com:8080 ``` SOCKS5: ```bash obscura fetch https://example.com --proxy socks5://proxy.example.com:1080 ``` ### Custom User-Agent ```bash obscura fetch https://example.com --user-agent "Mozilla/5.0 (...) ..." obscura serve --user-agent "Mozilla/5.0 (...) ..." ``` Default UA matches a recent Chrome on the build platform. ### Browser profile, timezone, and geolocation The engine presents one of a built-in pool of realistic browser profiles (a mix of Windows and macOS, recent Chrome versions). Each profile keeps `navigator.platform`, `navigator.userAgentData` (platform and platform version), and the UA string internally consistent, so the surfaces a site fingerprints agree with each other. There is no GPU renderer among them: `canvas.getContext('webgl')` returns `null`, so a page cannot read a renderer string at all. A single stable profile is used by default. One IP cycling through different identities is itself a signal, so rotation is opt-in: ```bash OBSCURA_PROFILE=2 obscura serve # pin a specific profile by index OBSCURA_ROTATE_PROFILE=1 obscura serve # random profile per browser context ``` Timezone is driven by the process zone so `Date` (`getTimezoneOffset`, `toString`) and `Intl.DateTimeFormat` report the same region. Default is `Europe/Berlin`; set it to match the exit IP: ```bash OBSCURA_TIMEZONE=America/New_York obscura serve ``` `navigator.geolocation` reports configurable coordinates. Set them as `lat,lon` and keep them consistent with the timezone and proxy region: ```bash OBSCURA_GEOLOCATION="40.7128,-74.0060" obscura serve ``` Keep these aligned. A rotated or mismatched profile carries no matching TLS or timezone fingerprint, so when you pin a proxy region or TLS fingerprint, leave rotation off and set the timezone and geolocation to the same region. See [Environment variables](/reference/environment-variables) for the full list. ### Combine ```bash obscura serve \ --stealth \ --proxy http://user:pass@proxy.example.com:8080 \ --user-agent "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 ..." ``` # Markdown extraction `--dump markdown` converts the rendered page to markdown. ```bash obscura fetch https://example.com --dump markdown ``` ### What gets converted * Headings (`

` through `

`) * Paragraphs, line breaks * Bold, italic, code spans * Links (with `href`) * Images (with `src` and `alt`) * Ordered and unordered lists * Block quotes * Code blocks (`
`, ``)
* Tables

### What gets stripped

* `
`;

const server = http.createServer((req, res) => {
  if (req.url === "/events") {
    res.writeHead(200, {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-store",
      Connection: "keep-alive",
    });
    res.socket.setNoDelay(true);
    if (latest) res.write(`data:${latest}\n\n`);
    clients.add(res);
    req.on("close", () => clients.delete(res));
  } else {
    res.writeHead(200, { "Content-Type": "text/html" });
    res.end(page);
  }
});

server.listen(httpPort, "127.0.0.1", () => {
  console.log(`live view: http://localhost:${httpPort}`);
});

function broadcast(base64) {
  latest = base64;
  for (const res of clients) {
    if (res.writable) res.write(`data:${base64}\n\n`);
  }
}

async function connect() {
  ws = new WebSocket(`ws://127.0.0.1:${cdpPort}/devtools/browser`);
  let id = 0;
  const pending = new Map();
  const call = (method, params = {}, sess) =>
    new Promise((resolve, reject) => {
      const mid = ++id;
      pending.set(mid, { resolve, reject });
      const msg = { id: mid, method, params };
      if (sess) msg.sessionId = sess;
      ws.send(JSON.stringify(msg));
    });

  ws.addEventListener("message", (ev) => {
    const msg = JSON.parse(ev.data);
    if (msg.id && pending.has(msg.id)) {
      const p = pending.get(msg.id);
      pending.delete(msg.id);
      msg.error ? p.reject(new Error(msg.error.message)) : p.resolve(msg.result);
    }
  });
  ws.addEventListener("close", () => {
    sessionId = null;
    setTimeout(() => connect().catch(retry), 2000);
  });
  ws.addEventListener("error", () => ws.close());

  await new Promise((resolve) => ws.addEventListener("open", resolve));

  // reuse the page target an agent session may already have created
  const { targetInfos } = await call("Target.getTargets");
  const existing = targetInfos.find((t) => t.type === "page");
  if (existing) {
    // pre-existing target: attach explicitly and use the returned session id
    const attached = await call("Target.attachToTarget", {
      targetId: existing.targetId,
      flatten: true,
    });
    sessionId = attached.sessionId;
  } else {
    // a freshly created target is auto-attached under a managed session id
    const created = await call("Target.createTarget", { url: "about:blank" });
    sessionId = `${created.targetId}-session`;
  }
  await call("Page.enable", {}, sessionId);

  // capture on an interval instead of Page.startScreencast: screencast
  // frames stream to the session that drives the page, so a passive
  // viewer stops receiving them once an agent takes over. An explicit
  // capture always reflects the current page state.
  const capture = async () => {
    if (ws.readyState !== WebSocket.OPEN || !sessionId) return;
    try {
      const shot = await call(
        "Page.captureScreenshot",
        { format: "jpeg", quality: 70 },
        sessionId
      );
      if (shot.data && shot.data.length > 100) broadcast(shot.data);
    } catch {
      // transient failures during navigation are normal, retry next tick
    }
    setTimeout(capture, 500);
  };
  capture();
}

function retry(err) {
  console.error(err.message);
  sessionId = null;
  setTimeout(() => connect().catch(retry), 2000);
}
connect().catch(retry);
```

> For a packaged version with adaptive pacing (fast while painting, idle back-off) and multi-page handling, see `tools/live-view.mjs`.

## Things worth knowing

* **Why captureScreenshot polling instead of screencast.** `Page.startScreencast` frames stream to the CDP session that drives the page, so once an agent session takes over, a passive viewer session stops receiving frames. It also only produces frames when the page paints something new. An explicit `Page.captureScreenshot` always reflects the current page state regardless of which session navigated, which makes it the reliable choice for watching someone else's session.
* **Acknowledge every frame.** Without `Page.screencastFrameAck`, frame delivery stops.
* **One client per page socket.** If an agent's CDP client already holds the page's `webSocketDebuggerUrl`, connecting to it again fails with `503`. Attach through the browser endpoint instead (`ws://127.0.0.1:9222/devtools/browser`) using `Target.attachToTarget` with `flatten: true`, then pass the returned session id as `sessionId` on every command.
* **Still images vs continuous view.** The MCP server exposes `browser_screenshot` for one-shot captures. Screencast is the right tool when you want to watch continuously; it stays CDP-only by design.

## Verifying

With `obscura serve` running and the viewer open:

1. Navigate from another client, for example `obscura fetch https://example.com` through a separate worker, or any Puppeteer/Playwright/MCP session connected to port 9222.
2. The tab shows the page within a second of it painting.
3. Closing the viewer tab and reopening it resumes from the most recent frame.


# Use as a Rust library

The `obscura` crate embeds the engine in a Rust program with a `Browser` / `Page` / `Element` API plus a cookie store, no CDP round-trips. It builds V8 from source, so it is a git dependency rather than a crates.io release.

### Add the dependency

```toml
[dependencies]
obscura = { git = "https://github.com/h4ckf0r0day/obscura" }
tokio = { version = "1", features = ["rt", "macros"] }
anyhow = "1"
```

The first build compiles V8 from source, so it is slow and needs the same build tools as [Build from source](/guides/build-from-source). Pin a tag for reproducible builds:

```toml
obscura = { git = "https://github.com/h4ckf0r0day/obscura", tag = "v0.1.7" }
```

### Quickstart

```rust
use obscura::Browser;
use std::time::Duration;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let browser = Browser::builder()
        .stealth(true)
        .build()?;

    let mut page = browser.new_page().await?;
    page.goto("https://example.com").await?;

    println!("URL: {}", page.url());
    println!("HTML bytes: {}", page.content().len());

    let el = page.wait_for_selector("h1", Duration::from_secs(5)).await?;
    println!("Heading: {}", el.text());

    let title = page.evaluate("document.title");
    println!("Title: {}", title);

    Ok(())
}
```

### API surface

`Browser::builder()` configures the engine: `.stealth(bool)`, `.proxy(url)`, `.user_agent(ua)`, `.storage_dir(dir)`, then `.build()`. `Browser::new()` uses defaults.

`Page`:

* `goto(url).await` navigate and wait for load
* `content()` rendered HTML
* `url()` current URL
* `evaluate(js)` run JavaScript, returns a `serde_json::Value`
* `query_selector(css)` first match as an `Element`, or `None`
* `wait_for_selector(css, Duration).await` poll until present
* `settle(max_ms).await` drive the event loop so async work (`fetch`, timers) completes
* `on_request(cb)` / `on_response(cb)` passive callbacks for every request and response
* `enable_interception()` channel to block, mock, or rewrite requests
* `add_preload_script(js)` run a script before the page's own scripts

`Element`: `text()`, `attribute(name)`, `click()`.

`CookieStore`: `set`, `get_all`, `get_for_url`, `save_to_file`, `load_from_file`.

### Intercept requests

The interception API observes, blocks, mocks, and rewrites the requests a page makes, including JavaScript `fetch()` and XHR. Use it to capture API payloads while crawling, block trackers, or mock responses in tests.

#### Passive callbacks

`on_request` and `on_response` fire for every request and response (navigation and JS `fetch()`/XHR) and are non-blocking. `on_response` is the main path for capturing the JSON an SPA loads asynchronously. Both return a stable id; pass it to `off_request` / `off_response` to detach the callback when a crawl phase is done. Callbacks are scoped to the page that registered them: they never fire for another page's requests and are dropped with the page.

```rust
use obscura::{Browser, ResourceType};
use std::sync::Arc;

let browser = Browser::new()?;
let mut page = browser.new_page().await?;

page.on_response(Arc::new(|info, resp| {
    if info.resource_type == ResourceType::Fetch {
        println!("{} -> {} bytes", info.url, resp.body.len());
    }
}));

page.goto("https://example.com").await?;
page.settle(2000).await;   // let in-page fetch() calls resolve
```

#### Active interception

`enable_interception()` returns a channel of every JS `fetch()`/XHR request. Resolve each through its `resolver` to pass, block, mock, or rewrite it.

```rust
use obscura::{Browser, InterceptResolution};

let mut page = browser.new_page().await?;
let mut rx = page.enable_interception();

tokio::spawn(async move {
    while let Some(req) = rx.recv().await {
        let action = if req.url.contains("/ads") {
            InterceptResolution::Fail { reason: "blocked".into() }
        } else if req.url.ends_with("/api/flags") {
            InterceptResolution::Fulfill {
                status: 200,
                headers: Default::default(),
                body: r#"{"newDashboard":true}"#.into(),
            }
        } else {
            // Pass through, or rewrite by setting url/method/headers/body.
            InterceptResolution::Continue { url: None, method: None, headers: None, body: None }
        };
        let _ = req.resolver.send(action);
    }
});

page.goto("https://example.com").await?;
page.settle(2000).await;
```

A `Continue` with `url: Some(...)` rewrites the target. The new URL is re-checked against the SSRF / private-network gate, so a rewrite cannot reach an internal address that would otherwise need `--allow-private-network`.

#### Preload scripts

`add_preload_script` runs a script before any of the page's own `