Chromium Bridge

by dashi96

254 downloads

Not rated

GitHub

About

MCP bridge between Chromium browsers and Claude Code — browser automation tools + Claude chat panel for browsers where the official Claude in Chrome extension doesn't work (Arc, Vivaldi, …)

Details

Author: dashi96
Downloads: 254
Categories: Web Scraping, Other, AI, Automation

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Chromium Bridge

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

From the repository

Add it to your MCP client config:

{
  "mcpServers": {
    "chromium-bridge": {
      "command": "npx",
      "args": ["chromium-bridge"]
    }
  }
}

Then install the extension in the browser profile you want to automate. The tools only work while the server is running (typically an active Claude Code session).

`browser_status`

Check whether the browser extension is connected to the bridge. Returns {connected: boolean}. Read-only, no side effects. Call it first in a session, or when other browser_* tools fail, to distinguish "extension not connected" from page-level errors.

`browser_tabs_list`

List all open browser tabs with their id, title, and URL. Read-only. Use it to pick a tabId for the other browser_* tools; prefer reusing an existing tab over creating a new one when the target page is already open.

`browser_tab_create`

Open a new browser tab and return its id and windowId. Mutating: adds a tab to the user's real browser and focuses it. Use when a fresh page is needed; to work with a page that is already open, find its id via browser_tabs_list instead.

`browser_tab_close`

Close a browser tab by id. Destructive: the tab and its unsaved page state are gone, with no undo. Close only tabs this session created, unless the user explicitly asked to close theirs.

`browser_navigate`

Navigate an existing tab to a URL, or move through its history with url="back" / url="forward". Mutating: replaces the page currently shown in that tab. Returns when navigation is committed; dynamic pages may still be rendering — verify with browser_page_text or a screenshot before interacting.

`browser_page_text`

Get a tab's title, URL, and visible text (up to 80 kB) from the live DOM. Read-only and cheap — prefer it over a screenshot whenever layout does not matter. Content rendered to canvas or images is invisible to it; use a browser_computer screenshot for those.

`browser_computer`

Mouse, keyboard, and screenshots in a browser tab via the DevTools protocol; the tab does not need to be active (first use shows Chrome's "started debugging" info bar — that is expected). Actions: screenshot (viewport image in CSS pixels — its coordinates map 1:1 to click coordinates), zoom (magnified region [x0,y0,x1,y1]), left_click, right_click, double_click, triple_click, hover, left_click_drag (start_coordinate→coordinate), type (insert text at the current focus), key (space-separated combos, e.g. "cmd+a Backspace"), scroll (scroll_direction+scroll_amount), scroll_to (ref), wait (duration, max 10 s). Clicks, typing, and key presses are real input events and mutate page state; screenshot/zoom/hover/wait are read-only. Positions come from coordinate:[x,y] or from a ref returned by browser_read_page/browser_find — refs are more reliable than eyeballed coordinates.

`browser_read_page`

Accessibility tree of the page with a ref id per element; use refs with browser_computer (clicks, scroll_to) and browser_form_input. filter=interactive returns only clickable/editable elements — a compact map of the page. Read-only. Refs go stale after navigation or heavy DOM changes; call again to refresh.

`browser_find`

Find elements by visible text, accessible name, or role, and return their refs for use with browser_computer and browser_form_input. Read-only. Cheaper than reading the whole accessibility tree when you know what you are looking for. An empty result means nothing matched — not an error.

`browser_form_input`

Set a form control's value directly in the DOM: input/textarea/contenteditable (text), select (option value or label), checkbox/radio ("true"/"false"). Fires input/change events so frameworks pick the value up. Mutating. Target by CSS selector or ref. Reliable for plain form fields; rich editors (CodeMirror and the like) and custom comboboxes often ignore it — for those, click the field with browser_computer and type.

`browser_click`

Click an element via DOM .click() by CSS selector. Mutating. Works without the debugger — including on pages where CDP attach fails — but only fires the click handler, with no hover/focus/mousedown chain. If the page ignores it (custom dropdowns, canvas UI), use browser_computer left_click for a real mouse event.

`browser_upload_file`

Put local files into an <input type="file"> selected by CSS selector, as if the user picked them in the file dialog (fires change). Mutating. files are absolute paths on the user's machine; the input must already exist in the DOM.

`browser_javascript`

Run arbitrary JavaScript in the page context and return the resolved value (await is supported; runs with the page's own permissions). Can read and mutate anything on the page — treat as mutating unless the code is clearly read-only. Never call alert/confirm/prompt: modal dialogs freeze all automation. Requires the CDP debugger.

`browser_console_messages`

Read a tab's console output (log/warn/error), newest 200 entries. Read-only unless clear=true, which empties the buffer after reading. Messages are captured only from the first time a CDP tool touches the tab — nothing is recorded retroactively; reload the page after attaching to capture its startup logs. Use pattern (regex) to cut noise.

`browser_network_requests`

List a tab's network requests (method, URL, status), newest 200. Read-only unless clear=true, which empties the buffer. Captured only from the first CDP touch of the tab — reload the page after attaching to see its full traffic. urlPattern (regex) filters by URL.

`browser_resize_window`

Resize the browser window that contains the tab to width×height CSS pixels. Mutating and user-visible: it resizes the user's real window. Use for reproducing responsive layouts or framing a recording, and consider restoring the original size afterwards.

`browser_gif_start`

Start recording the tab into an animated GIF: a frame every intervalMs (default 800 ms); on long recordings the frame rate halves automatically so the whole scenario fits in ~80 frames. One recording per tab at a time; starting twice is an error. Nothing is saved until browser_gif_stop.

`browser_gif_stop`

Stop the recording started by browser_gif_start and write the animated GIF to an absolute path on the user's machine. Mutating: creates or overwrites that file. Errors if no recording is active or no frames were captured.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "chromium bridge": {
            "chromium-bridge": {
                "command": "npx",
                "args": [
                    "chromium-bridge"
                ]
            }
        }
    }
}

McpServers

{
    "chromium-bridge": {
        "command": "npx",
        "args": [
            "chromium-bridge"
        ]
    }
}

MCP server + Chrome extension that connects Claude Code to Chromium browsers (Arc, Vivaldi, Brave) where the official Claude in Chrome extension doesn't work.

A bridge between your Chromium-based browser and Claude Code. The official "Claude in Chrome" extension connects in some Chromium browsers (Arc, Vivaldi, and others) but automation hangs: its tools are built on the tab groups API, which is missing or broken there. This bridge uses only plainchrome.tabs/chrome.scripting/chrome.debugger, so it works in any Chromium browser that can load an extension.

Claude driving the browser through the bridge — opening Wikipedia, typing a search, and landing on the article:

Claude Code ⇄ (stdio MCP) ⇄ server/index.mjs ⇄ (WebSocket, 127.0.0.1:8929) ⇄ extension in the browser ⇅ (WebSocket /chat) chat panel (popup on the extension icon)

- extension/— an MV3 extension: the service worker keeps a WebSocket to the local server and executes its commands (tabs, navigation, page text, screenshots, clicks, form filling). Clicking the icon opens the chat panel (chat.html) — a popup anchored to the extension icon.
- server/— an MCP server (stdio) that exposes thebrowser_tools to Claude Code and proxies them to the extension. It accepts WS connections only from achrome-extension://…Origin — regular web pages cannot connect. It also serves the/chatchannel: panel messages run through the Claude Agent SDK (authenticated via the Claude Code login) with the samebrowser_tools; built-in tools (Bash, Read, etc.) are disabled.

An equivalent of the "Claude in Chrome" side panel: a popup that opens when you click the extension icon (nochrome.sidePanel— it is not supported everywhere). The chat can see the browser: list tabs, read pages, take screenshots, and click.

The panel UI is in English by default and switches to Russian automatically when the browser UI language is Russian. A language selector (Auto / English / Русский) in the bottom bar overrides auto-detection; the on-page badge follows the same choice.

- The popup closes when it loses focus (clicking the page) — that is browser behavior. The conversation context is not lost: the panel remembers the session_id and the server resumes the conversation via the Agent SDKresume. A turn that is in flight when the popup closes is interrupted.
- It only works while the server is running (usually an active Claude Code session with thechromium-bridgeMCP); otherwise the panel shows "Server unavailable".
- Model picker in the panel header: "Default" takes the model from~/.claude/settings.json(whatever was set via/model; SDK sessions do not read Claude Code settings themselves, the server passes the model explicitly), the other entries are hard overrides. Switching applies on the fly (setModel) and is remembered. Startup override:CHROMIUM_BRIDGE_CHAT_MODEL=sonnetin the server environment. Port:CHROMIUM_BRIDGE_PORT(8929 by default) — server side only; the extension always connects to 8929, so changing the port also means editingWS_URLinextension/sw.jsandextension/chat.js.
- Chat history: the 🕓 button in the header lists past conversations (stored in the panel's localStorage, the last 30).
- After each turn there is a usage line: turn tokens (↑ input incl. cache / ↓ output) and the accumulated session cost in $ (on a subscription this is an estimate, not a separate bill).
- Screenshots the agent takes along the way are shown right in the chat feed (click to expand). They are not saved to history (localStorage is finite).
- You can paste images from the clipboard (Cmd+V in the input, up to 5 per message) — the model sees them; only a marker remains in history.
- "Ask before acting" mode (checkbox above the input): reading (tabs, text, screenshots, console, network) proceeds without questions, while mutating actions — clicks/typing/navigation/JS/forms/closing tabs/file uploads — wait for an Allow / Deny card. The agent sees a denial and continues the conversation. Toggling applies immediately, without recreating the session (via the Agent SDK's canUseTool).

When Claude acts on a tab (from the panel or from Claude Code):

- an orange glow burns around the page edges with a "✳ Claude is working…" badge, fading 2.5s after the last action;
- a virtual cursor (an orange arrow) glides to the action point and pulses a ring on click; it disappears after 3.5s of inactivity.

Both are hidden on screenshots so they don't end up in the frame and confuse the model when working with coordinates. On pages where scripts cannot be injected (chrome://and the like) the indication is silently skipped.
-

Extension: clone this repository, openchrome://extensions(in the right space/profile!), enable "Developer mode", click "Load unpacked", and pick theextension/folder.

- via npm:claude mcp add -s user chromium-bridge -- npx chromium-bridge
- from the clone:cd server && npm install, thenclaude mcp add -s user chromium-bridge -- node "$(pwd)/index.mjs".

It loads at session start — restart your Claude Code session after installing the extension.

For other MCP clients, add this to your config:

{ "mcpServers": { "chromium-bridge": { "command": "npx", "args": ["chromium-bridge"] } } }

Check: thebrowser_statustool should return{"connected": true}.

Everything except basic tab operations works throughchrome.debugger(CDP): screenshots don't require activating the tab, clicks are real mouse events, and console/network are collected from the first CDP touch of the tab.

- The extension lives in one browser profile — install it in the one you want to automate.
- While the server is running, its periodic ping keeps the extension's service worker awake. If the worker is asleep anyway (e.g. the server has just started), a keepalive alarm wakes it within ~30 seconds, and the server waits up to 12 seconds for reconnection before erroring.
- Trust model: the WS server listens on 127.0.0.1 and rejects connections whose Origin is notchrome-extension://…, which keeps web pages out. It does not distinguish between extensions, and a non-browser local process can fake the Origin header — anything running as your user is trusted, like with most local dev tools. Don't run the bridge on a shared machine.
- On the first CDP action the browser shows a "Chromium Bridge started debugging this browser" bar — that's normal, the debugger is the control mechanism. Closing the bar detaches the debugger (the next action re-attaches it).
- Console/network are not recorded retroactively — only after the tab is first touched.
- Port 8929 is owned by one session: a second parallel Claude Code session cannot start its own WS server (the extension stays with the first one).

An MCP server that lets an AI agent (like Claude) read data from Discord servers through your own account. It pairs with a BetterDiscord plugin, so the Python side never handles your token — data is read straight from the already-authenticated Discord client.

Web scraping skill for Claude AI. Crawl websites, extract structured data with CSS/LLM strategies, handle dynamic JavaScript content. Built on crawl4ai with complete SDK reference, example scripts, and tests.

KYB due diligence, competitive intelligence, and strategic accounts research for AI agents. KYB covers corporate registries, sanctions screening (OFAC/UN/EU/UK), FCA Register lookup, directors, UBOs, and adverse media. CI covers pricing, hiring, product, sentiment, and corporate events. New accounts get 3 free trial calls. Pay-per-call after: $0.40 per /findings, $2.00 per /run with Claude analysis. Top up from $20 at getsonar.report.

Scrape Google Maps business leads (names, phones, emails, websites, ratings) from Claude, Cursor or any MCP client via the gmapsscraper.io API.

The Import.io Web Scraper MCP server brings hosted scraping, browser automation, proxy routing, captcha handling, and structured data extraction into your AI tools. Point Claude, ChatGPT, Cursor, or any MCP client at our hosted endpoint. Import.io runs the scraping engine, you just connect.

Screenshot & Render API for AI Agents. MCP Server lets Claude, Cursor capture webpages and render HTML.

Give Claude web browsing powers - fetch webpages, extract data, discover sitemaps, summarize content

Fetches content from deepwiki.com and converts it into LLM-readable markdown.

Extract documentation for AI agents from any site with llms.txt support. Features MCP server, REST API, batch processing, and multiple export formats.

Scrape LinkedIn profiles, companies, and jobs using direct URLs. Features Claude AI integration and secure credential storage.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

browser_status

browser_tabs_list

browser_tab_create

browser_tab_close

browser_navigate

browser_page_text

browser_computer

browser_read_page

browser_find

browser_form_input

browser_click

browser_upload_file

browser_javascript

browser_console_messages

browser_network_requests

browser_resize_window

browser_gif_start

browser_gif_stop

Claude Desktop / Cursor

McpServers

Install

More like this

@mendableai/firecrawl Mcp Server

Sequential Thinking

Filesystem

EverArt

Google Drive

Puppeteer

`browser_status`

`browser_tabs_list`

`browser_tab_create`

`browser_tab_close`

`browser_navigate`

`browser_page_text`

`browser_computer`

`browser_read_page`

`browser_find`

`browser_form_input`

`browser_click`

`browser_upload_file`

`browser_javascript`

`browser_console_messages`

`browser_network_requests`

`browser_resize_window`

`browser_gif_start`

`browser_gif_stop`