Chrome DevTools MCP
Official MCP server by Google that lets coding agents control, debug, and performance-check a real Chrome browser via DevTools traces.
- Skill Road
- Chrome DevTools MCP
Categories
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:
npx -y chrome-devtools-mcp@latest
In an MCP client, it is registered through the usual configuration file:
{
"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:
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:
{
"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:
{
"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:
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
- 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.