Skip to main content
Glama

chrome-control-mcp

MCP server + Chrome extension. Claude (or any MCP client) controls your real Chrome through the DevTools Protocol, in the background. Tool names follow chrome-devtools-mcp, so prompts written for it work here too.

Quick start

Needs Node 18 or newer and Chrome (Edge, Brave and Chromium also work).

npm install -g chrome-control-mcp
chrome-control-mcp setup

No global install? Use npx -y chrome-control-mcp setup instead.

setup opens chrome://extensions and copies the extension folder path to your clipboard. Then:

  1. Turn on Developer mode (top right).

  2. Click Load unpacked and paste the folder path.

  3. Restart Claude Desktop or Claude Code.

The extension gets its token by itself and turns ON. You paste nothing. Loading the extension is the only manual step, because Chrome does not allow silent extension installs.

Check it works: ask Claude "open github.com and take a snapshot".

Related MCP server: Claude Chrome MCP

Commands

Run chrome-control-mcp help any time to see this list.

Command

What it does

setup

One-time install: native host, extension copy, Claude config. Opens chrome://extensions.

serve

Runs one shared server for many clients at http://127.0.0.1:8766/mcp, in this terminal.

start

Runs that shared server in the background.

stop

Stops the background server. --force if it does not answer.

restart

Stops and starts it again.

status

Shows if it is running, how many clients are connected and which Chromes. Exit code 0 when running, 1 when not.

logs

Shows the end of the server log. -n 100 for more lines, -f to follow.

url

Prints the shared server URL with its token.

token

Prints the secret token.

extension

Prints the folder to load in chrome://extensions.

chrome

Starts Chrome with the debugger banner hidden (--silent-debugger-extension-api).

uninstall

Removes the native host registration, host files and the extension copy.

version (-v, --version)

Prints the version.

help (-h, --help)

Shows the command list.

(no command)

Runs as an MCP server over stdio. This is what Claude launches. In a plain terminal it shows the help instead.

setup options:

Option

Meaning

--no-claude

Do not touch Claude Desktop or Claude Code config.

--no-claude-desktop / --no-claude-code

Skip just one of them.

--no-open

Do not open chrome://extensions or copy the path to the clipboard.

--no-flag

Do not add --silent-debugger-extension-api to Chrome shortcuts.

--force

Replace an existing chrome-control entry in Claude Desktop config.

--extension-id <id>

Allow another extension id, for example a Chrome Web Store build.

Setup in detail

setup does five things and prints each step:

  1. Creates the secret token in ~/.chrome-control-mcp/token (never printed).

  2. Installs a small native host in ~/.chrome-control-mcp/native-host and registers it for Chrome, Edge, Brave and Chromium. The extension uses it to read its token and port, so you never paste a token.

  3. Copies the extension to ~/.chrome-control-mcp/extension (a stable folder that survives package updates).

  4. Adds chrome-control to Claude Desktop (a backup .bak-chrome-control is saved next to the config) and to Claude Code, when they are installed.

  5. Hides Chrome's "started debugging this browser" banner by adding --silent-debugger-extension-api to your Chrome, Edge and Brave shortcuts (desktop, Start menu and taskbar on Windows; user launchers on Linux; on macOS use chrome-control-mcp chrome). Fully quit Chrome and reopen it from a patched shortcut for this to take effect. Skip it with --no-flag.

It is safe to run again. Existing entries are left alone unless you pass --force.

Using it

After setup, Claude launches the server itself when needed, so you run nothing by hand. Control is off by default: click the extension icon and use the toggle (it turns on automatically the first time). Turning it OFF closes the connection and detaches the debugger from all tabs.

Example prompts:

  • "Open example.com in a background tab and tell me the page title."

  • "Fill the login form on this tab and click Sign in."

  • "Take a screenshot of the pricing page."

  • "List failed network requests on the current tab."

If you update the package, run chrome-control-mcp setup again, then ask Claude to run reload_bridge_extension (or click reload on chrome://extensions).

Run once, use from many clients

By default each client starts its own server process (they share the one extension connection). To run a single server that every client connects to:

chrome-control-mcp serve            (or npx -y chrome-control-mcp serve)

Windows users can also double-click start-server.cmd if they cloned the repo.

Run it in the background

serve stays in your terminal. To keep the server running without a window, use the daemon commands:

chrome-control-mcp start       start in the background
chrome-control-mcp status      running? how many clients? which Chromes?
chrome-control-mcp logs -f     watch the log (Ctrl+C to leave)
chrome-control-mcp restart
chrome-control-mcp stop

They also work as chrome-control-mcp daemon start and so on. The process id is kept in ~/.chrome-control-mcp/server.pid and the output in ~/.chrome-control-mcp/server.log (readable by you only, and it never contains the token). start does not make the server start by itself after a reboot; run it again after you log in.

The server listens on http://127.0.0.1:8766/mcp (change with CHROME_BRIDGE_HTTP_PORT). Print the full URL, which includes the token:

chrome-control-mcp url

Connect clients to that URL:

claude mcp add --transport http chrome-control "<url from the command above>"

Other clients that support Streamable HTTP MCP can use the same URL. Treat the URL like a password. The HTTP server only accepts loopback connections, checks the Host header and rejects browser Origin headers.

Install by hand

Use this if you do not want setup to edit anything.

  1. Add the MCP server.

    Claude Code:

    claude mcp add chrome-control -- npx -y chrome-control-mcp

    Claude Desktop config:

    { "mcpServers": { "chrome-control": { "command": "npx", "args": ["-y", "chrome-control-mcp"] } } }

    On Windows Claude Desktop use "command": "cmd", "args": ["/c", "npx", "-y", "chrome-control-mcp"].

  2. Get the extension folder and the token:

    chrome-control-mcp extension
    chrome-control-mcp token
    
  3. In Chrome open chrome://extensions, turn on Developer mode, click Load unpacked, pick the extension folder.

  4. Click the extension icon, paste the token, turn on Enable control. (Not needed when the native host from setup is installed.)

Tools (33)

Group

Tools

Input

click, click_at, drag, fill, fill_form, handle_dialog, hover, press_key, type_text, upload_file

Navigation

list_pages, new_page, select_page, close_page, navigate_page, wait_for

Emulation

emulate, resize_page

Performance

performance_start_trace, performance_stop_trace, performance_analyze_insight

Network

list_network_requests, get_network_request

Debugging

take_snapshot, take_screenshot, evaluate_script, list_console_messages, get_console_message

Memory

take_heapsnapshot

Extra

cdp (raw DevTools command), status, list_browsers, reload_bridge_extension

Not included: lighthouse_audit, screencast, heap snapshot analysis tools, extension/PWA/WebMCP categories. Performance analysis is a lightweight reading of the raw trace, not the full DevTools trace engine.

Tab reuse

new_page checks open tabs first. Same URL: the tab is reused. Same site: that tab is reused and navigated. A new background tab opens only when no tab for that site exists. Pass forceNew=true to skip this. close_page only closes tabs opened by the MCP unless force=true.

Hide the yellow debugging banner

Chrome shows "started debugging this browser" with a Cancel button while an extension is attached. An extension cannot hide it; only a Chrome startup flag can. setup adds the flag for you (see above). To do it by hand, add this to the Chrome shortcut's Target field, or run chrome-control-mcp chrome:

chrome.exe --silent-debugger-extension-api

Fully quit Chrome first and turn off "Continue running background apps" in chrome://settings/system so it really quits. Check chrome://version: the flag must appear in the Command Line row. Chrome opened from a shortcut without the flag, or by clicking a link in another app, still shows the banner.

Several Chromes at once

Any number of Chromes can connect to one server, for example your office PC, your laptop and a remote machine. Give each one a name in the extension popup (ADVANCED CONFIG, BROWSER NAME). A random name such as chrome-3fa9 is made for you, and you can change it. Names may use letters, digits, spaces, ., _ and -, up to 40 characters.

  • list_browsers shows which Chromes are connected.

  • list_pages shows the pages of every Chrome. When more than one is connected, each page is marked [chrome: name].

  • A page id already belongs to one Chrome, so tools that take a pageId (click, snapshot, navigate and so on) always act on the right one. The first Chrome that connects keeps its normal page ids. Others get larger ids.

  • new_page takes a browser option with the Chrome's name. With one Chrome connected you can leave it out. With several connected, the tool refuses to guess and asks for the name. The same applies to reload_bridge_extension.

  • If you leave pageId out and more than one Chrome is connected, the tool asks you to choose a page instead of picking one.

  • If two Chromes use the same name, the newer one wins and the older one shows NAME TAKEN in its popup and stops reconnecting. Rename one of them.

Control a Chrome on another PC

By default the extension and the server run on the same computer. To drive the Chrome of a different PC, put the server on one machine and point the extension on the other machine at it.

  1. On the machine that runs the server (where Claude runs), start it listening on the network and note the token:

    set CHROME_BRIDGE_HOST=0.0.0.0        (Windows cmd)
    export CHROME_BRIDGE_HOST=0.0.0.0     (macOS, Linux)
    chrome-control-mcp token

    For Claude Desktop or Claude Code, add CHROME_BRIDGE_HOST to the env of the chrome-control entry. Allow the port (8765) through the firewall.

  2. On the remote PC, load the extension, open the popup, ADVANCED CONFIG, and fill in:

    • ACCESS KEY: the token from step 1 (the remote PC has its own, so paste the server's).

    • SERVER HOST: the IP or domain of the server machine, for example 192.168.1.20 or pc.example.com. Empty means this PC.

    • PORT: 8765, or the port you chose.

  3. Turn the link ON.

With a remote host the extension no longer reads the local token and port from the native host, so nothing you typed is overwritten. Setting the host back to empty returns to local mode.

The connection is plain ws:// and the token travels in the URL, so use it only on a trusted network, over a VPN, or through an SSH tunnel (ssh -L 8765:127.0.0.1:8765 server, then leave SERVER HOST empty). For TLS, put a reverse proxy in front and write the host as wss://pc.example.com, with the port the proxy listens on.

Safety

  • Off by default. Toggle OFF closes the connection and detaches the debugger from all tabs.

  • The WebSocket listens on 127.0.0.1 only, unless you set CHROME_BRIDGE_HOST yourself. It needs a secret token and a chrome-extension:// origin.

  • The shared HTTP server listens on loopback only, needs the token, checks the Host header and blocks browser Origin headers.

  • "Allowed sites" in the popup limits which sites can be controlled. Empty means all http/https sites.

  • Target.*, Browser.*, Storage.* and Network.getAllCookies are blocked through the bridge.

  • The extension can act as you on any allowed site while it is ON. Turn it OFF when you do not need it.

Environment variables

Variable

Default

Meaning

CHROME_BRIDGE_PORT

8765

WebSocket port between the extension and the server.

CHROME_BRIDGE_HOST

127.0.0.1

Address the extension socket listens on. 0.0.0.0 lets a Chrome on another PC connect (see "Control a Chrome on another PC").

CHROME_BRIDGE_TOKEN

saved in ~/.chrome-control-mcp/token

Override the token.

CHROME_BRIDGE_HTTP_PORT

8766

Port for serve.

Troubleshooting

Problem

Fix

Claude says the MCP is not connected

Restart Claude. Run chrome-control-mcp setup again. For Claude Code run claude mcp list.

CONNECTION_CLOSED or the tools time out

Check the extension is loaded and its toggle is ON. Run the status tool.

Extension does not turn on by itself

Run chrome-control-mcp setup, then reload the extension. Or paste the output of chrome-control-mcp token in the popup.

Port 8765 or 8766 is in use

Set CHROME_BRIDGE_PORT or CHROME_BRIDGE_HTTP_PORT and run setup again.

chrome-control-mcp is not found after global install

Open a new terminal. Check that the npm global bin folder is on your PATH (npm prefix -g).

Yellow "debugging" banner is still there

Quit Chrome fully, reopen from a patched shortcut or run chrome-control-mcp chrome. See Hide the yellow debugging banner.

Setup did not edit Claude config

Use Install by hand.

Update and uninstall

Update:

npm install -g chrome-control-mcp@latest
chrome-control-mcp setup

Uninstall:

chrome-control-mcp uninstall
npm uninstall -g chrome-control-mcp

Your token file is kept. Remove the extension in chrome://extensions yourself, and remove the chrome-control entry from Claude Desktop or Claude Code (claude mcp remove chrome-control).

License

MIT

Available Tools

32 tools
cdpC

Send any raw Chrome DevTools Protocol command to a page.

Inputs: method (required), pageId, params.

clickC

Clicks on the provided element

Inputs: uid (required), pageId, dblClick, includeSnapshot.

click_atC

Clicks at the provided coordinates (CSS pixels in the viewport).

Inputs: x (required), y (required), pageId, dblClick, +1 more.

close_pageA

Closes a page by its ID. Only tabs opened by this MCP can be closed unless force is true.

Inputs: pageId (required), force.

dragC

Drag an element onto another element

Inputs: to_uid (required), from_uid (required), pageId, includeSnapshot.

emulateC

Emulates various features on the page. Settings last until the debugger detaches.

Inputs: pageId, viewport, userAgent, colorScheme, +4 more.

evaluate_scriptC

Evaluate a JavaScript function inside the page. Returns the result as JSON.

Inputs: function (required), args, pageId, filePath, +2 more.

fillC

Type text into an input, text area or select an option from a element.

Inputs: uid (required), value (required), pageId, includeSnapshot.

fill_formA

Fill out multiple form elements (inputs, selects, checkboxes, radios) at once. Prefer this over many fill calls.

Inputs: elements (required), pageId, includeSnapshot.

get_console_messageC

Gets a console message by its ID.

Inputs: msgid (required), pageId.

get_network_requestB

Gets a network request by reqid (the latest request if omitted). Includes headers and bodies.

Inputs: reqid, pageId, requestFilePath, responseFilePath.

handle_dialogC

If a browser dialog was opened, use this to handle it

Inputs: action (required), pageId, promptText.

hoverC

Hover over the provided element

Inputs: uid (required), pageId, includeSnapshot.

list_console_messagesC

List console messages for the page since the last navigation.

Inputs: types, pageId, pageIdx, pageSize, +3 more.

list_network_requestsC

Lists the most recent requests for the page since the last navigation.

Inputs: pageId, pageIdx, pageSize, resourceTypes, +1 more.

list_pagesB

Get a list of pages open in the browser.

Inputs: no named parameters.

new_pageB

Open a page. It first looks for an already open tab: same URL is reused as is, same site is reused and navigated. A new background tab is opened only if none exists.

Inputs: url (required), timeout, forceNew, background, +1 more.

performance_analyze_insightC

More detail on a specific insight from the last trace.

Inputs: insightName (required), insightSetId (required), pageId.

performance_start_traceC

Start a performance trace on the page. Use to find frontend performance issues and Core Web Vitals.

Inputs: pageId, reload, autoStop, filePath.

performance_stop_traceC

Stop the active performance trace on the page.

Inputs: pageId, filePath.

press_keyB

Press a key or key combination, e.g. "Enter", "Control+A", "Control+Shift+R". Modifiers: Control, Shift, Alt, Meta.

Inputs: key (required), pageId, includeSnapshot.

reload_bridge_extensionA

Reload the Chrome Control extension (use after updating its files).

Inputs: no named parameters.

resize_pageC

Resizes the page's window so that the page has the specified dimension

Inputs: width (required), height (required), pageId.

select_pageC

Select a page as a context for future tool calls.

Inputs: pageId (required), bringToFront.

statusA

Is the Chrome extension connected? Also shows if this MCP instance owns the port or shares it as a peer.

Inputs: no named parameters.

take_heapsnapshotC

Capture a heap snapshot of the page to a .heapsnapshot file.

Inputs: filePath (required), pageId.

take_screenshotC

Take a screenshot of the page or element.

Inputs: uid, format, pageId, quality, +2 more.

take_snapshotA

Take a text snapshot of the page based on the a11y tree. Lists elements with a unique uid. Always use the latest snapshot. Prefer this over a screenshot.

Inputs: pageId, verbose, filePath.

type_textA

Type text using the keyboard into a previously focused input

Inputs: text (required), pageId, submitKey.

upload_fileC

Upload a file through a file input, or an element that opens a file chooser.

Inputs: uid (required), filePaths (required), pageId, includeSnapshot.

wait_forC

Wait for the specified text to appear on the selected page.

Inputs: text (required), pageId, timeout.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    C2.9/5.0

    Scored across 32 tools

    Disambiguation4/5

    Most tools have clearly distinct purposes (element click vs coordinate click, page snapshots vs screenshots, console vs network listings). A few pairs overlap enough to risk misselection: fill vs type_text vs fill_form, and the three performance_* tools share a narrow domain. Descriptions do clarify these boundaries, so misselection is unlikely but possible.

    Naming Consistency4/5

    The set mostly follows a consistent snake_case verb_noun convention (navigate_page, take_snapshot, click_at, list_pages). Deviations like 'status' (noun without verb), 'cdp' (bare acronym), and 'emulate' (verb without object) are minor and still readable. No mixed camelCase/snake_case confusion.

    Tool Count2/5

    At 32 tools this server is well above the typical well-scoped range and feels heavy for browser control. Several capabilities could be consolidated (performance_start/stop/analyze_insight, take_heapsnapshot, cdp) or are only occasionally needed. The count increases selection burden without proportional unique value.

    Completeness4/5

    The surface covers the core browser-automation lifecycle well: navigation, element interaction, page management, and diagnostics (console, network, performance, heap). Minor gaps exist around cookie/local-storage management and download handling, but these can be worked around via evaluate_script or cdp. No dead ends for common workflows.

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      B
      maintenance
      Use your signed-in Chrome through a local MCP server and companion extension. Supports tabs, navigation, forms, screenshots, and page reading, with a deny-all domain allowlist. Install: npx -y mcp-browser-extension@latest.
      22
      291 npm
      6
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables browser automation through the Claude Chrome Extension, allowing agents to navigate websites, fill forms, take screenshots, and debug web apps via standard MCP protocols.
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Chrome extension + MCP bridge that gives Claude control over your real browser via CDP, enabling navigation, clicking, typing, scrolling, screenshots, and JS execution with a visible cursor and tab-bring-to-front.
      1
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      Enables browser control through your existing signed-in Chrome profile, letting MCP clients like Claude Code manage tabs, navigate, inspect pages, and perform real user interactions via tool calls. Works with any model backend without needing Playwright or a fresh browser profile.
      21
      MIT