🌏 中文版
Tool Info
| Item | Value |
|---|---|
| Name | turbo-browser-mcp |
| Type | MCP server |
| GitHub | Tthanh2k6/turbo-browser-mcp |
| Stars | 101 (at time of writing; repo created 2026-11-14) |
| Language | JavaScript (Node.js, single dependency: playwright-core) |
| License | MIT |
| Install | npx -y turbo-browser-mcp (requires Node ≥ 20) |
What Problem It Solves
Have you noticed how filling out one form with a browser agent can burn through a dozen tool calls? The standard pattern: snapshot the full ARIA tree, then fill one field at a time, select_option for dropdowns, a separate round for file uploads — and every single round resends the growing conversation history back to the model. A benchmark against a 10-field form took 11 turns and replayed over 70,000 tokens cumulatively, most of it the same barely-changed DOM tree being restated over and over.
turbo-browser-mcp's answer is to collapse @playwright/mcp's 25 fine-grained tools (browser_click, browser_type, browser_select_option, and so on) and chrome-devtools-mcp's 33 tools into 10 batched ones. inspect_compact returns a trimmed list of interactive elements by default, and with onlyChanged: true it returns only what changed since the last snapshot instead of rescanning the whole tree. smart_fill_form takes an entire list of fields at once — React-controlled inputs, Shadow DOM, fields inside iframes, contenteditable editors — fills them in one call, and validates the result in the same response. File uploads take a disk path directly, so a PDF never gets Base64-encoded into context. The README's own tiktoken-measured benchmark: the same 10-field form drops from 11 turns and 72,614 cumulative tokens to 1 turn and 811 tokens.
Just as important is the built-in human-in-the-loop submit guard: allowSubmit defaults to false, so anything that looks like a Submit, Publish, Send, or payment button gets blocked unless you explicitly pass allowSubmit: true. It's a good fit for agents that need to operate on web pages frequently and in many steps — scraping, automated testing, form-filling agents — especially when context window size or token cost is the bottleneck. It also suits workflows where an agent should fill out a form but a human needs to approve the actual submission.
Turn counts and token counts come from the README benchmark (10-field form, measured with tiktoken o200k_base); the call stages shown here are simplified.
Quick Start
Install
# Option 1: run directly with npx (fastest)
npx -y turbo-browser-mcp
# Option 2: local clone, with an environment check
git clone https://github.com/Tthanh2k6/turbo-browser-mcp.git
cd turbo-browser-mcp
npm install
npm run doctor # prints Node / Playwright / Chromium / CDP diagnostics
# If no Chrome/Edge/Brave is installed, grab Playwright's bundled Chromium
npx playwright-core install chromium
MCP client config (same shape for Claude Code, Cursor, and Codex):
{
"mcpServers": {
"turbo-browser": {
"command": "npx",
"args": ["-y", "turbo-browser-mcp"]
}
}
}
Basic Usage
You: Open example.com/signup and fill out the registration form with this
data, but don't submit it yet.
What the agent actually calls:
1. tabs_batch { operations: [{ op: "open", url: "https://example.com/signup" }] }
2. inspect_compact { mode: "forms" } → form elements only, ~1,000 tokens
3. smart_fill_form { fields: [...10 fields...], returnSnapshot: true }
→ fills text fields, dropdowns, and checkboxes in one call, returns the
filled-in snapshot for confirmation
4. Submitting for real requires passing allowSubmit: true — otherwise
clicking Submit gets blocked
Advanced Usage
// Turn off image/media loading before scraping a page — saves bandwidth
// and cuts the diagnostics noise that comes with unrelated requests
{
"name": "network_session",
"arguments": { "preset": "turbo" }
}
// Hand off to a human when a login or bot check blocks the flow; the agent
// resumes in the same tab once the condition is met
{
"name": "wait_for_human",
"arguments": {
"message": "Please finish logging in or pass the verification, then leave the window open.",
"selector": "#account-menu",
"timeoutMs": 120000
}
}
Comparison with Existing Tools
| turbo-browser-mcp | @playwright/mcp | chrome-devtools-mcp | |
|---|---|---|---|
| Tool count | 10 (batched) | 25 (fine-grained) | 33 (fine-grained) |
| Delta snapshots (only changed elements) | ✅ | ❌ (full ARIA tree every time) | ❌ |
| Fill an entire form in one call (React/Shadow DOM/iframe) | ✅ | ❌ (needs multiple calls) | Basic fill_form only |
| File upload without Base64 (direct disk path) | ✅ | Needs a separate browser_file_upload call | Needs a separate upload_file call |
| Default human-in-the-loop submit guard | ✅ | ❌ | ❌ |
| Lighthouse / performance tracing / heap snapshots | ❌ | ❌ | ✅ |
Caveats
- Still a new project. The repo was created on 2026-11-14 and has 101 stars. It does have CI (400+ tests across Node 20/22), but a low issue count doesn't mean there are no edge cases — test it yourself before wiring it into anything that touches real money or real data.
- The submit guard isn't an anti-detection mechanism. The README is explicit that it does no stealth, doesn't patch
navigator.webdriver, and doesn't solve CAPTCHAs. For sites that detect automation, use--open-profileto let a human log in or pass verification in a normal Chrome window first, then have the agent take over the same browser profile. - The network submit guard is off by default.
TURBO_BROWSER_NETWORK_GUARDdefaults tofalsebecause multi-step wizards often POST on every "Next" click; turning it on without checking your flow first can block normal navigation.
Today's Takeaway
I used to think MCP tools should be sliced as finely as possible, so an agent could call exactly what it needed. turbo-browser-mcp's benchmark makes the opposite case: the real cost of a tool call isn't just the tokens in that one call — it's that every round trip resends the entire conversation history. Ten rounds means ten history replays, and that adds up to far more than the output tokens of a single round. Batching actions that naturally happen together — filling every field in a form, opening several tabs — trades away call-by-call flexibility for savings that scale with the number of rounds. It's a useful check for anyone designing an agent's tool surface: ask whether a group of actions usually happens together before assuming every low-level operation deserves its own tool.