ghostfox
Ghostfox is an MCP-native stealth browser server for creating coherent sessions, navigating pages, observing/interacting via accessibility refs, solving captchas, and debugging network/JS/visual behavior.
Create sessions with fresh coherent identities, optional proxies, headful mode, platform restriction, and persistent profiles.
Navigate pages and list all tabs/popups, including OAuth/payment windows.
Inspect pages with semantic accessibility snapshots, text snapshots, screenshots, ref reads, pixel grids, contrast maps, OCR, text bounding boxes, and template matching.
Act on pages by clicking CSS selectors or accessibility refs, typing, filling, pressing keys, dragging, hovering, uploading files, and submitting comments.
Wait for selectors, dismiss modals, and run JS eval or document-start init scripts.
Capture console logs, uncaught JS errors, and network responses/bodies at protocol level.
Solve captchas: GeeTest slide/icon-click, rotate captcha, OCR captcha, hCaptcha via host vision model, and provider-backed captcha solving.
Generate/audit identities, check current user, and retrieve session evidence/audit trails.
Use a confirmation safety gate for dangerous actions.
Enables automated browsing on Cloudflare-protected sites by using engine-level anti-detect fingerprinting and solving Cloudflare Turnstile challenges through a CAPTCHA provider.
Ghostfox
The agent-native stealth browser you can own.
Self-hosted · Open source · MCP-first · Engine-level anti-detect
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, MCPGhostfox | 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.
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.
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.
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.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 |
| bg-vs-fullbg diff + largest-blob gap detection |
GeeTest icon-click (文字点选) |
| custom-trained YOLOv8s + siamese similarity (rten, CPU) |
Rotate |
| 24-angle sweep + programmatic verdict |
Normal OCR |
| ported ddddocr (CRNN+LSTM, onnxruntime) |
hCaptcha |
| layout router + 553-model QIN2DIM zoo + optional vision-model ensemble |
Cloudflare Turnstile / TikTok |
| proven playbooks in |
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— everyconsole.log/warn/errorsince loadpage_errors— uncaught JS exceptions with stack tracespage_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 withGHOSTFOX_TOOLSET=full.
The server also publishes instructions (a decision tree agents read before choosing tools) — the disambiguation layer for both tiers.
Category | Tools |
Session |
|
See |
|
Wait |
|
Act |
|
Captcha |
|
Network broker |
|
Debug |
|
Vision |
|
Inspect |
|
Harvest |
|
Identity |
|
Body sense |
|
Recipes |
|
Evidence & safety |
|
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_nativefires 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_auditjudges 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:
GitHub Sponsors — monthly support, any amount
Buy Me a Coffee — one-time
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 | bashFrom 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.mdfirst — 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 asupstream; 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
engine/— MPL-2.0 (inherited from Firefox / Camoufox). See engine/LICENSE.runtime/— MIT OR Apache-2.0. See runtime/LICENSE-MIT.
Available Tools
42 toolscaptcha_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
Scored across 42 tools
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.
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.
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.
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
Related MCP Connectors
Cloud browsers for AI agents: saved logins, residential IPs, live human takeover, 57 browser tools.
Real Chrome for coding agents over MCP: browse, replay playbooks, human takeover, HIPAA & BAA.
Cloud browsers for AI agents: get past bot detection, sign in with MFA, run web tasks at scale.
Browser agents and stealth cloud browsers for AI: run web tasks, fill forms, extract data.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables 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.14Apache 2.0
- AlicenseNot gradedqualityCmaintenanceA 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
- AlicenseNot gradedqualityCmaintenanceEnables 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
- AlicenseAqualityAmaintenanceA stealth Firefox browser exposed as an MCP server that lets AI agents browse and interact with real websites without being blocked by anti-bot systems.184MIT