Skip to main content
Glama

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.

PyPI npm License CI Claude MCP Discord

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 --js adds DOM-XSS sinks, the callable API surface and header posture; repeat / probe / race turn 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 gets 200, the other 401/403 on 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 report

That'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/cart

All 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

zerodom_parse_url(url, verbose=False, frames=False, viewport_only=False, check_occlusion=False)

navigate, return the compact graph; frames=True also reads same- and cross-origin iframes (auth portals, payment fields)

zerodom_read_page(verbose=False)

re-read the live DOM without navigating

zerodom_find(query)

return only the nodes matching a phrase

zerodom_click_node(node_id)

click, then return what changed — flags a same-page no-op shortly after navigation as a possible hydration miss

zerodom_fill_node(node_id, text)

type via real keystrokes — works in contenteditable editors (Notion, Slack, Discord, Jira)

zerodom_hover(node_id)

hover, revealing hover-triggered menus/tooltips

zerodom_press_key(node_id, key)

press a key on a focused node (Enter, Escape, Tab, …)

zerodom_upload_file(node_id, path)

set a file input's value to a local path

zerodom_drag(source_node_id, target_node_id)

drag one node onto another

zerodom_scroll(direction, amount=800)

scroll, return what's newly visible

zerodom_new_tab(url=None)

open a tab and make it active

zerodom_list_tabs()

list every open tab, marking the active one

zerodom_switch_tab(tab_id)

make another open tab active

zerodom_close_tab(tab_id=None)

close a tab (the active one by default)

zerodom_screenshot(path=None)

full-page screenshot of the active tab, saved to disk

zerodom_set_viewport(width, height)

resize the viewport for responsive-design testing

zerodom_resize_window(width, height)

resize the real browser window (not just the page viewport)

zerodom_get_styles(node_id)

curated computed styles + box model for a node — design/CSS review

zerodom_network_log(clear=False)

recent requests/responses the active tab has made

zerodom_status()

diagnose the connection: relay/extension reachability, active tab, recent relay log

zerodom_eval_js(code) ⚠️

run arbitrary JS in the real page, return the result

zerodom_get_cookies() ⚠️

list cookies for the active tab, including httpOnly ones

zerodom_get_storage()

list the localStorage / sessionStorage keys the active page holds

zerodom_hidden_fields()

list the page's <input type="hidden"> fields (CSRF tokens, per-view payload)

zerodom_crawl(url, max_pages=10, scope=None, deny=None)

BFS-walk in-scope routes; one JSONL record per page (forms, links, fired API calls, and js_endpoints — the callable surface read from the page's JS)

zerodom_scan(js=True)

surface rules over the active page: DOM-XSS sinks + callable API surface from its JS, plus CSP/CORS header posture

zerodom_repeat(url, method="GET", body=None)

send one request over the active session (in-page fetch) — a Repeater returning {status, body}

zerodom_probe(url, tamper, body=None, method="POST")

replay with a tampered body and diff vs baseline — mass-assignment / tampering

zerodom_race(url, bodies=None, n=20, method="POST", setup=None, check=None)

concurrent burst over the active session (browser multiplex) to flag a check-then-act race (TOCTOU)

zerodom_set_scope(hosts, deny=None, max_rps=None)

constrain the hunt to authorized hosts — enforced in code, not on trust

zerodom_add_identity(name, storage_state=None, header=None, from_live=False, via="auto", endpoint=None)

register a second identity (e.g. user B) for cross-tenant testing. from_live snapshots the current login; via="live" sends with the real Chrome fingerprint (cookie-swap) to pass a fingerprinting WAF like DataDome; endpoint binds a second real Chrome profile (its own relay) as the identity

zerodom_switch_profile(name, endpoint=None)

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. "default" is the original session; endpoint="ws://127.0.0.1:8766/cdp/local" registers another

zerodom_replay(url, method="GET", body=None, header=None, as_identity=None)

replay a request under a chosen identity — Burp Repeater for the agent

zerodom_compare_identities(url, method="GET", body=None, identities=None)

fetch one URL as each identity and diff — flags identical responses and 2xx-vs-401/403 splits

zerodom_create_group(name, color="cyan")

create a named, colored tab group the agent is sandboxed to; persists across a browser restart

zerodom_list_groups()

list the agent's groups (no groups = sandbox off)

zerodom_use_group(name)

make a group the target for new tabs

zerodom_close_group(name)

ungroup its tabs and forget it; closing the last one turns the sandbox off

zerodom_adopt_group(name)

hand a tab group you arranged yourself (by title) to the agent

zerodom_restore_groups()

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 aria_snapshot(mode="ai")

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 line

Map 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 Chrome

Attack-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 report

Check 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

✅ compare / sweep

✅ (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 (subfinder→httpx→…)

✅ 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 relay

Each 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 picked
import { 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_page wait 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 pass settle=False to read exactly as-of-now.

  • zerodom <url> is a static fetch (no JS) — use --render or 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).

  • --stealth is POSIX-only. The MCP server drives multiple real Chrome profiles — one per relay (zerodom relay --port 8766), switched with zerodom_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_identities fires 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 suite

Most 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 tools
zerodom_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 header for 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_hidden_fieldsA

List hidden <input type="hidden"> fields on the current page.

Hidden inputs are deliberately NOT graph nodes — an agent acting on a page has no reason to click them, so listing them as nodes would be noise. But they carry the payload a form submission needs (CSRF tokens, per-view state like a draft id or a sort order), which is exactly what an agent re-submitting a POST after a stale parse is missing. Returns each field's name, value and CSS selector, so the values can be fed straight into a zerodom_fill_node call if the target form expects them.

Inputs: no named parameters. 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

    A3.6/5.0

    Scored across 40 tools

    Disambiguation3/5

    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.

    Naming Consistency4/5

    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.

    Tool Count2/5

    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.

    Completeness4/5

    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

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Agent-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 npm
      Apache 2.0
    • A
      license
      C
      quality
      C
      maintenance
      Hosted 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.
      6
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Gives 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.
      26
      13 npm
      19
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      An 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 npm
      MIT