Google's Chrome DevTools MCP: 63 Tools Let AI Agents Debug Pages Themselves
Google's open-source chrome-devtools-mcp exposes Chrome DevTools as an MCP server with 63 tools across 13 categories, enabling AI agents to autonomously trace performance, analyze memory snapshots, set logpoints, and record screencasts—complete with installation steps, privacy defaults, and architectural insights.
Introduction
When developers modify a component, AI agents can only screenshot and guess the result. They cannot see console errors, failed requests, or why LCP is 4 seconds—developers must copy errors into the chat manually. Chrome DevTools already holds all the truth, but its panels are built for human clicking. chrome-devtools-mcp breaks those panels into 63 tools across 13 categories so agents can drive DevTools themselves.
Project Basics
The repository lives under the ChromeDevTools GitHub organization; the npm maintainer list includes google-wombot. Official support is limited to Google Chrome and Chrome for Testing—other Chromium builds may work but are not guaranteed. The tool is free, requires no API key, and runs the browser locally; model costs remain on the model provider side.
Prerequisites: Node ^20.19, ^22.12, or >=23 (the .nvmrc pins 24), and a local Chrome stable installation. The npx download weighs 15.7 MB. The same package also ships a CLI named chrome-devtools that can drive pages and capture screenshots without any agent.
Standout Capabilities
Performance Tracing
Agents start a trace with performance_start_trace, stop with performance_stop_trace, then query insights by name via performance_analyze_insight (e.g., LCPBreakdown, DocumentLatency). The project's design principle states: "LCP is 3.2 seconds, better than 50,000 lines of JSON." Heavy assets return only file paths, not raw data streams.
Previously, developers had to open the Performance panel, record, inspect flame graphs, and hunt long tasks. Now the agent records and immediately reports which insight exceeds its threshold, then drills down to the root cause—oversized images or main-thread congestion.
Limitations: insights come from DevTools' built-in rules; they explain but do not decide. By default, trace URLs are sent to Google CrUX for real-user data; internal or sensitive domains require --no-performance-crux.
Memory Analysis (14 Tools)
This category is largely absent from other browser MCP implementations. Tools include take_heapsnapshot, compare_heapsnapshots, get_heapsnapshot_dominators (who retains memory), and get_heapsnapshot_duplicate_strings. Since version 1.12, snapshots can be analyzed offline without a live browser connection.
Typical scenario: after five route navigations, memory only grows. Humans cannot feasibly inspect heap snapshots, but an agent can compare two snapshots and surface the leaking classes.
Trade-offs: all 14 tool descriptions consume significant context; snapshot files often reach hundreds of megabytes and must reside on disk.
Logpoints & Screencast
set_logpointsinjects logs without modifying source or pausing execution. Syntax: src/cart.ts:42 'cart total:', cart.total. Locations respect source maps and survive reloads and navigation. screencast_start produces an MP4 recording.
This is especially valuable for bugs that only reproduce on a specific branch. Adding a logpoint and letting the agent run the flow ten times is cleaner than repeatedly editing console.log statements.
Documented limitations: logpoints are unsupported in workers and cross-process iframes; disabling source maps leaves only minified line numbers.
Tool Scale
13 categories, 63 tools total. Only 47 are enabled by default; the remaining 16 require explicit opt-in. The --slim flag reduces the set to just 3 tools. There are 55 launch parameters—more than many CLIs.
Architecture: One npm Package Built on Chromium's Build System
Inspecting package.json reveals an oddity: dependencies is empty, yet bin points to ./out/Default/gen/src/bin/.... out/Default is the output directory of GN + Ninja. scripts/build runs node scripts/ninja.ts; build:release executes gn-gen.ts then ninja; sync includes gclient-sync.ts.
The root .gn sets devtools_location to third_party/devtools-frontend/, and .gitmodules references the DevTools frontend submodule. In short, this is not a typical npm package—it is a slice of the Chromium build chain that reuses the DevTools frontend codebase, which is why it possesses the same panel insights. The cost: 388 files, 15.7 MB, and a tightly constrained Node version range.
Privacy & Security Defaults You Must Adjust
The official disclaimer is blunt: the tool exposes the browser instance to the MCP client, allowing inspection, debugging, and modification of any data inside the browser or DevTools.
Four defaults warrant attention:
Usage statistics enabled. Google collects tool success rates, latency, and environment info. Disable with --no-usage-statistics or CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS (CI environments default to off).
Trace URLs sent to CrUX. Disable with --no-performance-crux.
Sensitive request headers not redacted. --redactNetworkHeaders defaults to false; cookies and authorization headers are returned verbatim.
JavaScript evaluation enabled. --javascriptEvaluation defaults to true. The docs note this is not a sandbox—page scripts and click-triggered scripts execute normally.
Another easily overlooked default: the browser profile directory is %USERPROFILE%\.cache\chrome-devtools-mcp\chrome-profile. It persists across runs, preserving login state. On shared machines, add --isolated to use a temporary directory.
The tool provides tightening knobs: --blockedUrlPattern and --allowedUrlPattern restrict agent-accessible domains; file I/O is confined to the system temp directory unless the client negotiates roots. These defaults are conservative, but the 55 parameters go unread.
Red line: Do not point --autoConnect or --browserUrl at your daily Chrome profile that has banking or email sessions—that hands the entire browser session to the agent.
Installation & Configuration
Prerequisites: correct Node version and Chrome stable in the standard path.
Three steps (Claude Code example):
Add to client MCP config: command: "npx", args: ["-y", "chrome-devtools-mcp@latest"] Restart the client to reload configuration.
Send Check the performance of https://developers.chrome.com —the browser opens and records a trace.
Common launch parameters: --isolated – temporary profile, cleaned on exit (multi-session, shared machines) --headless – no window (CI/servers) --slim – only 3 tools (context-constrained environments) --no-usage-statistics – disable telemetry (internal projects) --channel – choose canary/dev/beta/stable (testing new features)
Verification: browser launches, trace completes, agent reports LCP and insights. Without MCP, run globally: chrome-devtools navigate_page 1 --url ...; a screenshot confirms functionality.
Real-world pitfalls: Node version mismatch causes immediate startup failure (engine mismatch error). Non-standard Chrome paths require --executablePath, which conflicts with --channel and --browserUrl. Time to first successful run: ~10 minutes; remaining time is spent teaching the agent how to use the tools.
Personal Assessment
My criterion for such tools is simple: can they replace the makeshift workflows I currently tolerate? The old workflow: paste errors into chat, manually open performance panel for perf issues, essentially give up on memory issues. The first two now have dedicated tools; the third previously had no automated alternative.
This is not the same as Playwright MCP. Playwright excels at cross-browser automation—one script runs on Safari too. chrome-devtools-mcp excels at Chrome-specific insights: traces, heap snapshots, Lighthouse audits—capabilities only DevTools provides. Put differently: Playwright helps me operate the page; chrome-devtools-mcp tells me why the page behaves that way. Both are needed, but the latter didn't exist before.
Key shortcomings reiterated: Chrome-only (no Firefox/Safari support); default data emission requires explicit configuration changes before team adoption.
Two audiences should try it: frontend developers already using Claude Code, Cursor, or Copilot—adding a config block costs near zero; backend developers who only occasionally inspect pages—avoid it, because 63 tools idling in context are pure overhead.
Open-source repository: github.com/ChromeDevTools/chrome-devtools-mcp
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
