Browser Bridge is a local MCP server + Manifest V3 Chrome extension that lets AI coding agents - Claude Code and OpenAI Codex CLI - control the Chrome you use every day. Because it runs inside your real profile, the agent inherits your cookies, HttpOnly sessions, SSO, and 2FA state automatically. Ask it to "read my feed and summarize it" or - and it works against the live, authenticated app.
Drive your real, logged-in Chrome from an AI agent (Claude Code / Codex) over MCP - 55 tools for browsing, DevTools-grade network capture, and web-security testing.
Estrelas
18
Ferramentas
—
Disponibilidade
—
"capture the API traffic on this page and show me the responses"
It ships 78 tools spanning everyday browsing, DevTools-grade network capture, a full web-security testing toolkit, playbooks (saved, self-healing recipes), session recording - record an interaction into a self-contained, offline-faithful HTML replay (full-page, custom-designed player, with a smooth mouse-trail / click / keystroke overlay) and export it to a high-resolution MP4 - and watch mode, which runs the whole thing in reverse: you browse, and the agent reads a live, labeled timeline of what you did and what the page sent.
Build both packages, run the server, load the extension, connect your agent - about 60 seconds:
git clone https://github.com/vitalysim/browser-bridge.git && cd browser-bridge
( cd server && npm install && npm run build ) # MCP server (TypeScript → dist/)
( cd extension && npm install && npm run build ) # bundles background.js + options.js
( cd server && npm run install-service ) # run the server at login (systemd/launchd)
Load the extension - open chrome://extensions, enable Developer mode, click Load unpacked, select the extension/ folder, then open its options and paste the token from ~/.browser-bridge/token → Save & connect.
Connect your agent:
Claude Code
claude mcp add --transport http --scope user browser-bridge \
http://127.0.0.1:8765/mcp --header "Authorization: Bearer $(cat ~/.browser-bridge/token)"
OpenAI Codex CLI - export the token so Codex can read it, then register the server in one command:
export BROWSER_BRIDGE_TOKEN="$(cat "$HOME/.browser-bridge/token")" # add to your shell profile
codex mcp add browser-bridge --url http://127.0.0.1:8765/mcp --bearer-token-env-var BROWSER_BRIDGE_TOKEN
Verify:curl -s http://127.0.0.1:8765/health → {"ok":true,"extensionConnected":true}. Full details, autostart options, and the manual config alternatives are in Setup.
Update an existing installation
Update the server and extension together from the existing checkout:
git pull --ff-only
( cd server && npm ci && npm run build )
( cd extension && npm ci && npm run build )
( cd server && npm run install-service ) # reinstall/restart the login service on macOS/Linux
Then toggle Browser Bridge Off → On at chrome://extensions to load the rebuilt service worker. For a manually started server, stop the old process and run cd server && npm start instead. Use bridge_status to verify that both versions are 0.19.2. Existing tokens and MCP client configuration stay valid.
Version 0.19.2 removes the replay logo and decorative header, fixes recording startup/navigation loss and input masking, and makes canvas pixels and MP4 dimensions reliable. The appearance and rendering fixes apply to newly generated HTML; existing saved HTML keeps its embedded player.
Why Browser Bridge?
Browser Bridge
Headless Playwright / Puppeteer
A raw CDP debug port
Uses your real logged-in profile
✅
❌ (fresh profile, re-login)
⚠️ blocked on default profile since Chrome 136
Works from Claude Code and Codex
✅
-
-
No open debug port on your session
✅ (outbound WS)
n/a
❌ any local process can hijack it
DevTools-grade capture (bodies, WS)
✅
partial
✅
One-command install, no native host
✅
✅
✅
One server, two clients. Both agents connect to the same token-authed endpoint http://127.0.0.1:8765/mcp. Anthropic's Claude in Chrome is Claude-only and OpenAI's Codex browser extension is desktop-app-only - neither gives the Codex CLI a real browser. Browser Bridge does.
Extension, not a debug port. Chrome 136+ blocks --remote-debugging-port on your default profile. A Manifest V3 extension runs inside that profile instead - banner-free by default, with chrome.debugger (CDP) power features attached only on demand.
Outbound WebSocket, no native-messaging host. The extension dials ws://127.0.0.1:8765/ws; there are no host-manifest files to install, and the WS keepalive keeps the MV3 service worker alive.
Localhost-only + token auth. The server binds 127.0.0.1, checks a bearer token on both the MCP endpoint and the WS handshake, and rejects any WS origin that isn't chrome-extension://.
See it in action
With Chrome open and logged in, just ask your agent in natural language:
# Everyday
list my open tabs
open github.com, read my notifications, and summarize them
# Screenshots
take a full-page retina screenshot of this page and save it to ~/Downloads/page.png
# Network capture
start a network capture on this tab, reload it, and show me the JSON API responses
# Record & export
record my session, I'll click around and type, then stop - build the HTML replay and a 2x MP4
# Web-security (authorized targets only)
capture identity "A" for app.example.com, then log in as B and capture "B";
replay the invoices request as A, B and anon and show me the authz_matrix
# Remote desktop / canvas (e.g. a CTF AttackBox)
screenshot the DCV desktop, click the terminal, type "id" and press Enter, then screenshot the output
# Watch mode - you drive, the agent follows
watch what I do on this site, with network capture
...browse normally...
what did I just do? what did that "Publish" click actually send?
Both Claude Code and Codex drive the same live browser through the same endpoint.
Architecture
Features & tools
Batch multi-step work - browser_batch runs a predictable sequence (navigate → click → fill → press_key → screenshot) in one round trip instead of five. The per-call round trip, not the browser, is what makes multi-step tasks slow, so this is the single largest speedup available.
Browse & interact - tabs, navigation, and click / fill / hover / type / scroll with auto-wait actionability (found + visible + enabled, auto-escalating to a trusted CDP click when a target is overlay-covered), plus file and image upload - all reaching into iframes (incl. cross-origin) and open shadow DOM - and coordinate-level trusted input (input) for <canvas> remote desktops (VNC/RDP/Amazon DCV), games, and drawing apps.
Read & inspect - rendered page text, interactive-element snapshots with stable refs, a compact accessibility tree (role + name + states, refs the action tools accept), screenshots (viewport → full-page retina, element clip, save-to-disk), and JavaScript evaluation that bypasses strict CSP via CDP.
DevTools-grade capture - full request/response bodies, response headers, Set-Cookie, timings, and WebSocket/SSE frames - with durable on-disk persistence and HAR / MHTML evidence export.
Emulate the environment - drive a page as a specific device (viewport/DPR/touch/UA presets), network (slow-3G → offline), CPU, locale/timezone, or geolocation, then emulate_reset back to normal.
Web-security toolkit - named identities, an in-session request replayer, BOLA/IDOR/BFLA access-control diffing (authz_matrix), Burp-style live interception, an intruder-style fuzzer (sniper/pitchfork/clusterbomb/race), passive header/CORS/secret analysis, JWT decode, and copy-as-curl.
Session & storage - read/write the real cookie jar (incl. HttpOnly), localStorage / sessionStorage, and console + CSP + exception logs.
Watch mode (copilot) - the inverse of everything above: you browse and the agent follows along. A content script emits already-labeled events (click <button#publish> "Publish", typed text, SPA route changes) into a cursor-addressable timeline you read with watch_read({since}) - with requests and console errors folded in and attributed to the action that caused them.
Tool
Description
tabs_list · tab_new · tab_activate · tab_close
Manage tabs. tabs_list(short:true) returns id/title/origin/active only (no path/query), for quickly identifying tabs without echoing full URLs
navigate · go_back · go_forward · wait_for
Navigation. waitUntil: "load" (default) / "domcontentloaded" / "none"; a load that hits the ~20s cap returns loadTimedOut:true instead of looking like success, and a navigation blocked by a beforeunload dialog reports it. wait_for waits for a selector, visible text, or role+name, in every frame and open shadow root, for state: "visible" (default) / "attached" / "hidden" / "detached"; an invalid selector fails immediately; with no target it sleeps timeoutMs (default 1000ms)
handle_dialog
Accept or dismiss an open alert/confirm/prompt (accept, promptText). Chrome limit: a debugger can only answer a dialog that opened while it was attached; a dialog that opened earlier is reported as not answerable and must be closed by the user. Avoid that by passing onDialog to the action that opens it (below)
click · fill · hover · type · press_key · scroll
Interaction (iframe + open-shadow aware). Auto-waits for the element to be actionable (found + visible + enabled, timeoutMs) and returns structured {notActionable, reason} on failure. click detects overlay-covered targets and auto-escalates to a trusted CDP click (via:"trusted"); fill/type register in React inputs (native setter) and rich editors (execCommand). Synthetic clicks send the full pointer/mouse sequence (pointerdown…click, so Radix/MUI/react-select menus open) and are dispatched after the tool returns, so a page dialog can't wedge the call; click/press_key return {url, title, urlChanged, newTabId?}. fill verifies the value stuck (selects match option value or visible text; checkboxes take true/false) and fails instead of reporting a silent no-op. A selector that matches several elements acts on one (visible, top frame first) and reports matchCount. **`onDialog: "accept"
input
Coordinate-level trusted input via CDP for targets element selectors can't reach - a <canvas> remote desktop (VNC/RDP/Amazon DCV), a game, a WebGL app. Actions: mouse_move, left/right/middle_click, double_click, left_mouse_down/up, left_click_drag, scroll, type (to the focused element), key (combos like ctrl+c). Coords are CSS viewport pixels (= screenshotPixel / dpr, and screenshot now returns dpr). activate:true to foreground the tab so you can observe
browser_batch
Run a sequence of tools in one call - navigate → click → fill → press_key → screenshot as a single round trip instead of five. The per-call round trip, not the browser, is what makes multi-step tasks slow, so batching whenever you can predict two or more steps ahead is the single biggest speedup available. Runs sequentially and stops at the first failure - a thrown error, or a step that returns {notActionable} / {filled:false} / an error field (so a failed click can't send the next type into the wrong field) - reporting what completed plus the failing index, tool and reason. Set continueOnError:true on a step to tolerate its failure, or stopOnNotActionable:false on the batch to tolerate only not-actionable steps. Cannot be nested; capped at 50 actions. Allowlisted to tools that add no approval surface when batched: navigation + interaction (navigate, go_back, go_forward, tabs_list, tab_new, tab_activate, click, fill, hover, type, press_key, scroll, wait_for), page reads (snapshot, ax_snapshot, get_page_text, screenshot, eval_js), pure functions (jwt_decode, response_diff) and inert status/buffer reads (bridge_status, debugger_status, identity_list, session_record_status, watch_status, net_get_*, console_get, intercept_pending, watch_read - each gated behind a start tool that is itself not batchable; a batched watch_read has its waitMs forced to 0 so it can never stall the sequence). Everything that mutates state, reads credentials, issues outbound requests or touches disk stays a direct call so it keeps its own per-call approval - including cookies_get, storage_dump, input, cdp_eval, tab_close and request_to_curl
file_upload
Set a file input via base64 or a local path (DOM.setFileInputFiles)
paste_html
Paste formatted HTML (plus a plain-text fallback) through the real clipboard into the focused rich-text editor, using a trusted paste so editors that only trust genuine paste events save their model. Replaces the clipboard; never submits a form
paste_image
Paste a local image into a rich-text / contenteditable field; trusted:true uses the real OS clipboard + a genuine Cmd/Ctrl+V for strict editors (e.g. YesWeHack) that ignore synthetic events
Tool
Description
get_page_text
Rendered text of the page (and its iframes). includeHidden:true reads textContent instead of innerText, capturing display:none/collapsed content (e.g. un-expanded accordion bodies) that the default drops. Paged: returns {text, totalChars, offset, nextOffset} - 40k chars per call by default (maxChars up to 55k); call again with offset: nextOffset until nextOffset is null, so a long page is never cut to an unrecoverable preview
snapshot
Interactive elements with refs - each entry has name, role, tag, state (disabled/checked/expanded/selected/value) and inViewport. Open dialogs/popovers come first, then in-viewport elements; elements behind a modal are flagged behindModal (modalOnly:true to drop them). Default limit 400 (max 2000), with count/total/truncated/hint when cut; filter (name text) and viewportOnly narrow it. Custom controls (ARIA roles, labels of visually-hidden checkboxes, summary, tabindex/onclick and pointer-cursor elements) get refs too. Taking any snapshot invalidates refs from earlier ones; a ref whose element changed is re-resolved when unambiguous or reported as stale-ref. deep:true pierces closed shadow roots. Refs are held in an off-DOM registry, so a snapshot no longer mutates the page (a ref whose element was since re-rendered is reported so the caller re-snapshots). Deep-snapshot refs are numbered in their own range per snapshot generation, so they can never be confused with a plain-snapshot ref or a stale one from an earlier deep snapshot
ax_snapshot
Compact accessibility tree (role + accessible name + agent-relevant states: checked/expanded/selected/disabled/required/level/value/focused), indented YAML-like, across iframes and open shadow DOM. Banner-free (a plain ARIA walker, no debugger). Interactive nodes carry a [ref=N] that works with click/fill/hover/type exactly like a snapshot ref. Prefer it over snapshot to understand page structure (landmarks, headings, form fields with their labels) and over get_page_text when you need to act, not just read; interactiveOnly:true trims to actionable nodes. See docs/AX-SNAPSHOT.md
screenshot
Visible viewport (banner-free) by default; fullPage for the whole page, scale for retina, format/quality, selector to clip, savePath to write a file. Returns dpr + CSS viewport size (to map screenshot pixels → input coords) and visibilityState - warns when the tab is occluded (its frame may be throttled/stale)
download_resource
Download a URL to disk via Chrome's own download engine - no size limit unless you pass maxBytes; fails fast on a "dangerous file" verdict, a paused download, or no progress for stallTimeoutMs (30s), correct binary handling, real session cookies, banner-free; savePath to relocate it from the Downloads folder
eval_js
Evaluate JavaScript in the page's main world (banner-free). Auto-falls back to cdp_eval on strict-CSP pages where in-page eval is blocked (via:"cdp-fallback"); cdp:true forces it, noFallback:true disables it. timeoutMs to wait past the 30s default
cdp_eval
Evaluate JS in the page's real main-world context via CDP Runtime.evaluate - not subject to CSP unsafe-eval, so it runs on strict-CSP sites, and reaches the page's live JS (in-memory state, framework internals, closures, the app's own functions). Uses chrome.debugger (shows the banner). timeoutMs raises the 30s cap for a long await/poll
bridge_status
Is the extension connected? Reports the server version beside the loaded extension's version/build stamp, and adds a warning when they don't match (e.g. extension is older than server - reload it at chrome://extensions)
Tool
Description
net_capture_start
Begin capturing; then navigate/reload to record load traffic. excludeExtensionTraffic:true drops non-http(s) requests - your OTHER installed extensions inject scripts and fonts into every page and can outnumber the page's own requests 20:1. maxEntries sizes the in-memory ring (default 500, max 5000); persist:true + savePath also streams each finished request/WS frame to a JSON-Lines file on disk (durable - survives the ring cap and, up to the last batch, a service-worker crash; persistBodies:true includes bodies)
net_get_requests
Requests with headers, Set-Cookie, timings, and (opt-in) response bodies. Redirect hops are kept as distinct entries (each 302 carries its own status + redirectLocation); the final response attaches to the last hop. A body over the size cap reports truncated/originalLength instead of an in-band marker (base64 stays decodable)
net_get_body
Fetch one response body on demand; returns truncated/originalLength when size-capped
net_get_ws_frames
Captured WebSocket / EventSource frames
export_har
Write the tab's captured traffic to a HAR 1.2 file (import into Burp / DevTools / Playwright); bodies included by default. maxBodyBytes caps each inlined body (real size kept in content.size, capped count reported); the on-disk byte size is returned so a huge capture is never a silent write
debugger_detach · debugger_status
End a session (banner off) / inspect sessions
Tool
Description
emulate_device
Set the viewport, DPR, mobile, and touch, plus a UA override. Pass a preset (iPhone 15, iPhone SE, Pixel 8, Galaxy S23, iPad, iPad Pro, desktop, …) or explicit width/height; explicit fields override the preset
emulate_network
Throttle bandwidth/latency or go offline. Preset (slow-3g, fast-3g, wifi, offline) or explicit downloadKbps/uploadKbps/latencyMs; reload to see a page load under it
emulate_cpu
CPU slowdown multiplier (rate:4 = 4× slower, 1 = none)
emulate_locale
Override locale, timezoneId (IANA), and/or acceptLanguage - drives Intl / Date / navigator.language and the request header
emulate_geolocation
Override the coordinate returned to navigator.geolocation (or clear:true). The page's geolocation permission still applies
emulate_reset
Clear all of the above on a tab, returning it to normal
See docs/EMULATION.md for the preset tables and lifecycle (overrides are in-memory and revert when the debugger detaches).
Tool
Description
identity_capture · identity_list · identity_purge
Snapshot/manage named sessions (cookies incl. HttpOnly, storage, bearer)
replay_request
In-session Repeater - replay a captured or ad-hoc request; override any header or swap identity (anon strips auth). viaAppClient:true replays through the page's own fetch so app CSRF/auth interceptors apply
authz_matrix
Replay a request set across identities and diff → flags access-control breaks (BOLA / IDOR / BFLA)
response_diff
Structural diff of two responses (status, length, token-Jaccard, noise-suppressed)
Burp-Proxy-style live interception (CDP Fetch): pause matching requests/responses, then continue (optionally mutating url/method/headers/body), fail (block), or fulfill/modify (synthesize a response). rules auto-apply; otherwise requests queue for resolution
fuzz
Intruder-style fuzzer over a request template - modes sniper / pitchfork / clusterbomb (multi-marker payloadSets) / race (fire N together for race conditions). Per-request status/length/timeMs with anomalies flagged first
analyze
One-call passive recon: grades response security headers (CSP/HSTS/CORS/X-Frame/nosniff/leaks), cookie flags, and sweeps the body for exposed secrets/API-keys/JWTs → findings ranked by severity. deep:true also fetches same-origin external <script src> bundles and sweeps those
jwt_decode
Decode a JWT (header/payload, no verify); flags alg:none, HS/RS confusion, expiry
request_to_curl
Emit a ready-to-run curl command reproducing a captured request (real sent headers incl. Cookie, plus body) or an ad-hoc one - for handoff to a terminal / Burp workflow
Tool
Description
cookies_get · cookies_set · cookies_delete
Read/write the real browser cookie jar via chrome.cookies - includes HttpOnly, with full flags (secure, sameSite, expirationDate)
Read/write this origin's localStorage / sessionStorage
console_start · console_get · console_stop
Buffer console output, uncaught exceptions, and CSP/log violations (via CDP; CSP-independent). Filter console_get by regex pattern / level
save_page
Save the tab as a single self-contained .mhtml evidence snapshot
Tool
Description
watch_start
Begin watching a tab: a content script (<all_urls>, document_start, all frames, persists across service-worker restarts) emits already-labeled semantic events - navigations incl. SPA route changes, clicks with the element's real label and a selector click/fill can reuse, coalesced typed text, special keystrokes, form submits, copy/paste, tab open/close/focus. Follows tabs the watched tab opens (target=_blank, window.open, OAuth popups). network:true captures traffic (attaches chrome.debugger → shows the banner): requests appear in the timeline and the full record - request/response headers, request body, response bodies - streams to disk per tab, surviving navigation (Chrome evicts a response body once its document is replaced, so bodies are fetched eagerly at load-finish). Other extensions' traffic is excluded - on one ordinary page load it was 66 of 69 captured requests. console:true (default) folds in uncaught errors and unhandled rejections banner-free, captured passively from an isolated world - no page global touched. console:"calls" also wraps console.error/warn to catch explicit calls, at the cost of putting this extension's file in the page's own stack traces (and any error telemetry the site ships) - use the CDP path instead if you'd rather not tell a target you're instrumented. redact (auto default / all / none) controls masking of typed values
watch_read
Read the timeline. since is an opaque cursor - pass it back verbatim; it carries the watch id, so a cursor from an earlier server process is detected (reset:true) instead of silently reinterpreted. waitMs (max 25000) blocks until something happens - and a single click or one typed query wakes it right away instead of waiting out the timeout. Returns one compact line per action plus {nextCursor, dropped, more, health}. Requests and errors carry ← #seqcausality that chains through navigations, so a page load doesn't hang 80 requests off one click, and the agent's own clicks/fills are tagged [agent] so they're told apart from yours. file: re-reads a saved digest
watch_detail
The full request + response - headers, request/response bodies, timing - for one net line, by its seq or requestId, read from the watch's on-disk capture (network:true). Drill into a request without a separate capture
watch_status · watch_stop
Is capture actually live (per-tab listener state, ring occupancy, unscriptable tabs)? / stop this watch (by watchId, or the current one - others keep running), flush the in-progress typing burst, close the digest
Blindness is a first-class timeline entry: gap actions (extension-disconnected, sw-restarted, watch-lost, ring-evicted, unscriptable) and health.state distinguish "you were idle" from "capture was down" - including the case where the socket is connected but the extension no longer holds the watch, which otherwise reads as perfectly healthy. Also exposed over plain HTTP at GET /watch so a Claude Code UserPromptSubmit hook can prepend recent activity to every message - continuous awareness with no tool call and no approval prompt. Details: docs/WATCH.md.
Tool
Description
playbook_record_start · playbook_record_stop
Record mode: stream every tool call to a JSON-Lines draft, then stop - a seed you distill into a durable playbook
playbook_save
Write a playbook's Markdown to disk server-side (global home or project-local), regardless of the client's write scope
Tool
Description
session_record_start
Start recording the tab as a session replay (rrweb) - DOM + mutations + input/scroll/mouse (~60 fps), banner-free. allFrames:true also records cross-origin iframes (best-effort, per-frame with a timeout); maskInputs:true redacts form values (default off); recordCanvas:true captures <canvas>/WebGL as image frames the replay paints (canvasFps/canvasQuality/canvasMaxDim/canvasBudgetMB)
session_record_stop
Stop and assemble a self-contained, offline-faithful HTML replay: inlines every external asset (cross-origin CSS/fonts/images/lazy-images) through the extension, strips other extensions' nodes, and renders full-page (fits the viewer at the recorded viewport's exact aspect). A minimal unbranded player (play/scrub, speed, skip-idle, fullscreen) with a live interaction overlay - smooth mouse trail, click ripples, keystroke HUD - toggleable on. Opens offline in any browser. Options: inlineAssets, assetBudgetMB, perAssetMB, skipInactive, autoplay
session_record_status
List active recordings (tab, events file, events so far) - now including whether the recorder is actually alive in the page, probed live, so a recording that died in the browser can't keep reporting as healthy from server-side bookkeeping
render_recording_video
Render a saved replay .html into a high-resolution MP4 (fps, scale up to 4× ≈ retina/4K, crf). Deterministic + frame-exact: seeks the player per frame, captures lossless PNGs, then ffmpeg → H.264. Video = the recorded page + the interaction overlay, matching the live playback
screenshot defaults to a banner-free capture of the visible viewport. Options (these use chrome.debugger, so they show the debugging banner):
savePath returns { path, bytes, width, height } instead of a multi-MB inline image. Capture maxes out at Chrome's ~16384px surface size, and an oversized PNG auto-falls back to JPEG.
Playbooks
Repetitive tasks - "delete this kind of post", "run a BOLA check on an endpoint" - cost expensive first-time understanding (snapshot, find selectors, trial and error). A playbook saves that resolved knowledge to a local Markdown file so the next run is cheap.
A playbook is a self-healing document, not a macro: it records intent + robust role/accessible-name locators + checkpoints + the hard-won "understanding" - never raw clicks, coordinates, snapshot refs, or captured requestIds (those are ephemeral and break next run). The agent runs it with judgment - re-perceiving each step, verifying the target before acting, and re-deriving a step that has drifted - which is the whole advantage over a brittle record-replay macro. Destructive/irreversible steps require confirmation.
Playbooks live at ~/.browser-bridge/playbooks/<slug>.md (global) or ./playbooks/<slug>.md (project-local, git-shareable); every connected agent learns the convention automatically via the MCP instructions field. Capture one with record mode: playbook_record_start → do the task once → playbook_record_stop → distill the draft → playbook_save.
Format, execution protocol, heal/safety rules, and two worked examples (a DOM delete + a BOLA/IDOR flow): docs/PLAYBOOKS.md.
Recording
Record a live interaction and replay it. session_record_start captures the DOM + mutations + input/scroll/mouse over time (rrweb), banner-free; interact with the page; session_record_stop assembles a single self-contained HTML file that plays the whole thing back with a play button, timeline scrubber, and speed control - offline, in any browser.
With allFrames:true, the extension also injects the recorder into cross-origin iframes (which page-level rrweb can't). Injection is CSP-immune, so it records sites and embedded frames a normal recorder can't even load on. Events stream to ~/.browser-bridge/recordings/*.events.jsonl during capture (surviving long sessions), then get inlined with the rrweb-player into the HTML on stop.
The replay is truly self-contained / offline-faithful: on stop, the server fetches every external asset the capture references — cross-origin stylesheets, fonts, images, and lazy-loaded images — through the extension (background fetch under <all_urls> has no CORS wall + sends your session cookies) and inlines them, and strips nodes injected by your other extensions. So it renders from captured data, not by re-fetching the live site (page-level rrweb can't read cross-origin CSS at all).
The player is a minimal unbranded UI: the replay fills the window at the recorded page's exact aspect ratio (rescaling on resize), with a play/scrub timeline, speed, skip-idle, and fullscreen. A toggleable interaction overlay annotates the playback with a smooth mouse trail, click ripples, and a keystroke HUD (typed text, plus physical keys like Enter / ⌘C on new recordings). Then render_recording_video turns a saved .html into a high-resolution MP4 (fps, scale up to 4× ≈ retina/4K) - a deterministic, frame-exact render (seek + lossless PNG per frame → ffmpeg H.264) whose motion matches the live playback. Note: input masking is OFF by default (cleartext values; maskInputs:true to redact); recordCanvas:true captures <canvas>/WebGL as image frames the replay (and the MP4 export) paints - live video pixels still aren't. Details: docs/RECORDING.md.
Recording now registers its disk sink before injection, rejects duplicate starts without replacing the active recording, and flushes final clicks and mutations before navigation. maskInputs:true also covers open shadow-root inputs, contenteditable text, and identifying printable key codes. Slow frames time out independently at stop and are reported in warnings. MP4 output uses the initial recorded viewport × scale, independent of the viewer window: 1600×1000 at scale:1, 3200×2000 at scale:2. Results include the actual encoded width and height.
Watch mode
Everything else in Browser Bridge is agent-driven. Watch mode is the inverse: you browse and the agent follows along, so you can ask "what did I just do?", "what did that click actually send?", or "where did I get logged out?" at any moment.
watch_start({ tabId }) → { watchId, cursor, banner:false }
…you browse normally…
watch_read({ since: cursor }) → the timeline + the next cursor
WATCH live tabs=5 actions=6 dropped=0 more=false
12:04:39.8 #411 click <input#user_login> "Username or Email Address"
12:04:41.0 #412 input <input#user_login> = "attacker" (8 keys / 1.2s)
12:04:41.3 #413 key ↵
12:04:41.4 #414 net POST /wp-login.php → 302 (91ms) ← #412
12:04:41.9 #415 console error "Uncaught TypeError: x is undefined" ← #414
Events are labeled in the page, where the DOM is, so a click arrives as <button#publish> "Publish" with a selector click/fill can reuse - not as an opaque node id. Typing is coalesced into one action with the final value. Requests and errors are attributed to the action that caused them, and the attribution chains through navigations so a page load doesn't hang eighty requests off one click.
This is deliberately not derived from the rrweb recording stream. That was measured first and rejected: rrweb node ids restart at 1 in every document (one missed batch mislabels every later click), SPA routes go up to 30s stale or never appear, a click that navigates in under 300ms is lost to the recorder's batching, and an 8-hour session costs ~910MB against ~120KB. The two are independent and compose - run session_record_start on the same tab when you also want the visual replay. Details: docs/WATCH.md.
Setup
Prerequisites
Node.js 20+ and Chrome, Chromium, or Edge - on Linux, macOS, or Windows (Chromium-based; not Brave/Arc, not WSL)
Claude Code ≥ 2.0.73 and/or OpenAI Codex CLI
1 · Build
git clone https://github.com/vitalysim/browser-bridge.git
cd browser-bridge
( cd server && npm install && npm run build ) # MCP server
( cd extension && npm install && npm run build ) # bundles background.js + options.js
2 · Run the server
The server generates a random bearer token on first run and stores it at ~/.browser-bridge/token (0600). The startup log prints that file path, never the token itself. Read it with cat ~/.browser-bridge/token. The server refuses to start with an empty or too-short token. Pick one:
Autostart (recommended) - one command installs a background service for your OS (systemd user service on Linux, launchd LaunchAgent on macOS):
cd server && npm run install-service # runs at login, restarts on crash
# Linux: to start at boot without an active login: loginctl enable-linger "$USER"
# remove later with: npm run uninstall-service
Manual - just run it in a terminal:
cd server && npm start # or: nohup node dist/index.js >/dev/null 2>&1 & (it writes ~/.browser-bridge/server.log itself)
Environment variables (all optional):
Variable
Default
Effect
BRIDGE_PORT
8765
Port for the MCP endpoint, the extension WebSocket and /health (always bound to 127.0.0.1). Set the same port in the extension options page
BRIDGE_TOKEN
contents of ~/.browser-bridge/token
Use this bearer token instead of the token file (must be at least 16 characters; an empty value refuses to start)
BRIDGE_RETENTION_DAYS
off
Opt-in. Delete files and directories in ~/.browser-bridge/recordings/ and ~/.browser-bridge/watch/ whose last modification is older than this many days - at startup and then daily. Nothing is ever deleted while it is unset. Playbooks, the token and the logs are never touched
BRIDGE_LOG_FILE
~/.browser-bridge/server.log
Where the server writes its own log (off disables the file)
BRIDGE_LOG_MAX_MB / BRIDGE_LOG_KEEP
10 / 3
Size-based rotation: server.log rolls to server.log.1 … .3 at 10 MB
BRIDGE_LOG_STDERR
1
0 stops mirroring log lines to stderr (the LaunchAgent sets this - see Logs)
BRIDGE_TOOLSETS
all tools
Comma list of tool groups to register, e.g. core,devtools. Groups: core (tabs, navigation, reading, interaction, screenshots, eval_js, browser_batch - always included), devtools (network/console capture, cookies, storage, HAR/curl), security (identities, replay, authz_matrix, intercept, fuzz, analyze, jwt_decode, response_diff), watch (watch_*), record (session_record_*, playbook_*, render_recording_video), emulate (emulate_*). Each group's descriptions + schemas are sent to the agent every session (all 77 tools ≈ 16k tokens; core alone ≈ 6.7k), so trimming unused groups saves context. Unknown names are logged and ignored
Logs. The server writes its own log to ~/.browser-bridge/server.log and rotates it by size (10 MB × 3 old files, all 0600) - launchd can't rotate a StandardErrorPath, which is how the old setup grew a single unbounded log. The macOS LaunchAgent points launchd's stdout/stderr at a separate ~/.browser-bridge/launchd.log and sets BRIDGE_LOG_STDERR=0, so that file only ever receives output from before the logger starts (an import-time crash after a bad build, a fatal Node error); the server trims it on startup if it ever passes 1 MB. Under systemd, stderr also goes to the journal. Every line in the server log is prefixed with an ISO timestamp, and each tool call writes one line - <time> [call] <tool> tab=<id> <ms>ms ok|error|notActionable <short reason> - so failures and latency can be measured from the log. Parameter values are never logged. If the port is already taken (usually a second instance), the server logs one line saying so and exits after 30 s instead of crash-looping under launchd/systemd.
Verify: curl -s http://127.0.0.1:8765/health → {"ok":true,"extensionConnected":false} (becomes true once the extension is loaded). Logs: tail -f ~/.browser-bridge/server.log (Linux also journalctl --user -u browser-bridge -f; macOS early-crash output: ~/.browser-bridge/launchd.log).
3 · Load the extension
Open chrome://extensions, enable Developer mode.
Load unpacked → select the extension/ folder.
Open the extension's popup/options → paste the token from ~/.browser-bridge/token → Save & connect. The status turns green.
The token never travels over the WebSocket: the server sends a nonce, the extension answers with an HMAC of it keyed by the token, and the server must answer with its own HMAC before the extension sends anything or runs any command. Something else squatting the port while the bridge is down therefore learns nothing and gets no control; the status shows Server failed authentication. Extension and server versions must match - a v0.18-or-older server rejects the new handshake (status: version mismatch), so rebuild/restart the server when you update the extension. (The server still accepts the old ?token= URL from an older extension for one release, logging it as deprecated.)
Which build is actually running?bridge_status reports the server version and the loaded extension's build stamp. Reloading an unpacked extension gives no feedback, and a stale bundle is indistinguishable from a code bug - if the stamp predates your last npm run build, reload at chrome://extensions. Likewise, if a rebuilt server seems to have no effect, check that only one instance is running: launchctl list | grep browser-bridge (macOS) should show exactly one job, and lsof -nP -iTCP:8765 -sTCP:LISTEN exactly one listener. A second, older service that loses the port race will keep serving stale code while restarts appear to succeed - npm run uninstall-service && npm run install-service resolves it.
Data directory. Everything under ~/.browser-bridge is owner-only: the server runs with umask 077, creates its directories 0700 and files 0600, and on startup tightens existing ones in playbooks/, recordings/, watch/ (captures and recordings contain cookies, auth headers and cleartext form input). recordings/ and watch/ grow without bound unless you opt into BRIDGE_RETENTION_DAYS.
Rotating the token (e.g. after it leaked into an old log): node scripts/rotate-token.mjs --dry-run --update-claude-configs shows what would change; drop --dry-run to write a new token (the old one is kept as token.prev for rollback) and update literal Bearer headers for browser-bridge in ~/.claude.json / ~/.claude-shadow/.claude.json (a .bak is written first). Then paste the new token into the extension options, restart the service, and open a new shell if you export BROWSER_BRIDGE_TOKEN. To remove historical log lines that contain the token: node scripts/scrub-log.mjs --dry-run (counts only), then without --dry-run, then restart the service.
Reloading the extension after an update may prompt for new permissions (e.g. webNavigation, debugger, downloads) - re-enable it if Chrome disables it.
4 · Connect your agent
Claude Code
claude mcp add --transport http --scope user browser-bridge \
http://127.0.0.1:8765/mcp --header "Authorization: Bearer $(cat ~/.browser-bridge/token)"
Codex CLI - export the token, then register with one command:
export BROWSER_BRIDGE_TOKEN="$(cat "$HOME/.browser-bridge/token")" # add to your shell profile
codex mcp add browser-bridge --url http://127.0.0.1:8765/mcp --bearer-token-env-var BROWSER_BRIDGE_TOKEN
Codex reads the token by env-var name, so BROWSER_BRIDGE_TOKEN must be exported in the shell that launches codex (hence adding it to your profile). Verify with codex mcp list.
Platform support
OS
Server
Extension
Autostart
Linux
✅
✅
systemd user service (npm run install-service)
macOS
✅
✅
launchd LaunchAgent (npm run install-service)
Windows
✅
✅
manual (npm start); register with your service manager
Security & responsible use
The agent acts with your real cookies. Treat every tool call as running as you.
Prompt injection is the ambient risk. Pages the agent reads are untrusted input; a malicious page can try to steer it. Keep write-capable tools behind your MCP client's permission prompts and don't point it at pages you don't trust.
Debugger mode is powerful. While attached it can read full request/response bodies (including auth headers) and dispatch trusted input. It shows Chrome's "started debugging this browser" banner, auto-detaches after ~5 min idle (unless actively capturing), and can be ended immediately with debugger_detach.
The security-testing tools are raw offensive primitives with no built-in scope guard - by design. Like Burp Suite Repeater/Intruder/Autorize, staying within an authorized engagement's scope is the operator's responsibility. Only point Browser Bridge at systems you are authorized to test.
No secrets in the repo. The bearer token lives in ~/.browser-bridge/ (gitignored); binding is localhost-only. See SECURITY.md to report a vulnerability.
Limitations
Interaction auto-waits for actionability and, on click, auto-escalates to a trusted CDP click when the target is overlay-covered (via:"trusted", shows the banner); force it anytime with trusted:true. A covered/hidden/disabled target returns a structured {notActionable, reason}.
A strict page CSP (script-src without 'unsafe-eval') blocks the banner-free eval_js; it auto-falls back to cdp_eval (CDP Runtime.evaluate, banner shown), which CSP cannot block. The isolated-world read/interact tools and all CDP/background tools are unaffected by CSP either way.
chrome.debugger requires sole access to a tab - it can't attach if DevTools is open on that tab. net_capture_start only records traffic sent after it's called (navigate/reload to capture a page load).
The capture buffer is in-memory (a ring of maxEntries requests/tab, default 500, ~512 KB/body). An active capture is not torn down by the idle sweep; for a durable record beyond the ring cap use net_capture_start(persist:true, savePath:…), which streams to disk. Persistence is durability, not continuity - if the service worker dies the debugger detaches and capture stops until restarted; the file holds what was captured before that.
One extension connection at a time (last connect wins); multiple MCP clients can share it concurrently. A call in flight when the extension disconnects fails fast instead of waiting out the timeout. The connect path holds a synchronous in-flight guard so two triggers in the same tick (a settings save, a startup alarm) can't open duplicate sockets, and a superseded socket can no longer flip the status to disconnected underneath the live one.
Tool results that would overflow are truncated structure-aware: a large list drops trailing items into a still-valid-JSON {truncated, returned, total, hint} envelope rather than a blind slice that yields a half-object no agent can parse. Every tool error also carries a stable machine code (TIMEOUT, NO_EXTENSION, TAB_NOT_FOUND, NOT_SCRIPTABLE, CSP_BLOCKED, RESULT_TOO_LARGE, UNKNOWN) prefixed to the human-readable message.
An oversized reply no longer drops the connection: the server accepts frames up to 256 MiB and the extension refuses anything past a safe threshold with a RESULT_TOO_LARGE error instead of a frame that would close the socket (which failed every in-flight call). Captured identities and any active session recording are persisted to chrome.storage.session, so they survive a service-worker eviction; on restart the extension also reconciles chrome.debugger targets, detaching any attach an evicted worker left dangling.
input coordinates are CSS viewport pixels, but screenshots are device pixels - map with the dpr the screenshot returns (coord = screenshotPixel / dpr). input is delivered even to a backgrounded tab, but a hidden tab's frame is throttled, so you can't observe the result until it's foregrounded (activate:true / tab_activate); screenshot flags this via visibilityState.
Linux Chromium can still delay hidden-tab frames with keepAlive:true; the hidden-tab-raf-commit regression test exposes this timing/commit limitation. Use tab_activate when an action requires an immediate rendered result.
The default screenshot uses chrome.tabs.captureVisibleTab, which Chrome rate-limits to roughly 2 captures/second. Back-to-back screenshots are therefore spaced automatically (~550 ms apart) rather than failing on the quota; an isolated screenshot - the normal case - waits nothing. The fullPage/scale/selector path uses CDP Page.captureScreenshot and is not subject to this limit.
Watch mode cannot see pages content scripts can't run on (chrome://, the Web Store, view-source:, other extensions' pages) - watch_status reports those tabs as unscriptable, and the timeline records a gap rather than letting a blind spot look like idleness. Typed values are captured in cleartext unless redacted (redact:"auto" is the default and masks password/secret-looking fields; redact:"none" disables it). network:true needs chrome.debugger and therefore shows the banner for the whole session; everything else in watch mode is banner-free. Selectors on hash-heavy CSS frameworks may not be re-queryable.
download_resource always uses the browser's live session - it can't download as a captured identity. Cookie/Host/Origin/Referer/Content-Length in its headers param are browser-forbidden and silently ignored. If Chrome's "Ask where to save each file" setting is enabled, downloads may prompt for a location instead of completing automatically.
Roadmap
Shipped (newest first):
v0.19.2 · Reliable recording and clean replay - unbranded HTML player with compact controls; recording startup, duplicate-start and rapid-navigation fixes; shadow-input/contenteditable/keystroke masking; visible 2D/WebGL/iframe/shadow canvas pixels with document-aware seeking; exact MP4 dimensions, compatible legacy exports and failure cleanup. 255 server tests and 95 e2e tests pass, including six new recording regression scenarios with screenshot and decoded-video pixel assertions. → Recording details
v0.19–0.19.1 · Reliable agents and full tool coverage - bounded browser operations, dialog handling, realistic pointer events, better snapshots and form filling, authenticated WebSocket challenge-response, owner-only data files, configurable toolsets and full e2e coverage of all 78 tools. → Release notes
v0.18.1 · Concurrency correctness - found by stress-testing with several agents driving real navigation and clicking at once. screenshot could return another tab's pixels: captureVisibleTab shoots whichever tab is active in the window, and the activation sat outside the capture lock, so concurrent callers stole each other's active tab - 12 of 16 concurrent captures came back as a different page, reported as success, which for an agent is worse than an error. Activation and capture are now atomic per window. wait_for no longer fails on the commonest usage: a poll landing while the page committed a navigation threw Frame with ID 0 was removed (14 of 24 failures at 8 clients) - a failed poll is just "not there yet". Captures also serialize per window instead of tripping Chrome's capture quota, wait for a real paint signal (two requestAnimationFrame ticks) rather than a blind 350 ms, and share an in-flight capture of the same tab. Net: 19 errors → 0 across 648 calls, screenshot p95 ~9 s → 6.7 s, same-tab bursts p95 ~5 s → 0.85 s, and 16/16 captures return the right tab.
v0.18 · Performance - a measurement-driven pass (30+ tool calls timed end-to-end through the live bridge, on a small form, a ~15k-element synthetic page and Wikipedia). Memory: MCP sessions were only freed when a client sent DELETE, so every crashed or short-lived client leaked its own copy of all 76 tool registrations - observed at 2,303 sessions opened / 26 closed over ~5 days and a 2.9 GB footprint growing ~560 MB/day. Idle sessions are now reaped (never one with a request in flight, so a watch_read long poll is safe) and an unknown session id answers 404 instead of 400, which is the signal an MCP client needs to re-initialize; footprint 2,983 MB → 70 MB. Tokens: JSON results are compact instead of 2-space-indented, which had inflated them 36-96% - snapshot on the big page went 49,489 → 29,873 chars (-40%). Latency: a ref that no frame can resolve now fails immediately with stale-ref/unknown-ref and advice to re-snapshot instead of retrying for the full timeout (5,107 ms → instant; selector misses still retry and notActionable still auto-waits); a plain format:"jpeg" screenshot no longer attaches the debugger (no banner) and its viewport-meta read runs concurrently with the capture; net_get_requests({includeBodies}) finally uses its 6-slot semaphore instead of awaiting each body in turn. Your pages: watch mode built each event's selector + label before checking whether the tab was being watched, so unwatched tabs paid for it on every click and keystroke while any watch was active - all 8 listeners now return early.
v0.17 · Control surface & reliability - a big pass on what the agent can see, drive, and trust. New reads/controls: ax_snapshot (compact accessibility tree - roles, accessible names, states - with [ref=N]s that drive click/fill like a snapshot ref, across iframes + open shadow DOM, banner-free → docs/AX-SNAPSHOT.md); environment emulation (emulate_device / emulate_network / emulate_cpu / emulate_locale / emulate_geolocation / emulate_reset → docs/EMULATION.md); watch_detail (full request/response for one watch-timeline net line); and recordCanvas now actually captures <canvas>/WebGL as image frames the replay and MP4 paint. Reliability: survives the MV3 rough edges - the connect() double-socket race, oversized replies (server maxPayload + a structured RESULT_TOO_LARGE instead of a dropped socket), and service-worker eviction (identities + active recordings restored from chrome.storage.session); faithful redirect-chain capture on an indexed ring; decodable base64 body truncation; session_record_stop no longer loses the tail (drain + streaming parse); bridge_status warns on a server/extension version mismatch; structure-aware, always-valid-JSON result truncation with machine error codes; the bearer token is no longer written to the log; and watch mode gains per-watch watch_stop, server-restart recovery, single-action long-poll wake, correct click→request causality, agent-vs-human labels, and a real SPA-route hook. 101 tests (from 24).
v0.16 · Watch mode (copilot) - the inverse of agent-driven browsing: you browse, the agent follows. A persistent content script emits already-labeled events (click targets with real labels and reusable selectors, coalesced typing, instant SPA route changes) into a cursor-addressable timeline (watch_start / watch_read / watch_status / watch_stop), with network + console folded in and causality that chains through navigations. Blindness is a first-class entry, so silence never reads as inactivity. Also on GET /watch for a prompt hook. Plus five fixes to shipped capture code: flushRecord/flushCapture no longer discard batches when the socket is down, tab close keeps the recorder's last batch, debugger.onDetach reasons are surfaced, abandoned intercepts can no longer hang a page forever, and captured requests carry a real timestamp (fixing export_har's waterfall). net_capture_start also gains excludeExtensionTraffic - on one ordinary page load, 66 of 69 captured requests were other installed extensions injecting scripts and font blobs. First automated tests in the repo (24, via node --test). → docs/WATCH.md
v0.15 · Batching & latency - browser_batch collapses a predictable tool sequence into one round trip (allowlisted to tools that add no approval surface when batched). Plus a latency pass: screenshots no longer pay a flat 350 ms when the tab is already foregrounded (407 ms → 100 ms median, with explicit throttling so bursts can't trip Chrome's capture quota), snapshot walks the DOM once instead of twice and caps the walk itself, and analyze deep / session_record_stop batch what were serial per-item round trips. Three latent fixes: timeoutMs now reaches the hub timer, the capture sink no longer blocks the event loop on fsync, and concurrent debugger attaches on a cold tab share one attach.
v0.14 · MP4 export - render_recording_video renders a saved replay to a high-resolution, frame-exact H.264 MP4 (deterministic seek + lossless-PNG frames → ffmpeg); the mouse-trail / click / keystroke motion matches the live playback. chrome:true includes the player UI.
v0.13 · Designed replay player - a custom replay player with full-page fit-to-viewport rendering and a toggleable interaction overlay: smooth mouse trail, click ripples, and a keystroke HUD (typed text + physical keys).
v0.12 · Correctness & reliability - an audit-driven pass (56-agent review): a silent capture-loss guard on socket replacement, MV3 memory-leak caps, cross-session recording, and robust allFrames injection.
v0.11 · Offline-faithful replay - session_record_stop inlines every external asset (cross-origin CSS / fonts / images, fetched through the extension - no CORS wall) and strips foreign-extension nodes, so the HTML is truly self-contained.
v0.10 · Session recording - record a live interaction and replay it as a self-contained HTML timeline (rrweb; session_record_start / stop / status), banner-free, capturing cross-origin iframes. → docs/RECORDING.md
v0.5 · Security-toolkit foundation - interception, fuzzing, cookie / storage, console / CSP capture, and MHTML.
Exploring next:
A realtime-screencast video mode - to also capture time-based page animation (CSS keyframes / GIF / <video>) that deterministic seek can't pin.
Source-map de-minification on downloads.
GraphQL introspection helpers.
A client-side DOM-XSS / postMessage / prototype-pollution suite.
Project structure
server/ MCP server (TypeScript · @modelcontextprotocol/sdk · ws · express)
src/index.ts HTTP MCP endpoint + auth + session management
src/hub.ts single extension socket, request/response correlation, capture sinks
src/capture-sink.ts durable on-disk JSON-Lines sink for persist captures
src/tools.ts the 68 MCP tools
src/watch.ts watch mode: fold, action ring, cursor, causality, renderer
test/ node --test suites (run with `npm test`)
extension/ Manifest V3 extension (bundled with esbuild via build.mjs)
manifest.json
src/background.ts service worker: WS client, injection, chrome.debugger (CDP) layer
src/watch-entry.ts watch-mode activity listener (ISOLATED world content script)
src/watch-main.ts watch-mode console + history shim (MAIN world, opt-in)
src/options.ts token + connection UI
icons/ generated app icons
scripts/ install-service.mjs / uninstall-service.mjs (systemd or launchd)
docs/ PLAYBOOKS.md · RECORDING.md · WATCH.md · WATCH-SELFTEST.md · banner.svg · architecture.svg
server/vendor/ rrweb-player (inlined into session-replay HTML)
extension/vendor/ rrweb-record.js · bb-watch.js · bb-watch-main.js (injected; built by build.mjs)
Contributing
Contributions are welcome - see CONTRIBUTING.md for the build and dev loop (including the MV3 service-worker reload gotcha) and how to add a tool. Found a security issue in the bridge itself? Please report it privately per SECURITY.md.
License
MIT - see LICENSE. Bundled third-party components (rrweb, rrweb-player - both MIT) are credited in THIRD-PARTY-NOTICES.md.
Disclaimer
Browser Bridge is provided for authorized automation, research, and security testing only. You are responsible for complying with the terms of service of the sites you automate and with the scope of any security engagement. The authors accept no liability for misuse.
B
Browser Bridge
vitalysim·18 estrelas·
Drive your real, logged-in Chrome from an AI agent (Claude Code / Codex) over MCP - 55 tools for browsing, DevTools-grade network capture, and web-security testing.
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Perguntas
Como instalo Browser Bridge?
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
Browser Bridge precisa de uma chave de API?
Este registro não lista nenhuma variável de ambiente obrigatória.
Qual transporte Browser Bridge usa?
Browser Bridge roda localmente via stdio.
Quando Browser Bridge foi verificado pela última vez?
Última verificação: 2026-10-28. Drive your real, logged-in Chrome from an AI agent (Claude Code / Codex) over MCP - 55 tools for browsing, DevTools-grade network capture, and web-security testing.