Chrome Devtools Advanced MCP lets AI assistants drive a real (cloned) Chrome profile to browse, scrape, interact, test, and debug web pages with session persistence and stealth.
Launch/close Chrome with a cloned real profile (cookies, logins, extensions) and manage tabs.
Navigate, reload, go back/forward, wait for page load states, set viewport, and print pages to PDF.
Extract page data: full/simplified HTML, element text/attributes, links/images/metadata, layout metrics, accessibility tree, and screenshots (full page, clip, element).
Interact with pages: click, type, select dropdowns, scroll, fill forms, wait for selectors, and run custom JavaScript.
Scrape data and APIs: navigate and capture XHR/fetch responses, filter by URL pattern, extract specific JSON fields, and replay/resend captured requests.
Capture and modify network traffic: add custom headers, intercept and rewrite requests/responses, record HAR, monitor WebSocket messages, emulate network conditions, and run performance audits.
Manage cookies, localStorage, sessionStorage, IndexedDB, and full browser sessions (save/load/clear/export/import).
Test pages with different cookies in an isolated context without touching the real session.
Use anti-detection features: stealth mode, user-agent, geolocation, and timezone spoofing.
Dynamically show/hide advanced tools, and use attached resources/prompts for tab HTML, screenshots, HAR, accessibility audits, console error debugging, and table scraping.
Provides tools to launch, navigate, interact with, and extract data from Google Chrome using the Chrome DevTools Protocol, supporting undetectable automation with user profiles.
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., "@Chrome Devtools Advanced MCP Launch Chrome with my profile, go to amazon.com, and search for laptops."
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.
Your Intelligent Bridge Between AI and the Browser.
This Model Context Protocol (MCP) server enables AI assistants like Claude, Roo Code, or Windsurf to interact with Google Chrome in a natural, powerful, and stealthy way. Unlike other automation tools, this solution connects to your actual browser profile, allowing you to use your existing login sessions, cookies, and extensions without detection.
🕵️ "Human" Navigation: Uses a persistent clone of your real Chrome profile (cookies, localStorage, logged-in accounts). If you're logged into LinkedIn, Gmail, or your corporate ERP, your AI assistant is too — and the session survives between runs.
👤 Profile Cloning: list_chrome_profiles finds every profile on the machine, clone_chrome_profile mirrors the one you want into ~/.chrome-mcp/profiles/…, and sync_chrome_profile_to_real pushes logins back into your own Chrome.
🛡️ Undetectable: Stealth mode is applied per tab, and Chrome runs with the automation switch excluded.
🛠️ Robust Toolset: 96+ specialized tools, plus MCP resources and prompts, optimized for data scraping, specific element extraction, and visual analysis.
⚡ Fast & Safe: Safely executes scripts and screenshots, with intelligent output truncation to prevent crashing your AI context.
Related MCP server: chrometools-mcp
Simply add this to your mcp.json configuration file:
{
"mcpServers": {
"chrome-devtools-advanced-mcp": {
"command": "npx",
"args": ["-y", "chrome-devtools-advanced-mcp", "--port=9223"]
}
}
}Restart your assistant (Ctrl+R in VS Code), and you'll have instant access.
Ask your AI:
"Set up Chrome with my profile" → it calls
setup_chrome_profile
That mirrors your real profile (your profile name/avatar, bookmarks, history,
new-tab tiles, settings and — once — your extensions) into
~/.chrome-mcp/profiles/<profile> and opens Chrome on it.
What you have to do (the whole list):
Platform | You do this | Then |
Windows | Sign in to Google once, in the Chrome window that just opened | Done forever: that session lives in the clone and is reused on every launch. Chrome never needs closing, and your own browser keeps working normally |
macOS / Linux | Close Chrome once before the setup | Done: the cloned session works as-is, no sign-in needed |
Nothing else ever: no re-login, no closing Chrome afterwards, your personal browser is never touched (the clone is a separate Chrome instance). Saved passwords and autofill cannot be copied on Windows (Chrome encrypts them with a key bound to the browser) — save them once inside the clone if you want them there.
After that, ask your AI:
"Launch Chrome with my profile"
This triggers launch_chrome_with_profile, which reuses the clone window
(or an already-debuggable Chrome) without closing your other windows.
You can ask:
"Go to amazon.com and search for laptops"
"Analyze the HTML of the login form" (Uses optimized get_html)
"Take a screenshot of the pricing table"
The AI can click, type, and fill forms intelligently, waiting for elements to load automatically.
Tools are split into two tiers so the default list stays manageable for the AI: ~42 core tools are visible from the start; ~52 advanced tools (Network Advanced, Anti-Detection & Privacy, Service Workers, System, Performance) stay hidden until the AI calls show_advanced_tools (call hide_advanced_tools to collapse the list again).
Tool | Description |
| Start Here! Launches Chrome with your cookies/extensions. |
| Navigate, reload, go back/forward. |
| Create, close, switch, or list tabs. |
| Safely closes the controlled session. |
Tool | Description |
| Critical. Extracts simplified or full HTML. Supports selectors. |
| Captures visual proof (png/jpeg). |
| Layout and viewport analysis. |
| See the page structure as screen readers do (advanced tools). |
| Read console.log/warn/error/info/debug and uncaught exceptions for a tab — capture starts automatically on first call. |
Tool | Description |
| Click, Type, Hover, Drag & Drop with auto-wait. |
| Fill multiple fields (text/select/checkbox) in a single call instead of N |
| Run custom JavaScript safely (requires |
| Get specific text or attributes from elements. |
| Resize window for responsive testing. |
| Click a download trigger, wait for it to finish, and get the saved file path. |
Tool | Description |
| Hides automation flags. |
| Spoof device/browser identity. |
| Mock GPS coordinates. |
| Change browser timezone. |
Tool | Description |
| Record traffic while performing an action. |
| Replay captured API calls. |
| Save full network logs (HAR format). |
| Listen to socket traffic. |
| Throttle to Slow 3G/4G/offline to test resilience. |
| Core Web Vitals (LCP, CLS) + basic timing via PerformanceObserver. |
Tool | Description |
| Manage browser cookies. |
| Read/Write local storage data. |
| List IndexedDB databases, or read records from one. |
| Save current session state to file. |
| Test a URL with a different cookie set inside a throwaway, fully isolated browser context — never touches your real session. |
Beyond tools, this server exposes two other MCP primitives:
Resources (cacheable/listable, not just one-shot tool calls) — for each open tab:
chrome://tab/{tabId}/html, chrome://tab/{tabId}/screenshot, chrome://tab/{tabId}/har.
Prompts (pre-baked task templates that chain the tools above): audit-accessibility, debug-console-errors, scrape-table.
In clients that support them (e.g. Claude Desktop), these show up as attachable resources / slash-style prompts, separate from the tool list.
Do I need to close my Chrome? No! Thanks to "Shadow Profile" technology, this server creates a temporary safe clone of your profile. You can keep browsing normally while the AI works in parallel.
Does it work on Mac/Linux? Yes, it is fully cross-platform.
I see "Tool disabled by user" error This is a VS Code security feature.
Reload VS Code (Ctrl+R).
When the AI tries to use a tool again, click "Always Allow" on the popup.
Why are cookie values redacted / file:// blocked?
Security defaults (see docs/USAGE_GUIDE.md → Security defaults): navigation
is limited to http(s), cookie values require includeValues:true, and HAR
exports/downloads are sandboxed to your working dir or temp folder.
docs/USAGE_GUIDE.md — practical workflows for the AI on the current (v1.5) tool vocabulary.
docs/TOOLS.md — complete, machine-checked reference of all 96 tools.
docs/INSTALL.md — installation & configuration.
docs/CHANGELOG.md — release notes.
To contribute or run locally:
git clone https://github.com/Eddym06/chrome-devTools-advanced-mcp.git
cd chrome-devTools-advanced-mcp
npm install
npm run build
npm startBefore opening a PR:
npm run lint # ESLint (flat config)
npm run build # clean tsc build
npm test # vitest — includes an in-memory MCP client/server integration test
npm run docs:check # fails if any guide references a non-existent tool
# optional, on a machine with Chrome installed:
CHROME_MCP_E2E=1 npm test # real-Chrome end-to-end suiteCI (.github/workflows/ci.yml) runs lint + build + test on Node 20 and 22 for every push/PR.
Developed with ❤️ by @eddym06
Add a custom header to matching requests before sending. Simpler alternative to intercept_and_modify_traffic with flat parameters.
Inputs: headerName (required), urlPattern (required), headerValue (required), tabId, +2 more.
Control browser navigation: navigate to URL, go back/forward, or reload the page.
Inputs: action (required), url, tabId, timeout, +1 more.
Capture network requests triggered by an action (click, navigate, type). Returns full request details including URL, headers, body, and method.
Inputs: action (required), url, text, tabId, +3 more.
Clear all cookies for a specific domain or all domains.
Inputs: tabId, allDomains.
Clear all localStorage items for the current domain.
Inputs: tabId.
Close the Playwright-managed browser and release all connections. Only works for browsers launched by this MCP.
Inputs: no named parameters.
Delete a specific cookie by name. Use get_cookies first to find exact name and domain.
Inputs: name (required), path, tabId, domain.
Execute JavaScript in the page context. Must include a return statement. Set awaitPromise=true for async code.
Inputs: script (required), tabId, timeoutMs, awaitPromise.
Export complete session state (cookies, localStorage, sessionStorage) as JSON for later import.
Inputs: tabId.
Navigate to URL and capture all API/XHR responses. Returns parsed JSON data.
Inputs: url (required), tabId, timeout, apiPattern, +2 more.
Extract text content or HTML attributes from page elements using CSS selectors.
Inputs: action (required), selector (required), tabId, attributeName.
Get the accessibility tree of the page (ARIA roles, labels, interactive elements).
Inputs: tabId.
Check browser connection status, CDP port, and whether managed by Playwright or external.
Inputs: no named parameters.
Get browser cookies for the current page or a specific URL.
Inputs: url, tabId.
Extract HTML source from the page or a specific CSS selector. Output truncated at 50k chars.
Inputs: tabId, selector, outerHTML.
Get all localStorage key-value pairs for the current domain.
Inputs: tabId.
Get layout metrics of the page
Inputs: tabId.
Hide advanced tools to simplify the tool list. Call show_advanced_tools to unlock them again.
Inputs: no named parameters.
Import previously exported session data to restore cookies and storage. Navigate after import to activate.
Inputs: sessionData (required), tabId.
Intercept and modify network requests in real-time before sending. Preserves cookies and authentication. Supports header/body/method changes.
Inputs: action (required), urlPattern (required), modifications (required), tabId, +1 more.
Launch Google Chrome with your real profile (cookies, extensions, sessions). IMPORTANT: Only call this tool when the user EXPLICITLY asks to open or launch Chrome. Do NOT call it automatically or proactively.
Inputs: profileDirectory.
Save, load, clear, or export browser session (cookies + storage) in one call.
Inputs: operation (required), tabId, sessionData, sessionName, +2 more.
Manage browser tabs: list, create, close, switch, or get current URL. Tab ID required for close/switch.
Inputs: action (required), url, tabId.
Interact with page elements: click, type into inputs, select dropdown options, scroll, or wait for selector. Use get_html first to verify selectors.
Inputs: action (required), selector (required), text, tabId, +4 more.
Print the current page to PDF
Inputs: scale, tabId, landscape, paperWidth, +3 more.
Capture a PNG/JPEG screenshot of the full page or a specific element/area.
Inputs: clipX, clipY, tabId, format, +4 more.
Set a browser cookie with name, value, domain, and optional flags (secure, httpOnly, sameSite).
Inputs: name (required), value (required), path, tabId, +5 more.
Set a localStorage key-value pair. Use JSON.stringify for object values.
Inputs: key (required), value (required), tabId.
Unlock advanced tools: network interception, request replay, API mocking, WebSocket monitoring, HAR recording, accessibility, anti-detection, service workers, and more.
Inputs: no named parameters.
Execute a sequence of user actions (click, type, wait, navigate, screenshot) automatically.
Inputs: steps (required), tabId, stopOnError, captureScreenshots.
Send HTTP request to an API endpoint and capture the response. Handles auth cookies automatically.
Inputs: url (required), body, tabId, method, +2 more.
Test a page with modified cookies. Saves original cookies, applies test cookies, optionally restores.
Inputs: url (required), cookies (required), tabId, extractContent, +1 more.
Wait for page to reach a specific load state. Checks current readyState first, only waits for event if page has not reached the target state yet. States: load (fully loaded), domcontentloaded (HTML ready), networkidle (no network activity for 500ms).
Inputs: state, tabId, timeout.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 34 tools
Several tools have overlapping purposes, such as add_custom_header_to_request vs intercept_and_modify_traffic, export_session/import_session vs manage_browser_session's save/load, and capture_network_on_action vs extract_api_data. Descriptions clarify specific use cases, but agents may still hesitate when choosing between similar options.
Most tools follow a consistent verb_noun pattern (get_cookies, set_cookie, clear_cookies, navigate_and_extract_content). Minor deviations like 'screenshot' (bare noun) and 'browser_action' (noun_noun) are rare, so the overall convention remains predictable.
With 34 tools, the set is too large and unwieldy. The server even includes show_advanced_tools/hide_advanced_tools to manage visibility, acknowledging the overwhelming surface. This exceeds the practical threshold for a coherent toolset.
The toolset covers an impressively broad range of browser automation: navigation, interaction, content extraction, cookies, storage, session management, network interception, performance metrics, and accessibility. Minor gaps exist, such as no tool to remove a single localStorage key or capture console logs, but core workflows are well supported.
Connect AI agents to your own Chrome with scoped access, approvals, and verified task results.
AI-powered browser automation — navigate, click, fill forms, and extract data from any website.
Cloud browsers for AI agents: saved logins, residential IPs, live human takeover, 57 browser tools.
Let AI agents use your real, signed-in Chrome: tabs, clicks, forms, screenshots and video.
