Chrome DevTools MCP vs Playwright MCP: Which Browser Server to Use

Short answer: In the Chrome DevTools MCP vs Playwright MCP choice, pick Chrome DevTools MCP when your agent needs to debug a page in Chrome: performance traces, network requests and console errors. Pick Playwright MCP when your agent needs to drive a page in Chrome, Firefox, WebKit or Edge: click, type, fill forms and read the result. Both are free and open source under Apache-2.0, and both run on your own machine.

Both servers give a coding agent a real browser to work with. Our Chrome DevTools MCP page and Playwright MCP page cover each one on its own. This post puts them side by side. If MCP is new to you, start with what MCP servers are.

Chrome DevTools MCP vs Playwright MCP at a glance

What is Chrome DevTools MCP?

Chrome DevTools MCP is a server that lets a coding agent control and inspect a live Chrome browser. It comes from the Chrome DevTools team, and its README lists agents such as Antigravity, Claude, Cursor and Copilot as clients.

Its strength is what DevTools already knows about a page. The README describes three groups of features:

• Performance: it records traces and pulls out performance insights.
• Debugging: it analyzes network requests, takes screenshots and reads console messages with source-mapped stack traces.
• Automation: it drives the page with Puppeteer and waits for each action to finish.

The README also lists skills for specific jobs, including accessibility debugging, memory leak debugging and Largest Contentful Paint (LCP) optimization. Our listing names tools such as performance_start_trace, list_network_requests and evaluate_script.

What is Playwright MCP?

Playwright MCP is Microsoft’s server for browser automation with Playwright. Instead of looking at pixels, it reads the page’s accessibility tree. The README calls this fast and lightweight and says it needs no vision model. Each snapshot gives the model element references, so a click lands on the element the model meant.

Its core tools are always on: click, type, fill form, navigate, snapshot, screenshot, evaluate, press key, wait, file upload and dialogs, plus tab management. More tool groups are opt-in through the --caps option, including network, storage, vision, pdf, devtools and testing. That keeps the default tool list small and lets you turn on more only when a task needs it.

Browser support

This is the clearest split. Playwright MCP’s --browser option accepts chrome, firefox, webkit and msedge, so one server can test a page in several engines. The Docker image supports headless Chromium only.

Chrome DevTools MCP officially supports Google Chrome and Chrome for Testing. Its README says other Chromium-based browsers may work but are not guaranteed, and that support is only guaranteed for the latest Extended Stable Chrome. If you need to check a page in Firefox or Safari’s engine, this server is not the one.

That trade makes sense. DevTools features such as traces and source-mapped errors are built around Chrome, so the server stays close to it.

Setup

Both install with one npx line. Here is the standard config for Chrome DevTools MCP:

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

And the standard config for Playwright MCP:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

Using Claude Code, Playwright MCP is one command:

claude mcp add playwright npx @playwright/mcp@latest

For Codex the README gives codex mcp add playwright npx "@playwright/mcp@latest". Chrome DevTools MCP has a Claude Code plugin: run /plugin marketplace add ChromeDevTools/chrome-devtools-mcp, then /plugin install chrome-devtools-mcp@chrome-devtools-plugins. Our guides to adding MCP servers to Claude Code and adding MCP servers to Codex show the general steps.

You need Node.js for both. Chrome DevTools MCP asks for the current LTS release and a current stable Chrome. Playwright MCP asks for Node.js 18 or newer.

Options worth knowing

Both servers share a few switches. --headless runs without a visible window, and --isolated keeps the browser profile separate from your own. Playwright MCP runs headed by default, so a headless server needs --headless or a configured display.

Chrome DevTools MCP adds --slim, which exposes a reduced tool set for basic browser tasks. Playwright MCP adds --extension, which connects to a Chrome or Edge window you already have open, and --port, which runs it as a standalone server your client reaches over HTTP.

One more detail for Playwright MCP: a persistent profile can be used by only one browser instance at a time. If you run several clients in parallel, use --isolated or give each its own --user-data-dir.

Security and privacy

Treat both as tools that hand a browser to a model.

• Chrome DevTools MCP exposes browser content to the MCP client, so its README says to avoid sharing sensitive data. It collects usage statistics by default. You can turn that off with --no-usage-statistics, and it is off when the CI environment variable is set. The --no-performance-crux option stops it sending trace URLs to the CrUX API.
• Playwright MCP says plainly that it is not a security boundary. Its browser_run_code_unsafe tool runs arbitrary JavaScript in the server process, which the README describes as equivalent to remote code execution. Use it with a model and a client you trust.

On a shared or sensitive machine, an isolated profile is a good habit with either one.

Token cost

Playwright MCP’s accessibility snapshots are text, and a busy page can make a long one. Our listing notes this as the main con. The Playwright project itself says that for coding agents, a CLI-plus-skills approach can use fewer tokens, and that MCP suits persistent, exploratory or long-running work better.

Chrome DevTools MCP is lighter to reason about for narrow jobs, since a trace insight or a list of network requests is more focused than a full page snapshot. Its --slim mode trims the tool list further. We have not measured token use for either server, so test on your own pages before you decide on cost.

Where Chrome DevTools MCP wins

• Performance work. Trace recording and insight analysis are built in.
• Debugging. Network requests and console messages with source-mapped stack traces.
• Chrome fidelity. It works with the real Chrome you ship to.
• A slim mode. A smaller tool set for basic tasks.

Where Playwright MCP wins

• More browsers. Chrome, Firefox, WebKit and Edge.
• Page control. Forms, uploads, dialogs and tabs are core tools.
• No vision model. The agent works from the accessibility tree.
• Flexible setup. Docker, a standalone HTTP server and a browser extension mode.

What neither does

Neither server writes your tests or fixes your bugs. They give the agent eyes and hands, and the agent still has to reason about what it sees. Neither is a security sandbox. Both start from your machine and your network, so a page the agent visits can still try to steer it. And both move fast: pin a version in production work and read release notes before you upgrade.

Can you use both?

Yes, and plenty of setups do. Nothing stops you adding both to the same client. A common split is Playwright MCP for the click-through flow and Chrome DevTools MCP for the question “why is this page slow?” Keep an eye on the combined tool list, since two servers mean more tools for the model to choose from. If that gets noisy, use Chrome DevTools MCP’s --slim option or turn off the extra capability groups on Playwright MCP.

Which should you choose?

• You are debugging speed, layout or console errors in Chrome: Chrome DevTools MCP.
• You need to inspect network requests as a page loads: Chrome DevTools MCP.
• You want an agent to fill forms, click through flows or upload files: Playwright MCP.
• You need Firefox, WebKit or Edge: Playwright MCP.
• You run in Docker or want an HTTP server: Playwright MCP.
• You want the agent to work on a page where you are already signed in: Playwright MCP with --extension.
• You are not sure: start with Playwright MCP for general browsing, then add Chrome DevTools MCP when a debugging task comes up.

FAQ

Is Chrome DevTools MCP better than Playwright MCP?

Neither is better for every job. Chrome DevTools MCP is stronger for performance traces, network inspection and console errors in Chrome. Playwright MCP is stronger for driving pages across several browsers.

Are Chrome DevTools MCP and Playwright MCP free?

Yes. Both are open source under the Apache-2.0 license and run on your own machine. Your agent’s model usage is billed separately by whoever provides the model.

Does Chrome DevTools MCP work with Firefox or Safari?

No. It officially supports Google Chrome and Chrome for Testing. Other Chromium-based browsers may work, but the README does not guarantee it. For Firefox or WebKit, use Playwright MCP.

Does Playwright MCP need a vision model?

No. It works from the page’s accessibility tree, so the model reads structured text rather than screenshots. Screenshots are available as an optional capability.

Can I run both on the same machine?

Yes. Add both to your MCP client’s config. Just remember that each server adds tools the model must choose from, so keep the list tidy.

Which browser server is easier to install?

They are about equal. Each is one npx command, and each needs Node.js. Chrome DevTools MCP also needs Chrome installed.

Keep reading

Details here come from the project READMEs on GitHub plus the Chrome DevTools MCP announcement and the Playwright MCP docs, checked in October 2026. To see more servers like these, browse the Browser and web category or compare the tools they pair with in our best AI coding agents list.