Chrome DevTools MCP vs Claude in Chrome

The core conclusion first: pick by lock-in and subscription before features. Chrome DevTools MCP is a free, open protocol server that works with any agent and owns the strongest debugging toolkit in the category; Claude in Chrome gets you zero-config access to your signed-in browser but serves only Claude, on a paid plan. No paid Claude plan means the choice is already made: DevTools MCP.

Both options put agent and human in one browser. If you want your logins without surrendering your window or picking a vendor, that's ego (lite)'s slot, an agent browser for browser automation, free: any agent drives it through the ego-browser skill, and it works in its own Space so your window stays yours.

Search "claude mcp chrome" and you land between two products that both put an AI agent inside Chrome: Google's Chrome DevTools MCP and Anthropic's Claude in Chrome extension. Here's both layers of the choice, honestly, with the February 2026 task-test data where the marketing pages go quiet.

Why is lock-in the first question?

Because it's the only dimension you can't configure your way out of later. Chrome DevTools MCP registers with one command (claude mcp add chrome-devtools -- npx chrome-devtools-mcp@latest) and the same server serves Cursor tomorrow and a custom in-house agent next quarter; switching coding agents costs you nothing.

Claude in Chrome installs from the Chrome Web Store in one click and attaches to Claude Code with claude --chrome, and if you ever leave the Claude ecosystem, the extension leaves with it.

Neither position is wrong. Vendor integration buys polish (the extension's permission controls are genuinely well designed). Open protocol buys options. But you should pick that trade on purpose, not inherit it from whichever blog post you read first.

A concrete way to feel the difference: imagine your team switches from Claude Code to Codex next quarter. With DevTools MCP, that's codex mcp add chrome-devtools and the same server keeps working. With the extension, your browser workflows don't migrate; they end.

Lock-in is a decision, not a detail.

How do they compare on five dimensions?

Five dimensions cover the practical differences. Note where each cell says what the tool can't do; that's where the decisions actually live.

Anthropic's own safety guidance belongs in this table's margins: the extension ships site-level permissions and confirms before irreversible actions, and the docs still say to keep it away from financial transactions and password management because prompt-injection protections "aren't foolproof." The same caution applies to any agent touching a logged-in browser, DevTools MCP under auto-connect included.

What does real task testing show?

The most useful public data point is ayyaztech's February 2026 hands-on test, which ran all three Claude Code browser tools (these two plus Playwright MCP) against the same tasks.

On diagnostic work, it wasn't close: Chrome DevTools MCP was the only tool with performance profiling at all, returning Core Web Vitals (LCP, CLS, TBT), source-mapped console errors, and deep network inspection, and it could emulate slow 3G and different viewports on demand.

On authenticated work, the finding flipped: Claude in Chrome was the only tool that handled logged-in workflows out of the box, operating through your real sessions on sites like Gmail and Notion, with multi-tab support.

Baseline footprints, for the context-budget minded: the test counted roughly 26 tools (~9% of the context window in definitions) for DevTools MCP against 16 tools (~7.7%) for the extension, with the extension sending the lightest per-action payloads of the three.

We ran our own check the same way today, live, against a simple page: a real MCP session against Chrome DevTools MCP (chrome-devtools-mcp@latest, headless and isolated) listed 29 tools, and a single take_snapshot call on that page came back as 38,285 characters of accessibility-tree text, roughly 9-10K tokens for one snapshot.

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main():
    params = StdioServerParameters(
        command="npx",
        args=["--yes", "chrome-devtools-mcp@latest", "--headless", "--isolated"],
    )
    async with stdio_client(params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            nav = await session.call_tool("navigate_page", {"url": "https://news.ycombinator.com/"})
            print("navigate_page chars:", len("".join(c.text for c in nav.content if hasattr(c, "text"))))

            snap = await session.call_tool("take_snapshot", {})
            snap_text = "".join(c.text for c in snap.content if hasattr(c, "text"))
            print("take_snapshot chars:", len(snap_text))
            print(snap_text[:700])

asyncio.run(main())

# Real output:
# navigate_page chars: 123
# take_snapshot chars: 38285
# ## Latest page snapshot
# uid=1_0 RootWebArea "Hacker News" url="https://news.ycombinator.com/"
#   uid=1_1 link url="https://news.ycombinator.com/"
#   uid=1_2 link "Hacker News" url="https://news.ycombinator.com/news"
#     uid=1_3 StaticText "Hacker News"
#   uid=1_4 link "new" url="https://news.ycombinator.com/newest"
#     uid=1_5 StaticText "new"
#   uid=1_6 StaticText " | "
#   uid=1_7 link "past" url="https://news.ycombinator.com/front"
#     uid=1_8 StaticText "past"
#   uid=1_9 StaticText " | "
#   uid=1_10 link "comments" url="https://news.ycombinator.com/newcomments"
#     uid=1_11 StaticText "comments"
#   uid=1_12 StaticText " | "
#   uid=1_13 link "ask" url="https://news.ycombinator.com/ask"
# ...
#
# Real tool list (29 tools) returned by session.list_tools():
# click, close_page, drag, emulate, evaluate_script, fill, fill_form, get_console_message,
# get_network_request, handle_dialog, hover, lighthouse_audit, list_console_messages,
# list_network_requests, list_pages, navigate_page, new_page, performance_analyze_insight,
# performance_start_trace, performance_stop_trace, press_key, resize_page, select_page,
# take_heapsnapshot, take_screenshot, take_snapshot, type_text, upload_file, wait_for

Same conclusion from both halves: these tools aren't competing on the same jobs. The tester's own setup ended up being both at once, one for debugging, one for authenticated access.

To make the split concrete, here's where five everyday tasks land. Notice that only one of the five is genuinely contested.

Which should you pick, by subscription status?

Subscription status decides more of this than features do, so branch on it first. Each branch below is the whole recommendation; skip to yours.

No paid Claude plan: Chrome DevTools MCP, and the decision is made for you: the extension requires a paid plan, the MCP doesn't. You lose nothing on the debugging side, which is the stronger half anyway.

Paid Claude plan, mostly debugging work: Still Chrome DevTools MCP first; traces and heap snapshots have no equivalent in the extension. Add the extension when a task needs your logins with zero setup.

Paid Claude plan, mostly logged-in web chores: Claude in Chrome earns its slot: dashboard pulls, CRM updates, and email triage are exactly Anthropic's own example list, and no other setup matches its onboarding.

Want logins without lock-in or losing your window: Both options above put the agent in the browser you're using, and one of them ties you to a vendor.

ego (lite) is the branch for people who reject both terms: an agent browser for browser automation, built for sharing your logged-in browser state with AI agents like Claude Code and Codex, where any agent drives it through the ego-browser skill, and the agent works in its own Space with its own tabs, so your window stays yours while tasks run in parallel.

What it doesn't bring: a debugging panel, so DevTools MCP keeps the diagnosis jobs either way.

Compare ego (lite) with Claude in Chrome in detail, or download ego (lite) for Mac, free.

FAQ

What does claude mcp add chrome-devtools do?

It registers Google's Chrome DevTools MCP server with Claude Code: claude mcp add chrome-devtools -- npx chrome-devtools-mcp@latest. After that, Claude Code can drive and debug Chrome through the server's tools; add --autoConnect to attach it to the browser you're signed into.

Can I use both at the same time?

Yes, and it's a sensible pairing on a paid plan: the extension for authenticated tasks, the MCP for traces and profiling. They register through different mechanisms (Web Store extension vs MCP config) and don't conflict.

Is Claude in Chrome available on the free plan?

No. It's in beta on all paid Claude plans; free-tier users see the install but can't run it. Chrome DevTools MCP has no plan requirement at all.

What's the difference between Claude in Chrome and claude --chrome?

Same product, two doors: Claude in Chrome is the extension itself, and claude --chrome (or /chrome in a session) is how Claude Code attaches to it, so terminal-driven work can borrow the extension's browser access. You still need the extension installed and a paid plan for either door.

Which one costs fewer tokens per task?

The extension, on the February 2026 measurements: 16 tools (~7.7% of context in definitions) and the lightest per-action payloads of the three tools tested, versus roughly 26 tools (~9%) for DevTools MCP with heavier diagnostic responses. Neither approaches Playwright MCP's snapshot costs, so for this pair, tokens are a tiebreaker rather than a deciding factor.

Which is better for browser automation, as opposed to debugging?

Neither is the category's automation specialist. The extension automates within Claude's ecosystem and your window; the MCP automates with debugging strength but shares that window under auto-connect. For daily automation on logged-in sites with any agent, an isolated shared-state browser (ego (lite)'s design) fits better, and for cross-browser test automation, Playwright MCP does.