Skip to main content
Guide8 min read·Updated August 31, 2026
🧩

Chrome DevTools MCP Review: Worth Installing in 2026?

B

A. Frans

Published August 31, 2026

MCPChrome DevToolsDebuggingPerformanceReview

Most browser MCP servers let an agent click things. chrome-devtools-mcp lets an agent take a heap snapshot, diff it against a second one, and tell you which class is retaining the objects that leaked. That's a different category of tool, and it's why this one is worth the config line even if you already run Playwright.

It's maintained by the Chrome DevTools team at ChromeDevTools/chrome-devtools-mcp: Apache-2.0, 50,208 stars and 3,528 forks as of 2026-08-31, last pushed 2026-08-30. The npm package is chrome-devtools-mcp, currently 1.8.0. Automation underneath is Puppeteer; the debugging and performance surface is real DevTools.

Verdict up front: install it, and change two defaults before you point it at anything you care about.

What you actually get

The tool reference lists well over fifty tools across ten groups. Grouped by what they're for:

GroupNotable toolsWhy it matters
Performanceperformance_start_trace, performance_stop_trace, performance_analyze_insightRecords real traces and extracts insights, not synthetic timings
Memorytake_heapsnapshot, compare_heapsnapshots, get_heapsnapshot_retaining_pathsThirteen heap tools. Nothing else in this category comes close
Debugginglighthouse_audit, list_console_messages, evaluate_script, screencast_startSource-mapped stack traces from console errors
Networklist_network_requests, get_network_requestFull request inspection, not just a pass/fail
Inputclick, fill_form, drag, upload_file, press_keyStandard automation, with Puppeteer's auto-waiting
Emulationemulate, resize_pageDevice and network conditions
Extensionsinstall_extension, reload_extension, trigger_extension_actionExtension development, which almost nothing else supports
PWAinstall_pwa, launch_pwa, get_os_app_stateInstalled-app state
The memory group is the standout. compare_heapsnapshots, get_heapsnapshot_dominators, get_heapsnapshot_retaining_paths, and get_heapsnapshot_duplicate_strings together let an agent run the exact workflow a human does when hunting a leak: snapshot, exercise the app, snapshot again, diff, walk the retainer chain. Handing that loop to an agent is the first time I've seen memory debugging become something you can delegate rather than schedule an afternoon for.

The extension tools are the second surprise. If you build Chrome extensions, this is currently the only mainstream MCP server that will install, reload, and trigger one for you.

Installing it

Two routes. The CLI adds the MCP server only:

claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest

The plugin route adds the server plus the accompanying skills:

/plugin marketplace add ChromeDevTools/chrome-devtools-mcp
/plugin install chrome-devtools-mcp@chrome-devtools-plugins

Restart Claude Code afterward and check /skills to confirm both loaded. If you already had the MCP server configured the old way, remove it first. The repo is explicit about that, and running both gets you duplicate tool definitions.

Requirements are a Node.js LTS version, npm, and current stable Chrome or newer. Chrome and Chrome for Testing are the only officially supported browsers. Other Chromium builds may work and are not guaranteed, which in practice means Edge and Brave are fine until they aren't and you won't get a fix.

For clients that take JSON config rather than a CLI command:

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": ["-y", "chrome-devtools-mcp@latest"]
    }
  }
}

Change these two defaults

Usage statistics are on by default. Google collects tool invocation success rates, latency, and environment information. The repo says so plainly, which is more than most projects manage, and it also gives you three ways out: pass --no-usage-statistics, or set CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS, or set CI. This telemetry is separate from Chrome's own: opting out of Chrome metrics does not opt you out here.

Performance tools may send trace URLs to Google's CrUX API. This is to pull real-user field data alongside your lab data, which is a useful feature and also means the URLs you profile leave your machine. If you're tracing an internal staging host or anything with a token in the query string, run with --no-performance-crux.

Neither of these is a scandal. Both are defaults I'd change before profiling a client's site, and neither is obvious from a directory listing.

The third thing to sit with is broader. From the repo's own disclaimer: the server exposes the content of the browser instance to the MCP client, letting it inspect, debug, and modify any data in the browser or DevTools. If you attach it to your daily browser profile, an agent can read whatever that profile is logged into. Use a separate Chrome profile or Chrome for Testing. Don't attach it to the browser where your email is open.

What a session actually looks like

The leak hunt is the clearest example of why the tool grouping matters, so here's the shape of it.

You describe the symptom: memory climbs every time the user opens and closes the settings drawer. The agent navigates to the page, takes a baseline heap snapshot, drives the drawer open and closed a dozen times through the input tools, takes a second snapshot, and calls compare_heapsnapshots. The diff names the constructor that grew. Then get_heapsnapshot_retaining_paths walks back from an instance of that class to the GC root, and you get the chain: a detached DOM node held by an event listener that never got removed.

That's four tool calls to a specific line of code, and every step is one a human would have done by hand in the DevTools Memory panel. The value isn't that the agent is smarter about leaks. It's that the panel-driving part, the tedious half, stops being your afternoon.

The same pattern holds for performance. performance_start_trace, exercise the flow, performance_stop_trace, then performance_analyze_insight to pull out what DevTools itself flags rather than a wall of raw trace events. You get the same insights the Performance panel surfaces, in a form the agent can reason over and act on.

Two smaller tool groups didn't make the table and are worth knowing exist. list_3p_developer_tools and execute_3p_developer_tool expose third-party developer tooling registered in the browser, and list_webmcp_tools and execute_webmcp_tool reach tools a page itself publishes over WebMCP. Both are niche today. The WebMCP pair is the one to watch, because it's the seam where a page can hand an agent its own affordances instead of making it click through a UI built for humans.

Against Playwright MCP

They overlap on automation and diverge everywhere else.

Playwright MCP is Microsoft's, official, Apache-2.0, and cross-browser: Chromium, Firefox, and WebKit. If your test matrix includes Safari, the comparison ends there, because chrome-devtools-mcp supports Chrome only.

chrome-devtools-mcp wins on depth within Chrome. Playwright has no heap snapshot tooling, no Lighthouse audit, no DevTools performance-insight extraction, and no extension management. If your question is "does this flow still work in three browsers," use Playwright. If it's "why is this page slow" or "what's holding onto 400MB," use this one.

Running both is reasonable and I do. They cost tool-list space, not conflicts. Our Playwright vs Puppeteer comparison covers the automation-only side of that decision in more detail.

Where it falls down

Chrome only, and they mean it. The support commitment is to the latest Extended Stable Chrome. Everything else is best-effort.

Slim mode exists for a reason. The full tool list is large enough to crowd an agent's context and make tool selection worse. The repo ships --slim with a reduced set, and if you only want basic browser tasks that's the flag to use:

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": ["-y", "chrome-devtools-mcp@latest", "--slim", "--headless"]
    }
  }
}

97 open issues and pull requests. For a project this size and this young that's a sign of use rather than neglect, and pushes are near-daily. It does mean you'll hit rough edges. Check the tracker before assuming a behavior is your fault.

Plugin install can fail behind a corporate proxy. The repo documents a Failed to clone repository error on restricted networks and points at a troubleshooting guide. The CLI install route sidesteps it.

Should you install it

Yes, if you do front-end work in Chrome and any of these are true: you profile performance, you chase memory leaks, you read network waterfalls, or you build extensions. The heap tooling alone justifies it, and there's no real alternative.

Skip it if your browser work is cross-browser end-to-end testing, where Playwright is the better fit, or if you can't run a separate Chrome profile — the data exposure isn't worth it against a logged-in daily browser.

Use --slim unless you need the deep tools, opt out of telemetry, and add --no-performance-crux when the URLs matter. It's a good piece of software with defaults tuned for Google's convenience rather than yours, which is a fair trade once you know about it.

FAQ

Is chrome-devtools-mcp official? It's maintained by the Chrome DevTools team under the ChromeDevTools GitHub organization, Apache-2.0 licensed. Our directory lists it as verified rather than official because the trust tiers here track a specific review process, not the maintainer's badge.

Does it need a headless browser? No. It drives a real Chrome instance by default, which is what makes the DevTools integration work. --headless is available and pairs well with --slim for CI.

Can it debug a page that's already open? It manages its own pages through new_page, list_pages, and select_page. Attaching to an arbitrary existing browser session isn't the design, and given what the server can read, that's the right default.

What's the difference between this and the Chrome DevTools CLI? The repo ships a CLI for use without MCP. Same capabilities, driven from a terminal instead of an agent. If you want the tooling in a script rather than a conversation, that's the entry point.

Will it slow down my agent? The full tool set is large and every tool definition consumes context. That's the cost. --slim cuts it down when you don't need heap snapshots and Lighthouse audits in the same session.

Share this article

📬

Get More AI Tool Guides

New comparisons and guides every week. Join thousands of professionals staying ahead of the AI curve.