Fast Browser MCP is a CDP-powered MCP server/CLI for fast, token-efficient Chrome automation and deep browser inspection.
Connect/launch Chrome or Electron, manage tabs/navigation/window state, and control Chrome system pages/extensions.
Capture token-efficient @ref accessibility snapshots, screenshots, PDFs, HTML, console logs, and storage/session data.
Perform clicks, fills, forms, keyboard/mouse actions, scrolling, uploads, clipboard, dialogs, and high-speed multi-action browser_batch pipelines.
Inspect/control network traffic, WebSockets, cookies, localStorage/sessionStorage, CacheStorage, IndexedDB, and export traffic as JSON/HAR.
Emulate devices/network/CPU/geolocation/timezone/theme/zoom/User-Agent/headers and toggle stealth, resource blocking, permissions, downloads, and certificate handling.
Use DevTools features: raw CDP commands, CSS/event-listener inspection, V8 coverage, visual screenshot diffing, WebMCP tools, isolated incognito tabs, screencast recording, and performance metrics.
Access live browser state via MCP resources (browser://tabs, snapshots, DOM, console, network) and guided prompts for research, forms, and network debugging.
Enables browser automation and control for Brave via the Chrome DevTools Protocol, supporting tab management, navigation, DOM interaction, snapshots, screenshots, network inspection, and extension management.
Provides full browser automation and control for Google Chrome via the Chrome DevTools Protocol, including tab management, navigation, DOM interaction, snapshots, screenshots, network inspection, extension management, and access to chrome:// system pages.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Fast Browser MCP log into example.com and snapshot the dashboard page"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Universal, ultra-fast Model Context Protocol (MCP) server and command-line interface for browser automation powered directly by the Chrome DevTools Protocol (CDP).
Engineered specifically to eliminate the two biggest bottlenecks in AI web agents: round-trip LLM inference latency and context window token bloat.
Traditional AI browser tools suffer from severe limitations:
Round-trip Latency: Each individual action (click, type, scroll) requires an entire round-trip to the language model (~3–5 seconds per step). A 5-step form fill can take 25–40 seconds.
Context Bloat: Dumping entire raw HTML trees consumes 10,000–50,000 tokens per step.
Blind to Shadow DOM: Chrome internal pages (chrome://settings, chrome://extensions) and modern Web Components are invisible to standard document.querySelector tools.
Anti-Bot Roadblocks: Headless browsers frequently trigger Cloudflare, Captchas, and bot challenges.
Fast Browser MCP solves all of this:
Feature | Fast Browser MCP | Standard Browser MCPs |
Multi-Action Batching ( | Local execution in ~500ms for 5–10 actions | 20–30 seconds (1 LLM turn per action) |
Snapshot Context Cost | < 150 tokens via numbered | 10,000–50,000 tokens (raw HTML/DOM) |
Multimodal Screenshots ( | Native inline image content for Vision LLMs | ❌ Text base64 or file path only |
Dynamic Port Switching ( | Switch on the fly (e.g. Electron apps, port 43275) | ❌ Fixed single port |
Auto-Launch & Standalone ( | Auto-discovers and launches Chromium if not running | ❌ Crashes without manual start |
MCP Resources & Prompts |
| ❌ Tools only |
Shadow DOM & Web Components | Deep recursive traversal into all | ❌ Incomplete or completely blind |
Chrome System Pages | Full control over | ❌ Unsupported |
Extension Management | List, enable, disable, reload, and inspect extensions | ❌ Unsupported |
Real Browser Integration | Attaches to active Chrome session on port 9222 (bypasses Cloudflare) | Often isolated / detected headless |
Reverse Engineering & Traffic | Live WebSocket frames, XHR request/response bodies, cookie extraction | Usually basic console logs only |
Related MCP server: Browser-Debugger
browser_batch)Execute an entire pipeline of actions locally in a single MCP round-trip:
{
"steps": [
{"action": "navigate", "url": "https://example.com/login"},
{"action": "fill", "ref": "@1", "text": "agent@example.com"},
{"action": "fill", "ref": "@2", "text": "secret123"},
{"action": "click", "ref": "@3"},
{"action": "wait", "ms": 500},
{"action": "snapshot"}
]
}Result: Executed entirely over direct local WebSocket in ~600ms total!
@ref SnapshotCaptures a compact accessibility tree with numbered target handles (@1, @2, ...). Intelligently identifies non-textual UI elements:
Icons, SVG graphics, and title labels
CSS background-image sprites (e.g. bg:quest1.png)
ARIA roles, input states, and placeholder texts
Filters out internal presentation noise (cr-ripple, path, cr-icon inside buttons)
=== Page: Extensions ===
URL: chrome://extensions/
--- Interactive Elements (12 found) ---
@1 [button] "Search extensions"
@2 [input] [type=search]
@3 [button] [ checked]
@4 [button] "Load unpacked"
@5 [button] "Pack extension"
@6 [button] "Update"
@7 [menuitem] "My extensions" -> /
@8 [menuitem] "Keyboard shortcuts" -> /shortcuts
@9 [button] "Details"
@10 [button] "Remove"
@11 [button] "Reload"
@12 [button] [ checked]Window Bounds: Retrieve and set window states (normal, minimized, maximized, fullscreen) or exact pixel dimensions and coordinates.
System Pages: Direct navigation to chrome://settings, chrome://extensions, chrome://downloads, chrome://history, chrome://flags, chrome://version, and more.
Extension Controls: Query all installed Chrome extensions, enable/disable them, reload extensions, or open options and popup pages.
Download Management: Automatically configure download paths without interactive prompt dialogs.
Permissions: Programmatically grant or reset browser permissions (clipboardReadWrite, notifications, geolocation).
Inspect intercepted HTTP/XHR/Fetch requests, headers, and POST payloads.
Fetch raw response bodies (JSON, HTML, binary).
Real-time WebSocket frame capture (sent / received), critical for game automation, real-time sync, and bot development.
One-click traffic dump export to structured JSON.
Python 3.10 or newer
Google Chrome, Chromium, or Brave
# Clone the repository
git clone https://github.com/kqlio67/fast-browser-mcp.git
cd fast-browser-mcp
# Install dependencies
pip install -r requirements.txt
# (Optional) Install editable package
pip install -e .Start your browser with --remote-debugging-port=9222:
Linux (Standard Desktop GUI):
google-chrome --remote-debugging-port=9222 &
# Or if using Chromium / Helium:
chromium --remote-debugging-port=9222 &Linux (Completely Hidden Background Mode via Xvfb): Runs Chrome on a virtual display in memory — zero desktop windows, no keyboard/mouse focus stealing, full anti-bot evasion:
nohup xvfb-run -a google-chrome \
--remote-debugging-port=9222 \
--user-data-dir="/tmp/chrome_hidden_session" \
--no-first-run \
--no-default-browser-check \
--disable-gpu > /dev/null 2>&1 &macOS:
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --remote-debugging-port=9222 &Windows:
chrome.exe --remote-debugging-port=9222(Optional: Use --user-data-dir="/tmp/chrome_dev_session" to run alongside your personal browser profile without conflicts).
agy mcp add --env PYTHONPATH=/path/to/fast-browser-mcp fast-browser python3 -m fast_browser.serverclaude_desktop_config.json){
"mcpServers": {
"fast-browser": {
"command": "python3",
"args": ["-m", "fast_browser.server"],
"env": {
"PYTHONPATH": "/path/to/fast-browser-mcp"
}
}
}
}Add Fast Browser MCP as an MCP stdio server executing:
Command: python3
Args: ["-m", "fast_browser.server"]
Environment: PYTHONPATH=/path/to/fast-browser-mcp
Tool | Description |
| Connect dynamically to any running browser or Electron instance by host and port (e.g. port 9222 or custom devtools port) |
| Launch a managed Chromium/Chrome instance (headless/headed, custom port, proxy, and user data directory) |
| Terminate and clean up the launched or managed browser process |
| Wait for a file download to complete in the download directory within a given timeout |
| Export active session state (cookies, localStorage, sessionStorage, active URL) to JSON file or string |
| Restore session state (cookies, localStorage, sessionStorage, navigation) from exported data |
Tool | Description |
| List all open browser tabs (ID, title, URL) |
| Switch active connection to a tab by title or URL query |
| Open a new tab with a given URL |
| Close a tab by target ID (or close current tab) |
| Navigate active tab to a URL |
| Reload the page (with optional |
| Navigate backward in browser history (back button) |
| Navigate forward in browser history (forward button) |
| Retrieve full tab navigation history entries and current position |
Tool | Description |
| Click an element by snapshot ref ( |
| Type text into an input element by ref or CSS selector (supports |
| Fill multiple form elements in one fast batch execution |
| Dispatch keyboard key event ( |
| Scroll page by $(\Delta x, \Delta y)$ or scroll element into view |
| Advanced mouse operations: |
| Find text on page (Ctrl+F): count matches, extract snippets, and auto-scroll |
| Read or write to the system clipboard ( |
| Upload files natively into |
Tool | Description |
| Compact, token-efficient A11y tree with |
| Extract full document |
| Capture viewport, element clip, or full-page scrollable screenshot (PNG/JPEG) |
| Start capturing a screencast video of the browser viewport |
| Stop capturing screencast video and save the result |
| Print page to PDF file with landscape/background options |
| Evaluate arbitrary JavaScript expressions in the page context |
Tool | Description |
| Universal CDP Raw Dispatcher: Execute any of the 1,000+ Chrome DevTools Protocol commands directly (e.g. |
| Native Event Listener Inspection: Inspect native DOM event listeners (click, submit, change, keydown, custom) via CDP |
| V8 Code Coverage Profiling: Measure executed JS functions and code ranges in real time during an observation window |
| Start precise V8 JavaScript code coverage collection across subsequent browser actions |
| Stop V8 coverage collection and return filtered executed functions and call counts |
| Deterministic Visual Diffing: Compare two screenshots/PNGs with RGBA pixel delta, changed ratio, and bounding box without Vision LLM cost |
| List WebMCP tools exposed by the web page |
| Execute a WebMCP tool exposed by the web page |
| Inspect computed styles, applied stylesheet rules, bounding rect, and attached event listeners for any element by |
| Spawn a tab in a completely isolated incognito browser context ( |
| Emulate CPU slowdown factors ( |
| Automate JavaScript dialogs ( |
Tool | Description |
| Ultra-fast local batch execution: runs an array of actions in a single round-trip without model latency. Supports coordinate clicking/hovering ( |
| Wait until all in-flight network requests cease for a stable duration |
| Block images, video/audio media, web fonts, or tracking scripts/ads for up to 10x page load speedup |
| Block specific wildcard URL patterns (e.g. |
| Automatically close blank ( |
| Live memory profiling: JS heap used (MB), DOM nodes, layouts, and task durations |
Tool | Description |
| List captured HTTP/XHR/Fetch requests filtered by type or URL pattern (with optional secrets redaction) |
| Inspect headers, POST payload, and retrieve server response bodies |
| Monitor real-time WebSocket frames ( |
| Retrieve all cookies and authentication tokens for current origin |
| Inject cookies into the browser context |
| Inspect and dump |
| Inspect PWA and Service Worker CacheStorage entries and cached responses |
| Inspect all IndexedDB databases, version numbers, and object store names |
| Clear browser cache and/or cookies |
| Export captured HTTP & WebSocket traffic into JSON or standards-compliant HAR 1.2 format with automated secrets redaction |
Tool | Description |
| Inspect or set window bounds (coordinates, width, height) and state ( |
| Open or switch to Chrome system pages ( |
| Query all installed Chrome extensions (IDs, names, versions, enabled status) |
| Manage extensions: |
| Inject custom JavaScript evaluating before page scripts load (hooks / Tampermonkey) |
| Remove a previously registered preload script by identifier |
| Toggle anti-bot stealth overrides ( |
| Emulate network profiles ( |
| Emulate color scheme on page: |
| Adjust page zoom scale (e.g. |
| Mute or unmute all audio/video media playback on the active tab |
| Bypass or enforce SSL/TLS certificate warnings on HTTPS websites |
| Inspect Chrome version, V8 engine, User-Agent, environment readiness, and memory metrics |
| Set download folder and allow downloads without browser dialogs |
| Grant or reset permissions ( |
| Override device GPS coordinates ( |
| Emulate local timezone (e.g. |
| Emulate geolocation coordinates and/or timezone simultaneously in a single call |
| View captured console logs ( |
| Configure viewport dimensions and mobile device emulation |
| Override User-Agent header |
| Inject custom HTTP headers into all outgoing requests |
Fast Browser MCP provides native Model Context Protocol (MCP) Resources and Prompts for seamless integration with MCP clients (Antigravity, Claude Desktop, Cursor, etc.).
Directly read live browser state as structured MCP resources without executing tool calls:
Resource URI | MIME Type | Description |
|
| Real-time list of all open browser tabs (ID, title, URL, WebSocket debugger URL) |
|
| Token-efficient formatted accessibility snapshot of the currently focused tab |
|
| Complete raw HTML document of the active page |
|
| Captured browser console output (logs, warnings, errors, exceptions) |
|
| Ring-buffer captured HTTP/XHR network requests and traffic summary |
Pre-configured agent workflows:
Prompt Name | Description |
| Systematic web browsing workflow: search, navigate, snapshot, and extract information |
| Structured guide for safely inspecting, validating, and filling multi-step web forms |
| Guided workflow to inspect network API requests and WebSocket frames for reverse engineering |
Fast Browser MCP also includes a complete standalone CLI for manual operations and shell scripting:
# List open tabs (optionally with a persistent profile)
python3 -m fast_browser.cli --profile my_session list-tabs
# Take a snapshot of a tab
python3 -m fast_browser.cli --tab mmobitva snapshot
# Navigate history (Back & Forward)
python3 -m fast_browser.cli back
python3 -m fast_browser.cli forward
python3 -m fast_browser.cli history
# Activate stealth mode (hide automation markers)
python3 -m fast_browser.cli stealth
# Emulate network conditions (Slow 3G, Offline, or reset)
python3 -m fast_browser.cli throttling slow3g
python3 -m fast_browser.cli throttling none
# Emulate dark mode theme
python3 -m fast_browser.cli theme dark
# Adjust page zoom level (125%)
python3 -m fast_browser.cli zoom 1.25
# Mute tab audio
python3 -m fast_browser.cli mute
# Search text on page (Ctrl+F)
python3 -m fast_browser.cli find "SearchQuery"
# Read/write clipboard
python3 -m fast_browser.cli clipboard --write "Hello from Fast Browser"
python3 -m fast_browser.cli clipboard
# Inspect IndexedDB databases
python3 -m fast_browser.cli indexeddb
# Inspect browser window geometry
python3 -m fast_browser.cli window
# Maximize browser window
python3 -m fast_browser.cli window --state maximized
# Open Chrome Settings or Extensions
python3 -m fast_browser.cli system-page settings
python3 -m fast_browser.cli extensions
# Send raw Chrome DevTools Protocol command ("God Mode")
python3 -m fast_browser.cli cdp-send Page.getNavigationHistory
# Inspect computed CSS styles of an element
python3 -m fast_browser.cli css-styles --ref @1
python3 -m fast_browser.cli css-styles --selector "button.primary"
# Create a tab in an isolated incognito browser context
python3 -m fast_browser.cli isolated-tab https://example.com
# Emulate 4x CPU slowdown
python3 -m fast_browser.cli cpu-throttling 4.0
# Configure JavaScript dialog handling
python3 -m fast_browser.cli dialog --action accept
# Run high-speed batch actions
python3 -m fast_browser.cli --tab mytab batch '[
{"action": "stealth", "enabled": True},
{"action": "theme", "theme": "dark"},
{"action": "snapshot"},
{"action": "click", "ref": "@2"},
{"action": "wait", "ms": 200},
{"action": "snapshot"}
]'The automated test suite runs in a 100% isolated headless background process on an ephemeral dynamic port with a temporary user data directory. It never touches your personal browser session (port 9222), never opens or closes visible desktop tabs, and never steals mouse or keyboard focus:
PYTHONPATH=. python3 -m unittest discover -s tests(Optional: To explicitly run tests against an existing custom port, set the CDP_PORT environment variable: CDP_PORT=9222 python3 -m unittest discover -s tests).
This project is licensed under the MIT License.
Inject custom JavaScript to run on every new document before page scripts load (hooks / Tampermonkey).
Inputs: source (required).
Navigate backward in browser history (back button).
Inputs: delta.
ULTRA-FAST MULTI-ACTION BATCH EXECUTION: Execute a sequence of browser actions in a single round-trip without model latency. Supports: 'navigate', 'click', 'double_click', 'right_click', 'drag_and_drop', 'mouse_move', 'fill', 'press_key', 'scroll', 'select_option', 'hover', 'wait', 'eval', 'extract', 'snapshot', 'screenshot' (with full_page and clip selector support), 'pdf', 'get_html', 'set_viewport', 'set_user_agent', 'set_headers', 'block_urls', 'set_geolocation', 'set_timezone', 'get_storage', 'clear_cache', 'clear_cookies', 'set_cookie', 'export_traffic', 'console_logs', 'upload_file', 'window', 'system_page', 'extensions', 'extension_action', 'set_download_path', 'grant_permissions', 'system_info'.
Inputs: steps (required).
Block heavy resources (images, video/audio media, web fonts, tracking scripts/ads) or custom URLs to dramatically accelerate page load speed (up to 10x).
Inputs: block_ads, block_fonts, block_media, block_images, +1 more.
Block specific URL patterns (e.g. *.png, analytics, ads) to speed up page loading.
Inputs: patterns (required).
UNIVERSAL RAW CDP (GOD MODE): Send any raw Chrome DevTools Protocol command directly with custom parameters (e.g. 'DOM.getBoxModel', 'CSS.enable', 'Memory.getDOMCounters', 'Tracing.start', 'Fetch.enable').
Inputs: method (required), params, timeout, session_id.
Automatically close stale, blank (about:blank), or pattern-matching tabs to free browser memory and maintain cleanliness.
Inputs: close_blank, keep_current, url_patterns.
Clear browser cache and/or cookies.
Inputs: clear_cache, clear_cookies.
Click an element by its snapshot reference (@1, @2, ...) or CSS selector.
Inputs: ref, trusted, selector, wait_for.
Read or write to the system clipboard.
Inputs: text, action.
Terminate the managed browser instance if one was launched via browser_launch.
Inputs: no named parameters.
Close a browser tab by target ID, or close current tab if ID is omitted.
Inputs: target_id.
Deterministic visual comparison of two screenshots or PNG images. Calculates changed pixel count, changed ratio, and bounding box without Vision LLM overhead.
Inputs: image1 (required), image2 (required), diff_output_path, channel_threshold.
Dynamically switch or reconnect CDP connection to a specified host and port (e.g. switch between Chrome on 9222 and Antigravity IDE on 43275).
Inputs: port (required), host.
View captured JavaScript console logs (console.log, console.error, console.warn) and unhandled page exceptions.
Inputs: limit, log_type.
Emulate geolocation coordinates and/or timezone.
Inputs: latitude, longitude, timezone_id.
Evaluate arbitrary JavaScript in the active page context and return the result.
Inputs: script (required).
Execute a WebMCP tool exposed by the current webpage.
Inputs: name (required), arguments.
Export current session state (all cookies, localStorage, sessionStorage) as structured JSON.
Inputs: save_path.
Export all captured network requests, responses, headers, POST data, and WebSocket frames to a structured JSON file or standards-compliant HAR 1.2 file.
Inputs: file_path (required), format, redact_sensitive_headers.
Perform management action on a Chrome extension: enable, disable, reload, open options, or open popup.
Inputs: action (required), extension_id (required).
Fill text into an input element by its snapshot reference (@1, @2, ...) or CSS selector. Auto-detects contenteditable and rich text editors.
Inputs: text (required), ref, clear, paste, +2 more.
Fill out multiple form elements (inputs, selects, checkboxes, radios) at once. Prefer this tool over multiple individual 'fill' or 'click' calls when interacting with forms. It is significantly faster and reduces turn count.
Inputs: elements (required).
Find text on page (Ctrl+F): count matches, extract context snippets, and scroll to first match.
Inputs: query (required), scroll_to_first.
Navigate forward in browser history (forward button).
Inputs: delta.
Inspect Service Worker and PWA CacheStorage caches, cached endpoints, and responses via CDP.
Inputs: limit, cache_name, include_response_body.
Retrieve all cookies for the current tab (auth tokens, session IDs).
Inputs: no named parameters.
Inspect element computed CSS styles and matched stylesheet rules by selector or @ref.
Inputs: ref, selector.
Inspect native DOM event listeners (click, submit, keydown, change, etc.) attached to an element via CDP DOMDebugger without invoking handlers.
Inputs: ref, depth, selector, ancestors.
Extract full outerHTML of the entire document or save to file.
Inputs: save_path.
Inspect all IndexedDB databases and object stores for current origin.
Inputs: no named parameters.
Inspect and dump all items from localStorage, sessionStorage, and optionally CacheStorage for the current origin.
Inputs: storage_type.
Grant or reset browser permissions (e.g. notifications, clipboardReadWrite, geolocation) for an origin.
Inputs: reset, origin, permissions.
Handle or configure behavior for JavaScript dialogs (alert, confirm, prompt) or dismiss DOM modal overlays and cookie banners.
Inputs: action, prompt_text.
Retrieve tab navigation history entries and current index.
Inputs: no named parameters.
Import session state (cookies, localStorage, sessionStorage) into the browser.
Inputs: path, session_data.
Launch an isolated Chrome or Chromium browser instance with CDP remote debugging enabled.
Inputs: port, headless, profile_name, user_data_dir.
List all installed Chrome extensions with their IDs, names, versions, enabled status, and options URLs.
Inputs: no named parameters.
List all open browser pages/tabs with their title, URL, and ID.
Inputs: no named parameters.
List all WebMCP tools exposed by the current webpage via navigator.modelContext.getTools().
Inputs: no named parameters.
Advanced mouse operations: right-click, double-click, move, or drag-and-drop.
Inputs: action (required), x, y, ref, +3 more.
Mute or unmute all media audio playback in the active tab.
Inputs: muted.
Retrieve full request details (headers, POST payload) and response body (JSON/HTML) for a specific request ID.
Inputs: request_id (required).
List captured HTTP/XHR/Fetch/WebSocket network requests for reverse engineering. Filter by type or URL pattern.
Inputs: limit, filter_type, url_pattern.
Emulate network profiles ('offline', 'slow3g', 'fast3g', '4g', 'none') or custom bandwidth and latency.
Inputs: latency, offline, profile, upload_throughput, +1 more.
Open a new tab in a fresh, completely isolated browser context (incognito mode: zero shared cookies, clean session storage).
Inputs: url.
Open a new browser tab with the specified URL.
Inputs: url.
Measure and observe precise V8 JavaScript code coverage during execution to discover which scripts and functions actually ran.
Inputs: detailed, call_count, url_filter, duration_ms, +1 more.
Open or switch to a Chrome system page: 'settings', 'extensions', 'downloads', 'history', 'bookmarks', 'flags', 'version', 'gpu', 'net-internals'.
Inputs: page (required).
Retrieve real-time browser performance metrics: JS heap memory usage (MB), DOM node count, layout count, and task duration.
Inputs: no named parameters.
Press a keyboard key (e.g. Enter, Escape, Tab, Backspace, ArrowDown, ArrowUp, Space).
Inputs: key (required).
Print the current page to a PDF file.
Inputs: save_path (required), landscape.
Reload the current page.
Inputs: ignore_cache.
Remove a previously registered preload script by its identifier.
Inputs: identifier (required).
Starts recording a screencast (video) of the target page and saves it as an MP4 file.
Inputs: file_path (required).
Stops the active screencast recording.
Inputs: no named parameters.
Capture screenshot of current page, entire scrollable page, or a specific element.
Inputs: selector, full_page, save_path.
Scroll the page or scroll an element into view.
Inputs: ref, delta_x, delta_y, selector.
Select and connect to an open browser tab by query (matching URL or title).
Inputs: query.
Set a cookie in the browser.
Inputs: name (required), value (required), path, domain.
Emulate slower CPU speeds (1.0 = normal, 2.0 = 2x slowdown, 4.0 = 4x slowdown).
Inputs: rate (required).
Set browser download directory and behavior (automatically allow downloads without popup prompt).
Inputs: download_path (required), behavior.
Override device GPS geolocation coordinates (latitude, longitude, accuracy).
Inputs: latitude (required), longitude (required), accuracy.
Inject custom HTTP headers into all outgoing requests from the browser.
Inputs: headers (required).
Bypass or enforce SSL/TLS certificate warnings on HTTPS websites.
Inputs: ignore.
Emulate system color scheme on page: 'dark', 'light', or 'no-preference'.
Inputs: theme (required).
Adjust page zoom level (e.g. 0.5 for 50%, 1.0 for 100%, 1.5 for 150%).
Inputs: scale (required).
Override browser timezone (e.g. 'America/New_York', 'Europe/Kyiv', 'UTC').
Inputs: timezone (required).
Override User-Agent string for the browser tab.
Inputs: user_agent (required).
Set browser viewport dimensions and mobile device emulation.
Inputs: width (required), height (required), mobile, device_scale_factor.
Capture a compact, token-efficient snapshot of the active page showing interactive elements with numbered references (@1, @2, ...), smart labels (icons/images/CSS backgrounds), headings, and accessible iframes. Supports scoping to a CSS selector and viewport-only filtering.
Inputs: selector, in_viewport, max_elements.
Start precise V8 code coverage measurement across subsequent browser interactions.
Inputs: detailed, call_count.
Enable or disable comprehensive anti-detection stealth overrides (masks navigator.webdriver, plugins, languages).
Inputs: enabled.
Stop active V8 code coverage measurement and return executed scripts and functions.
Inputs: url_filter, only_executed.
Get comprehensive browser information: Chrome version, V8 version, User-Agent, protocol version, environment validation, and memory performance metrics.
Inputs: no named parameters.
Upload one or more files to an element via CDP.
Inputs: files (required), selector (required).
Wait for a file download to complete in the download directory without .crdownload extension.
Inputs: directory (required), timeout, filename_pattern.
Wait until network is completely idle (no active in-flight requests) for the specified duration.
Inputs: timeout, idle_time.
List captured WebSocket frames (sent/received messages in real-time). Essential for game battle packets and real-time reverse engineering.
Inputs: limit, direction.
Manage browser window: inspect bounds or set state ('normal', 'minimized', 'maximized', 'fullscreen') and dimensions/position.
Inputs: top, left, state, width, +2 more.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 81 tools
Most tools have clearly distinct browser-specific purposes, but there are notable overlaps: browser_batch duplicates dozens of individual actions, browser_emulate_environment overlaps with browser_set_geolocation and browser_set_timezone, and browser_block_urls overlaps with browser_block_resources. Tab cleanup/close and storage inspection tools also have fuzzy boundaries, though descriptions generally help.
All 81 tools use the browser_ prefix with snake_case, which is highly consistent. A few tools deviate from the strict verb_noun pattern (e.g., browser_window, browser_history, browser_console_logs), but the overall convention is clear and predictable.
With 81 tools, the surface is extremely large for a browser automation server. The count far exceeds a well-scoped set, and the mega browser_batch tool plus many granular duplicates make the surface unwieldy rather than focused.
The tool set covers an exceptionally broad browser automation lifecycle: navigation, tabs, DOM interaction, network inspection, storage, cookies, screenshots, PDF, CDP, extensions, WebMCP, coverage, and performance. There are no obvious gaps for the stated browser-automation purpose.
Give AI agents a real cloud Chrome: open sessions, navigate, read pages, click, type and screenshot.
Cloud browser, web extraction, screenshots, and remote CDP tools for AI agents.
Control a real browser from AI agents: navigate, click, type, screenshot, read the page.
Hosted browser for AI agents: screenshots, post-JS DOM, console, WCAG. No install, no API key.