M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
Z

ZeroToken

Community
Record once, automate forever. Lightweight MCP for AI agent browser automation with trajectory recording and low-token script replay.
How to install ↓ Compare GitHub source repository ↗
Category
Browser #15 of 32
Stars
★ 453 Popular
Transport
stdio (local process) · Streamable HTTP
Runtime
Python · Prebuilt binary
Credentials
No credential needed
License
MIT
Last commit
Tools
33
54FMRS · D

ZeroToken is an MIT-licensed, community-maintained lightweight browser automation MCP engine built around record-once, replay-forever: trajectory recording plus deterministic script replay cuts token usage on repetitive tasks. It offers 26 browser_* primitives, multi-tab and iframe management, SmartSelector/SmartWait/ErrorRecovery stability layers, adaptive element fingerprint re-location, an exploration recording mode, SQLite persistence, and both stdio and Streamable HTTP transports. OpenClaw users must use HTTP mode to keep browser state, and must install Playwright Chromium themselves. It is not an official product and carries no commercial support; users are responsible for target-site terms and local data security.

Strongest · Documentation 13/20 Weakest · Security and permissions 8/20

Reliability
10/20
Security and permissions
8/20
Maintenance
12/20
Documentation
13/20
Setup experience
11/20
Why each score
Reliability 10/20
server.json declares version 2.0.0 while both packages pin pypi identifier zerotoken at 0.2.0 with no integrity/hash fields — a verifiable, self-contradictory manifest that caps trust in the declared artifact. The README describes a coherent happy path: dual stdio + Streamable HTTP transports, a five-layer architecture, 26 browser_* tools, a Script Engine with flow control, and pause/resolution Step-as-Unit handling with structured code/retryable errors. However, the supplied material contains no CI workflow files and no test sources — only a CI badge and a tests/ directory claim — so there is no verifiable execution evidence. Per the static calibration rule, reliability is capped at 12 without real CI plus committed tests covering key paths; the manifest/version contradiction and the documented Browser-state-loss failure mode (process per call under stdio) push it down to 10.
Security and permissions 8/20
No red line is triggered: no malware, no credential theft, no covert exfiltration, no unconfirmed destructive defaults, and no real tokens in examples (the username/password are placeholders). Deductions come from incomplete security disclosure: browser_init(stealth=true) explicitly provides fingerprint spoofing and anti-bot evasion with no stated usage boundary or authorization caveat; browser_evaluate permits arbitrary in-page JS and click/input/upload/download carry real side effects with no confirmation model described; the HTTP mode defaults to binding 0.0.0.0:8000/mcp and the sample client config uses a bare URL with no auth or token. There is also no disclosure of least privilege, what data is persisted (base64 screenshots, page state, SQLite zerotoken.db) or retention. Main risks are visible but scoping, confirmation and data-flow disclosure are all incomplete.
Maintenance 12/20
Positive signals: MIT license, semantic versioning, a CONTRIBUTING.md reference, a CI badge, PyPI and download badges, and a community channel (QQ group) — indicating a real release path with clear repository ownership. Deductions: the static material contains no commit history, release cadence, issue-response record, dependency-update automation, or security-response policy; the 454 stars / 0 open issues are discovery signals only and add nothing per the evidence rules. The manifest-vs-PyPI version mismatch is itself a versioning governance gap. Assessed as active but with governance and version-consistency gaps.
Documentation 13/20
Documentation is layered and substantial: install (pip/uv plus playwright install chromium), both transports, a five-step OpenClaw onboarding flow, a Cursor config example, tool-call walkthroughs for browser_*/trajectory_*/script_*, the OperationRecord and fuzzy_point JSON structure, a five-layer architecture diagram with Mermaid, a project tree, a Python API snippet, and a troubleshooting FAQ (browser state loss, connection failure). Gaps: no full parameter schema, defaults, timeouts or response-field reference for the 26+ tools; token cost and session-data retention — the project's core selling point — are never quantified; stealth and browser_evaluate capability limits and compliance risk are unaddressed; implicit assumptions such as iframe/tab nesting depth limits and SQLite concurrency are undisclosed; and the docs contradict themselves on version. Usable but with hidden assumptions and troubleshooting gaps.
Setup experience 11/20
The install path is reasonably clear: pip install zerotoken or uv sync, followed by a mandatory playwright install chromium, with two entry points — zerotoken-mcp (stdio) and zerotoken-mcp-http (HTTP, default 0.0.0.0:8000/mcp, configurable via --port or ZEROTOKEN_HTTP_PORT) — plus concrete openclaw.json and Cursor client configuration examples. It is nonetheless manual and fragile: HTTP mode requires the user to keep a foreground process permanently running with no systemd, container or daemon option; the OpenClaw path adds an npm mcporter install, a separate Skill install, and a client-side enablement step; Playwright browser download is an extra platform-dependent dependency; and there is no per-OS (macOS/Linux/Windows) guidance, no stated Python version requirement, and no minimal connectivity self-check. Capped at 15 by the static calibration; scored 11 given this fragility.

Static review · not runListed 2026-09-10

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesWrites / deletes local filesUses the networkControls a browserConnects to a database

Best for

  • Record-once, run-forever scheduled or repetitive tasks such as daily logins and timed scraping
  • Agent setups that want lower token cost instead of step-by-step LLM reasoning on every run
  • Projects needing rich browser primitives: multi-tab, iframes, file upload/download, drag and drop
  • Automation flows that need element fingerprints and adaptive re-location to survive site redesigns

Not for

  • Environments that cannot run Playwright/Chromium or install a browser
  • Clients that rely only on stdio while needing browser state across calls (the README states command mode spawns a new process per tool call, destroying the browser instance)
  • Production-critical systems requiring official commercial support or an SLA
  • Setups that do not accept local SQLite persistence of trajectories, screenshots and sessions

Required permissions

  • Local filesystem read/write (SQLite database zerotoken.db, upload and download paths)
  • Network access (target websites, Playwright/Chromium download)
  • Launch and control a local Chromium browser process
  • In OpenClaw, run a local HTTP service on a listening port (default 8000)

Risks and side effects

  • Scripts act as a real browser and perform clicks, typing, uploads and downloads, so mistakes can change data or submit forms unintentionally
  • Trajectories store page state and screenshots (base64 images may contain sensitive data) on disk in SQLite, creating privacy and credential-leak risk
  • Fingerprint masking via browser_init(stealth=true) may violate target sites' terms of service
  • Depends on target page structure: selector failure remains the main instability factor (60% per the README), so scripts may break after redesigns
  • HTTP mode listens on 0.0.0.0 by default and can be called by others if exposed to untrusted networks

Setup

Before you start

Runtime：Python · Prebuilt binary

Other optional settings (1)
ZEROTOKEN_HTTP_PORT optional Optional env var to set the listen port of the zerotoken-mcp-http service; defaults to 8000 when unset.
  1. Install: pip install zerotoken or uv add zerotoken
  2. Install the browser: playwright install chromium (required)
  3. For OpenClaw, run zerotoken-mcp-http in the background (defaults to http://0.0.0.0:8000/mcp; set the port with --port or ZEROTOKEN_HTTP_PORT)
  4. In ~/.openclaw/openclaw.json, configure zerotoken under mcpServers as url: "http://localhost:8000/mcp" — do not use command
  5. Install the zerotoken-openclaw Skill (clawhub install zerotoken-openclaw, or copy skills/zerotoken-openclaw)
  6. Enable the MCP server in OpenClaw and make sure the skill is loaded. Cursor and similar IDEs use stdio mode with command: "zerotoken-mcp" (or command: "uv", args: ["run", "zerotoken-mcp"]).
.cursor/mcp.json 
{
  "mcpServers": {
    "zerotoken": {
      "url": "http://localhost:8000/mcp"
    }
  }
}

Shown for Cursor. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "zerotoken": {
      "url": "http://localhost:8000/mcp"
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add --transport http zerotoken http://localhost:8000/mcp

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

Start zerotoken-mcp-http in the background and confirm it listens on http://localhost:8000/mcp; after connecting the client, tools such as browser_init, trajectory_start and script_run should appear in the tool list, and a successful browser_list_tabs call proves the connection works.

Troubleshooting

  1. Browser state lost, every action feels like the first: you are still in command (stdio) mode; make sure zerotoken-mcp-http runs in the background and openclaw.json configures zerotoken with url instead of command
  2. Connection failure / MCP unavailable: verify zerotoken-mcp-http is running on the expected port (default 8000) and the URL matches the config
  3. Browser will not start: run playwright install chromium
  4. Responses too large: pass include_screenshot: false to browser tools
  5. Too many records: inspect saved trajectories with trajectory_list and remove unneeded ones with trajectory_delete(task_id)
  6. Element lookup failures: pass auto_save: true for key elements to store fingerprints, then adaptive: true to re-locate after redesigns
  7. Repeated script failures: check script_health for success rate and use script_deprecate followed by script_restore if needed

Things to try

Once connected, you can ask your AI assistant things like:

  • Open https://example.com/login, fill in the username and password, click the login button, and record the trajectory
  • Convert the login_task trajectory into a replayable script and bind it to my scheduled job_id
  • List all saved trajectories in zerotoken
  • Run the script bound to job id daily-report to replay the recorded login flow

Tools 33

browser_init writes
Initialize the browser; pass stealth=true for stealth launch and fingerprint masking against anti-bot defenses
browser_open writes
Open a URL in the page
browser_click writes
Click a page element
browser_input writes
Type text into an input field
browser_hover writes
Hover the mouse over an element
browser_keyboard writes
Send a keyboard key combination (e.g. Control+S)
browser_scroll writes
Scroll the page by direction and amount
browser_drag_drop writes
Drag a source element onto a target element
Show 25 more tools
browser_upload writes
Upload a local file to a file-type input
browser_download writes
Trigger and complete a file download, returning the saved path
browser_evaluate read-only
Evaluate a JavaScript expression in the page
browser_new_tab writes
Open a new tab and return its tab_id
browser_list_tabs read-only
List all open tabs
browser_switch_tab writes
Switch to a given tab
browser_close_tab writes
Close a given tab
browser_enter_iframe writes
Enter the context of a given iframe
browser_exit_iframe writes
Exit the current iframe context
trajectory_start writes
Start recording an operation trajectory (task_id, goal)
trajectory_complete writes
Finish recording; with export_for_ai=true export an AI prompt that marks fuzzy points
trajectory_list read-only
List saved trajectories
trajectory_delete destructive
Delete a given trajectory to avoid accumulating too many records
trajectory_to_script writes
Convert the trajectory of a task_id into a replayable script
trajectory_explore_start writes
Start exploration recording mode to isolate AI trial-and-error paths from the real trajectory
trajectory_explore_stop writes
Stop exploration mode; keep can be none / last / all
script_generate writes
Generate a script from a trajectory
script_run writes
Deterministically replay a script, optionally with vars; failures or judgment points pause into a session
script_resume writes
Resume a paused script session with resolution retry / skip / patch / abort
script_health read-only
Check consecutive failures and success rate of a script
script_deprecate writes
Mark a script as deprecated (e.g. after a site redesign)
script_restore writes
Restore a deprecated script
script_bind writes
Bind an external job_id to a script, with optional default_vars
script_binding_set writes
Bind an OpenClaw job_id to a script task_id
run_script_by_job_id writes
Run a script in one step by binding key (job_id) with no step-by-step LLM reasoning

Use cases

AI agent browser automation (OpenClaw, LLM agents)
RPA replay of repetitive web operations
Scheduled web data scraping
Automated testing by recording and replaying test steps
Exporting trajectories as AI prompts for Skills or other modules to analyze

Supported clients

OpenClaw
Cursor

Listed from the project's documentation, not tested by this site.

Overview

ZeroToken is a lightweight browser automation MCP engine for AI agents. The agent drives the browser step by step in ReAct style through atomic MCP tools, while the system records a full trajectory (page state, screenshots, results, and fuzzy points). Trajectories can be exported as AI-friendly prompts or converted into deterministic replayable scripts, so repeated runs need no step-by-step LLM reasoning and consume far fewer tokens. It uses a five-layer architecture (Transport → Handler → Service → Domain → Repository/Infrastructure) with Pydantic v2 models, stores scripts, trajectories, sessions, fingerprints, bindings and runtime state in SQLite, and drives a real browser through Playwright/Chromium.

Similar servers

Compare with other MCP servers

Source revision e6cc92c36222 Data synced 2026-10-19 Read the FMRS scoring method