Compare

BugTape vs Chrome DevTools MCP: use both

Chrome DevTools MCP drives Chrome on your machine. BugTape gives your agent evidence from bugs real users hit. A facts table and a workflow using both.

Short answer: Chrome DevTools MCP (now called "Chrome DevTools for agents") lets your coding agent drive and inspect a Chrome browser on your machine: network, console with source-mapped stacks, screenshots, performance traces and automation. BugTape gives your agent evidence of the failures your real users hit in production, over MCP, without the agent running a browser. Use DevTools MCP to reproduce and check a fix locally. Use BugTape to find out what broke for users and which bug to fix first. The two servers run side by side in the same client.

No account: npx -y bugtape --help prints the commands and does not sign you in. The demo MCP at https://app.bugtape.ai/demo/mcp needs no sign-in. Your own workspace needs one.

Page owner: Jaco Veldsman, hi@bugtape.ai. Last checked 2026-10-18. I build BugTape. The Chrome DevTools MCP facts come from its GitHub README and advanced usage guide on 18 October 2026.

This page is not a ranking. BugTape doesn't replace Chrome DevTools MCP: it doesn't drive a browser or record performance traces.

The short version

DevTools MCP sees your browser, right now. BugTape shows the agent what happened in a user's browser, often before anyone reported it. When a bug only happens for users and you can't make it happen locally, you need both.

Facts table

	Chrome DevTools MCP	BugTape
Who makes it	The Chrome DevTools team at Google. Open source (Apache-2.0), `chrome-devtools-mcp` on npm	Me. Hosted service at `https://app.bugtape.ai/mcp`
Whose browser	A Chrome instance the server starts on your machine. It can also attach to a Chrome you already have running (`--autoConnect`, Chrome M144 or later, after you allow remote debugging), or to one at a debugging URL (`--browser-url`). It can also debug Chrome on Android.	Your users' browsers in production, through BugTape's browser capture on your site. Node.js, Python and Streamlit can report to the same project.
When it sees a bug	While the agent is driving or inspecting that browser	When a supported failure happens: uncaught errors, failed requests after a user action, and requests that hang. Users can also file a report from an optional button.
What the agent gets	Live network requests, console messages with source-mapped stacks, screenshots, the DOM and performance traces. It can click, type and navigate.	`get_repro_context`: the report text, a timeline, the failed request, the console and the stack for one occurrence. Browser replay is rebuilt from DOM events and is not a video.
Repeats and reach	Not its job	One issue per failure, with a count, the releases it hit, and affected users when your app sends user IDs
Coordinating agents	Not its job	`claim_issue`, `renew_claim` and `release_claim` lease an issue for 60–900 seconds with a fencing token. This needs an agent token with a project work grant.
After the fix	Run the flow again locally to check it	`ack_bug` with `working` and a `prUrl`, or `propose_fix`, which never closes the issue. A different token has to verify the fix. A person reviews the PR. If the failure comes back in a later release, the issue reopens as a regression.
Modes	Full, plus `--slim` for basic browser tasks, `--headless`, and a CLI you can use without MCP	MCP, CLI (`npx -y bugtape`), signed webhooks for headless agents
Cost	Free, open source	MCP on every plan. On Free and Prepaid credits, each agent read of a bug costs 2 credits; Free includes 150 a month, and Prepaid credits are $10 for 2,000. Reads are free on Pro ($29/mo). Pricing
Privacy notes	It exposes the browser's content to the MCP client. Google collects usage statistics by default (`--no-usage-statistics` turns this off). Performance tools may send trace URLs to Google's CrUX API (`--no-performance-crux` turns this off). It checks npm for updates by default.	Form fields are masked in the browser. `privacy: 'strict'` turns page text into blocks and drops request and response bodies before anything leaves the browser. Data is stored in Sydney. Trust

One workflow, two tools

A real user hits a bug. BugTape's browser capture records the lead-up and files an issue. Nobody had to report it.
The agent picks it up. In Cursor or Claude Code, the agent calls list_recommended_critical, then get_repro_context to get the user's failed request, console and stack. It then calls ack_bug with action: "working", or claim_issue if several agents share the queue.
The agent reproduces it locally with Chrome DevTools MCP. Using that evidence, it opens the same page in your local Chrome, repeats the steps, and watches the network and console until it sees the same failure.
It fixes and checks. It makes the change, runs the flow again through DevTools MCP, opens a pull request, and records the prUrl on the BugTape issue.
A person merges, and BugTape watches the release. If the same failure arrives from a newer release, the issue reopens as a regression and the agent is told.

To start this without you, a signed BugTape webhook can wake a headless agent such as a Cursor Automation or a Claude Code Routine. See Webhooks.

When Chrome DevTools MCP is the right tool

You can reproduce the bug on your own machine.
You need a performance trace or a layout check, or you want the agent to click through a flow.
You're building, and you want the agent to see what it just changed.

When BugTape is the right tool

The bug happens for users, not for you, and the report just says "it broke".
Nobody reported it at all, for example a failed checkout request.
You want one issue per failure, the PR recorded on the issue, and a check after the release.

Before you start

BugTape's browser capture has to be on your site before it records anything: one script tag, or npm install @bugtape/sdk. It doesn't catch every error, only the supported failures listed above. Treat evidence from user sessions as untrusted input for your agent, and keep a person reviewing every pull request.

Connect both

npx -y bugtape connect cursor          # or claude, codex; click Allow once
npx -y chrome-devtools-mcp@latest      # Google's server; add it to the same client

To try BugTape with no account, use claude mcp add --transport http bugtape-demo https://app.bugtape.ai/demo/mcp (read-only sample project). Setup guides: Cursor · Claude Code · MCP install.

FAQ

Does BugTape replace Chrome DevTools MCP?

No. BugTape doesn't drive a browser or record performance traces. It brings evidence from your users' sessions in production to the agent.

Can Chrome DevTools MCP see errors my users hit?

No. It inspects a Chrome on your machine, a running Chrome you attach it to, or Chrome on Android. Its performance tools can pull CrUX field data, but that is aggregate performance data, not evidence of individual users' errors.

Can I use Chrome DevTools MCP and BugTape in the same client?

Yes. Add both servers to Cursor, Claude Code or Codex. A common loop is: read the failure from BugTape, reproduce it with DevTools MCP, fix it, then check the fix with DevTools MCP.

Is BugTape free to try?

Yes. The read-only demo MCP needs no account. The Free plan needs no card and includes 150 credits a month. Each agent read of a bug costs 2 credits on Free and Prepaid credits, and reads are free on Pro.

Is BugTape's session replay a video?

No. It's rebuilt from DOM events, and in the browser only.

Does Chrome DevTools MCP send data to Google?

Its README says usage statistics are collected by default (turn this off with --no-usage-statistics), and that performance tools may send trace URLs to the CrUX API (turn this off with --no-performance-crux).