OpenChrome
by
Provides browser automation via a Model Context Protocol server that controls a real Chrome instance, enabling fast, parallel, authenticated interactions for AI agents.
OpenChrome Overview
What is OpenChrome about?
OpenChrome is a Model Context Protocol (MCP) server that lets AI agents drive a real Chrome browser. By sharing a single Chrome process among many workers, it delivers massive parallelism while keeping authentication state, cookies, and session data intact, eliminating the need for repetitive log‑ins and bypassing typical bot‑detection mechanisms.
How to use OpenChrome?
# Quick one‑line setup
npx openchrome-mcp setup
# Start the server (auto‑launches Chrome)
npx openchrome-mcp serve --auto-launch
For manual configuration with popular MCP clients, add the following to the client’s config file (VS Code example):
{
"mcpServers": {
"openchrome": {
"command": "npx",
"args": ["-y", "openchrome-mcp", "serve", "--auto-launch"]
}
}
}
Use the oc CLI alias in prompts to your AI agent, e.g., oc compare "AirPods Pro" prices across Amazon, eBay, Walmart.
Key Features of OpenChrome
- 20+ parallel workers on a single 300 MB Chrome process.
- Authenticated sessions persist across runs; no repeated log‑ins.
- Bot‑detection evasion by operating a real user‑profile Chrome.
- Hint engine watches tool calls, auto‑generates recovery rules, and reduces wasted LLM calls.
- 47 built‑in tools covering navigation, interaction, extraction, environment control, parallel workflow management, and memory utilities.
- DOM mode (and
ax/cssmodes) drastically cuts token usage for LLM‑driven tasks. - Stable selectors (
backendNodeId) avoid "ref not found" errors. - Cross‑platform support for macOS, Windows, and Linux (including CI‑friendly
--no‑sandbox). - Session persistence for headless mode via
--persist-storage.
Use Cases of OpenChrome
- Price/comparative monitoring across dozens of e‑commerce sites within seconds.
- Multi‑account dashboards: fetch data from personal & business accounts simultaneously.
- Competitive intelligence: scrape product listings, pricing, and stock status without triggering captchas.
- Debugging production UIs using real logged‑in sessions to reproduce user‑level issues.
- Parallel monitoring of SaaS dashboards (AWS, GCP, Stripe, Datadog) for ops alerts.
- AI‑driven research assistants that need live web data while staying within token budgets.
FAQ from OpenChrome
Q: Do I need Chrome installed?
A: Yes. OpenChrome launches the Chrome binary found on the system (or the path set in CHROME_PATH).
Q: Can I run it headless?
A: Use npx openchrome-mcp serve --headless-shell. Note that headless mode does not persist cookies unless --persist-storage is added.
Q: How does the hint engine work? A: It watches tool‑call patterns across six layers (error recovery, composite suggestions, etc.) and promotes frequent fix patterns to permanent rules, dramatically reducing LLM call volume.
Q: What platforms are supported?
A: Full support on macOS, Windows, and Linux. Linux requires --no-sandbox for CI environments.
Q: How many parallel workers can I run? A: Tested up to 50+ workers; performance scales linearly until Chrome or system resources become a bottleneck.
Q: How do I add OpenChrome to other MCP clients?
A: Provide an entry in the client’s mcpServers config with the npx command (see the example above).
Q: Is the tool open source? A: Yes, licensed under MIT.
OpenChrome's README
What is OpenChrome?
Imagine 20+ parallel Playwright sessions — but already logged in to everything, invisible to bot detection, and sharing one Chrome process at 300MB. That's OpenChrome.
Search across 20 sites simultaneously. Crawl authenticated dashboards in seconds. Debug production UIs with real user sessions. Connect to OpenClaw and give your AI agent browser superpowers across Telegram, Discord, or any chat platform.
You: oc compare "AirPods Pro" prices across Amazon, eBay, Walmart,
Best Buy, Target, Costco, B&H, Newegg — find the lowest
AI: [8 parallel workers, all sites simultaneously]
Best Buy: $179 ← lowest (sale)
Amazon: $189
Costco: $194 (members)
...
Time: 2.8s | All prices from live pages, already logged in.
| Traditional | OpenChrome | |
|---|---|---|
| 5-site task | ~250s (login each) | ~3s (parallel) |
| Memory | ~2.5 GB (5 browsers) | ~300 MB (1 Chrome) |
| Auth | Every time | Never |
| Bot detection | Flagged | Invisible |
Guided, Not Guessing
The bottleneck in browser automation isn't the browser — it's the LLM thinking between each step. Every tool call costs 5–15 seconds of inference time. When an AI agent guesses wrong, it doesn't just fail — it spends another 10 seconds thinking about why, then another 10 seconds trying something else.
Playwright agent checking prices on 5 sites:
Site 1: launch browser 3s
navigate 2s
⚡ bot detection LLM thinks... 12s → retry with UA
⚡ CAPTCHA LLM thinks... 10s → stuck, skip
navigate to login 2s
⚡ no session LLM thinks... 12s → fill credentials
2FA prompt LLM thinks... 10s → stuck
...
finally reaches product after ~20 LLM calls, ~4 minutes
× 5 sites, sequential = ~100 LLM calls, ~20 minutes, ~$2.00
Actual work: 5 calls. Wasted on wandering: 95 calls.
OpenChrome eliminates this entirely — your Chrome is already logged in, and the hint engine corrects mistakes before they cascade:
OpenChrome agent checking prices on 5 sites:
All 5 sites in parallel:
navigate (already authenticated) 1s
read prices 2s
⚡ stale ref on one site
└─ Hint: "Use read_page for fresh refs" ← no guessing
read_page → done 1s
= ~20 LLM calls, ~15 seconds, ~$0.40
The hint engine watches every tool call across 6 layers — error recovery, composite suggestions, repetition detection, sequence detection, learned patterns, and success guidance. When it sees the same error→recovery pattern 3+ times, it promotes it to a permanent rule across sessions.
| Playwright | OpenChrome | Savings | |
|---|---|---|---|
| LLM calls | ~100 | ~20 | 80% fewer |
| Wall time | ~20 min | ~15 sec | 80x faster |
| Token cost | ~$2.00 | ~$0.40 | 5x cheaper |
| Wasted calls | ~95% | ~0% |
Quick Start
npx openchrome-mcp setup
That's it. Say oc to your AI agent.
Claude Code:
claude mcp add openchrome -- npx -y openchrome-mcp serve --auto-launch
VS Code / Copilot (.vscode/mcp.json):
{
"servers": {
"openchrome": {
"type": "stdio",
"command": "npx",
"args": ["-y", "openchrome-mcp", "serve", "--auto-launch"]
}
}
}
Cursor / Windsurf / Other MCP clients:
{
"mcpServers": {
"openchrome": {
"command": "npx",
"args": ["-y", "openchrome-mcp", "serve", "--auto-launch"]
}
}
}
Examples
Parallel monitoring:
oc screenshot AWS billing, GCP console, Stripe, and Datadog — all at once
→ 4 workers, 3.1s, already authenticated everywhere
Multi-account:
oc check orders on personal and business Amazon accounts simultaneously
→ 2 workers, isolated sessions, same site different accounts
Competitive intelligence:
oc compare prices for "AirPods Pro" across Amazon, eBay, Walmart, Best Buy
→ 4 workers, 4 sites, 2.4s, works past bot detection
47 Tools
| Category | Tools |
|---|---|
| Navigate & Interact | navigate, click_element, fill_form, wait_and_click, find, computer |
| Read & Extract | read_page, page_content, javascript_tool, selector_query, xpath_query |
| Environment | emulate_device, geolocation, user_agent, network |
| Storage & Debug | cookies, storage, console_capture, performance_metrics, request_intercept |
| Parallel Workflows | workflow_init, workflow_collect, worker_create, batch_execute |
| Memory | memory_record, memory_query, memory_validate |
navigate computer read_page find click_element wait_and_click form_input fill_form javascript_tool page_reload page_content page_pdf wait_for user_agent geolocation emulate_device network selector_query xpath_query cookies storage console_capture performance_metrics request_intercept drag_drop file_upload http_auth worker_create worker_list worker_update worker_complete worker_delete tabs_create_mcp tabs_context_mcp tabs_close workflow_init workflow_status workflow_collect workflow_collect_partial workflow_cleanup execute_plan batch_execute lightweight_scroll memory_record memory_query memory_validate oc_stop
CLI
oc setup # Auto-configure
oc serve --auto-launch # Start server
oc serve --headless-shell # Headless mode
oc doctor # Diagnose issues
Cross-Platform
| Platform | Status |
|---|---|
| macOS | Full support |
| Windows | Full support (taskkill process cleanup) |
| Linux | Full support (Snap paths, CHROME_PATH env, --no-sandbox for CI) |
DOM Mode (Token Efficient)
read_page supports three output modes:
| Mode | Output | Tokens | Use Case |
|---|---|---|---|
ax (default) |
Accessibility tree with ref_N IDs |
Baseline | Screen readers, semantic analysis |
dom |
Compact DOM with backendNodeId |
~5-10x fewer | Click, fill, extract — most tasks |
css |
CSS diagnostic info (variables, computed styles, framework detection) | Minimal | Debugging styles, Tailwind detection |
DOM mode example:
read_page tabId="tab1" mode="dom"
[page_stats] url: https://example.com | title: Example | scroll: 0,0 | viewport: 1920x1080
[142]<input type="search" placeholder="Search..." aria-label="Search"/>
[156]<button type="submit"/>Search
[289]<a href="/home"/>Home
[352]<h1/>Welcome to Example
DOM mode outputs [backendNodeId] as stable identifiers — they persist for the lifetime of the DOM node, unlike ref_N IDs which are cleared on each AX-mode read_page call.
Stable Selectors
Action tools that accept a ref parameter (form_input, computer, etc.) support three identifier formats:
| Format | Example | Source |
|---|---|---|
ref_N |
ref_5 |
From read_page AX mode (ephemeral) |
| Raw integer | 142 |
From read_page DOM mode (stable) |
node_N |
node_142 |
Explicit prefix form (stable) |
Backward compatible — existing ref_N workflows work unchanged. DOM mode's backendNodeId eliminates "ref not found" errors caused by stale references.
Session Persistence
Headless mode (--headless-shell) doesn't persist cookies across restarts. Enable storage state persistence to maintain authenticated sessions:
oc serve --persist-storage # Enable persistence
oc serve --persist-storage --storage-dir ./state # Custom directory
Cookies and localStorage are saved atomically every 30 seconds and restored on session creation.
Benchmarks
Measure token efficiency and parallel performance:
npm run benchmark # Stub mode: AX vs DOM token efficiency (interactive)
npm run benchmark:ci # Stub mode: AX vs DOM with JSON + regression detection
npm run benchmark -- --mode real # Real mode: actual MCP server (requires Chrome)
npx ts-node tests/benchmark/run-parallel.ts # Stub mode: all parallel benchmark categories
npx ts-node tests/benchmark/run-parallel.ts --mode real --category batch-js --runs 1 # Real mode
npx ts-node tests/benchmark/run-parallel.ts --mode real --category realworld --runs 1 # Real-world benchmarks
By default, benchmarks run in stub mode — measuring protocol correctness and tool-call counts with mock responses. Use --mode real to spawn an actual MCP server subprocess and measure real performance (requires Chrome to be available).
Parallel benchmark categories:
| Category | What It Measures |
|---|---|
| Multi-step interaction | Form fill + click sequences across N parallel pages |
| Batch JS execution | N × javascript_tool vs 1 × batch_execute |
| Compiled plan execution | Sequential agent tool calls vs single execute_plan |
| Streaming collection | Blocking vs workflow_collect_partial |
| Init overhead | Sequential tabs_create vs batch workflow_init |
| Fault tolerance | Circuit breaker recovery speed |
| Scalability curve | Speedup efficiency at 1–50x concurrency |
| Real-world | Multi-site crawl, heavy JS, pipeline, scalability with public websites (httpbin.org, jsonplaceholder, example.com) — NOT included in all, requires network |
Development
git clone https://github.com/shaun0927/openchrome.git
cd openchrome
npm install && npm run build && npm test
License
MIT
OpenChrome Reviews
Login Required
Please log in to share your review and rating for this MCP.
Similar MCP Servers like OpenChrome
Explore related MCPs that share similar capabilities and solve comparable challenges
Activepieces
by activepieces
A self‑hosted, open‑source platform that provides a no‑code builder for creating, versioning, and running AI‑driven automation workflows. Pieces are TypeScript‑based plugins that become MCP servers, allowing direct consumption by large language models.
Skyvern
Officialby Skyvern-AI
Automates browser‑based workflows by leveraging large language models and computer‑vision techniques, turning natural‑language prompts into fully functional web interactions without writing custom scripts.
BlenderMCP
Officialby ahujasid
Enables Claude AI to control Blender for prompt‑assisted 3D modeling, scene creation, and manipulation via a socket‑based Model Context Protocol server.
Pipedream
by PipedreamHQ
Connect APIs quickly with a free, hosted integration platform that enables event‑driven automations across 1,000+ services and supports custom code in Node.js, Python, Go, or Bash.
Inbox Zero
by elie222
Organizes email inbox, drafts replies in the user's tone, tracks follow‑ups, and provides analytics to achieve inbox zero quickly.
Cursor Talk To Figma
by grab
Enables Cursor AI to read and programmatically modify Figma designs through a Model Context Protocol integration.
Windows MCP
by CursorTouch
Enables AI agents to control the Windows operating system, performing file navigation, application launching, UI interaction, QA testing, and other automation tasks through a lightweight server.
Ableton MCP
by ahujasid
Enables Claude AI to control Ableton Live in real time, allowing AI‑driven creation, editing, and playback of tracks, clips, instruments, and effects through a socket‑based server.
N8n Mcp Server
by leonardsellem
Provides tools and resources to enable AI assistants to manage and execute n8n workflows via natural language commands.