ZeroDOM
ZeroDOM is an MCP server that lets an AI agent drive a real logged-in browser, parse pages into compact interaction graphs, automate UI actions, and run deterministic recon/security checks including cross-identity IDOR testing.
Navigate to URLs and return token-lean interaction graphs; re-read pages, search nodes, and inspect hidden form fields.
Interact with pages: click, fill, hover, press keys, upload files, drag/drop, scroll, manage tabs, take screenshots, and resize viewport/window.
Inspect page state: computed styles, cookies including httpOnly, localStorage/sessionStorage, network logs, and arbitrary JS evaluation.
Crawl in-scope apps and scan the active page for surface findings, DOM-XSS sinks, callable APIs, and CSP/CORS posture.
Send and replay HTTP requests over the active session; probe tampered bodies for mass assignment; run concurrent race/TOCTOU bursts.
Manage identities and browser profiles for cross-tenant testing, including live-cookie snapshots, storage-state files, headers, and second real Chrome profiles.
Compare responses across identities to flag byte-identical cross-tenant IDORs and 2xx-vs-401/403 access-boundary splits.
Enforce authorized scope, destructive-action deny rules, rate limits, and agent tab-group sandboxing.
Diagnose relay/browser connectivity and active-session status.
ZeroDOM can drive Discord in an attached browser session — typing into Discord's contenteditable editors with real keystrokes via zerodom_fill_node and reporting what changed on the page.
ZeroDOM can drive Jira in an attached browser session — typing into Jira's contenteditable editors with real keystrokes via zerodom_fill_node and returning the resulting structural diff.
ZeroDOM can drive Notion in an attached, already-logged-in browser session — typing into Notion's contenteditable editors with real keystrokes via zerodom_fill_node and returning the resulting structural diff of the page.
ZeroDOM can drive Slack in an attached browser session — typing into Slack's contenteditable editors with real keystrokes via zerodom_fill_node, which a plain value-set on a contenteditable would not accomplish.
ZeroDOM
Point it at an app as two users. It finds the broken access control.
ZeroDOM drives your real, logged-in browser as two identities, replays the same requests as each, and flags where one user reaches what another can't — IDOR / broken access control, caught deterministically. Open-core, runs local, no account, no API key, nothing leaves your machine.
Under the hunt is a deterministic, token-lean perception engine for AI agents — the same core powers scan, crawl and any browser-driving task. IDOR is just where it bites hardest.
Site · Docs · Playground · Discord · Quickstart ↓
A normal user is denied the admin console (401) — then walks in by flipping one client-controlled cookie. ZeroDOM proves it: same request, two identities, 401 vs 200. Full recording (mp4).
Contents
Related MCP server: Rove
Why ZeroDOM
Two audiences, one engine:
AppSec —
compare/sweep: deterministic two-identity authorization testing that runs headless in CI or your recon pipeline — no GUI, no account.scan --jsadds DOM-XSS sinks, the callable API surface and header posture;repeat/probe/raceturn recon into verification (Repeater, mass-assignment diff, and a TOCTOU burst).AI agents — MCP: a flat interaction graph that cuts ~71% of the tokens vs Playwright's
aria_snapshot, with handles that resolve 1:1 and don't drift when the page re-renders.
Broken access control is the #1 web vulnerability (OWASP A01) and the one automated scanners miss — because catching it means knowing who should be allowed to do what, not just fuzzing one session. The usual answer is a human in Burp, clicking through the app as one user, then again as another, diffing by eye.
ZeroDOM does that mechanically. Give it two logged-in sessions; it replays the same request as each and reports the deterministic tells:
access-boundary-split— one identity gets200, the other401/403on an identical request. If the only difference between them is client-controllable (a cookie, header or param), that's broken access control.cross-identity-identical-response— two users get a byte-identical body on a per-user resource: a cross-tenant IDOR.
No LLM guessing, no "the AI thinks maybe." ZeroDOM surfaces the tell with the exact replay that proves it — a reviewable diff you drop straight into a bug report. You confirm the bug.
It drives your real Chrome (relay mode) over chrome.debugger, so your cookies, MFA and
SSO are already done — or a throwaway browser (--stealth) if you'd rather not touch your
session. Either way the page's markup never leaves your machine, and it's read-only by
default: destructive actions and out-of-scope hosts are refused.
It works equally well as a one-line CLI, a recon pipeline stage, or a native tool an AI agent drives through MCP. Same deterministic primitives, three front doors.
Quickstart
See it run in 10 seconds — no account, no browser download (bare zerodom <url> is a static
fetch, no Chromium needed):
pip install zerodom # or: uvx zerodom · npm i @vexralabs/zerodom
zerodom https://news.ycombinator.com # the interaction graph + a token reportThat's the perception engine — a flat, 1:1-addressable graph instead of 12k tokens of HTML.
Now the flagship — find an IDOR. Save two logged-in sessions as Playwright storage_state
files (one per account), then diff a protected endpoint across both:
zerodom compare https://app.example.com/api/admin/dashboard \
--as user=user.json --as admin=admin.json{
"identities": {
"user": { "status": 401, "bytes": 2616 },
"admin": { "status": 200, "bytes": 3469 }
},
"only_admin": ["Manage users", "Billing & plans", "Overview"],
"note": "admin authorized (200) where user denied (401) — broken access control if the
only difference is client-controllable"
}That's the whole loop: same request, two identities, a 401-vs-200 split → a lead to confirm.
only_admin lists the privileged controls the normal user should never see.
Don't have storage-state files? Capture one with
context.storage_state(path="user.json") in Playwright, or export cookies from a logged-in
session. Want the whole app, not one URL? → zerodom sweep.
How it hunts — compare & sweep
zerodom compare — one endpoint, across identities
Fetch one URL under each saved session and diff the responses. Byte-identical content across
two users on a private resource is a cross-tenant IDOR; a 401-vs-200 split is a broken
boundary. only_<name> lists the actionable nodes each identity sees that the other doesn't.
# Sweep a range of object ids through two identities:
seq 1 500 | sed 's#^#https://app.example.com/api/invoice/#' \
| zerodom compare - --as alice=alice.json --as bob=bob.json \
| jq 'select(.identical_body_pairs | length > 0)'zerodom sweep — the whole app, one command
compare tests one URL. sweep does the entire app: it crawls as one identity to map the
GET surface (pages + the API calls the JS fires), then replays every in-scope URL under all
your identities and reports only the deterministic tells.
zerodom sweep https://app.example.com --as user=user.json --as admin=admin.json --format md| severity | rule | url |
| -------- | ---------------------- | ------------------------------------- |
| medium | access-boundary-split | https://app.example.com/api/admin/... |Read-only throughout: only GET is replayed, destructive URLs are dropped (--deny).
--format md emits a report-ready table (default is JSONL). This is the "point it at an app
with two logins and it finds the broken access control" pass.
Both take --proxy (route through Burp/Caido), --header (a program's WAF-bypass token), and
a scope you can lock. Challenge pages (Cloudflare / Turnstile / reCAPTCHA / hCaptcha) are
detected and climbed by a scope-gated clearance ladder; a wall nothing clears is reported as
an honest blocked, never worked around outside an authorized target.
When recon finds a lead — repeat / probe / race
Mapping an app surfaces the endpoints; these verbs act on them. repeat is a Repeater over the
session (--save writes HAR/.http evidence for a report). probe replays an endpoint with a
tampered body and diffs it against the baseline — an accepted, reflected field is a mass-assignment
lead. race fires a concurrent burst (one body, or a mix of operations via repeated --body) to
flag a check-then-act race (TOCTOU); the stdlib engine is always available, and --engine http2
multiplexes the burst over one connection via the optional zerodom[race] extra.
zerodom race https://app.example.com/api/coupon --body '{"code":"SAVE20"}' -n 30 \
--setup setup.json --check https://app.example.com/api/cartAll three are exposed to agents over MCP as zerodom_repeat / zerodom_probe / zerodom_race.
Use it from an AI agent (MCP)
Standard MCP browser tools hand the model raw pixels (slow, stale on scroll) or an accessibility
tree (no stable handles — repeated controls collide). zerodom-mcp gives your agent a flat,
token-frugal graph where every click [45] resolves deterministically over CDP to exactly one
element — and the same tools do cross-identity IDOR hunting the others can't. Why ↓
ZeroDOM is a native MCP server, so Claude, Cursor or any MCP agent can hunt with the same
primitives. Run zerodom setup for a guided first-run (checks Chromium, prints the extension
path + chrome://extensions steps, emits the config below, reports relay reachability —
print-and-guide, no account, nothing leaves your machine).
// Claude Desktop: claude_desktop_config.json · Cursor: .cursor/mcp.json
{
"mcpServers": {
"zerodom": { "command": "uvx", "args": ["--from", "zerodom", "zerodom-mcp"] }
}
}Once before first use (so the server never downloads mid-tool-call):
uvx --from zerodom playwright install chromium.
Using LangGraph, CrewAI, OpenAI Agents SDK, Pydantic AI, LlamaIndex, Google ADK or AutoGen?
Ready-to-run MCP examples — same server, a few lines each — are in
examples/integrations/.
tool | what it does |
| navigate, return the compact graph; |
| re-read the live DOM without navigating |
| return only the nodes matching a phrase |
| click, then return what changed — flags a same-page no-op shortly after navigation as a possible hydration miss |
| type via real keystrokes — works in |
| hover, revealing hover-triggered menus/tooltips |
| press a key on a focused node (Enter, Escape, Tab, …) |
| set a file input's value to a local path |
| drag one node onto another |
| scroll, return what's newly visible |
| open a tab and make it active |
| list every open tab, marking the active one |
| make another open tab active |
| close a tab (the active one by default) |
| full-page screenshot of the active tab, saved to disk |
| resize the viewport for responsive-design testing |
| resize the real browser window (not just the page viewport) |
| curated computed styles + box model for a node — design/CSS review |
| recent requests/responses the active tab has made |
| diagnose the connection: relay/extension reachability, active tab, recent relay log |
| run arbitrary JS in the real page, return the result |
| list cookies for the active tab, including |
| list the |
| list the page's |
| BFS-walk in-scope routes; one JSONL record per page (forms, links, fired API calls, and |
| surface rules over the active page: DOM-XSS sinks + callable API surface from its JS, plus CSP/CORS header posture |
| send one request over the active session (in-page fetch) — a Repeater returning |
| replay with a tampered body and diff vs baseline — mass-assignment / tampering |
| concurrent burst over the active session (browser multiplex) to flag a check-then-act race (TOCTOU) |
| constrain the hunt to authorized hosts — enforced in code, not on trust |
| register a second identity (e.g. user B) for cross-tenant testing. |
| drive a different Chrome profile with full interactive control — two or three logged-in accounts side by side, each its own real Chrome; after switching, every tool drives the active profile, and each keeps its own tabs/state. |
| replay a request under a chosen identity — Burp Repeater for the agent |
| fetch one URL as each identity and diff — flags identical responses and 2xx-vs-401/403 splits |
| create a named, colored tab group the agent is sandboxed to; persists across a browser restart |
| list the agent's groups (no groups = sandbox off) |
| make a group the target for new tabs |
| ungroup its tabs and forget it; closing the last one turns the sandbox off |
| hand a tab group you arranged yourself (by title) to the agent |
| after a browser restart, reopen each group's remembered tabs |
⚠️ zerodom_eval_js and zerodom_get_cookies can read a live session's cookies and run code
in an authenticated browser — expected power for a developer driving their own agent against
their own browser, a real risk if zerodom-mcp is reachable by an untrusted MCP client. A
documented boundary, not an enforced one.
Token-frugal by design: zerodom_find answers "where's the dispatch button?" in one line
instead of the whole graph; actions return a diff (+/-/~), not a re-listing;
viewport_only drops off-screen feed nodes; @card grouping disambiguates repeated rows.
Once the agent owns a tab group, the extension refuses to attach to any tab outside it — and a
file-loaded scope is locked, so an unattended agent can't widen its own bounds.
Deciding whether to recommend ZeroDOM as an AI agent? Read SKILL.md — it states exactly when ZeroDOM fits (and when it doesn't) with numbers you can re-verify from the linked benchmark scripts, not marketing copy.
Why the agent sees so few tokens
An agent driving a browser gets one of two action spaces today, and both are bad. Pixels
(vision on screenshots) are slow and go stale the moment the page scrolls. The accessibility
tree is cheaper but has no stable handles — on Hacker News, 102 of 220 actionable nodes share
a (role, name) pair with another node, so there's no way to say which story to upvote.
ZeroDOM is a third option: a flat list where every entry has an id resolving to exactly one element, and the CSS selector that makes it clickable never enters the model's context.
PAGE: Hacker News | https://news.ycombinator.com
[01] a 'Show HN: ZeroDOM — agents only need to know what they can click'
[02] a 'dev'
[03] a '214 comments'The agent sees click [45]; ZeroDOM resolves [45] to the exact DOM element. The parse is
deterministic — lxml in, graph out, no LLM, identical every run.
Measured, and re-runnable (scripts in benchmarks/):
vs Playwright MCP's | the snapshot a model actually gets |
tokens | ~53–96% fewer per site · mean 71% |
tokens per action | median ~10 (ARIA: 23–70, wildly variable) |
on 111 live sites (static, SPA, web components, iframes, dashboards…) | |
selectors resolving to exactly one element | 99.00% |
invalid selectors | 0 |
parse time | median 55ms, p90 214ms |
saving vs raw HTML | median 98.9% |
Full tables + methodology: benchmarks/RESULTS.md. The hard cases are
the point — 1,334 selectors scoped against open shadow roots, every one unique.
More of the CLI
zerodom https://example.com # the compact graph + a token report
zerodom https://example.com --find "sign in" # only the nodes that match
zerodom https://example.com --frames # also read inside iframes
zerodom https://example.com --json # full graph, selectors included
zerodom https://example.com --render # headless Chromium, for JS pages
zerodom https://example.com --stealth # throwaway Chrome over a CDP pipe, no port
cat targets.txt | zerodom inspect --pipe - # JSONL, one node per lineMap the attack surface — zerodom crawl. Deep, authenticated, read-only recon: it walks a
rendered app (real JS SPAs load), stays in scope, and emits a JSONL surface map — each page's
forms (and CSRF fields), in-scope links, and the API calls its JavaScript fires. Feed its
api_calls straight into compare for the IDOR pass.
zerodom crawl https://app.example.com --storage-state session.json --max-pages 60
zerodom crawl https://app.example.com --relay # against your already-open ChromeAttack-surface rules — zerodom scan. Evaluates every parsed node against a deterministic
YAML ruleset and emits JSONL findings — forms with no CSRF token, password inputs without one,
admin/internal/debug links, sensitive inputs. Rules are fixed match keys, not an expression
language, so nothing in a rules file gets evaluated.
subfinder -d example.com | httpx -silent | zerodom scan - # into your recon pipeline
zerodom scan https://app.example.com --js # + DOM-XSS sinks, callable API surface, header posture
zerodom scan https://app.example.com --format md # Markdown table for a reportCheck the selectors you already have — zerodom audit. Reads the selectors in a Playwright/
Cypress/Selenium suite, resolves each against your running app, and reports ok / dead /
ambiguous / invalid: zerodom audit tests/ --url http://localhost:3000.
Authenticated testing. --proxy routes through Burp/Caido/ZAP (--insecure trusts the
proxy CA); --header 'X-Bug-Bounty: …' carries a program token; --storage-state reuses a
human-cleared session. Works on every path. Only test targets you're authorized to.
See the graph. --screenshot page.png writes a capture with a numbered badge over every
node; --html report.html writes a self-contained graph-left / page-right inspector (hover a
line to spotlight the element). Both print a located count — how many selectors resolve.
How it compares
Honest version: ZeroDOM complements Burp (it doesn't replace it) and isn't a general browser-automation framework. What it uniquely packages is the two-identity authorization method — deterministic, token-lean, and runnable headless in a pipeline or driven by an AI agent.
If you do AppSec, the column that matters is the last one. Burp + Autorize is the standard way to test broken access control today — and it's genuinely good — but it lives inside the Burp GUI. ZeroDOM brings the same replay-and-compare method to a scriptable CLI and an MCP agent.
ZeroDOM | Burp + Autorize | Playwright MCP | browser-use | |
Cross-identity authz / IDOR, native | ✅ | ✅ (heuristic) | ❌ | ❌ |
Scriptable · headless · CI pipeline | ✅ CLI → JSONL | ❌ Burp-GUI-bound | ✅ | ~ LLM-driven |
Output you can diff & drop in a ticket | ✅ reviewable diff / MD table | ⚠️ GUI verdict ("Is enforced???") | — | — |
Pipes into your recon stack ( | ✅ stdin/stdout | ❌ | — | — |
Scope lockable so it can't widen itself | ✅ locked scope | ❌ (operator-driven) | ❌ | ❌ |
Deterministic, no LLM in the parse | ✅ | ✅ | ✅ | ❌ |
Drives your real logged-in Chrome | ✅ relay | ✅ (proxy) | partial (CDP) | ✅ |
Agent / MCP-native | ✅ | ❌ | ✅ | ✅ |
Local · accountless · zero-egress | ✅ | ✅ | ✅ | depends on the LLM |
Why ZeroDOM over Autorize for automation. Autorize is the benchmark — but it's bound to the Burp GUI, heuristic (its own README flags false positives and an "Is enforced???" state), and has no headless / CLI / agent interface. So it can't run in CI, can't pipe into the recon stack you already use, and can't be driven by an AI agent. ZeroDOM runs the same replay-and-compare as a one-line command that emits JSONL (or a Markdown table for the ticket), enforces a locked scope, and hands back a reviewable diff instead of a verdict you have to eyeball. Rule of thumb: reach for Autorize when you're already in Burp clicking around; reach for ZeroDOM when the authz check has to be automated, repeatable, and pipeline-native — a nightly sweep across 50 apps, a CI gate on a PR, or an agent hunting unattended.
Install
pip install zerodom # Python 3.10+ · or: uvx zerodom (runs straight off PyPI)
npm install @vexralabs/zerodom # TypeScript / Node 5.6+Only if you use the browser-backed features (from_page, --render, --screenshot, relay):
playwright install chromium (the CLI does this for you on first browser use — a one-time
~150MB download).
Relay mode (your logged-in Chrome) needs the bundled extension:
zerodom setup # guided: Chromium, the extension, MCP config, relay
zerodom extension # prints the bundled extension's directory
# chrome://extensions → Developer mode → Load unpacked → select that directory
zerodom relayEach release also attaches zerodom-extension-<version>.zip with a .sha256.
Library quickstart (Python / TypeScript):
from zerodom import ZeroDOM
graph = ZeroDOM.from_page(page) # any Playwright page, sync or async
print(graph.to_compact_text()) # what you send the model
selectors = graph.selector_map() # {"node_01": "#email", …} — stays your side
# Driving a browser agent? One call gives the full-page view + a ref map keyed to
# the [NN] refs the model reads, so `[03]` resolves straight to a selector:
text, refs = ZeroDOM.agent_snapshot(page) # viewport_only=False by default
page.click(refs["03"]) # act on what the model pickedimport { ZeroDOM } from "@vexralabs/zerodom";
const graph = await ZeroDOM.fromPage(page);
console.log(graph.toCompactText());
// For a browser agent: full-page snapshot + ref map ([NN] -> selector).
const { text, refMap } = await ZeroDOM.agentSnapshot(page);
await page.click(refMap["03"]);Security & scope
It's a security tool, so the safety posture is enforced, not promised:
Read-only by default — destructive clicks/fills are refused.
Scope is enforceable and lockable (
ZERODOM_SCOPE/zerodom_set_scope): host allowlist, destructive-action denylist, rate limit. A file-loaded scope is locked so an unattended agent can't widen its own bounds.Undrivable targets refused —
chrome://, the Web Store, devtools.Zero-egress — the parse and relay run locally; the only outbound traffic is the target you point it at. No telemetry, no accounts, no storage. (The one exception is an opt-in CAPTCHA solver, off by default, killable with
--no-solver.)In relay mode the tab is locked while driving — a cyan border, a visible cursor, your own input blocked at the browser level, and a "zerodom is driving this tab" banner.
Full posture: SECURITY.md.
Limitations
Known and worth knowing before you build on it:
compare's IDOR tell needs two real logged-in identities. It surfaces the tell — a same-response across identities, or a 403-vs-200 — for you to confirm. It does not autonomously confirm a bug.Closed shadow roots are unreachable. Open roots are handled;
{mode: 'closed'}is hidden from every API, Playwright's included.Canvas / WebGL apps have nothing to parse — Figma-style surfaces draw controls as pixels.
The settle wait is bounded, not semantic —
from_page/zerodom_read_pagewait for the DOM to go quiet (≤1200 ms, see 0.1.3), which covers hydration and late node injection, but not an arbitrary app condition (a specific element, a network response). For that, wait on your own condition first, or passsettle=Falseto read exactly as-of-now.zerodom <url>is a static fetch (no JS) — use--renderor the relay/MCP path for JS-rendered pages. Iframes are opt-in (--frames).The extension is unpacked/dev-mode only —
chrome.debugger+ a local WebSocket preclude a Web Store listing (like Playwright's own CDP relay).--stealthis POSIX-only. The MCP server drives multiple real Chrome profiles — one per relay (zerodom relay --port 8766), switched withzerodom_switch_profile— so two or three logged-in accounts can be driven side by side, each its own cookie jar and fingerprint. Within a profile, multi-tab is supported. Concurrent cross-identity requests (for cross-user races) are available only through the request-level identities (compare_identitiesfires independent profiles together); interactive driving is one active profile at a time, switched on demand.
Editions
ZeroDOM is open core. Everything in this repo — parser, CLI, relay, stealth, scan/crawl/compare/audit, the clearance ladder and the MCP server — is the free, Apache-2.0 Core, complete on its own: one operator does the whole job locally, no account, no key.
Core (Apache-2.0) | Enterprise (commercial) | |
Parse · relay · stealth · scan · crawl · compare · audit · MCP | ✅ | ✅ |
Clearance ladder (incl. opt-in solvers) · scope lock | ✅ | ✅ |
Runs fully local · zero-egress · no account | ✅ | ✅ |
Team fleet: many targets/agents, shared findings store, dashboard | — | ✅ |
Compliance export packs (SOC 2 / PCI / OWASP-ASVS-mapped) | — | ✅ |
Org-wide scope policy · SSO/RBAC · audit log | — | ✅ |
Parallel/scheduled runs · curated rule-pack library | — | ✅ |
Priority support · SLA · indemnification | — | ✅ |
The promise: the Core will always be open-source and run fully local with zero egress and no account — that's the product, not a trial. Enterprise is an additive team layer; it never gates, phones home from, or adds telemetry to the Core.
Enterprise features, support contracts and indemnification: contact@vexralabs.com (on the roadmap — reach out to shape it or become a design partner).
Contributing & development
uv sync && uv run playwright install chromium && uv run pytest
cd js && npm install && npm test # the TypeScript port's suiteMost useful thing to contribute: a page where a selector resolves to the wrong element.
Open an issue with the URL and the output of zerodom <url> --html report.html. Contributions
are under the Developer Certificate of Origin (Signed-off-by). Come say hi
in Discord.
License
Apache 2.0 — see LICENSE. Use it anywhere, including commercially; embed it in your own product. ZeroDOM is a trademark of Vexra Labs; the trademark and the Enterprise features are not covered by the Apache grant.
Available Tools
40 toolszerodom_add_identityA
Register a second identity (e.g. user B) for cross-tenant IDOR testing.
Source of the session (pick one):
endpoint— a SECOND real Chrome profile, already logged in as B, reached over its own relay:endpoint="ws://127.0.0.1:8766/cdp/local". Each request leaves through that profile's real Chrome (real fingerprint, its own live login) — no snapshot, no re-login, no blank browser. Set it up once:zerodom relay --port 8766, load the extension in profile B and click Connect (it auto-finds a free port — no URL to paste), log in. The port it lands on shows in that profile's popup; pass its/cdp/endpoint here. Its active tab must be on the target origin (same-origin, like 'live'). Best for a WAF target where two real profiles beat cookie-swap.from_live=True— snapshot the CURRENT logged-in tab's cookies. Log in as B, call this, then log the tab back into A. No file to manage.storage_state— a Playwright storage_state JSON file (cookies + origins).neither — anonymous (only useful with
headerfor token auth).
header adds one extra request header ('Authorization: Bearer …'); call
again to add more. The current logged-in session is always available as
identity 'live' without registering.
via picks the transport:
"auto" (default) — if a browser is attached, send with the REAL Chrome fingerprint by swapping this identity's cookies into the live tab per request (passes a fingerprinting WAF like DataDome); else Playwright's HTTP client.
"live" — force the real-fingerprint swap path.
"http" — force Playwright's APIRequestContext (cookies yes, Chrome's TLS fingerprint no). For CI/headless, or a cross-origin URL the in-page fetch can't reach (no CORS).
Once two identities exist, zerodom_compare_identities(url) fetches the same URL as each and flags a byte-identical response — the cross-tenant IDOR tell.
Inputs: name (required), via, header, endpoint, +2 more. Returns: result
zerodom_adopt_groupB
Hand an existing Chrome tab group (that you created yourself, by title) to the agent: it joins the agent's sandbox and becomes the active group. Lets you pre-arrange tabs and then scope the agent to exactly them.
Inputs: name (required). Returns: result
zerodom_click_nodeA
Click a node and return what changed on the page.
Returns a diff — + appeared, - gone, ~ value changed — because most
clicks alter a handful of nodes and re-listing the page would cost hundreds.
A navigation renumbers everything, so that returns the full graph instead.
A same-page click reporting "no structural change" shortly after navigation is ambiguous — could be a real no-op, could be a server- rendered control (Next.js/Remix/Nuxt) whose framework hasn't finished attaching its handler yet. Flagged, not retried automatically: a false retry risks a real double-submit on a control that did fire. Suppressed when the click triggered a network request even without a DOM change yet — an in-flight fetch/GraphQL mutation (auth actions routinely take 800ms-2s to resolve) is itself evidence the handler did fire, just hasn't finished.
Inputs: node_id (required). Returns: result
zerodom_close_groupB
Close an agent group: ungroup its tabs and forget it. If it was the last one, the sandbox turns off (the agent can drive any tab again).
Inputs: name (required). Returns: result
zerodom_close_tabA
Close a tab — the active one by default. Refuses to close the last tab.
Inputs: tab_id. Returns: result
zerodom_compare_identitiesA
Fetch one URL as each identity and diff — the cross-tenant IDOR check.
Sends method url through every identity in identities (default: the
live session plus every registered one) and reports each response's status
and size. A byte-identical response under two identities on a per-user
resource is a cross-tenant IDOR. The live identity leaves through Chrome's
own network stack (in-page fetch), so a fingerprinting WAF sees your real
browser there; registered identities go through Playwright's HTTP client —
cookies included, Chrome's TLS fingerprint not.
Inputs: url (required), body, method, identities. Returns: result
zerodom_crawlA
BFS-walk an app's in-scope routes and return one JSONL record per page:
final URL, forms, in-scope links, the XHR/fetch API calls it fired, hidden
fields, and blocked when the route is a challenge interstitial.
Recon, not action: it navigates and reads, never clicks or submits. A link
matching deny (logout/delete/… default) is never followed; a blocked route
is recorded but not descended into; session scope (zerodom_set_scope) is
enforced per navigated URL, including its max_rps rate limit. Runs in the
active tab, so on an attached session the walk resolves authenticated routes
the way the human's own Chrome does (CLI: zerodom crawl --relay).
scope adds extra in-scope hosts (comma-separated, beside the start URL's
host); deny overrides the link-follow regex. The crawl leaves the active
tab on the last crawled page and re-reads the graph to match — call
zerodom_read_page to see it.
Inputs: url (required), deny, scope, max_pages. Returns: result
zerodom_create_groupA
Create a named, colored tab group the agent is sandboxed to, and make it the target for new tabs. Persists across a browser restart (stored by the extension).
Once any agent group exists the agent may ONLY drive tabs inside its groups —
attaching to any other tab is refused. color is a Chrome tab-group color:
grey, blue, red, yellow, green, pink, purple, cyan or orange. Relay mode only
(the extension drives your real Chrome).
Inputs: name (required), color. Returns: result
zerodom_dragA
Drag source onto target and return what changed.
Drag-to-reorder lists, drag-and-drop upload zones, sliders — anything a click/fill pair can't express because the gesture itself is the input.
Inputs: source_node_id (required), target_node_id (required). Returns: result
zerodom_eval_jsA
Run arbitrary JavaScript in the active tab's real page context and return the result — Runtime.evaluate over the same chrome.debugger connection everything else here uses, the same power as typing into DevTools' own console.
Inputs: code (required). Returns: result
zerodom_fill_nodeA
Type text into a node and return what changed on the page.
The text is echoed back in the first line; the diff below it reports structural change — a validation error appearing, an autocomplete list opening.
Inputs: text (required), node_id (required). Returns: result
zerodom_findA
Search the current page's graph for nodes matching query.
Case-insensitive substring match over each node's label and type. Prefer this over re-reading the whole page when you already know what you are looking for: "checkout" costs three lines, the full graph costs every node on the page.
Inputs: query (required). Returns: result
zerodom_get_cookiesA
List cookies visible to the active tab's origin.
Reads via CDP's Network domain (Playwright's context.cookies()), which sees httpOnly cookies too — unlike a content script's document.cookie, which httpOnly exists specifically to hide them from.
Inputs: no named parameters. Returns: result
zerodom_get_storageA
List localStorage and sessionStorage keys the active tab's page holds.
Session state that never touches the network — an issued draft id, a collapsed sidebar preference, a half-typed form — lives here. Same trust boundary as zerodom_eval_js (page context), but purpose-built and read-only, so it returns keys + values without the power of the eval tool. Values that look like a JWT (three base64url segments) get their claims (sub/role/exp/iss/aud) decoded into a second line.
Inputs: no named parameters. Returns: result
zerodom_get_stylesA
Computed styles and box-model dimensions for a node — for design/CSS review, not just interaction.
Runs getComputedStyle() in the real page over the same chrome.debugger connection everything else here uses (also reachable ad hoc via zerodom_eval_js; this is the purpose-built version with a curated property list instead of getComputedStyle()'s full ~300-property dump).
Inputs: node_id (required). Returns: result
zerodom_hoverA
Hover over a node and return what changed on the page.
Reveals hover-triggered menus and tooltips — content that a click alone would never surface, and that isn't in the graph until this fires.
Inputs: node_id (required). Returns: result
zerodom_list_groupsA
List the agent's named tab groups (its sandbox), as remembered across restarts. No groups → the sandbox is off and the agent can drive any tab.
Inputs: no named parameters. Returns: result
zerodom_list_tabsA
List every open tab, marking the active one with *.
Inputs: no named parameters. Returns: result
zerodom_network_logA
Requests/responses the active tab has made since it opened (or since this was last called with clear=True) — method or status, and URL.
Passive visibility only, capped at the most recent 200 entries — not interception or modification of traffic (that needs page.route(), a bigger, stateful feature; zerodom_eval_js can already override window.fetch/XMLHttpRequest from the page side for ad hoc cases).
Inputs: clear. Returns: result
zerodom_new_tabA
Open a new tab and make it the active one — every other tool (read, click, fill, scroll) then acts on it until you zerodom_switch_tab away.
In an attached (real-browser) session the new tab lands in the same "zerodom" tab group as every other tab this session touches.
Inputs: url. Returns: result
zerodom_parse_urlA
Navigate to a URL and return its interaction graph.
Returns the compact text graph: [03] button 'Sign In'. CSS selectors are
kept server-side and resolved by node id, so they never cost context — pass
verbose=True for the full JSON including selectors. Nodes sharing a
repeated-list-item ancestor (<article>/<li>/<tr>, e.g. a feed or
Hacker-News-style table) are grouped under @card "title": whenever a
card holds 2+ controls — twenty identical button 'Upvote' lines are
meaningless without knowing which story each belongs to.
Set frames=True when the controls you need are inside an iframe — embedded editors, payment fields, consent gates. Off by default because it costs a read per frame and most frames on a commercial page are advertising.
Set viewport_only=True on long feed/infinite-scroll pages (a social feed,
a video site's homepage) where most of the graph is scrolled off-screen
and you only need what's currently visible — this can cut node count by
more than half on pages like that. On by default for interactive agents;
costs a getBoundingClientRect() per element. Sticks for the rest of this
session (every click/fill re-read honors it too) until the next
zerodom_parse_url call changes it — same lifetime as frames. When nodes
are being skipped, the graph's first line says how many; scroll and re-read
to see them.
Set check_occlusion=True when clicks keep failing with Playwright's
"element intercepts pointer events" — a modal backdrop, an open dropdown,
or a cookie banner is covering nodes that are still in the DOM and still
listed. This filters them out at parse time instead of at click time,
same sticky-for-the-session lifetime as viewport_only. Off by default:
the cost of an elementFromPoint() hit-test per node on a large page is
unmeasured, so it isn't imposed on every caller by default.
Inputs: url (required), frames, verbose, viewport_only, +1 more. Returns: result
zerodom_press_keyA
Press a key while a node is focused and return what changed.
key uses Playwright's key names ("Enter", "Escape", "Tab", "ArrowDown", ...). For "press Enter to submit" forms, "Escape to close a modal", and keyboard-only widgets a click/fill can't drive.
Inputs: key (required), node_id (required). Returns: result
zerodom_probeA
Replay an endpoint with a tampered body over the active session and diff vs
baseline — the mass-assignment / tampering check. tamper (JSON) is merged over
body; an injected field accepted (2xx) and reflected in the tampered response
but absent from baseline is flagged. Returns baseline/tampered responses and any
finding.
Inputs: url (required), tamper (required), body, method. Returns: result
zerodom_raceA
Fire a concurrent burst over the active session — the TOCTOU probe, run as
the browser's own multiplexed fetch (the tightest client-side engine). bodies
is one or more request bodies, each fired n times and interleaved (a mix of
operations on one record widens a read-modify-write window); setup is a list
of prep requests [{url|path, method?, body?}]; check is a URL GET-ed after the
burst. Returns the status spread, per-body breakdown, and a race-condition
finding when a single-use action over-applies.
Inputs: url (required), n, check, setup, +2 more. Returns: result
zerodom_read_pageA
Re-read the current page without navigating.
Use after an action changed the page, or when node ids look stale. Unlike zerodom_parse_url this does not reload, so anything typed into the page stays. Honors whatever frames/viewport_only/check_occlusion zerodom_parse_url last set.
Inputs: verbose. Returns: result
zerodom_repeatB
Send one request over the active authenticated session (in-page fetch) and return {status, body} — the Repeater for crafting or verifying a request by hand, e.g. replaying a crawl-discovered POST with a tweaked body.
Inputs: url (required), body, method. Returns: result
zerodom_replayA
Replay an HTTP request under a chosen identity — Burp Repeater for the agent.
Sends method url (with optional body and one extra header 'K: V')
through as_identity (default the live logged-in session). Returns the
response status, size and a body preview. Use it to probe an endpoint,
tamper with a request, or check an object reference — then change the id/body
and replay again. Pair with zerodom_compare_identities for the A-vs-B diff.
Inputs: url (required), body, header, method, +1 more. Returns: result
zerodom_resize_windowA
Resize the real browser window (not just the page's viewport).
chrome.debugger's CDP surface has no browser-level window-management grant, but chrome.windows.update is a plain extension API, entirely unrelated to chrome.debugger — so this genuinely works despite that. Sent as Browser.setWindowBounds (a real CDP method name Playwright's own driver will actually transmit — a made-up method name gets rejected client-side before reaching the relay at all) and repurposed server-side; see docs/DECISIONS.md D16. Only meaningful for an attached (real-browser) session; a launched headless session has no window to resize.
On a tiling window manager (i3/sway/Hyprland/bspwm-style setups), this call succeeds but the window won't visibly move or resize — on Wayland compositors specifically this isn't a WM being uncooperative, it's the protocol itself: clients are deliberately not allowed to force their own geometry. Works normally on a floating window. Confirmed live on Hyprland.
Inputs: width (required), height (required). Returns: result
zerodom_restore_groupsA
Reopen the remembered tabs of every agent group (best-effort) after a browser restart, re-grouping them under their saved name and color. A tab whose URL now hits a login wall or is otherwise unreachable is skipped, not fatal.
Inputs: no named parameters. Returns: result
zerodom_scanA
Run zerodom's surface rules over the ACTIVE page and return findings as
JSONL: the interaction-graph rules, DOM-XSS sinks and the callable API surface
(method + body shape) read from the page's same-origin JS (js=True), and
CSP/CORS response-header posture. Recon over the page you are on — navigate
first with zerodom_parse_url. (Cookie-flag and CSRF correlation are CLI
zerodom scan only: a page cannot read its own Set-Cookie header.)
Inputs: js. Returns: result
zerodom_screenshotA
Full-page screenshot of the active tab, saved to disk; returns the path.
report.py has a screenshot path already, but it's wired to the CLI's own
throwaway sync browser (playwright_wrapper.py's sync/async split), not
this attached async session — this is that same capability for here.
Pass path to choose where it's saved; omitted, a temp file is used.
Inputs: path. Returns: result
zerodom_scrollA
Scroll the page and return what's newly visible.
direction: "up" or "down". amount: pixels, roughly one screenful is 800.
Dispatches a real wheel event at the viewport center rather than
window.scrollBy, so it scrolls whatever scrollable container is actually
under the cursor — a nested feed/sidebar, not just the document body,
matching what a real scroll gesture would do.
Inputs: amount, direction. Returns: result
zerodom_set_scopeA
Constrain the hunt to authorized targets — enforced in code, not on trust.
hosts: comma-separated in-scope host globs (app.example.com,*.example.com).
Navigation, replay and clicks to any other host are then refused. deny: a
regex of destructive URLs/labels to refuse (default covers logout/delete/
remove/deactivate/revoke) so an unattended agent can't take an irreversible
action. max_rps: throttle to at most N requests/second (program rate limits).
An operator can instead lock scope before the agent starts by setting the ZERODOM_SCOPE env var to a YAML file; a locked scope can't be widened here.
Inputs: hosts (required), deny, max_rps. Returns: result
zerodom_set_viewportA
Resize the active tab's viewport for responsive-design testing.
Not the real browser window — that's zerodom_resize_window. This is Emulation.setDeviceMetricsOverride: the page's own rendered layout at a given width, without touching the chrome around it. Use this one for "how does this render at width X"; use zerodom_resize_window for an actually different-sized window on screen.
Inputs: width (required), height (required). Returns: result
zerodom_statusA
Diagnose the current connection: relay reachability, whether a browser session is attached yet, which tab is active, and the tail of the relay's own log — the single-call version of the manual WebSocket-probing and log- tailing this project's own debugging needed before this tool existed.
Inputs: no named parameters. Returns: result
zerodom_switch_profileA
Drive a different Chrome profile — full interactive control, not just fetch.
Each profile is its own real Chrome (its own relay + login). After switching, EVERY tool (navigate, scroll, click, read, screenshot, …) drives THIS profile; switch back and the other is right where you left it. Use it to work two or three logged-in accounts side by side.
endpoint— register a new profile the first time: zerodom_switch_profile("B", endpoint="ws://127.0.0.1:8766/cdp/local"). Set up once:zerodom relay --port 8766, then click Connect in that profile's extension (it auto-finds a free port — no URL to type).name alone — switch to an already-registered profile. "default" is the original session (ZERODOM_CDP_ENDPOINT / port 8765).
Inputs: name (required), endpoint. Returns: result
zerodom_switch_tabA
Make another open tab active and return its interaction graph.
Node ids are per-tab, so re-read (this returns the graph already) before clicking or filling anything on the tab you just switched to.
Inputs: tab_id (required). Returns: result
zerodom_upload_fileA
Set a file input's value to a local file path and return what changed.
path is resolved on the machine driving the browser — the same trust boundary as zerodom_eval_js, not a new one.
Inputs: path (required), node_id (required). Returns: result
zerodom_use_groupA
Make name the active group — subsequent new tabs join it.
Inputs: name (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 40 tools
Most tools are clearly scoped (read vs parse vs find, set_viewport vs resize_window, get_cookies vs get_storage), and descriptions explicitly disambiguate the tricky pairs. But the request-sending cluster — zerodom_repeat, zerodom_replay, zerodom_probe, zerodom_race, zerodom_compare_identities — overlaps heavily in purpose, as do the six group-management tools and the recon pair crawl/scan. An agent must read carefully to pick the right one rather than inferring it from the name.
Everything is snake_case under a uniform zerodom_ prefix, and most names follow verb_noun (parse_url, switch_tab, compare_identities, upload_file). A handful of bare nouns/single verbs break the pattern (status, screenshot, find, drag, hover, crawl, scan, probe, race), but they remain readable and few enough not to be confusing.
40 tools for a browser-automation-plus-security-testing surface is well past the point where an agent can hold the set in mind, and the descriptions themselves are enormous. Several families could be consolidated — the five request-replay tools, the six tab-group tools, and the parse/read/find trio are natural single tools with mode flags. Each tool is individually defensible, so it is over-scoped rather than arbitrary.
Coverage is unusually deep: navigation, interaction (click/fill/hover/drag/key/upload), inspection (styles, cookies, storage, hidden fields, network log), multi-identity, tab groups, and active security probes (IDOR, race, mass-assignment). Minor gaps remain — no history/back navigation, no form submit or <select> option tool, no cookie-setting/clearing or wait-for-network-idle primitive — but agents can work around these via eval_js.
Maintenance
Related MCP Connectors
Hosted browser for AI agents: screenshots, post-JS DOM, console, WCAG. No install, no API key.
Deterministic Zero-LLM Web Compiler, Scraper, Crawler, and Site Mapper for AI Agents.
Web scraping, browser automation, screenshots and AI data extraction for AI agents via MCP.
Official Browserless MCP server: browser automation, scraping, screenshots and PDFs for AI agents.
Related MCP Servers
AlicenseNot gradedqualityDmaintenanceAgent-native headless browser for AI agents. Converts web pages to a Semantic Object Model (SOM) instead of raw HTML — 17x average token reduction across real-world sites (up to 117x on complex pages). Native MCP server with fetch_page, extract_text, extract_links, and full browser automation. No API key required.50 npmApache 2.0- AlicenseCqualityCmaintenanceHosted Playwright browser automation for AI agents. Returns accessibility trees instead of screenshots, cutting token usage by 77%. Navigate, interact, extract structured data, and take screenshots — all via MCP. Zero infrastructure, credit-based pricing.6MIT
- AlicenseAqualityBmaintenanceGives AI agents a compact, semantic interface to the browser, returning structured page snapshots with stable element IDs instead of raw DOM. Enables agents to navigate, interact, and extract information from web pages efficiently.2613 npm19MIT
- AlicenseNot gradedqualityAmaintenanceAn MCP server that gives AI agents token-efficient, structured access to web pages, returning compact page orientations and targeted element queries instead of full accessibility-tree dumps, plus browser interaction, monitoring, and session management tools.4 npmMIT