Chrome DevTools MCP: Let coding agents inspect and debug Chrome directly
It gives coding agents Chrome DevTools for performance analysis and debugging, not just scripted clicks.
GitHub ChromeDevTools/chrome-devtools-mcp Updated 2026-09-04 Branch main Stars 50.9K Forks 3.6K
MCP Chrome DevTools Puppeteer Browser automation

🧭 Decision Guide

Try it if you

  • Your coding agent runs in Antigravity, Claude, Cursor, or Copilot
    The README sections “Chrome DevTools for agents” and “Getting started” list these MCP client examples
  • You need to record Chrome traces and extract performance insights
    The README section “Key features,” under “Get performance insights,” explicitly describes recording traces with Chrome DevTools
  • You need to analyze network requests, screenshots, and source-mapped console messages
    The README section “Key features,” under “Advanced browser debugging,” lists these capabilities

Skip it if you

  • Your environment is not Google Chrome or Chrome for Testing
    The README “Disclaimers” section says other Chromium browsers may work but are not guaranteed, while official support covers only those two
  • You cannot allow MCP clients to access sensitive or personal browser data
    The README “Disclaimers” section says the tool lets MCP clients inspect, debug, and modify browser data
  • The environment lacks Node.js LTS, current stable Chrome, or npm
    The README “Requirements” section explicitly lists Node.js LTS, Chrome current stable version or newer, and npm

Requirements

  • Node.js LTS version; Chrome current stable version or newer; npm
  • An MCP client is required; the README example starts chrome-devtools-mcp@latest with npx

First step (verbatim from README)

"args": ["-y", "chrome-devtools-mcp@latest"]

Watch out

  • Usage statistics are enabled by default; opt out with --no-usage-statistics
    The README “Usage statistics” section and its JSON configuration example
  • Performance tools may send trace URLs; disable this with --no-performance-crux
    The README “Disclaimers” section describes sending data to the Google CrUX API
  • The server periodically checks the npm registry and logs update notifications by default
    The README “Update checks” section
  • Connecting to the MCP server alone does not automatically start the browser
    The README note under “Your first prompt” says the browser starts only when a tool requiring it is used

Not stated in the README

  • The primary programming language and exact versions are not provided in the project data
  • The README does not state performance overhead, concurrent session limits, or stability metrics
  • Project metadata reports 0 contributors, 0 versions, and No releases; the actual release process is unspecified
  • The README does not provide a complete MCP client compatibility matrix
  • Permission boundaries and isolation details for browser data modification are not specified

💡 Deep Analysis

6
Yes I only need the agent to perform basic browser tasks and do not need the full DevTools diagnostics. My environment has Node.js LTS, npm, and Chrome. Should I use slim and headless mode?
For: An automation developer running Node.js LTS, npm, and Chrome who only needs basic web tasks and wants headless mode with fewer agent tools

Yes. The README explicitly positions --slim for basic browser tasks and provides an example combining it with --headless.

  • “Getting started” says to use --slim when only basic browser tasks are needed.
  • The example configuration includes "--slim", "--headless", confirming support for a smaller tool set and headless Chrome.
  • “Requirements” lists Node.js LTS, the current stable Chrome version or newer, and npm, matching your environment.
  • The full mode includes tracing, network inspection, and console diagnostics, so slim avoids exposing capabilities that basic tasks do not need.

The README does not enumerate exactly which tools slim removes. It also provides no benchmark for startup time, memory usage, or agent-call cost between slim and full modes.

  • Getting started: If you are interested in doing only basic browser tasks, use the `--slim` mode
  • Getting started example: `"args": ["-y", "chrome-devtools-mcp@latest", "--slim", "--headless"]`
  • Requirements: Node.js LTS, Chrome, and npm
Not stated in the README:The full inclusion and exclusion list for slim mode is not provided in the README body;Resource usage and performance differences between slim and full mode are not documented
Yes I do not use Claude, Cursor, or another MCP client, but I have Node.js LTS, Chrome, and npm. Can I use this project’s browser-debugging and performance-analysis capabilities through the CLI alone?
For: A browser-debugging developer with Node.js LTS, Chrome, and npm who does not use an MCP client and wants to access automation and DevTools capabilities through a CLI

Yes. The README explicitly states that a standalone CLI is available without an MCP client, so your lack of Claude, Cursor, or another MCP client is not a blocker.

  • The project introduction says: “A CLI is also provided for use without MCP.” This is a direct statement of standalone usage.
  • “Requirements” lists Node.js LTS, the current stable Chrome version or newer, and npm, matching your environment.
  • “Key features” describes Chrome DevTools tracing and performance insights, network analysis, screenshots, console inspection, and Puppeteer’s automatic waiting.
  • Official support is limited to Google Chrome and Chrome for Testing. Other Chromium browsers may work but are not guaranteed.

The README body does not show concrete CLI subcommands, argument examples, or a complete feature-parity list with MCP mode. It therefore confirms the usage direction but not that every DevTools capability is exposed identically through the CLI.

  • Project introduction: A CLI is also provided for use without MCP
  • Requirements: Node.js LTS, Chrome, and npm
  • Key features: performance insights, network requests, screenshots, and console messages
Not stated in the README:The README body does not provide complete CLI subcommand and argument examples;The README does not state whether CLI and MCP modes have full feature parity
Yes I am integrating browser capabilities into a browser-subagent product and need concurrent sessions, persistent user-data directories, and connections to an existing Chrome instance. Can this project serve as the underlying infrastructure?
For: An engineer building a browser-subagent product that needs concurrent sessions, persistent user-data directories, or connections to an existing Chrome instance

Yes. The README explicitly recommends building an integrated browser subagent on top of Chrome DevTools for agents and lists the advanced runtime modes you need.

  • “Integrating as a browser subagent” recommends using the project for an in-product browser subagent and links to the Gemini CLI browser-agent implementation.
  • “Advanced Usage” explicitly covers concurrent sessions, persistent user-data directories, and connecting to an already running Chrome instance.
  • “Configuration” mentions --headless, --isolated, and WebSocket connections, showing that the project supports more than one-off local interaction.
  • MCP decouples browser capabilities from a specific AI client, while a CLI is also available without an MCP client.

However, the README does not specify concurrency limits, isolation strength, permissions for shared Chrome instances, or multi-tenant security boundaries. Those gaps matter if the product serves untrusted users.

  • Integrating as a browser subagent: we recommend building on top of Chrome DevTools for agents
  • Advanced Usage: concurrent sessions, persistent user data directories, connecting to a running Chrome instance
  • Configuration: `--headless`, `--isolated`, and WebSocket connections
Not stated in the README:The README does not specify concurrency limits, resource isolation, or session scheduling;The README does not define multi-tenant permissions, cookie isolation, or security boundaries for existing Chrome instances
Yes I use Cursor to modify frontend code, but I still switch manually between Chrome, DevTools, and the agent. Can this project let the agent interact with pages, take screenshots, and locate console errors with source-mapped stacks?
For: A frontend developer using Claude, Cursor, or Copilot who wants the coding agent to inspect a real Chrome page, network requests, and console errors after changing code

Yes. It is designed for this workflow because it exposes a live Chrome browser and Chrome DevTools through MCP, enabling a modify–run–observe–fix loop.

  • The “Key features” section says Puppeteer automatically waits for action results, which helps with asynchronous page state after interactions.
  • The same section includes network-request analysis, screenshots, browser-console inspection, and source-mapped stack traces.
  • “Getting started” explicitly names Antigravity, Claude, Cursor, and Copilot and shows MCP client configuration.

The README does not specify success rates for pop-ups, CAPTCHAs, authentication flows, or complex cross-origin pages. It also does not document a deterministic assertion system, so those capabilities cannot be assumed from the tool list alone.

  • Key features: Puppeteer automatically waits for action results
  • Key features: Analyze network requests, take screenshots and check browser console messages
  • Getting started: Antigravity, Claude or Cursor
Not stated in the README:The README does not define support boundaries for complex login flows, CAPTCHAs, pop-ups, or cross-origin workflows;The README does not state whether deterministic assertions, retries, or test-report formats are provided
It depends I already use Chrome DevTools for lab trace analysis and want the agent to include Google CrUX real-user experience data for the same page. Is this project suitable for that performance workflow?
For: A frontend performance engineer already using Chrome DevTools traces who wants to compare them with Google CrUX real-user experience data

It depends. The project can combine lab traces with CrUX data in one performance workflow, but the README defines important external-request and interpretation boundaries.

  • “Key features” says it records Chrome DevTools traces and extracts actionable performance insights.
  • “Disclaimers” says performance tools may send trace URLs to the Google CrUX API to fetch real-user experience data, presenting field data alongside lab data.
  • The CrUX request can be disabled with --no-performance-crux when external data transfer is not allowed.
  • Project insights state that local network conditions, machine resources, browser version, and page state affect traces, so a trace cannot represent every real user environment.

It is suitable as a performance-diagnosis aid, not as a complete production monitoring or population-statistics system. The README does not specify CrUX fields, freshness, coverage, or fallback behavior when the API fails.

  • Key features: record traces and extract actionable performance insights
  • Disclaimers: Performance tools may send trace URLs to the Google CrUX API
  • Disclaimers: To disable this, run with the `--no-performance-crux` flag
Not stated in the README:The README does not specify the exact CrUX metrics, freshness, or coverage;The README does not document error handling or fallback behavior when the CrUX API is unavailable
It depends I need to run Chrome DevTools MCP in CI, but my organization does not allow default tool-usage telemetry or sending trace URLs to Google CrUX. Can this project meet those constraints?
For: An engineer running Node.js LTS, Chrome, and npm in CI or a shared development environment who must disable usage statistics and avoid Google CrUX requests by default

It depends. The README provides switches for both categories of collection, but compliance still depends on the CI environment and any other outbound-request policies.

  • “Usage statistics” says Google collects tool-call success rates, latency, and environment information by default. --no-usage-statistics opts out, and setting the CI environment variable also disables collection.
  • “Disclaimers” says performance tools may send trace URLs to the Google CrUX API; --no-performance-crux disables that behavior.
  • “Update checks” says the server periodically checks the npm registry by default; CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS disables those checks.
  • “Requirements” still require Node.js LTS, Chrome, and npm, so CI must permit those runtimes and browser processes.

The README does not provide one setting that disables every outbound connection, nor does it document whether other network requests exist. Full offline operation therefore cannot be guaranteed from the README.

  • Usage statistics: Data collection is enabled by default
  • Usage statistics: `--no-usage-statistics`; `CI` environment variable
  • Disclaimers: `--no-performance-crux`
  • Update checks: `CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS`
Not stated in the README:The README does not state whether outbound requests exist beyond telemetry, update checks, and CrUX;The README does not specify Chrome sandbox, permission, or resource requirements in CI

✨ Highlights

  • Chrome DevTools records traces and extracts performance insights
  • Puppeteer waits for action results to support reliable automation
  • Supports network requests, screenshots, and source-mapped console stacks
  • MCP clients can inspect and modify data in the browser instance

🔧 Engineering

  • Exposes Chrome DevTools debugging and performance tools as an MCP server
  • Uses Puppeteer to control Chrome and automatically wait for action results
  • The CLI works without MCP and supports --slim and --headless

⚠️ Risks

  • MCP clients can access browser content, which may expose sensitive data
  • Official support is limited to Google Chrome and Chrome for Testing
  • Usage statistics are enabled by default and may collect invocation and environment data
  • Performance tools may send trace URLs to the Google CrUX API

👥 For who?

  • Developers using Antigravity, Claude, Cursor, or Copilot
  • Teams whose coding agents need Chrome network, screenshot, and console debugging
  • Tool developers building browser subagents with Gemini CLI as a reference