Skip to main content
Glama

Ghostfox

The agent-native stealth browser you can own.

GitHub stars npm downloads PyPI downloads CI MCP Registry Sponsor

Self-hosted · Open source · MCP-first · Engine-level anti-detect

License License Engine MCP Registry PyPI npm Docker ghostfox MCP server – quality and maintenance score on Glama ghostfox MCP server – quality score on Glama CI Release Stars

Watch the full demo · Docs site


AI agents get blocked. Headless Chrome triggers Cloudflare 403s on ~20% of the web, and hosted "stealth browsers" route your agent's cookies, identities and sessions through someone else's cloud.

Ghostfox is the alternative: a complete browser stack you run yourself — a fingerprint-coherent stealth engine plus a Rust MCP runtime, in one repo.

Firefox (MPL-2.0)
  └─ Camoufox (anti-detect patches, by daijro)
       └─ Ghostfox engine          engine/   — spoofing at the C++ level
            └─ Ghostfox runtime     runtime/  — Rust: sessions, identities, MCP

Ghostfox

Hosted stealth (Browserbase etc.)

playwright-mcp

Anti-detect suites (Multilogin etc.)

Self-hosted

✓

✗

✓

partially

Open source

✓

✗

✓

✗

MCP-native

✓

✓

✓

✗

Engine-level anti-detect

✓ (C++/Firefox)

vendor partnerships

✗

✓ (closed)

Coherent identities + auditor

✓

✗

✗

partial

Runtime language

Rust

—

Node

—

The moat — why this isn't just another wrapper.

  1. We own the engine. The anti-detect lives in C++ patches inside our own Firefox fork — not in injected JS that detectors can read. Upstream Camoufox has signaled partially-closed patches ahead; wrappers inherit that risk, a fork that owns its engine doesn't.

  2. A living proof corpus. Every claim here has a receipt: bilibili icon-click ×6, hCaptcha on production signups, TikTok OAuth+OTP live, 500/500 identity audits, Docker E2E. Features get copied in a week — verified history can't be.

  3. Agent-native ergonomics. 43 coherent MCP tools, fire-then-verify receipts, evidence recording, and a playbook (AGENTS.md) distilled from real runs. Agents (and their prompts) build habits on this surface — switching costs are real.

  4. Canonical distribution. PyPI, npm, GHCR and the official MCP Registry under one name, with the docs, benchmarks and changelogs to back it. Forks will exist; the verified trunk is here.

Captcha suite — 8 families, solved on-device (v0.6.7+). The runtime ships native MCP solvers with local models — no paid captcha farms, no cloud, no browser rent:

Family

Native tool

How

GeeTest slide / v4 radar

page_geetest_slide

bg-vs-fullbg diff + largest-blob gap detection

GeeTest icon-click (文字点选)

page_geetest_click

custom-trained YOLOv8s + siamese similarity (rten, CPU)

Rotate

page_captcha_rotate

24-angle sweep + programmatic verdict

Normal OCR

page_captcha_ocr

ported ddddocr (CRNN+LSTM, onnxruntime)

hCaptcha

page_hcaptcha

layout router + 553-model QIN2DIM zoo + optional vision-model ensemble

Cloudflare Turnstile / TikTok

captcha_solve + behavioral recipes

proven playbooks in AGENTS.md §6b–6e

E2E-verified against production sites (not vendor demos): bilibili icon-click ×6 "Verification Succeeded", hCaptcha on real signups (dashboard.hcaptcha.com, dosya.co), TikTok OAuth+OTP live session.

Debug cortex — page tools that tell you WHY (v0.7). Agents stop guessing when a page misbehaves:

  • page_console — every console.log/warn/error since load

  • page_errors — uncaught JS exceptions with stack traces

  • page_network_start/read/body — request/response capture with body fetch

That's the DevTools trio, exposed over MCP.

Multi-model vision (optional). page_vision + page_ocr + page_match_image + page_pixels + page_contrast — wire any vision-capable model (Cloudflare Workers AI, GLM, Qwen, ...) as cross-checks for grid puzzles and layout questions. Keys are optional; the native solvers above run fully local.

Native-sourced observation — page_a11y {"native": true} reads the engine's OWN accessibility tree (Gecko's DocAccessible walk — the ariaSnapshot plumbing), so page scripts cannot tamper with what you see: shadow DOM, iframes and ARIA semantics handled by Gecko itself, richer states (focused/required/checked/expanded/disabled/level). Native refs are observation handles; acting goes through role+name anchors or the JS-walk source.

Eyes for agents — page_a11y. One call returns every visible interactive element with a stable ref, semantic role, accessible name, live value — piercing shadow DOM and same-origin iframes, so web-component UIs (Reddit, modern frameworks) are fully visible. The snapshot also reports login_state (logged-in / logged-out / unknown), page URL and title — agents check session health before acting, not after failing.

Agents act by ref: page_click_ref e38, page_type_ref e21 "text" — no CSS selectors needed. Rich editors (Lexical, Draft, ProseMirror) are handled via editor-native input paths with fire-then-verify receipts. page_wait_for replaces manual sleeps. page_read_ref gives full untruncated values. page_upload_file bypasses native file pickers.

Android personas too — session_create {"platform": "android"} gives portrait screens, Adreno/Mali GPUs, Android font stacks and Firefox-on-Android UAs, all audited like desktop identities (500/500 coherent, see runtime/docs).

One identity, no contradictions. Identities are generated from coherent device presets (platform, screen, GPU, fonts that actually ship together), injected at the engine level, and audited before use — a spoofed browser's worst enemy is itself saying "4 cores on a MacBook".

Quickstart

Pick a distribution:

# Python (Linux x86_64)
pip install ghostfox
python -c "import ghostfox; ghostfox.install_engine(); ghostfox.install_runtime()"

# npm / any MCP host
npm install -g ghostfox        # or: npx ghostfox install
{
  "mcpServers": {
    "ghostfox": { "command": "npx", "args": ["-y", "ghostfox", "mcp"] }
  }
}

# Docker (engine + MCP runtime, ubuntu:24.04 base)
docker run -i --rm ghcr.io/autokeren/ghostfox:v0.7.2
# or one-line install of the binary stack:
curl -fsSL https://raw.githubusercontent.com/autokeren/ghostfox/main/install.sh | bash
# Windows (PowerShell):
powershell -ExecutionPolicy Bypass -Command "irm https://raw.githubusercontent.com/autokeren/ghostfox/main/install.ps1 | iex"

Also listed on the official MCP Registry (io.github.autokeren/ghostfox) — one-click add in registry-aware clients.

From source:

# 1) Get the engine (prebuilt) and unpack it somewhere, e.g. /opt
unzip ghostfox-<ver>-lin.x86_64.zip -d /opt/ghostfox

# 2) Build the runtime
git clone https://github.com/autokeren/ghostfox.git
cd ghostfox/runtime
cargo build --release
{
  "mcpServers": {
    "ghostfox": {
      "command": "/path/to/ghostfox/runtime/target/release/ghostfox-mcp",
      "env": { "GHOSTFOX_HOME": "/opt/ghostfox" }
    }
  }
}

Then the agent can: session_create → page_open → page_a11y → act by ref.

Portable sessions. session_create accepts profile_dir for persistent profiles: cookies, storage and the identity TOML live together in one place, so a login survives restarts. Migrating a session from another Camoufox-lineage browser? Copy the cookies and match the identity to the origin device (platform, timezone, locale, screen) — a session that suddenly changes identity looks like an impossible login and anti-fraud systems revoke it. Proven flow, see AGENTS.md §8.

Full tool surface (72 tools) — two tiers, one binary:

  • core (default): 26 curated tools — the golden loop (read → act → verify) plus debugging essentials, zero overlapping variants. This is what agents and registry inspectors see out of the box: an efficient, disambiguated surface (each tool's description says when to prefer it).

  • full: all 72 tools — captcha families, pixel/vision tiers, network interception, WebSocket capture/inject/block, identity morph, chrome-mode, Android, page_download (browser-identity media harvesting). Run the server with GHOSTFOX_TOOLSET=full.

The server also publishes instructions (a decision tree agents read before choosing tools) — the disambiguation layer for both tiers.

Category

Tools

Session

session_create · session_pages · session_me

See

page_a11y (semantic + login_state + shadow DOM/iframe) · page_extract (typed, token-efficient a11y filters) · page_snapshot · page_screenshot · page_read_ref (full value) · page_diff (observeDiff: what changed since the last snapshot) · page_mutations (M3: unhookable DOM-change whispers) · page_a11y_events (M3: the a11y tree as a stream — focus/text/state/live-region events, the incremental diff)

Wait

page_wait_for (poll until visible) · page_dismiss_modal · page_wait_stable (render-settled) · page_wait_visual (M3.5: refresh-driver visual stability — the sleep killer)

Act

page_click_ref · page_click_native (trusted a11y-bounds click: scroll-first, DOM-proof coordinates) · page_click_at (raw trusted coords — no a11y resolution) · page_type_ref · page_click · page_type · page_fill · page_press · page_drag · page_move_to · page_upload_file · page_init_script · page_a11y_set_text (AT-native text input — the Flutter route)

Captcha

captcha_solve · page_geetest_slide · page_geetest_click · page_captcha_rotate · page_captcha_ocr · page_hcaptcha · page_captcha_vision (host-VLM reader for warped text captchas)

Network broker

page_network_intercept (hold every request) · page_network_resume (modify url/method/headers/postData) · page_network_abort (block) · page_network_fulfill (mock the response)

Debug

page_console · page_errors · page_network_start · page_network_read (per-request DNS/TLS/TTFB timing) · page_network_body · page_frame_stats (M3.5: jank detector — frame-cadence stats) · page_timing_report (M3.5: nav-timing + paint) · page_ws_frames (M3: the WebSocket stream — sockets + frames both directions) · page_ws_send (M3: WS injection — client→server message) · page_ws_block (M3: WS blocking — drop frames both directions) · page_ui_audit (M5: visual QA of the rendered UI)

Vision

page_vision · page_ocr · page_match_image · page_pixels (compositor pixels — region/semantic/ref, no toDataURL) · page_contrast

Inspect

page_eval · page_open · page_comment

Harvest

page_download (media through the browser identity — cookies, TLS fingerprint, referer; streams to <session>/downloads/)

Identity

identity_generate · identity_audit · identity_morph (stop→relaunch→swap identity without losing the session)

Body sense

page_proprio (M4: honest body state — focus, selection/caret, scrollers) · page_cookie_events (M4: cookie/session heartbeat — auth-cookie deletion = earliest session-death signal) · session_vitals (M4.5: per-process CPU/memory)

Recipes

recipe_record · recipe_save · recipe_list · recipe_replay (deterministic replay, semantic anchors, strict/lenient escalation)

Evidence & safety

session_evidence · confirm_action

Every mutation returns a receipt — page_fill reports landed_chars, while type_ref fire-then-verifies async editors, so a silent page swap can't eat an edit unnoticed. Sessions can also run headful ({"headful": true}) when humans want to watch the agent work.

Every run records evidence. Each session writes an append-only event log (events.jsonl), full page snapshots and the identity it used under ~/.ghostfox/recordings/ — fetch it any time with session_evidence.

Engine diagnostics. ghostfox-mcp --self-test walks the engine pipeline (detection → spawn → juggler handshake → Browser.enable) and prints a step-by-step report plus the engine's stderr tail on failure — paste the output into an issue when a platform misbehaves.

Related MCP server: ffmcp

E2E without emulators: Flutter web + any web app

Android E2E normally means emulators, Appium and a farm of devices. Ghostfox takes the web route: build the Flutter app for the web (flutter build web — same Dart codebase) and drive it with the same senses used against hostile sites:

  • Semantics tree, read natively — Flutter's a11y nodes (roles, labels, bounds) land in page_a11y(native=true) once semantics are enabled (one line in the app: SemanticsBinding.instance.ensureSemantics()).

  • Native clicks — page_click_native fires the Flutter buttons at their trusted a11y coordinates (verified: submit triggers, status renders).

  • Receipts + page_diff + page_mutations + page_wait_stable — the same Act→Observe→Compare evidence loop, no polling guesswork.

  • Visual QA — page_ui_audit judges the rendered UI.

Honest scope: logic/flow/UI = fully covered; final visual parity with real devices (Impeller rendering) and platform channels (sensors, camera) still need a device or emulator pass.

Sponsor

Ghostfox is independent and self-funded. If it saves your team from captcha walls or vibe-code UI bugs, help keep the house open:

Companies: sponsorship + early access to the hosted Visual QA service is open — sponsor the repo or open an issue with the title sponsorship.

Or install in one command (Linux x86_64):

curl -fsSL https://raw.githubusercontent.com/autokeren/ghostfox/main/install.sh | bash

From source end-to-end (build the engine yourself): see engine/README.md — make dir && make build.

Repository layout

runtime/   Rust: ghostfox-{core,fingerprint,mcp,eval}     (MIT OR Apache-2.0)
engine/    Browser fork: patches, branding, build system    (MPL-2.0)
AGENTS.md  The agent playbook — how AI agents drive Ghostfox like a human
SKILL.md   The compact agent skill — the golden loop + tool map at a glance
docs/JOURNEY.md  The dev-log, todo list and the road ahead (the five senses)

Two directories, two licenses, one product. The runtime speaks Juggler natively — no Node, no Python at runtime.

Using Ghostfox with an AI agent (opencode, Codex, Cursor, Claude Code, ...)? Read AGENTS.md first — it's the distilled playbook from real agent runs: the READ → REASON → DECIDE → ACT loop, self-health (rate limits, drafts, notifications), rich-editor typing, and every known wall with its proven solution.

Why own the engine?

  • Anti-detect that survives inspection. Spoofing happens inside the engine (navigator, screen, WebGL, fonts, WebRTC, timezone, audio) — not in injected JS that detectors can read.

  • No cloud dependency. Your agent's identities and cookies never touch a third-party host.

  • Upstream insurance. engine/ tracks daijro/camoufox as upstream; Ghostfox applies its own branding and can rebase whenever it wants — including if upstream patches go closed-source.

Status

v0.7 — alpha. Verified: identity coherence (500/500), full MCP round-trip E2E (create → open → fill → submit), 8 captcha families E2E on production sites (bilibili, hCaptcha-protected signups, TikTok), debug cortex (console/errors/network), Docker image E2E (session → open → snapshot inside a container), portable sessions across Camoufox-lineage browsers. Distributed via PyPI, npm, Docker (GHCR) and the official MCP Registry. Known limits are tracked in the changelogs under runtime/ and engine/.

Do not use against targets you don't have permission to test. This is a testing / research tool.

Credits

Ghostfox stands on the shoulders of giants — Camoufox (daijro) for the anti-detect patch stack, Mozilla Firefox for the engine, LibreWolf for the patch tooling lineage, and Playwright for the Juggler protocol.

License

Available Tools

42 tools
captcha_solveA

Solve a CAPTCHA through the configured provider (env GHOSTFOX_CAPTCHA_PROVIDER=2captcha + GHOSTFOX_CAPTCHA_KEY). Turnstile/hcaptcha: pass sitekey + pageurl; image captchas: pass image_base64. Stealth-first: prefer not being challenged at all.

Inputs: session_id (required), pageurl, sitekey, image_base64.

confirm_actionA

SAFETY GATE: confirm a dangerous action before executing it. Call this BEFORE clicking refs on pages flagged with danger_zone (financial/medical/legal/auth).

Inputs: ref (required), action (required), page_id (required), session_id (required).

identity_auditA

Audit an identity TOML for coherence violations (contradictory signals a detector would flag).

Inputs: identity_toml (required).

identity_generateA

Generate a new coherent browser identity, returned as TOML.

page_a11yA

Semantic snapshot of the page: every visible interactive element with a stable ref, role (button/link/textbox/...), accessible name and CURRENT value — pierces shadow DOM, so web-component UIs (Reddit, modern frameworks) are fully visible. Use this instead of guessing CSS selectors.

Inputs: page_id (required), session_id (required).

page_captcha_ocrA

CAPTCHA OCR: classify the text of a normal image captcha (the distorted-text family) with the ddddocr model (CRNN+LSTM trained specifically on captcha text, 8210-char charset). 100% local — runs on onnxruntime inside the runtime. Takes the ref of the captcha element (or the whole viewport) and returns the recognized text. Feed it into the answer field and submit. Far stronger than generic OCR on captcha fonts.

Inputs: page_id (required), session_id (required), ref.

page_captcha_rotateA

ROTATE CAPTCHA SOLVER: brute-force sweep + human replay. Rotate challenges ask to turn an image upright; standard demos rotate 15deg per button click and answer with a check button. The tool first sweeps every angle programmatically (instant JS clicks, ~30s), reads the visible feedback after each check (success keywords: pass/通过/正确/成功/verif/succeeded), then REPLAYS the winning rotation with real human mouse drags and the final check. Returns JSON {clicks, angle, status}. For fixed-image demos the sweep converges every time.

Inputs: page_id (required), check_ref (required), reset_ref (required), session_id (required), +2 more.

page_clickA

Click an element by CSS selector. For form controls (buttons, inputs), uses a JS click; for links and other elements, dispatches real mouse events at coordinates. Prefer page_click_ref when you have a page_a11y ref — it scrolls into view first and is more reliable on web-component UIs. Returns 'ok' on success.

Inputs: page_id (required), selector (required), session_id (required).

page_click_refA

Click an element by its ref from page_a11y. Scrolls it into view first. No selectors needed.

Inputs: ref (required), page_id (required), session_id (required).

page_commentA

Submit a comment on the current page. Automatically: 1) detects your username via session_me, 2) checks if you already commented (skips if duplicate), 3) finds the comment editor (Reply or Join conversation), 4) opens it, 5) types your text, 6) clicks submit, 7) verifies. Returns result JSON.

Inputs: text (required), page_id (required), session_id (required).

page_consoleA

DEBUG CORTEX: read the page's console output (log/warning/error) captured at the PROTOCOL level — the page cannot hide or patch it. Invisible debugger for AI agents: reproduce the bug, read what the page logged. Optionally filter noise by clearing after read. Returns JSON [{kind, text, url, line, ts}]. Auto-starts capture on first call.

Inputs: page_id (required), session_id (required), clear.

page_contrastA

HIGH-PASS VISION: local-contrast grid of an element's image (|gray - gaussian_blur|). Makes ANYTHING blended into a background VISIBLE — captcha characters on photos, watermarks, hidden strokes. 0 = flat area, 9 = strong edge. This is the native tool born from solving GeeTest icon-click with pure math. Works on canvas / img / background-image (one fetch per challenge).

Inputs: ref (required), page_id (required), session_id (required), grid_h, +2 more.

page_dismiss_modalA

Detect and dismiss common modals: cookie banners, consent dialogs, popups, overlays. Returns what was dismissed.

Inputs: page_id (required), session_id (required).

page_dragA

Drag with a HUMAN-LIKE movement profile: approaches the source, presses, drags along a bezier arc with ease-in-out velocity and micro-pauses, settles, releases. Pass from_ref + to_ref to drag element onto element, or from_ref + offset_x/offset_y to drag by pixels (slider captchas, resize handles). All from page_a11y refs.

Inputs: page_id (required), from_ref (required), session_id (required), to_ref, +2 more.

page_errorsA

DEBUG CORTEX: read the page's UNCAUGHT JS EXCEPTIONS with stack traces, captured at the protocol level. The error console a developer opens in DevTools — as a tool. Returns JSON [{text, url, line, stack: [frames], ts}]. Auto-starts capture on first call.

Inputs: page_id (required), session_id (required), clear.

page_evalA

Evaluate a JavaScript expression in the page's main frame and return its JSON value. Read-only introspection is safest; treat results of mutations with care.

Inputs: page_id (required), expression (required), session_id (required).

page_fillA

Set an input's value directly (form fill). Works where key-event typing hits engine bugs; fires input/change events like real edits.

Inputs: text (required), page_id (required), selector (required), session_id (required).

page_geetest_clickA

GEETEST ICON-CLICK SOLVER: solve the GeeTest v3 word-click captcha (characters on a photo, click in the strip's order) from the live page. Fetches the challenge image off the element's background, runs the trained ONNX pair (YOLOv8s char detection + siamese order matching, 100% local CPU, ~0.5s), and returns click targets in page coordinates plus the raw boxes. Call AFTER the challenge popup is open. Then click each 'click' point via page_drag and press the geetest confirm button. Returns JSON {clicks: [{x, y}, ...] in page px, boxes_raw: [[x, y], ...] in image px, rect: {...}, img: {w, h}}.

Inputs: ref (required), page_id (required), session_id (required).

page_geetest_slideA

GEETEST SLIDE SOLVER: solve the GeeTest v3-style slide puzzle from the live page, then perform the human drag itself. Extracts the three canvases (bg, puzzle slice, full reference bg) via toDataURL, finds the hole with |bg-fullbg| diff + largest-blob + morphological closing (the JPEG-noise trap), measures the piece's solid-alpha left edge, and drags the slider by hole_x0 - piece_x0 with the engine's humanized mouse. Returns JSON {drag_x, hole: [x0, x1], piece_x0}. Call AFTER the challenge popup is open. No vision model, pure pixel math.

Inputs: page_id (required), session_id (required), slider_ref.

page_hcaptchaA

HCAPTCHA SOLVER: solve hCaptcha image challenges from the live page with the host vision model (Cloudflare Workers AI GLM). Handles ALL challenge variants — tile grids, pattern-break icon fields, any image-pick — by asking the model for the exact pixel coordinates of every element to click, then clicking with the humanized mouse. Multi-round: loops until the page's h-captcha-response field receives a token (up to max_rounds, default 4). Credentials come from CLOUDFLARE_API_KEY / CLOUDFLARE_ACCOUNT_ID env or the params. Returns JSON {success, rounds, response_len}.

Inputs: page_id (required), session_id (required), cf_api_key, max_rounds, +2 more.

page_init_scriptA

INIT SCRIPTS: run your JS at DOCUMENT START on every navigation — BEFORE any page script loads. The deepest interception layer in Ghostfox: hooks installed here are what page libraries (gt.js, analytics, frameworks) capture, so their stored references are YOURS. Use for: API response interception (JSONP callback swaps), state capture, anti-detection instrumentation, environment patches. Applies to subsequent navigations.

Inputs: source (required), page_id (required), session_id (required).

page_match_imageA

REAL TEMPLATE MATCHING: multi-scale normalized cross-correlation of a needle against a haystack, computed IN-PAGE at full grayscale resolution (no grid loss). Returns top matches [{x, y, score, scale}] — needle-center positions in haystack-image pixels. needle_rect optionally crops the needle (e.g. an instruction glyph band from the same image — GeeTest icon-click pattern). Images are cached per URL: single-use challenge URLs fetch exactly once. THE tool for: captcha piece->gap, glyph->character, logo->page.

Inputs: hay_ref (required), page_id (required), needle_ref (required), session_id (required), +2 more.

page_move_toA

Move the mouse onto an element (hover) along a HUMAN-LIKE path: bezier arc, ease-in-out velocity, sub-pixel tremor, overshoot+correction. Triggers hover menus and tooltips. Pass the ref from page_a11y.

Inputs: ref (required), page_id (required), session_id (required).

page_network_bodyC

Fetch the BODY of a captured response by requestId — Network.getResponseBody BY PROTOCOL. The JSONP/API answer data that page JS can't see, served from the engine. THIS is the 0s and 1s layer.

Inputs: page_id (required), request_id (required), session_id (required).

page_network_readA

List captured HTTP responses [{url, requestId}] since capture start. Optionally filter by URL substring (e.g. 'geetest' or 'api.'). Pair with page_network_body to read the response content BY PROTOCOL.

Inputs: page_id (required), session_id (required), filter.

page_network_startA

PROTOCOL-LEVEL NETWORK CAPTURE: start recording every HTTP response for this page, BELOW the page (invisible to page JS, unpatchable). The answer data of any captcha/API travels here. Start before triggering the flow you want to see.

Inputs: page_id (required), session_id (required), filter.

page_ocrA

TIER 2 VISION — LOCAL OCR: extract text from an element (or the whole viewport if no ref). 100% local (pure-Rust ML models auto-download once to GHOSTFOX_HOME/models). Answers 'what text is written there' — for image captchas, canvas text, scanned UI. Models download on first call (~12MB, once).

Inputs: page_id (required), session_id (required), ref.

page_openA

Navigate to a URL in an existing session. Returns a page_id (string) that must be passed to all subsequent page tools. Waits for the page to load. If the page has iframes or shadow DOM, use page_a11y instead of guessing CSS selectors. Example: page_open(session_id, 'https://example.com') returns a page_id like 'abc123'.

Inputs: url (required), session_id (required).

page_pixelsA

SUPERMAN GLASSES: render an element (canvas / img / background-image) as a compact luminance GRID of digits 0-9 the agent READS directly — see shapes, holes, object orientation, image layout WITHOUT a vision model. 0=black, 9=white. Captcha gaps appear as darker cells, upright skies are bright rows on top. Pass the ref from page_a11y. Returns JSON {w, h, grid:[rows of digits]}.

Inputs: ref (required), page_id (required), session_id (required), grid_h, +1 more.

page_pressA

Press a named key (Enter, Tab, Escape, ArrowDown, ...) — e.g. Enter to submit a search box.

Inputs: key (required), page_id (required), session_id (required).

page_read_refA

Read the FULL value of an element by its page_a11y ref — no truncation. Use when the snapshot's 200-char preview isn't enough (body text, long input fields).

Inputs: ref (required), page_id (required), session_id (required).

page_screenshotA

Capture a PNG screenshot of a page (viewport by default, full page with full_page=true). Saved under the session recordings dir; returns the file path. Feeds the live view when enabled.

Inputs: page_id (required), session_id (required), full_page.

page_snapshotA

Extract the visible text content of a page as plain text (token-friendly). Returns: url, title, and content (all visible text, no HTML). For semantic element data with refs and values, use page_a11y instead — it gives you interactive elements with roles and names. Use this when you just need to READ page content without needing to interact with elements.

Inputs: page_id (required), session_id (required).

page_typeA

Type text character-by-character into an element by CSS selector (human-like key events). Prefer page_type_ref when you have a page_a11y ref — it handles rich editors (Lexical/Draft/ProseMirror) and returns a verified receipt. Use this only when you only have a CSS selector and don't need rich editor support. Returns 'ok' on success.

Inputs: text (required), page_id (required), selector (required), session_id (required).

page_type_refA

Type text into the element a page_a11y ref points at (inputs and rich editors). Returns landed chars as a receipt.

Inputs: ref (required), text (required), page_id (required), session_id (required).

page_upload_fileA

Upload a file to an input[type=file] by CSS selector. The file must exist on the machine running the engine.

Inputs: page_id (required), selector (required), file_path (required), session_id (required).

page_visionA

TIER 4 VISION — VISUAL CORTEX: detect word bounding boxes in an element (or viewport) via the built-in text-detection ML model. Returns JSON [{x, y, w, h}, ...] in image pixels. The first shipped visual-cortex model — see where text lives in ANY image (click-order captchas, canvas text, scanned layout). 100% local.

Inputs: page_id (required), session_id (required), ref.

page_wait_forA

Wait until a CSS selector becomes visible on the page (replaces manual sleeps). Returns true if found, false on timeout.

Inputs: page_id (required), selector (required), session_id (required), timeout_ms.

session_createA

Create a new browsing session: launches the engine with a fresh coherent identity. Returns session_id.

Inputs: proxy, headful, platform, profile_dir.

session_evidenceA

READ-ONLY: Retrieve the complete audit trail for a session. No side effects — does not modify the session or browser. Returns JSON with: session_id, dir (evidence directory path), identity_toml (path to the identity file used), event_count (total tool calls recorded), events (array of all events with timestamps), and snapshots (list of page snapshot file paths). The session_id must come from a previous session_create call. For a nonexistent session, returns an error. Evidence persists after the session ends and includes: append-only events.jsonl, page snapshots (markdown), screenshots (PNG), and identity.toml. Use session_create first if you need a session.

Inputs: session_id (required).

session_meA

Detect the currently logged-in username on the page (Reddit, X, GitHub, HN). Returns username or 'unknown'. Use before commenting to avoid duplicates.

Inputs: session_id (required), page_id.

session_pagesA

POPUP/TAB VISION: list EVERY browser target — pages you opened AND popups the site opened (OAuth windows, payment flows). Popups are auto-attached and given a page_id usable with every page_* tool immediately. Returns JSON [{page_id, target_id, url}].

Inputs: session_id (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 42 tools

    Disambiguation3/5

    Some overlap exists among the many vision, input, and captcha tools (e.g., page_snapshot vs page_a11y vs page_ocr, or page_type vs page_type_ref vs page_fill), though the descriptions do a good job of explaining when to prefer one over another. The highly specialized captcha solvers are each tied to a specific challenge type, but the sheer number of adjacent tools still creates selection ambiguity.

    Naming Consistency4/5

    The vast majority of tools follow a clear page_<verb_or_noun> snake_case convention, with session_ and identity_ prefixes for lifecycle and identity concerns. Minor deviations like captcha_solve, confirm_action, and the noun-style page_console/page_a11y keep it from being perfectly uniform, but the overall pattern is predictable.

    Tool Count2/5

    At 42 tools, this is well above the 25+ threshold and feels too heavy even for a broad stealth-browser and captcha-solving purpose. Many vision and captcha variants could likely be consolidated or surfaced through a smaller capability-oriented set. The count is not chaotic enough for a 1, but it will tax an agent's ability to choose efficiently.

    Completeness4/5

    The toolset covers the core lifecycle thoroughly: session creation, identity generation/audit, page navigation, interaction, reading, network capture, console/error introspection, captcha solving, and evidence retrieval. Minor gaps like explicit session teardown, page reload/back-forward navigation, or cookie management are missing, but agents can work around those with page_eval and navigation to a URL.

    Maintenance

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables cloud browser automation through Browserbase and Stagehand, allowing LLMs to interact with web pages, take screenshots, extract data, and perform automated actions with support for proxies, stealth mode, and parallel sessions.
      14
      Apache 2.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      A local MCP server for Firefox that gives AI agents full control over the browser via a Unix socket, enabling automation of tabs, pages, cookies, and more without exposing any network ports.
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to drive a privacy-first browser via MCP, using diff-based page observation to reduce token consumption, and offering secure autofill from a local vault.
      MIT