Chrome DevTools MCP

Chrome DevTools MCP

Apache-2.0 MCP server that gives coding agents a live Chrome DevTools session for debugging, traces, and browser automation.

82/100Safe BetFreeFree

If your agent keeps flailing at a broken page because it can't see the console or the network tab, this closes that gap for $0 under Apache-2.0. You get source-mapped console errors, request analysis, Puppeteer-backed actions that wait, and CrUX field data alongside trace insights — all through one npx line in your MCP client config. The real costs are trust and scope: browser contents flow to your MCP client, telemetry is on by default, and Chrome is the only officially supported browser. Compare Playwright MCP if you need multi-browser coverage.

Verified 13h ago · liveness 82/100 · cite: rightaichoice.com/tools/chrome-devtools-mcp

Best for
  • AI coding agents that need live Chrome inspection to debug a broken web app
  • Teams wanting performance traces plus CrUX field data inside the agent workflow
  • Diagnosing console errors and failed requests through an MCP client
  • Automating browser tasks with screenshot and network verification plus auto-wait
Not ideal for
  • Pages holding sensitive or personal data — browser contents are exposed to your MCP client
  • Non-Chrome browsers — only Google Chrome and Chrome for Testing are officially supported
  • Simple scripted clicking where a lighter automation server suffices
Visit Website

IntermediateAbout 5 minutes if your MCP client is already configured: add the npx chrome-devtools-mcp@latest entry, restart the client, then ask the agent to check performance on a URL to trigger a browser launch and a trace. Cursor, Claude and Gemini users can start from the repo's plugin folders instead of hand-writing config. Budget Node.js LTS and a current stable Chrome as prerequisites.CLI · PluginNo public API6.1k viewsVerified 13h ago
Pricing
Free
FreeFree tier
Learning curve
Intermediate
About 5 minutes if your MCP client is already configured: add the npx chrome-devtools-mcp@latest entry, restart the client, then ask the agent to check performance on a URL to trigger a browser launch and a trace. Cursor, Claude and Gemini users can start from the repo's plugin folders instead of hand-writing config. Budget Node.js LTS and a current stable Chrome as prerequisites.
Runs on
CLIPlugin
No public API · 6 integrations
Who it's for
Front-end engineer with a broken staging pagePerformance-focused developerQA engineer automating a checkout flow
Live sentiment
Is Chrome DevTools MCP actually worth it?

We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.

  • Honest verdict, not marketing
  • Real pros & cons from real users
  • Attributed quotes with receipts
Run a free scan

3 free scans · no card needed

Skip it if

Skip Chrome DevTools MCP if you need one agent to drive Firefox and WebKit as well as Chrome, or if the pages you'd point it at carry customer data you can't let an MCP client read.

The 30-second take
Price reality

The software is $0 under Apache-2.0, so the budget conversation is about the agent seat and the browser, not this repo. A solo dev already paying for a Claude or Cursor plan adds it for nothing; an org standardizing on Copilot in VS Code gets the same through the GitHub Copilot and VS Code plugin paths. Compare Playwright MCP, also free — you're choosing depth vs browser coverage, not price.

In short

Chrome DevTools MCP — Apache-2.0 MCP server that gives coding agents a live Chrome DevTools session for debugging, traces, and browser automation. Best for AI coding agents that need live Chrome inspection to debug a broken web app, Teams wanting performance traces plus CrUX field data inside the agent workflow, Diagnosing console errors and failed requests through an MCP client. Free to use.

No head-to-head comparison for Chrome DevTools MCP yet — the alternatives below are the closest matches we list.

What people actually say about Chrome DevTools MCP — is it worth it?

We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.

58 mentions across 3 sources (Hacker News, YouTube, Lemmy) · researched Oct 8, 2026.

69% positive31% critical

Weighted by the 59 posts each of 3 sources contributed.

Recurring strengths
  • +Official Google-backed MCP server gives agents real DevTools reach, not simulated state
  • +Network request inspection exposes headers, auth, and cookies for deep debugging
  • +Performance traces plus CrUX field data pair lab numbers with real-user metrics
  • +Built on Puppeteer, so clicks, navigation, and form fills wait for results predictably
  • +Slim, headless, isolated, and CLI modes cover CI, throwaway profiles, and non-MCP workflows
Recurring frustrations
  • −MCP bloats agent context badly; some developers switch to Playwright CLI instead
  • −Install can fail with cryptic 'Invalid URL' and process-exit errors on first launch
  • −Exposes browser session contents to the MCP client, so logged-in data is at risk
  • −Small local models like qwen3-coder hallucinate when driving the MCP tool
  • −Only Chrome and Chrome for Testing officially supported — no Firefox or Safari
Patterns worth knowing
Debugging with real DevTools data beats simulated page state
Seen on Hacker News, YouTube, Lemmy
MCP context bloat makes Playwright CLI more efficient for some workflows
Seen on Hacker News, Lemmy
Security boundary — browser contents exposed to the MCP client is a real risk
Seen on Hacker News, Lemmy
Learning curve
intermediateProductive in ~5 minutes for a standard VS Code or Claude setup; a few hours if you're configuring headless CI or isolated profiles
Hidden costs people mention
  • • Your own Chrome and Node.js LTS setup and maintenance time
  • • Agent token spend can climb because the MCP inflates context
  • • If you opt in to telemetry or update checks (both can be disabled), you accept data sharing

Viability Score

82/100
Safe Bet

How well maintained and how widely used is Chrome DevTools MCP? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this

Recent activity
not measured
Traction
100
Site health
95
User sentiment
67
What the vendor publishes
60

Last calculated: October 2026

How we score →

Key Features

  • Control and inspect a live Chrome browser via the Model Context Protocol
  • Companion CLI for workflows without an MCP client
  • Console messages with source-mapped stack traces
  • Network request analysis for front-end failures
  • Performance trace recording with extracted actionable insights
  • Real-user field data via the Google CrUX API, disableable with --no-performance-crux
  • Screenshots to verify rendered page state
  • Puppeteer-backed automation that waits for action results
  • Slim mode (--slim) limited to basic navigation and interaction
  • Headless mode (--headless) for CI and background runs
  • Isolated mode (--isolated) for throwaway browser profiles
  • Browsers launch automatically when a tool needs a running instance
  • Opt out of usage statistics via --no-usage-statistics or CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS
  • Disable npm update checks via CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS
  • Plugins for Claude, Cursor, Gemini and Kimi tooling

About Chrome DevTools MCP

FreeIntermediateNo APICLI · Plugin

Chrome DevTools MCP is an Apache-2.0 Model Context Protocol server — and a companion CLI — that lets a coding agent such as Antigravity, Claude, Cursor or Copilot control and inspect a real Chrome instance instead of guessing at page state. The agent gets the DevTools surface directly: console messages with source-mapped stack traces, network request analysis, screenshots to confirm what actually rendered, and recorded performance traces with extracted insights. Automation is Puppeteer-backed, so clicks, navigation and form fills wait for their result rather than firing blind. Performance work extends past lab numbers — trace recordings can be paired with Google's CrUX API for real-user field data, switchable off with --no-performance-crux. Setup is a one-line npx chrome-devtools-mcp@latest entry in your MCP client config, with --slim for basic navigation only, plus --headless and --isolated for CI and throwaway profiles. The repo ships as plugins for Claude, Cursor, Gemini and Kimi tooling. Two boundaries matter: the server exposes the browser instance's contents to your MCP client, so keep it away from sensitive data, and only Google Chrome and Chrome for Testing are officially supported (support targets the latest Extended Stable Chrome). Against a broader-browser automation server like Playwright MCP, it trades browser breadth for DevTools-grade debug and performance depth.

Behind the Verdict

Chrome DevTools MCP is the rare case of a vendor building the bridge to its own product and then open-sourcing it: Google's DevTools team ships this as an Apache-2.0 repo with roughly 54k stars and 1.5k commits, which tells you it's an actively maintained project rather than a demo. The design bet is that a coding agent debugging a web app needs the same surface a human engineer uses — console, network, screenshots, performance traces — not a DOM snapshot alone. Three things make that bet credible. First, console messages arrive with source-mapped stack traces, so the agent reasons about your source rather than bundled output. Second, automation runs on Puppeteer and automatically waits for action results, which removes the classic failure mode of an agent clicking before the page settles. Third, performance work isn't limited to lab numbers: trace recordings can be paired with Google's CrUX API for real-user field data, and --no-performance-crux turns that lookup off. The operational surface is small and honest. Install is one npx line in your MCP client; --slim trims the toolset to basic navigation and interaction; --headless and --isolated cover CI and throwaway profiles; the browser starts automatically when a tool needs one. The repo also carries plugin folders for Claude, Cursor, Gemini and Kimi tooling, so setup inside those clients is more than a copy-paste of JSON. Where it bites: the server exposes the browser instance's contents to your MCP client, so a logged-in session on a sensitive account is readable by that client — treat it as a hard boundary, not a footnote. Telemetry is on by default (tool invocation success rates, latency, environment info) and needs --no-usage-statistics or CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS to stop. Only Google Chrome and Chrome for Testing are officially supported; other Chromium builds may work but aren't guaranteed. And it is not a high-concurrency scraping tool — it drives a real browser, one session at a time. Who should care: front-end and full-stack engineers already running an MCP client who want the agent to debug against live DevTools rather than a text dump. If you need Firefox and WebKit coverage, Playwright MCP covers more browsers but goes less deep on DevTools-grade profiling. If you just need scripted clicks, a lighter automation server does the job.

Researching Chrome DevTools MCP? Get your full AI stack in 60 seconds.

Free, no signup — tell us your goal and get tools matched to your budget & existing stack.

Real-world workflow fit

Concrete scenarios for the personas Chrome DevTools MCP actually fits — and what changes day-one when you adopt it.

Front-end engineer with a broken staging page

You point your Cursor agent at the failing URL and ask it to reproduce the error; it launches Chrome, reads console messages with source-mapped stack traces, and checks the failed network request.

Outcome: The agent proposes a fix grounded in the actual request and stack trace instead of guessing from a pasted error string.

Performance-focused developer

You ask the agent to record a trace on a slow page; it extracts insights from the recording and, unless you pass --no-performance-crux, pulls real-user field data from the Google CrUX API.

Outcome: You get lab trace insights and field data side by side in one agent turn, so you know whether the regression affects real users.

QA engineer automating a checkout flow

In headless mode (--headless) the agent walks the multi-step flow, Puppeteer auto-waits on each action, and screenshots plus DOM assertions verify each step.

Outcome: Repeatable pass/fail evidence with screenshots, runnable in CI without a visible window.

Use Cases

  • Debug a React hydration error by having your agent read live console output from your app.
  • Reproduce a production bug in the browser and get a fix proposal grounded in the network trace.
  • Profile a slow page and correlate trace insights to specific component renders.
  • Have the agent verify a CSS fix by taking before/after screenshots.
  • Automate manual QA steps with agent-assisted browser inspection.
  • Walk a multi-step flow in a web app and assert DOM state at each step.
  • Record a performance trace and compare lab insights against CrUX field data.

Limitations

  • Requires a local Chrome instance; some features may need a windowed browser or an existing Chrome profile for login-protected sites.
  • Not built for high-concurrency scraping.
  • Officially supports Google Chrome and Chrome for Testing only — other Chromium builds may work but aren't guaranteed.
  • Usage statistics are collected by default (tool invocation success rates, latency, environment info) and must be disabled with --no-usage-statistics or the env variable.
  • Performance tools may send trace URLs to the Google CrUX API unless you pass --no-performance-crux.
  • The server exposes the browser instance's contents to your MCP client, so anything the browser can see — including logged-in sessions and personal data — becomes visible to that client.

as of 2026-10-22

Verification history

We have re-verified Chrome DevTools MCP 22 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.

  1. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  2. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  3. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  4. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  5. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  6. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it

Showing the 6 most recent of 22 verification passes.

Free to cite with attribution — this page re-verifies continuously.

12-month cost

Project the real annual outlay, including the implied monthly cost when only an annual tier is published.

Annual total
Free
Over 12 months
Effective monthly
—
—

Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.

Plans compared

For each published Chrome DevTools MCP tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.

Open Source (Apache-2.0)

$0

Ideal for

Any developer or team already running an MCP client (Claude, Cursor, Copilot, Antigravity, Gemini) who needs live Chrome inspection in the agent loop.

What this tier adds

Free entry point and only tier: the full DevTools tool set, companion CLI, slim/headless/isolated modes and optional CrUX lookup at $0.

Where the pricing makes sense

The company stage and team size where Chrome DevTools MCP's pricing actually pencils out — and where peers do it cheaper.

The software is $0 under Apache-2.0, so the budget conversation is about the agent seat and the browser, not this repo. A solo dev already paying for a Claude or Cursor plan adds it for nothing; an org standardizing on Copilot in VS Code gets the same through the GitHub Copilot and VS Code plugin paths. Compare Playwright MCP, also free — you're choosing depth vs browser coverage, not price.

Setup time & first value

How long it actually takes to get something useful out of Chrome DevTools MCP — broken out by persona, not the marketing-page minute.

About 5 minutes if your MCP client is already configured: add the npx chrome-devtools-mcp@latest entry, restart the client, then ask the agent to check performance on a URL to trigger a browser launch and a trace. Cursor, Claude and Gemini users can start from the repo's plugin folders instead of hand-writing config. Budget Node.js LTS and a current stable Chrome as prerequisites.

Switching to or from Chrome DevTools MCP

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in
  • →From manual DevTools inspection: add the npx entry to your MCP config and let the agent read the same console, network and trace panels you were reading by hand.
  • →From Playwright MCP: swap the server entry in your MCP client config; re-check any workflow that relied on Firefox or WebKit, which aren't officially supported here.
  • →From screenshot-only agent tools: keep the same client, and add network analysis and trace recording by calling the DevTools tools instead of image capture alone.
Migrating out
  • ↗To Playwright MCP: replace the server entry in your MCP client config, and trade DevTools-grade trace and CrUX depth for Firefox and WebKit coverage.
  • ↗To a plain Puppeteer script: use the same Puppeteer automation primitives directly when you no longer need an agent in the loop.
  • ↗To a hosted browser-automation service: move session management off your local Chrome when high-concurrency runs matter more than live DevTools inspection.

Integrations

Resources & Guides

Tutorials & Learning

YouTube returned 6 videos for “Chrome DevTools MCP”, and we withheld 1: 1 did not mention Chrome DevTools MCP. Showing the 5 we can prove are about Chrome DevTools MCP.

Tools that pair well with Chrome DevTools MCP

Common stack mates teams adopt alongside Chrome DevTools MCP, with the specific reason each pairing earns its keep.

Alternatives to Chrome DevTools MCP

View all
Open Interpreter

Open Interpreter

Open Interpreter is an open-source terminal coding agent that reads files, edits code, and runs shell commands from plain English.

FreeTry
QuantDinger

QuantDinger

Self-hosted AI quant trading platform: one Python Strategy API V2 contract from reproducible backtest to live execution

FreemiumTry
Stagehand

Stagehand

Stagehand is the open-source browser agent SDK that pairs Playwright-style APIs with AI act, extract, and observe.

FreemiumTry

Frequently Asked Questions

Used Chrome DevTools MCP? Help shape our editorial sentiment research.