Chrome DevTools MCP (package chrome-devtools-mcp) is an open-source MCP server from the Chrome DevTools team that lets a coding agent open a real Chrome window, read console errors, inspect network requests and record performance traces. This tutorial shows the exact setup for Claude Code and Cursor from the official docs, three first prompts that turn the agent into a front-end debugger, and the settings worth changing before you point it at anything real. It costs nothing to run, and you only need Node.js, npm and a current Chrome.
Why give your coding agent a browser
Most coding agents write front-end code blind. They edit a React component, run the build, and assume the page works because the compiler is happy. The bugs that hurt users, such as a failed fetch, a CORS block, a hydration warning or a 4-second Largest Contentful Paint, only show up when the page actually runs in a browser. The Chrome team's launch post described the problem the same way: agents are "programming with a blindfold on."
Chrome DevTools MCP takes off the blindfold. It speaks the Model Context Protocol, so any MCP-capable client (Claude Code, Cursor, Copilot, Gemini CLI, Codex, Cline, Windsurf and more are listed in the docs) can call DevTools features as tools. Under the hood it uses Puppeteer to drive Chrome and waits for actions to finish, and it pulls in the same performance insights you see in the DevTools Performance panel. The current npm release is 1.13.0, and the repository is licensed under Apache 2.0.
The project has recently been folded into a wider "Chrome DevTools for agents" package that also ships a terminal CLI and agent skills, but the MCP server, the package name and the config below are unchanged.
What you need before you start
- Node.js LTS and npm. The server runs through
npx, so there is nothing to clone. - Google Chrome, current stable or newer. The README says it officially supports Chrome and Chrome for Testing only; other Chromium browsers "may work" without guarantees.
- An MCP client. This guide covers Claude Code and Cursor, but the same JSON works in most clients.
A quick sanity check that works on any OS: run npx -y chrome-devtools-mcp@latest --help in a terminal. On our Linux box with Node 22 it downloaded the package and printed the full list of flags in a couple of seconds. If that command fails, fix Node first; your editor will not do better than your terminal.
Step 1: Add the server to Claude Code
Claude Code has two documented routes. The plain MCP install is one command:
claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest
--scope user makes the server available in every project rather than just the current folder. If you want the bundled skills too (instructions that teach the agent how to chain tools for jobs such as LCP debugging, accessibility audits or memory leaks), install it as a plugin instead, from inside Claude Code:
/plugin marketplace add ChromeDevTools/chrome-devtools-mcp
/plugin install chrome-devtools-mcp@chrome-devtools-plugins
Restart Claude Code afterwards and check that the skills loaded with /skills. The docs warn that if you installed the MCP server earlier, you should remove the old entry first so you don't end up with two copies. If the plugin install fails with Failed to clone repository (common behind corporate firewalls that block git over HTTPS), fall back to the claude mcp add command above, which fetches from npm and skips git entirely, though without the skills.
Step 2: Add the server to Cursor
In Cursor, open Cursor Settings → MCP → New MCP Server and paste the standard config from the README (the docs also offer a one-click install link):
{
"mcpServers": {
"chrome-devtools": {
"command": "npx",
"args": ["-y", "chrome-devtools-mcp@latest"]
}
}
}
The -y flag auto-accepts the npx install prompt, which matters because an MCP client cannot answer it for you. Using @latest means each session picks up new releases; pin a version such as chrome-devtools-mcp@1.13.0 if you prefer predictable behavior over new tools.
The same block works in any client that reads an mcpServers key. On Windows 10, if the client reports MCP error -32000: Connection closed, the troubleshooting guide suggests launching through cmd: set "command": "cmd" and "args": ["/c", "npx", "-y", "chrome-devtools-mcp@latest"].
Step 3: Check that it works
The official first prompt is:
Check the performance of https://developers.chrome.com
Your client should launch Chrome and record a performance trace. One detail that confuses people: connecting to the server does not start a browser. Chrome only opens when the agent calls a tool that needs one, so an idle server with no Chrome window is normal.
The tools your agent gets
The tool reference lists the default set by category: input automation (10 tools such as click, fill_form and upload_file), navigation (6), emulation (2), performance (3), network (2), debugging (10) and memory (14), plus opt-in groups for network mocks, extensions, PWAs, WebAuthn and WebMCP. For front-end debugging, these are the ones that matter most:
list_console_messagesandget_console_message: every console message since the last navigation, with optional source-mapped stack traces (includeStackTraces).list_network_requestsandget_network_request: recent requests, filterable by resource type, with request and response headers and bodies for a single request.performance_start_trace,performance_stop_traceandperformance_analyze_insight: record a trace (optionally reloading the page, with or without cache) and drill into insights likeLCPBreakdownfor Core Web Vitals.take_snapshotandget_css_styles: a text snapshot of the page from the accessibility tree, then the matched CSS rules for an element, ordered by cascade precedence with overridden declarations marked.lighthouse_audit: Lighthouse scores and failing audits for accessibility, SEO and best practices (performance is left to the trace tools).evaluate_scriptandtake_screenshot: run JavaScript in the page and capture what it looks like.
You can see the full category list and our own symptom-to-tool table in the official screenshots at the end of this post.
Your first 3 debugging prompts
Chrome's launch post includes sample prompts such as "A few images on localhost:8080 are not loading. What's happening?" and "Localhost:8080 is loading slowly. Make it load faster." Those work, but agents do better when you name the evidence you want. These are our own versions for a dev server on localhost:3000; adjust the port.
Prompt 1: Fix console errors
Open http://localhost:3000/checkout in Chrome. List all console errors and
warnings with stack traces. For each error, find the source file in this repo,
explain the cause in one sentence, and fix it. Then reload the page and confirm
the console is clean.
This pushes the agent through navigate_page, list_console_messages and back again after the edit, so it verifies its own fix rather than declaring victory.
Prompt 2: Explain failing network requests
Load http://localhost:3000/dashboard and list every network request that
failed or returned 4xx/5xx. For the worst one, show the request URL, method,
status and the response headers, and tell me whether it is a CORS problem,
an auth/header problem or a server bug. Propose a fix in our code.
Asking for headers matters: get_network_request returns them, including Set-Cookie and CORS headers, which is usually where the real answer is.
Prompt 3: Find what slows the page down
Record a performance trace of http://localhost:3000 with a reload and no cache.
Report LCP, CLS and INP if available, pick the single insight with the biggest
impact, analyze it in detail, and make one code change that addresses it.
Record a second trace to compare.
The before-and-after trace keeps the agent honest. Without it, many agents will "optimize" by guessing.
Chrome DevTools MCP vs other browser MCP servers
Chrome DevTools MCP is not the only way to give an agent a browser. The two you will see most often are Microsoft's Playwright MCP and Browserbase's hosted MCP server. They overlap, but they are built for different jobs.
| Chrome DevTools MCP | Playwright MCP | Browserbase MCP | |
|---|---|---|---|
| Price | Free, open source (Apache 2.0) | Free, open source (Apache 2.0) | Hosted service: Free plan $0/mo (1 browser hour), Developer $20/mo (100 browser hours, then $0.12/hr), Startup $99/mo |
| Where the browser runs | Local Chrome (stable, beta, dev or canary), or connect to a running Chrome | Local browser driven by Playwright | Cloud browsers on Browserbase infrastructure |
| How the agent sees the page | Accessibility-tree snapshot, screenshots, DevTools data | Structured accessibility snapshots; no vision model needed | Stagehand natural-language tools: navigate, act, observe, extract |
| Console and network | Built in, console with source-mapped stack traces | Built in (browser_console_messages, browser_network_requests) |
Not among the six documented tools |
| Performance traces | Built in, with DevTools insights and optional CrUX field data | Tracing is opt-in via --caps=devtools |
Not a documented tool |
| Best for | Debugging and profiling your own front end | Cross-browser automation and test-style flows | Scraping and automation at scale, many parallel sessions |
The short version: if the question is "why is my page broken or slow," Chrome DevTools MCP gives the agent the deepest view. If the question is "click through this flow reliably," Playwright MCP is lighter. Its own README now points coding agents toward the Playwright CLI with skills to save context. If you need many browsers in the cloud, Browserbase is a paid service built for that.
Editor's note
Who it's for: front-end and full-stack developers who already use Claude Code, Cursor or a similar agent and keep pasting console errors into chat by hand. It also suits anyone chasing Core Web Vitals, because the trace insights are the same ones DevTools shows.
Who it's not for: people who want unattended scraping at scale (a hosted browser service fits better) and teams that cannot use Chrome specifically.
Gotchas we found in the docs:
- The agent sees everything in that browser. The README warns that MCP clients can inspect and modify any data in the browser instance. Use the default dedicated profile or
--isolated(a temporary profile deleted on close) rather than connecting it to your everyday Chrome. - Usage statistics are on by default. Add
--no-usage-statisticsto the args to opt out. Performance tools may also send trace URLs to Google's CrUX API for field data;--no-performance-cruxturns that off, which you may want for internal URLs. Target closederror: Chrome could not start. Close any running Chrome instances and make sure the latest stable Chrome is installed.ERR_MODULE_NOT_FOUND: usually an unsupported Node version or a corrupted npx cache. Clear it withnpm cache clean --forceand reinstall.- Running as root in Docker or CI: Chrome won't start as root. Run the server as a non-root user.
- Sandboxed clients: if your client sandboxes MCP servers, Chrome may fail to launch; either disable the sandbox for this server or start Chrome yourself and connect with
--browser-url=http://127.0.0.1:9222. - Only the last 3 navigations are kept for console and network data by default (
--max-navigation-saved, 1 to 25), so ask the agent to read logs right after reproducing the bug.
FAQ
Is Chrome DevTools MCP free?
Yes. It is an open-source npm package under the Apache 2.0 license and runs on your own machine. You still pay for whatever model your coding agent uses, and every tool result (snapshots, traces, logs) adds to that model's context.
Can it debug a page that is already open in my Chrome?
Yes. Start Chrome with remote debugging and pass --browser-url=http://127.0.0.1:9222, or use --autoConnect with Chrome 144+ after enabling remote debugging at chrome://inspect/#remote-debugging. Chrome requires a non-default user data directory when you enable the remote debugging port, so a separate profile is the safer default anyway.
Does it work headless, for example in CI?
Yes, add --headless to the args. The --slim flag cuts the tool list to three basic tools (navigation, script execution and screenshots) if you only need light automation and want a smaller context.
Related on lightmind24: Claude Code Errors Fixed: Login, PATH, 429 and Usage Limits · Agent Skills: One SKILL.md for Claude Code, Cursor, Copilot · AWS Emulator Tutorial: Let Coding Agents Test AWS Locally
Set it up once, keep the profile isolated, and your agent stops guessing about what the browser is doing.
Screenshots of the official README and Claude Code setup section, the tool reference and the Chrome for Developers launch post are at the end of this post, along with our own symptom-to-tool table. Screenshots: github.com/ChromeDevTools/chrome-devtools-mcp and developer.chrome.com, captured 2026-11-15; tool-by-task table by lightmind24.
Last verified: 2026-11-15
Sources: GitHub: ChromeDevTools/chrome-devtools-mcp · Client configurations guide · Tool reference · Configuration guide · Troubleshooting guide · Chrome for Developers: Chrome DevTools (MCP) for your AI agent · Get started with Chrome DevTools for agents · GitHub: microsoft/playwright-mcp · Browserbase MCP server docs · Browserbase pricing
lightmind24 is an independent review site, not affiliated with Google, Microsoft or Browserbase.
댓글
댓글 쓰기