Chrome DevTools MCP
Give coding agents direct Chrome automation, debugging, and performance analysis.
The evidence shows MCP roots, path validation, symlink-write defenses, and optional URL allow/block rules, with tests covering several boundaries. Least privilege is not complete because the OS temporary directory remains accessible, the network controls are explicitly not a full sandbox, and browser-control authority is broad. The server assigns validation of tool calls and parameters to the client and shows no built-in per-action user confirmation, so confirmation scores zero. The README thoroughly discloses browser-content exposure, default-on usage statistics, CrUX requests, update checks, and opt-outs, justifying full data-flow transparency. Sensitive-data handling includes warnings and opt-outs, but telemetry is enabled by default, browser data is exposed to clients, WebSocket headers may contain credentials, and no secret-redaction mechanism is shown. Dependency pins, script restrictions, commit-pinned Actions, and prerelease verification provide meaningful supply-chain controls; deductions remain because several dependencies use ranges and no vulnerability scanning or known-vulnerability response evidence is supplied. File writes, extension installation, navigation, and browser modifications are documented external effects, but there is no uniform confirmation gate. Isolation and selected close/uninstall operations offer limited recovery, not general rollback for page or filesystem changes. Repository, author, and licensing attribution are explicit, but registry verification is absent and the supplied files cannot independently establish publisher identity.
The README, configuration, package metadata, and tests are strongly consistent about page identifiers, reconnection, snapshots, structured output, timeout adjustment, and resource access, supporting full self-consistency. Node, Chrome, and npm requirements are clear and important runtime dependencies are pinned, but recommended @latest installation can drift, official browser support is narrow, and no offline or downgrade path is documented. Tests demonstrate explicit errors plus reconnect and fallback notices, and the README links troubleshooting material; however, the supplied excerpts do not show systematic error categories, remedies, and diagnostic context for every tool, so failure messaging is not full-score.
Documentation covers coding agents, a non-MCP CLI, slim basic-browser operation, debugging, performance, network, memory, extensions, and many client configurations, thoroughly addressing audiences and scenarios. Supported browsers, filesystem roots, temporary-directory access, incomplete network guardrails, prompt-injection exposure, and caller responsibilities are stated clearly, earning full capability-boundary credit. Tools are triggered through explicit MCP calls with structured parameters, but the server does not validate agent intent or require confirmation, leaving safety precision dependent on the client. Node and Chrome requirements, a Windows-specific configuration, numerous IDE and CLI integrations, headless operation, browser connection modes, profile paths, and isolation provide strong environment fit.
The README organizes tool reference, CLI, changelog, contribution, troubleshooting, design principles, and generated tool/option indexes well. Installation notes are unusually extensive, covering prerequisites, platforms, clients, and a first verification prompt. Package and MCP names are explicit and option aliases are maintained, but widespread @latest use and inconsistent omission of @latest in some examples reduce naming/version stability. Examples are plentiful, although a complete FAQ is not present in the supplied material. Browser support, telemetry, content exposure, prompt injection, roots, and network-sandbox limitations are documented thoroughly. Apache-2.0 metadata matches the full license text. Package versioning, a changelog link, conventional-commit enforcement, and prerelease checks show a clear update path. SECURITY reporting, an issue tracker, and the Google LLC author field provide maintenance channels, but registry provenance is unverified and no named maintainers or support commitment are supplied.
The product supplies text, images, and optional structured results, while tests cover stable element identifiers, page state, network details, file paths, and snapshot formatting; this strongly supports output usability. Combining DevTools, Puppeteer, performance insights, network, memory, extension, and PWA operations behind MCP and CLI offers clear marginal value beyond basic web automation. Slim and headless modes plus telemetry and CrUX opt-outs mitigate cost, but full operation has a large tool surface, requires launching or attaching to Chrome, and may impose performance, privacy, token, and maintenance costs. No quantitative benchmark is supplied, so cost-benefit is not full-score.
Core capability, risk, and configuration claims trace to concrete README, SECURITY, package, workflow, and test evidence, supporting full claim traceability. Version, license, tool behavior, path restrictions, structured output, and release checks are corroborated across multiple supplied sources. The documentation generally distinguishes official support, possible compatibility, incomplete sandboxing, and client responsibility; however, promotional claims such as reliable automation and full DevTools power lack benchmarks or comprehensive support in the supplied evidence, so fact/inference separation is not complete.
- Usage statistics are enabled by default and are independent of Chrome telemetry settings; use --no-usage-statistics or the documented environment variable when tool-success, latency, or environment data must not be sent.
- MCP clients can inspect, debug, and modify browser data. Do not retain personal information, sessions, or credentials in connected profiles or pages unless disclosure to the agent client is acceptable.
- MCP roots and URL allow/block patterns are not complete system sandboxes, and the temporary directory remains accessible. High-risk use should add OS- or VM-level filesystem and network isolation.
- Web content is returned as-is and may contain prompt injection. Clients should treat page text as untrusted and require confirmation before file writes, extension installation, downloads, or other consequential effects.
- Recommended configurations use chrome-devtools-mcp@latest, which does not preserve the reviewed revision or behavior across upgrades. Controlled deployments should pin an exact reviewed version.
- This assessment is based only on the supplied static files. Code, tests, dependency vulnerabilities, and network behavior were not executed or independently verified, and publisher identity remains unknown to the specified enterprise registry.
What does this agent do, and when should you use it?
Chrome DevTools MCP is a locally run Model Context Protocol server with an additional CLI for workflows that do not use MCP. It connects coding clients such as Codex, Claude Code, Cursor, and Copilot to a live Chrome browser and exposes traces, network traffic, console output, screenshots, and memory data. Puppeteer drives navigation and input automation and waits for action results, while Chrome DevTools supplies deeper debugging and performance analysis. The server can launch a dedicated Chrome profile or attach to an existing browser through automatic discovery, a remote-debugging URL, or a WebSocket endpoint. It is a strong fit for development teams that need browser-level evidence, provided they can accept its Chrome dependency, broad access to browser data, and default telemetry and CrUX behavior.
An MCP client starts npx -y chrome-devtools-mcp@latest over stdio and invokes the server's named tools. The server can drive pages with new_page, navigate_page, click, fill_form, press_key, and upload_file; run page code through evaluate_script; and return state through take_snapshot or take_screenshot. Debugging flows read console and network data with list_console_messages, get_console_message, list_network_requests, and get_network_request. Performance flows use performance_start_trace, performance_stop_trace, and performance_analyze_insight, while lighthouse_audit provides another auditing path. Optional categories add heap-snapshot comparison and inspection, extension management, screencasting, page-exposed third-party and WebMCP tools, and PWA installation or lifecycle operations. By default, the server starts a dedicated Chrome instance on demand, but --autoConnect, --browser-url, and --wsEndpoint can target an existing browser.
- A frontend engineer validating a change can have a coding agent reproduce the interaction, inspect console failures and source-mapped stacks, and examine the associated network requests.
- A performance engineer can record a page trace, extract actionable DevTools insights, and combine laboratory observations with CrUX field data when that default integration is acceptable.
- A test engineer reproducing a real user journey in Chrome can automate navigation, clicks, dragging, forms, keyboard input, dialogs, and file uploads through Puppeteer-backed actions.
- A developer investigating a memory leak can enable
--memory-debugging, capture and compare heap snapshots, and inspect dominators, retainers, retaining paths, duplicate strings, and object details. - A team running its coding client inside a restricted sandbox can connect the server to a host-side Chrome instance through
--browser-urlor--wsEndpoint. - A user who only needs basic browsing can run
--slim --headlessto expose navigation, script execution, and screenshot capabilities without the full tool catalog.
What are this agent's strengths and limitations?
- It exposes Chrome DevTools performance, network, console, Lighthouse, screenshot, and memory functions as explicit agent-callable operations instead of limiting automation to generic clicks.
- It supports a server-launched browser, Chrome 144+ automatic attachment, a remote-debugging URL, and a WebSocket endpoint, covering both local and sandbox-separated deployments.
- Puppeteer performs browser actions and automatically waits for their results, supporting more dependable development checks than raw input dispatch alone.
- The
--slimoption, category switches, screenshot compression, and size limits let adopters reduce tool surface area and conversation context consumption. - Documented setup paths span Codex, Claude Code, Cursor, Copilot, Gemini CLI, VS Code, and numerous other MCP clients, reducing dependence on one model provider.
- Official browser support is limited to Google Chrome and Chrome for Testing; other Chromium-based browsers are explicitly not guaranteed.
- MCP clients can inspect, debug, and modify any data available in the connected browser, creating substantial exposure if a personal profile or sensitive session is used.
- Usage statistics are enabled by default, and performance tooling may send trace URLs to Google CrUX unless adopters disable each behavior separately.
- Node.js LTS, npm, and a compatible Chrome installation are required; extensions, PWAs, WebMCP, memory analysis, and screencasting also depend on experimental switches, connection modes, Chrome versions, or ffmpeg.
- Opening a remote-debugging port allows other local applications to control that browser and requires a non-default Chrome user-data directory.
- The persistent default browser profile can be used by only one browser at a time, so parallel independent sessions need
--isolatedand lose persistent profile state.
How do you install or deploy this agent?
Install Node.js LTS, npm, and the current stable Google Chrome release or newer; Chrome for Testing is also officially supported. Add this to the MCP client configuration:
{
"mcpServers": {
"chrome-devtools": {
"command": "npx",
"args": ["-y", "chrome-devtools-mcp@latest"]
}
}
}
For Codex, the documented shortcut is codex mcp add chrome-devtools -- npx chrome-devtools-mcp@latest. For Claude Code, use claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest. Add --slim and --headless for a minimal headless setup. No API credential is documented as required. Attaching to an existing browser instead requires --autoConnect, --browser-url, or --wsEndpoint; authenticated WebSocket connections can pass headers with --wsHeaders.
How do you use this agent?
Save the MCP configuration, reload or restart the client, and enter Check the performance of https://developers.chrome.com. On the first browser-dependent tool call, the server should launch Chrome, open the site, and record a performance trace; merely connecting to the MCP server does not launch the browser. To share an existing Chrome 144+ session, enable remote debugging at chrome://inspect/#remote-debugging, start the server with --autoConnect, and approve Chrome's permission dialog. For a sandboxed client, start Chrome with a non-default profile—for example, /usr/bin/google-chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-profile-stable on Linux—and configure --browser-url=http://127.0.0.1:9222. Shared-server concurrent agents should use --experimentalPageIdRouting; separate sessions that each launch Chrome should also use --isolated to avoid contention over the default profile.
How does this agent compare with similar options?
Full mode targets deep debugging with automation, performance, network, console, and optional specialist categories; --slim exposes only navigation, script execution, and screenshots for basic browser work and a smaller tool surface. The MCP server is intended for structured integration with compatible coding clients, while the included CLI covers use without MCP. Launching a dedicated Chrome profile provides separation from everyday browsing, whereas attaching to an existing Chrome preserves logins and manual testing state at the cost of greater data-exposure risk.
FAQ
Does it require an API key or paid service?
Can it see logged-in sessions and private page data?
--isolated for a temporary profile that is removed after the browser closes.How do I disable telemetry and external field-data lookups?
--no-usage-statistics to opt out of usage collection and --no-performance-crux to prevent trace URLs from being sent to the CrUX API. Usage collection is also disabled when CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS or CI is set.Why did Chrome not open after the MCP server connected?
--autoConnect or remote debugging, the target Chrome instance must already be running and configured to accept the connection.Can multiple agents share one server?
--experimentalPageIdRouting should be enabled so page-scoped calls can target tabs by pageId. Multiple independent MCP sessions that launch their own browsers should also use --isolated to avoid sharing the default profile directory.