Chrome DevTools MCP

Official MCP server by Google that lets coding agents control, debug, and performance-check a real Chrome browser via DevTools traces.

Description

Chrome DevTools MCP is a Model Context Protocol server that lets an AI coding agent control and inspect a real, running Chrome browser. It is maintained by the Chrome DevTools team at Google in the ChromeDevTools/chrome-devtools-mcp repository.

At its core, the server uses Puppeteer for browser automation and adds genuine DevTools capabilities on top: recording and analysing performance traces, inspecting network requests, reading console messages, and capturing screenshots.

According to the documentation, tools are grouped into these categories:

Input automation (clicks, keyboard input, forms), navigation automation, emulation (e.g. network throttling, device profiles), performance (trace recording and analysis), network (request inspection), and debugging (console, stack traces).

For simpler tasks there is a reduced slim mode (--slim) with a smaller tool set. It requires an LTS version of Node.js and a current stable version of Chrome; other Chromium-based browsers are not officially supported.

The server runs directly via npx without any prior installation:

Code
npx -y chrome-devtools-mcp@latest

In an MCP client, it is registered through the usual configuration file:

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

The official client configuration guide covers setup for a large number of tools, including Claude Code, Cursor, Codex, VS Code/Copilot, Gemini CLI, Windsurf, Cline, JetBrains AI Assistant, and Antigravity.

What sets Chrome DevTools MCP apart from plain browser automation

Many browser automation tools limit themselves to clicks, input, and reading page content. Per the documentation, Chrome DevTools MCP goes further and brings genuine debugging and performance capabilities normally only accessible through the Chrome DevTools UI itself. A coding agent can therefore not just operate a page, but also measure why it loads slowly, which network requests fail, or which errors show up in the console — information that's often more decisive for debugging web applications than pure interaction ability.

Typical use cases

The server particularly suits tasks where an agent needs to understand the actual state of a web application in the browser: automatically catching performance regressions after a code update, tracing a layout bug through console messages, checking whether a page remains usable under network throttling, or compiling reproducible bug reports with trace data for a development team. For plain content retrieval without interaction or performance questions, a simpler fetch server is often the lighter alternative.

Installation, Options and Privacy

Installation runs through npx with the package chrome-devtools-mcp@latest. The requirements are a current Node.js LTS version, npm and a current stable Chrome. Officially, only Google Chrome and Chrome for Testing are supported; other Chromium browsers may work but are not guaranteed. Start options include --slim for basic browser tasks, --headless, --isolated and --no-performance-crux, which turns off calls to the CrUX API. According to the provider, Google collects usage statistics by default, such as success rates and latency of tool calls. This can be turned off with --no-usage-statistics or the environment variable CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS. The server exposes the content of the browser instance to the MCP client, so no sensitive data should be open there.

Mind the privacy defaults

Important for production use: the server collects anonymous usage statistics for Google by default and, with performance tools enabled, can send trace URLs to the Chrome User Experience Report API. Both behaviors can be disabled via dedicated flags. Anyone running the server in an enterprise setting or against sensitive internal applications should deliberately review and, where appropriate, disable these settings before production use.

Requirements

An LTS version of Node.js, npm, and a current stable version of Chrome (or Chrome for Testing). An MCP client with stdio support.

Installation instructions

Chrome DevTools MCP gives a coding agent access to a real Chrome browser along with DevTools capabilities such as performance traces, network analysis, and console access. Setup needs no prior installation: the server is launched via npx, which downloads it on the fly.

Quick start

Start the server directly via npx and add the command to the client's MCP configuration. A global installation is not required.

For simpler tasks with a smaller tool set, add --slim (optionally combined with --headless). Further options such as --browserUrl, --isolated, --channel, --executablePath, --viewport, or --proxy-server are documented in the official Configuration Guide.

Step 1: Requirements for Chrome DevTools MCP

An LTS version of Node.js and a current stable version of Chrome. Check your Node version with:

Code
node --version

Step 2: Registering Chrome DevTools MCP with your client

MCP clients read their servers from a JSON configuration. The entry for Chrome DevTools MCP looks like this:

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

Where this file lives differs by client. The official client configuration guide documents setup for, among others, Claude Code, Cursor, Codex, VS Code/Copilot, Gemini CLI, Windsurf, and Cline.

Step 3: Slim mode for simpler tasks

If you only need basic browser tasks, reduce the tool set with --slim, optionally combined with --headless:

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

Step 4: Disabling usage statistics and CrUX lookups

By default, Google collects anonymous usage statistics, and performance tools can send trace URLs to the Chrome User Experience Report (CrUX) API. Both can be turned off via flags:

Code
npx -y chrome-devtools-mcp@latest --no-usage-statistics --no-performance-crux

Step 5: Verifying the connection

After restarting the client, test with a simple task such as "Open example.com and take a screenshot" to confirm the browser launches and the agent receives a response. If nothing happens, check whether Chrome (or Chrome for Testing) is actually installed and reachable from the runtime environment — the server doesn't bundle its own browser binary.

Combining flags for CI environments

In continuous integration environments without a display server, --headless is required in addition to --slim if only basic automation is needed; without it, the server may fail to launch a visible browser window and error out. For debugging failed CI runs, temporarily removing --headless locally (on a machine with a display) can help reproduce the issue visually before diagnosing it purely from logs.

Attaching to an existing Chrome process

Instead of launching a new browser every time, the server can connect to an already-running Chrome process via the --browserUrl option, provided it was started with the remote debugging port enabled. This saves startup time on repeated test runs and lets you keep the same browser state across multiple agent sessions.

Troubleshooting missing tools

If the client shows no Chrome DevTools tools after configuration, it's usually malformed JSON syntax in the configuration file or an outdated Node.js version. A second common case is Chrome being installed but not discoverable on the system path — the path to the Chrome binary can then be specified explicitly via --executablePath.

Source: github.com/ChromeDevTools/chrome-devtools-mcp, checked on 2026-09-05.

npx -y chrome-devtools-mcp@latest

Authentication

No login required. The server launches a local Chrome process and communicates with the client over stdio.

Required access permissions

Requires permission to launch and control a Chrome process, plus network access to the visited websites. The client gains access to page content, console output, network data, and performance traces of the controlled browser.

Transmitted or stored data

The server exposes browser content, console messages, network data, and performance traces to the MCP client; per the documentation, sensitive or personal information that should not be shared with the client should be avoided. Performance tools can send trace URLs to the Google CrUX API (disable via --no-performance-crux). By default, Google also collects anonymous usage statistics to improve the tool, which can be disabled via --no-usage-statistics or the CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS environment variable.

Security risks

An agent controls a real browser and, with an authenticated session, can trigger real actions on websites or read confidential content. Page content flows into the model's context and should be treated like any untrusted external text. Run it only with the permissions actually needed and, where possible, in an isolated browser instance.

License and costs

License
Apache-2.0
Cost
free

The open-source server is free to use. Costs may only arise from your own runtime environment or proxies.

Alternatives

Not recorded yet.

At a glance

Provider
Google
Status
Official server
Deployment
Local
Current version
1.8.0
GitHub stars
54,983
Last reviewed
07.09.2026

Repository and documentation

Categories

Supported clients

Related guides

Guides and background related to this entry.

No related guides yet.