List the page animations: CSS animations, transitions, Web Animations and View Transitions, each with selector and ref, animated properties, duration, delay, easing (linear() curves included), iterations, play state, timeline (document, scroll, view). composited_estimate guesses whether only transform/opacity/filter move (an estimate, not the compositor's answer); fade_only marks opacity-only fades, what prefers-reduced-motion should leave. Without duration_ms: what runs now. With duration_ms: records every animation that starts in the window, optionally after an action (hover, click, scroll, key), since a 150 ms transition is over before a second call. Refuses on a hidden page. Pair with emulate_media reducedMotion to check the reduced version; how smoothly they run is frames.

Assert a page condition, polling until timeout: element exists/visible (optionally with count or containing text), text on page, tab url/title. Patterns: substring, or "/…/" for regex. Recorded flows replay it as a test. Unlike wait_for, which returns found: false, a failure is an error naming what did not match; success returns passed and waited_ms.

One-call page audit, pick the kinds: accessibility, keyboard (tab order and focus issues), SEO, security headers, broken links, Core Web Vitals, unused CSS, resources (which plugin/theme/module/host slows the page), cache (is the CDN serving the new version). A summary line per kind; with save_to the full Markdown report with every finding. Read-only. For one deep look at load speed use perf_trace, for Lighthouse scores lighthouse.

Save files the page builds itself, with no browser download and no "Save as" dialog: blob and data URL links (a[download]), window.showSaveFilePicker writes, and downloads the page starts (cancelled at once, bytes fetched again with the browser cookies). arm with save_dir, then click Export/Download, then wait: it returns the saved paths. A file with a URL: http_request save_to instead. Names are cleaned, existing files never overwritten, size capped by max_mb.

Click an element by CSS selector or by a ref (n1, n2…) from get_interactives or navigate. A real pointer sequence: it can submit, open a dialog or navigate — use wait_after. Not idempotent; a native confirm() blocks the bridge: handle_dialogs first. Returns page_changed (url, title and DOM deltas: nodes, text, open, expanded, checked, dialogs, focus): the effect, without a screenshot; when the click opens or reveals something, the refs of the visible interactives follow, no get_interactives needed.

Read or write the system clipboard (text). Activates the tab and focuses its window first. write overwrites whatever the user had copied, which is not recoverable. To fill a field use type_text instead of write and paste; read checks what a Copy button copied, and an empty clipboard returns text "".

Cookie and consent-banner audit: clears this site's cookies, reloads, records cookies and third-party requests BEFORE consent, accepts the banner, records again; the findings name the trackers contacted before consent. Logs you out of the audited site.

Open a new tab, optionally at a URL, and make it the implicit target of later commands in this session. Each call creates another tab: reuse a tab_id or navigate() to move an existing one instead of piling up tabs.

Dismiss cookie banners/modal overlays: OneTrust, Cookiebot, Usercentrics, then generic heuristic. Idempotent.

Drag an element onto another. html5 = DragEvent+DataTransfer; pointer = pointer/mouse events (sortable libraries). It scrolls the source into view and returns once the events are sent, without knowing whether the app accepted the drop (check with assert or query_dom); a missing element is an error.

Screenshot cropped to one element or to a viewport region (PNG), optionally enlarged. Read-only. The cheapest image in the set, because it carries only the box you asked for — and with scale the way to read fine print: crop the box, zoom it, verify.

Make the page believe it runs elsewhere, until reset or reload: prefers-color-scheme, prefers-reduced-motion, print mode, navigator.userAgent/platform. user_agent changes only what page JS reads — the request header is network_rules modify_header. via "page" (default for these) only patches matchMedia and, for reduce, zeroes every animation: the site's own @media rules do not apply. via "debugger" emulates like DevTools, so the site's @media (prefers-reduced-motion) rules really apply — use it to check reduced motion with animations — and adds contrast, CPU throttling, network profiles, device viewport with DPR, touch (these imply via debugger). via debugger keeps Chrome's "started debugging this browser" bar until reset: true; in launch mode nobody sees it. Pair with viewport_resize to emulate a device in page mode.

Run JavaScript in the page (MAIN world). Requires the extension's "Allow user scripts" toggle; errors explain setup if disabled. Use it when no dedicated tool fits: extract or extract_table read data, query_dom inspects elements, inject_css restyles, and none of them needs the toggle. A promise is awaited up to timeout. A cut result stays valid JSON and says truncated; save_to writes the whole result to disk.

Read repeated non-tabular structures — product cards, list items, search results — as one record per item: item_selector matches the repeating block, fields map output names to selectors relative to it. Read-only, deterministic, parsed server-side from the main-document HTML. Default output: total and shown, then one tab-separated row per item under the field names; a field with no match is empty (null in json).

Read a real as JSON: thead cells become keys, each row an object. Only for tabular markup — where filters rows server-side, so one matching row out of 1500 costs a few hundred bytes instead of the whole document. row_count is the table total, match_count how many rows passed the filter. No table at index is an error saying how many the selector found; for cards and lists use extract.

Batch fill form fields with React-compatible events. Handles input, select, checkbox, radio, and textarea. Fields and submit take a CSS selector or a ref (n1, n2…) from navigate/get_interactives. With submit_selector it also submits, so a repeated call submits twice — not safe to retry blindly; after a submit, after_submit carries url, title and the text the page gained (the confirmation or the errors). Each field reports value_after and mismatch; page_changed carries the DOM delta, and the refs of what appeared.

Where is a setting in an unknown admin panel: follows the panel's menu links (same origin) until a page contains the keyword. Returns the URL, the menu path (Settings › Media) and the matching text; when nothing matches, how many pages it tried. Navigates the tab and leaves it on the last page visited, at most max_pages.

Find text on the page: parent selector, context, visibility, position per match. Attaches nearby interactive elements (with refs for click/type_text/hover) for the first visible match. Use it when you know the words on screen but not the selector (query_dom needs one); no match returns count 0.

Record the page for duration_ms and report how smooth it ran: main-thread frame rate and dropped frames, Long Animation Frames (duration, blocking time, render and style/layout start, the scripts responsible), layout shifts with the elements that moved (CLS for the window only), and the slowest interaction (INP for the window, split into input delay, processing, presentation; needs trusted input, synthetic events have no interaction id). Optionally runs an action (click, hover, scroll, key) right after recording starts. Animations that started are counted too. Compositor-only animations can stay smooth while the main thread drops frames. Refuses on a hidden page: rAF and observers stop there. For load speed use perf_trace; for the settings of each animation, animations.

Full-page capture by scrolling: stitched segments of ~2 viewports (≤1568px), or one image per viewport with stitch=false. Expensive: ~2.7k image tokens per segment, only max_segments returned, the rest via segment_offset. Reading the text you need is cheaper by an order of magnitude — prefer read_page, extract or find_text unless layout is the question.

Why an element looks the way it does: for each CSS property the winning declaration — selector, stylesheet, rule position, !important, @layer, @media — and the ones it overrides, like the Styles panel of DevTools; query_dom gives the computed value, this gives who set it. Read-only, from the CSSOM: stylesheets of another origin without CORS are opaque and listed by href; user-agent styles, @container and @scope rules are not evaluated. properties narrows the output.

List frames (main + iframes) with frameId, parent, URL — for the frame_id parameter of DOM tools.

List actionable elements (buttons, links, inputs, [role], [onclick]) with ready-to-use CSS selector, label, position, flags. Prefer this over dumping HTML to discover selectors. Document order, cut at limit (count equal to limit: there may be more), each with a ref (n1, n2…) for click, type_text and hover. The full list also names the WebMCP tools the page declares, if any.

Page metadata: title, url, visibility, doctype, charset, meta tags, scripts, stylesheets, links and forms. visibility=hidden means the window is minimized, covered or in the background: the page does not render (screenshots fail) and its timers slow down. dev.server names a dev server (vite, webpack-dev-server, next, nuxt) and dev.overlay carries the compiler message when an error overlay is open: read it before treating the page as valid. For the text use read_page, for specific elements query_dom, for the bridge itself get_status.

Status of the bridge itself, not of a page: call it when a tool you expect is missing or browser commands fail (connected=false: the extension is not reachable, extension_install gives its Chrome Web Store link). Also reports mode (primary/relay), host, port, server and extension versions, js_evaluation (false under --no-js), write_root, read_root, session_tab_id (the implicit tab), owned_tabs (created by this session), uptime_sec, webmcp (whether WebMCP is active in the session tab, and how to enable it). caps_active and caps_available: a missing tool lives in an inactive cap. enable is the only change it makes: it switches caps on for this session, no restart, and lists the tools added. Optional caps: audits (cookie_audit); visual (inject_css, measure_spacing, emulate_media, viewport_resize); perf (animations, frames, perf_trace, screencast, lighthouse, heap_snapshot); network (http_auth, set_geolocation, track_events); storage (get_storage, set_storage, session_fixture); dom (modify_dom, watch_dom, drag_and_drop); files (save_page, manage_downloads, session_record).

Read localStorage, sessionStorage or cookies of the current origin (type=all for every one). Read-only. Cookies come with domain, path, expiry and the httpOnly/secure flags, so this also answers whether a session cookie is present — write them back with set_storage, or snapshot a logged-in state with session_fixture.

List every open tab with id, url, title, active flag and mine (created by this session). Find a tab_id when the implicit target is not the one you mean. include_windows adds position, size, state and type of each window — needed before moving or tiling. Session tabs gone since the last call come back once in closed_session_tabs with the reason (closed, window_closed, replaced, closed_by_bridge).

Auto-accept/dismiss future JS dialogs (alert/confirm/prompt), logging them. reset restores native dialogs and returns the log.

Hand the browser to the user for what only a person can do — 2FA, CAPTCHA, login, a choice — and wait: a banner in the page shows your message with Done/Cancel, the call returns on click or timeout, redirects included. pick_element: the user clicks an element and you get its selector. Never type credentials yourself. ask: the user types a reply in the banner ("which of the three?") and you get it as answer. pick_max: with pick_element, up to N elements; the user presses Done when finished.

Take a JS heap snapshot of the tab (after a garbage collection) and summarize it: object count, total size, detached DOM nodes, the classes that take most memory. With compare_to (an earlier snapshot file): which classes grew, to find a leak — snapshot, repeat the suspect action a few times, snapshot again. The .heapsnapshot file opens in DevTools > Memory. Works only in launch mode (chrome-bridge --launch [--headless]): it needs the DevTools port of the dedicated browser, which the extension in your own Chrome cannot provide: Chrome refuses the HeapProfiler domain to extensions.

Hover over an element, by CSS selector or ref. Default: synthetic mouseenter/mouseover/mousemove, which fire JS hover handlers but not CSS :hover. trusted moves the real mouse pointer (chrome.debugger), so CSS :hover rules and their transitions apply.

Set/clear credentials for HTTP Basic/Digest auth dialogs (browser-wide, in-memory only).

HTTP request sent from the browser, with the logged-in user's cookies: fetches what a server-side request gets a login page for (invoices, authenticated JSON, exports). Text bodies inline (capped by max_length); save_to writes the bytes — the way to read a PDF, since read_page returns nothing on a PDF tab, and the way to save any file that has a URL: no click on Download, no browser download, no "Save as" dialog.

Inject a CSS rule into the page. Stays until the next navigation or reload, and re-injecting the same id replaces it rather than stacking. Affects only what is rendered — the stylesheet of the site is untouched.

Run a full Lighthouse audit (performance included, unlike chrome-devtools-mcp, plus accessibility, best practices, SEO) and return scores, the five lab metrics and the failing audits that weigh most; the full report goes to .report.json and .report.html files. Works only in launch mode (chrome-bridge --launch [--headless]): it needs the DevTools port of the dedicated browser, which the extension in your own Chrome cannot provide. Loads the URL in a new tab of that browser; takes 20-60 s; the first call downloads Lighthouse through npx.

List downloads, start one, or wait for the newest to finish. Files land in the browser Downloads folder, not on the server. download reports the real state: with Chrome set to ask where to save, it comes back waiting_for_user — bytes fetched, nothing moves until someone picks a destination. To save a file that has a URL use http_request with save_to instead: browser cookies, bytes on disk, no dialog; a file the page builds goes through capture_downloads.

Measure the gap, overlap and distance in CSS pixels between two elements, with their margins and paddings. Read-only. Values come from the current layout, so zoom and viewport size change them: viewport_resize({zoom:1}) and a fixed viewport_resize make results comparable across runs.

Change an element in the live DOM: setAttribute, removeAttribute, addClass, removeClass, setStyle, setTextContent. Nothing is persisted — the next reload restores the page as the server sends it. For styling many elements at once inject_css is one call instead of N.

Monitor network requests. source=page: XHR/fetch hook (installed on first call); source=browser: all requests incl. static assets; source=websocket: connections and messages. format=har exports HAR 1.2. It only observes: to block, stub or rewrite requests use network_rules, to send one yourself http_request.

Move an existing tab into another window (chrome.tabs.move), keeping id, history and page state; works on chrome-untrusted:// tabs too. The destination must be a normal window: out of an app/popup window is fine, into one is refused. A ChromeOS Terminal tab can be pulled out (new_window, window_type popup) but never merged back: extensions cannot create app windows.

Navigate a Chrome tab to a URL and wait for the load; DNS and connection errors fail the call. Without tab_id it reuses the tab this session last navigated or created, else opens a new one rather than taking over the active tab. Returns a preview of interactive elements with refs usable in click/type_text/hover, plus the first console errors and failed requests, if any, and the WebMCP tools the page declares.

Network interception, browser-wide, survives reloads until cleared: block, redirect, set/remove headers, stub a synthetic body, or record real API responses and replay them with forced errors/latency (local helper; from HTTPS pages the stub host must be trusted). It changes traffic, while monitor_network only observes it and http_request sends one request; each rule comes back as added, list shows them, clear removes them all.

Record a DevTools performance trace and return its conclusions, never the trace: LCP with its phases (TTFB, resource load delay and duration, render delay), FCP, CLS (session windows), INP, the document request, render-blocking resources, long tasks with the function responsible, long animation frames. The raw trace goes to a JSON file (path and size in the result) that DevTools > Performance can load. action record (default) = start, reload unless reload: false, optional action, wait duration_ms, stop. start/stop bracket anything else done meanwhile. Uses chrome.debugger: Chrome shows its debugging bar while tracing; in launch mode nobody sees it. Refuses on a hidden page. For smoothness during an interaction use frames, for scores lighthouse.

Send a key to the focused element (or to selector, focusing it first) as a real keydown/keypress/keyup sequence, so framework handlers fire. For typing a value use type_text; this is for Enter, Tab, Escape, arrows and shortcuts. Not idempotent: two calls send the key twice. Returns page_changed like click; when the key opens or reveals something, the refs of the visible interactives follow.

Query DOM elements by CSS selector, returning structure, attributes, bounding rect and, with properties, computed styles. Use it when you already have a selector (no match: count 0); to find one, get_interactives or find_text; for the rule that set a style, get_css_styles.

Read console messages captured since page load, incl. uncaught errors and unhandled rejections. clear deletes the messages it returns, hence not read-only; since=cursor reads only newer ones without deleting, and failed requests are in monitor_network.

Read a form as the user filled it — label, type, value, checked/selected, required-but-empty, browser validity — to check it against the project's documents before an irreversible Submit. Password and card values come back [redacted]. Read-only, on request; to change values use fill_form.

Read the page as text (default), markdown, raw HTML, or accessibility tree. Read-only. markdown keeps headings, links and tables at a fraction of the HTML cost. Expensive on big pages: HTML on a large table costs tens of thousands of tokens for data you filter anyway — prefer extract_table/extract for repeated content, get_interactives for click targets.

Save the full page (DOM, styles, images) as an MHTML archive file on the server filesystem. An offline copy Chrome reopens as it looked, for evidence or a later comparison (for an image use screenshot, for the text read_page); it overwrites output_path and returns path and size.

Record the tab as a video (.mp4 or .webm) to watch an animation or interaction frame by frame; returns the file path and size, never the frames. action record (default) = start, optional interaction, wait duration_ms, stop. start/stop bracket anything else done meanwhile (max 120 s). Chrome sends a frame only when the page changes; the video keeps the real timing. Needs the tab active and its window visible, and ffmpeg on the server machine (without it: the JPEG folder and the ffmpeg command). Uses chrome.debugger: Chrome shows its debugging bar while recording; in launch mode nobody sees it.

Screenshot of the visible viewport only (PNG), at the current scroll position, or one per viewport preset with presets. Read-only. Activates the tab in the background without stealing window focus, then restores the previous tab. Downscaled to ≤1568px: for fine print, element_screenshot with scale.

Visual regression: save a named baseline (viewport, element, or a PNG such as the design mockup) and compare later — changed-pixel % and a red-highlighted diff; or compare_urls: production vs staging in this tab, pixels plus text diff, logged-in pages included. Baselines are in-memory (lost on service worker restart).

Scroll. action=to: once to element/coordinates; action=until: repeatedly until element visible, network idle, or no new content (infinite scroll). It moves the tab's scroll position and returns it (to) or stopped_reason and steps (until); full_page_screenshot scrolls by itself, wait_for waits without scrolling.

Snapshot localStorage, sessionStorage and cookies of the current origin into a named fixture (a logged-in state, usually), restore one, or list them. save overwrites silently; restore writes on top without clearing and refuses on a different origin — cookies would attach to the wrong site.

Record the commands of this session as a replayable jsonl (chrome-bridge replay --file ); observe what the user does in a tab ("watch how I do it") into the same format plus a readable procedure, never recording sensitive values; export a recording as a Playwright test for CI. Replays target the tab they navigate. Use it for a flow to repeat or a procedure to hand over; for one check now, assert.

Override navigator.geolocation with fixed coordinates (page-level patch). reset restores native. For location-based pages (store locators, delivery zones): it answers without a permission prompt, and a reload or navigation drops it, so call it after navigate.

Write, delete or clear a localStorage/sessionStorage key, or a cookie with its path, domain and expiry. action=clear wipes every entry of that type for the origin and cannot be undone — on a site the user is logged into, clearing cookies logs them out. Read the current values first with get_storage.

Tab lifecycle: close, activate, reload, back, forward, discard, mute, duplicate, close_session (only tabs this session created). close drops unsaved work and cannot be undone — it may be the user's tab. reload drops injected CSS, emulations and hooks. duplicate works where create_tab is forbidden (chrome-untrusted://) and lands in the source window, app windows included. discard replaces the tab id.

Tile Chrome windows over one monitor in equal parts with no gap. Only Chrome windows. The monitor is the one of a window already on it, whose work area is read from a page there: at least one target needs a scriptable tab (not chrome://). Maximized windows are restored first, since maximized ignores bounds. To restore a saved arrangement use window_layout; to move one tab into another window, move_tab.

Decode the tracking beacons the page fired (GA4, Meta Pixel, Google Ads, TikTok, LinkedIn, Pinterest, Microsoft Ads, GTM, Hotjar, Clarity) from the browser network log: one line per event with its key params. Read-only; POST-body params are flagged, not decoded.

Put text into an input, textarea or contenteditable, by selector or ref. Replaces the whole value through the native setter (React/Vue controlled inputs register it) and fires input and change. mode=keys emits keydown/input/keyup per character for autocomplete and masked fields: slower, use it only when mode=set leaves the field empty. Returns value_after; mismatch=true means the field did not keep the value: retry with mode=keys.

Set a file on input[type=file] from the server filesystem via DataTransfer (max 200 MB; over 6 MB it travels in pieces). Keys and credentials (~/.ssh, ~/.aws, ~/.gnupg, .env*, *.pem, .key, id_…) are refused, and a --read-root on the server limits the readable tree: the call fails with an error, nothing is read.

Resize the Chrome window to a preset (mobile 375x812, tablet 768x1024, desktop 1440x900) or explicit dimensions; the viewport is smaller by the browser chrome, action=get reports the real one. width/height override half a preset. A maximized window on ChromeOS ignores the request.

Block until a condition holds: element, text, function (JS expression; needs the "Allow user scripts" toggle), navigation (mode=spa for client-side routes), network_idle. Polls until timeout (10s element/function, 15s the rest) then returns found: false with a reason instead of raising: check it, or a failed wait reads as success. Read-only.

Keep watching a page in the background — "tell me when the pipeline is green / the Approve button appears / this number changes" — checked every interval_s by the extension. Events are collected, not pushed: action=poll, or a script blocking on "chrome-bridge watch --wait ". Survives extension idling, not a browser restart. poll returns one line per event (time, name, kind, url, value, previous); a change due within seconds is wait_for.

Watch DOM mutations (MutationObserver) under selector, to see what an action changed. First call installs the watcher in the page; later calls return the latest mutations (type, tag, attribute, nodes added/removed), clear deletes the ones returned, stop disconnects and empties the buffer. To wait for one element or text use wait_for.

Run a WebMCP tool the page declares (see webmcp_tools or the webmcp line of navigate): one call instead of the clicks and fields it replaces. Returns status (ok, error, timeout, not_found, inactive, needs_confirmation), the tool result and ms; navigated_to when the call led to another page. A sensitive tool (buy, pay, send, delete, a POST form) is not run without confirm:true: on needs_confirmation ask the user, then repeat with confirm.

List the WebMCP tools the page declares for agents: name, description, input_schema, origin, kind (imperative = registered with document.modelContext.registerTool; declarative = a ), sensitive (why webmcp_call wants confirm) and how many times each was called. active=false: WebMCP is off in this Chrome and only form tools are visible, as plain forms. calls adds the call log of the page, any caller (chrome-bridge or the browser agent): input, output, status, ms.

Save the current window arrangement under a name, restore, list or delete. save overwrites silently. Window ids do not survive a browser restart: restore matches windows by the overlap of their tab URLs and reports the ones it cannot recognise instead of guessing.