browser-use-mcp
Use this MCP server to give an agent a guarded browser it can read, inspect, and operate through indexed action spaces.
Open a URL and get an indexed action-space table with an observation number.
Re-read the current page under a new observation, especially after page changes or refusals.
Perform one guarded operation on a target from an observation: CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, or WAIT.
Delegate one step to the policy with an
intent, or run a whole goal in a separate tab withbrowser_goal(spends model quota).Evaluate a JavaScript expression over the same CDP connection for programmatic reads or one-off DOM operations.
Capture the visible viewport as a screenshot.
Read console messages, uncaught exceptions, failed requests, and 4xx/5xx responses since the last read.
Close the session’s tab and daemon without closing an attached browser.
Run a self-check/doctor and optionally install or repair the managed browser engine environment.
Drives Google Chrome through the Chrome DevTools Protocol, either by attaching to the user's existing Chrome instance or launching a dedicated Chrome/Chromium browser with a managed profile. Exposes the browser to agents as an indexed action space, enabling page reading and guarded operations such as clicking, typing, selecting, scrolling, and waiting.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@browser-use-mcp open news.ycombinator.com and click the top story"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@ricardochen1996/browser-use-mcp
English · 中文
An MCP server that gives any agent a browser it can see and click: a page is read as an indexed action-space table, and every step is one guarded operation on a target that came from that table.
browser-use-mcp is a Model Context Protocol server. Claude
Code, Claude Desktop, Cursor, Codex, a DeepSeek Harness conversation, or any other MCP client
connects to it, and its agent gets a browser: open a page, read the page as a table of numbered
targets, then name one operation on one target. The model never writes a selector, a coordinate, or
a script, and the server never retries a change by itself.
It is built on dsh-browser-use: the same
Python engine, the same sidecar protocol, the same page-as-indexed-action-space idea — with the
DeepSeek Harness plugin host replaced by an MCP host. So there is no browser logic of its own: this
package is the adapter that lets any MCP client drive the Jev Ultrafast
engine. The engine and browser-harness ship as a
pinned wheel plus hash-pinned requirements, and are installed into a managed Python environment on
first use. No engine clone, no manual Python setup.
What it is
The browser tools expose one loop:
Read.
browser_opendownloads the page and returns its action space as text: one line per reachable element, the operations that element supports, and the exact target indices those operations accept. The result carries an observation number.Choose. The agent picks one operation and one target from that observation:
browser_act({ observation, operation, target }).Guard. The server sends the operation together with the fingerprint of the observation it came from. The engine re-reads the page first. If the page changed, nothing is executed and the result starts with
Nothing was executed:followed by the fresh table. That is a refusal, not an error: the agent chooses again from something that is true.Verify. If the page matched, the one operation runs and the server returns the new observation. The next step refers to the new number. A tool result is never proof of an outcome; the next observation is.
Here is a real table, produced by the bundled test fixture (the visible-text line is clipped):
Page file:///…/test/fixtures/fixture.html — 🐴 Forma · Find a place to slow down
Observation 1. Targets below are valid only for this observation.
Visible text: forma. Find a stay Reading room PLACES WITH CHARACTER THE SLOWER WAY TO STAY …
[1] link forma. — CLICK
[2] link Find a stay — CLICK
[3] link Reading room — CLICK
[4] searchbox Destination — TYPE_TEXT, CLICK
[5] button Find stays — CLICK
[6] combobox Stay category · "All stays" — SELECT
6:1 → Stay category → Design
6:2 → Stay category → Nature
6:3 → Stay category → Coastal
[7] checkbox Free cancellation · "on" (not checked) — CLICK
[8] button View Casa Flora — CLICK
[9] button View The Glasshouse — CLICK
[10] button View Serra Lodge — CLICK
Without a target: SCROLL_DOWN, WAITA step against it is one object, not code:
{ "observation": 1, "operation": "CLICK", "target": "5" } // button Find stays
{ "observation": 1, "operation": "TYPE_TEXT", "target": "4", "text": "Lisbon" }
{ "observation": 1, "operation": "SELECT", "target": "6:1" } // Stay category → DesignIf the page moved between the read and the click, the answer is a refusal that hands back the current observation:
Nothing was executed: The page changed since that observation. Choose from the new one.
Page … — …
Observation 3. Targets below are valid only for this observation.The engine reads a page over a single CDP connection that this server's session owns. Every tool —
browser_eval included — uses that one connection. Starting a second client yourself (a raw
websocket, a puppeteer/playwright script, another browser-harness daemon) is how Chrome 144+'s
per-connection "Allow remote debugging?" prompt turns into a stack of prompts, and how two loops end
up driving one page.
Related MCP server: jev-ultrafast-mcp
How it differs from selector-based browser MCPs
Selector-based browser MCP |
| |
What the model sends | A selector, a coordinate, or code | One operation on an index from the table it just read |
What happens when the page moved | The selector may miss, or hit the wrong element | The action is refused, and the fresh table is returned |
Retries | Up to the client or the model | Never — a refusal is the retry point, not an automatic replay |
What the model knows is possible | It has to guess | Each line lists that element's targets and operations, dropdown options included |
CDP connections | Depends on the implementation | Exactly one per browser session, shared by every tool |
Token cost per step | Often a screenshot or the whole DOM | Structured text: visible text plus the element table |
browser_eval is the one deliberate exception: it evaluates a single JavaScript expression over
the same connection, returns a value as data, and produces no observation — so the next guarded
action still refers to the last table. It exists so a model that needs a programmatic read does not
start a second CDP client. --no-eval withdraws it.
Quick start
Requires Node.js ^22.19.0 || >=24.0.0, Chrome or Chromium, and a way to get Python 3.12+:
either python3.12–python3.14, python3 (3.12 or newer) on PATH, or uv,
which can fetch the Python itself. The executable checks the runtime it was started with: if a client
starts it on an older Node, it looks for a supported one on PATH and in the usual
nvm/fnm/mise/asdf trees and restarts itself with it; if there is none, it exits with a message naming
the required range instead of failing inside a dependency.
Which browser it drives. The default mode is attach: the server drives the Chrome you already
use, so its logins and tabs are the ones the agent sees. Enable remote debugging once in that Chrome
(chrome://inspect/#remote-debugging → allow); on macOS the application that runs the server also
needs Full Disk Access (System Settings → Privacy & Security → Full Disk Access). Prefer an
isolated browser? Pass --mode launch and the server starts its own Chrome with a profile under the
state root instead.
Install. The package is published on npm as
@ricardochen1996/browser-use-mcp.
Run the latest release without installing anything:
npx -y @ricardochen1996/browser-use-mcp@latest --versionor install the browser-use-mcp command, which is what the terminals below assume:
npm install -g @ricardochen1996/browser-use-mcp@latest
browser-use-mcp --versionBoth forms run the same server: npx -y @ricardochen1996/browser-use-mcp@latest can stand in for
browser-use-mcp in every command below. Client configs work with either npx or the installed
command; if a GUI client cannot find them on its short PATH, give it the absolute path from
command -v browser-use-mcp (or command -v npx for the npx form); per-client snippets are in
docs/clients.md.
Then check the machine (on a fresh machine the first browser call builds the environment;
install does it eagerly). Its output looks like this, with machine-specific paths shortened:
The example below asks for a dedicated browser (--mode launch); with the default attach mode the
Connection: line names the Chrome you browse with instead, and Status: ready requires that
browser to answer its debugging endpoint.
browser-use-mcp doctor --mode launchbrowser-use-mcp v0.1.4 — self-check (Node v22.23.2, darwin-arm64)
Transport: stdio (MCP over stdin/stdout)
Connection: launch Chrome/Chromium, profile "default" at /Users/you/.browser-use-mcp/profiles/default
State : /Users/you/.browser-use-mcp (managed Python environment)
Timeouts: 180s per browser request
Logging : info (stderr)
Jev : on, typesafe decider: default endpoint (model default), key unset; …
Tools : browser_open, browser_page, browser_act, browser_eval, browser_screenshot, browser_console, browser_goal, browser_close, browser_doctor
Session : idle (this transport has no browser session yet)
Engine : /Users/you/.browser-use-mcp/env/bin/python (Python 3.12.14, chosen by managed environment)
jev_ultrafast 0.1.2 at …/env/lib/python3.12/site-packages/jev_ultrafast
browser-harness 0.1.13
Install : none in this process; the engine is already importable
Sidecar : /…/node_modules/@ricardochen1996/browser-use-mcp/sidecar/bridge.py
Browser : /Applications/Google Chrome.app/Contents/MacOS/Google Chrome
Goal mode: enabled: browser_goal and browser_act intents spend model quota; …
Status : readyStatus: ready means the browser tools work. Jev … NOT READY is expected until a policy key is
configured: only browser_goal and browser_act's intent need one; everything else works.
To build the environment ahead of time instead of during the first browser call:
browser-use-mcp install
# or, without a global install:
npx -y @ricardochen1996/browser-use-mcp@latest installThat creates <state root>/env (default ~/.browser-use-mcp/env) with the bundled engine wheel and
browser-harness, and records what it built in <state root>/install.json. It is safe to re-run.
A browser tool that runs before the install finished waits for it instead of failing.
Put it in front of your agent
The snippets below start the published package through npx, so they need no global install.
Replace npx -y @ricardochen1996/browser-use-mcp@latest with browser-use-mcp (or its absolute
path) if you installed the command. Every client, including launch-mode variants, is wired in
docs/clients.md.
Claude Code:
# Use the Chrome you already browse with (the default attach mode):
claude mcp add --scope user browser-use \
-- npx -y @ricardochen1996/browser-use-mcp@latest
# Or give the agent a dedicated, unseen browser instead:
claude mcp add --scope user browser-use \
--env BROWSER_USE_MCP_MODE=launch --env BROWSER_USE_MCP_HEADLESS=1 \
-- npx -y @ricardochen1996/browser-use-mcp@latestGeneric mcpServers JSON (Claude Desktop, Cursor, and most hosts accept this shape):
{
"mcpServers": {
"browser-use": {
"command": "npx",
"args": ["-y", "@ricardochen1996/browser-use-mcp@latest"],
"env": { "BROWSER_USE_MCP_MODE": "launch", "BROWSER_USE_MCP_HEADLESS": "1" }
}
}
}The env block uses launch mode so the example is self-contained; drop it to drive the Chrome you
already use. A client can also run the installed command directly ("command": "browser-use-mcp");
pin a version instead of @latest when the whole team should run the same release. A GUI client with
a short PATH needs the command's absolute path (command -v browser-use-mcp; for Homebrew Node
that is usually /opt/homebrew/bin/browser-use-mcp).
Then ask the agent to browser_open a URL. A first call on a fresh machine may take a minute or two
while the environment is installed; later calls start at once.
From source
To run a commit that is not released yet, or to develop:
git clone https://github.com/ricardochen1996/browser-use-mcp.git
cd browser-use-mcp
npm install
node bin/browser-use-mcp.mjs doctor --mode launchnpm link in the checkout puts a browser-use-mcp command on your PATH that runs that checkout.
The published package and a checkout contain the same files; the commands above only differ in
whether browser-use-mcp comes from npm or from node bin/browser-use-mcp.mjs.
The nine tools
Tool | Parameters | What it does |
|
| Start (or reuse) the session's browser, open the page, return the first action-space table and observation number. |
| — | Re-read the current page under a new observation number. Use it when the page changed on its own, or after a refusal. |
|
| Run one operation on one target from that observation: |
|
| Evaluate one JavaScript expression over the session's CDP connection; returns a value as data and produces no observation. Hidden by |
| — | The visible viewport as an MCP image (JPEG). Target boxes are not drawn into it. Hidden by |
| — | Console messages, uncaught exceptions, failed requests and |
|
| Hand one goal to the policy in its own tab; it chooses every operation and target itself. Spends model quota. Hidden by |
| — | Close the session's tab. In launch mode the browser stays for the next |
|
| Self-check: interpreter, engine, browser, attach target, config, live session, and a fix per problem. |
A missing policy key, an unsupported target, missing TYPE_TEXT text and a stale page are
refusals in normal tool results. A broken browser or environment is a failed call (isError).
An agent should report a failure, not retry it blindly.
Transports and concurrency
Transport | What one agent gets | What two agents get |
stdio (default) | One server process, one browser session | Two processes; in attach mode both drive the same browser in their own tabs, in launch mode two browsers |
Streamable HTTP | One MCP session, one browser session | One long-running server; attach mode shares the running browser, launch mode gives each session its own tab of a dedicated browser |
Start an HTTP endpoint when several agents should share one installed server:
browser-use-mcp \
--transport http --host 127.0.0.1 --port 7331 --path /mcpThe endpoint is http://127.0.0.1:7331/mcp by default. Each MCP initialize session gets its own
browser session; in the default attach mode all of them drive the Chrome you already use (see
--attach-sharing below), while --mode launch gives every session its own tab of a dedicated
browser. A session that goes quiet for 15 minutes has its browser closed and its anonymous profile
removed (BROWSER_USE_MCP_HTTP_IDLE_MS overrides the timeout). There is no authentication: the
default bind is loopback, and a non-loopback bind logs a warning at startup. Put it behind a tunnel
or proxy you control if it must leave the machine.
Named profiles (launch mode). In launch mode an anonymous HTTP session gets a throwaway profile that is deleted when the session ends. A client that wants its logins to survive reconnects names its profile on the initialize request:
http://127.0.0.1:7331/mcp?profile=claude (or header X-Browser-Use-Profile: claude)The named profile lives at <state root>/profiles/<server profile>-<name> and is kept when the
session ends; the next session with the same name reuses it. Different names run at the same time on
different profiles, and two live sessions with the same name are refused by the profile lock rather
than silently sharing one browser. Names are 1–32 characters from [A-Za-z0-9_-].
Two servers configured for the same browser profile are refused rather than silently sharing a
browser: the first holds a lock in the profile directory and the second gets a tool error naming
--profile and the fix. A lock left behind by a crashed process is reclaimed.
Which browser: attach (default) or launch
attach (default) drives the Chrome you already use:
With no endpoint, the server finds that browser through the
DevToolsActivePortChrome publishes in its profile. Turn remote debugging on in that Chrome first (chrome://inspect/#remote-debugging). On macOS that file is privacy-protected, so the application running this server needs Full Disk Access (System Settings → Privacy & Security → Full Disk Access), then must be restarted.--cdp-endpoint http://127.0.0.1:9333(or aws://…endpoint) drives a specific browser you started with remote debugging on.--attach-sharing shared(default) lets several MCP sessions — and several server processes — drive that browser at once, each in its own tab over its own CDP connection. Chrome 144+ asks "Allow remote debugging?" once per connection, so two agents mean at least two prompts; approve each once and never retry an unanswered one.--attach-sharing exclusiverefuses the second live holder instead, with a fix, which is the safer choice when two agents must never touch the same browser.browser_closestops the session's tab and daemon and never closes the attached browser.
--mode launch starts a dedicated Chrome with its own profile under the state root, so your
everyday browser and its logins stay out of automation. browser_close keeps that browser for the
next browser_open; the server closes it when the connection ends. It is the right mode for a
headless CI machine, or for an agent that should not see your real sessions.
Configuration highlights
Every server setting is a flag with an environment-variable twin (the policy uses
TYPESAFE_*/TEXT_MODEL_*; a couple of extras are environment-only), and the flag wins when both
are present. The exhaustive tables, parsing rules, defaults and exit codes are in
docs/config.md.
Setting | Flag(s) | Env | Default |
Transport |
|
|
|
Own or attach |
|
|
|
Attach sharing |
|
|
|
Browser window |
|
| visible window |
Profile |
|
|
|
State root |
|
|
|
Interpreter |
|
| managed environment |
Tool surface |
|
| all tools offered |
Policy |
|
|
|
Request budget |
|
|
|
Logging |
|
|
|
State root layout:
~/.browser-use-mcp/
├── env/ managed Python virtualenv (engine + browser-harness)
├── install.json what was installed, with which strategy and Python
├── profiles/<name>/ launched Chrome profiles (logins, tabs); named HTTP profiles too
└── attachments/<hash>.lock exclusive attach-mode claims, one per DevTools endpointThe Jev policy
browser_goal runs a whole decision loop inside the engine; browser_act with an intent (and no
operation) delegates exactly one decision to the same policy. Both spend model quota. Who answers
is configuration:
--jev-decider typesafe(default): Jev at the TypeSafe endpoint. NeedsTYPESAFE_API_KEY; optionalTYPESAFE_BASE_URL,TYPESAFE_MODEL,TYPESAFE_FALLBACK_URL.--jev-decider chat: the engine serves its System One protocol on loopback and a chat model answers it. NeedsTEXT_MODEL_BASE_URLandTEXT_MODEL(plusTEXT_MODEL_API_KEYif the endpoint needs one).
TEXT_MODEL_* is also what writes a TYPE_TEXT value when the agent gives an intent but no text.
Without either setup the rest of the tool surface is unchanged; the policy tools refuse with one
sentence naming the variable to set. --no-jev withdraws browser_goal and the intent parameter
entirely.
Put credentials in the client's env block (or the flags), never in args:
"env": {
"TYPESAFE_API_KEY": "…",
"TEXT_MODEL_BASE_URL": "https://your-endpoint/v1",
"TEXT_MODEL": "your-model",
"TEXT_MODEL_API_KEY": "…"
}The server passes those variables only with the request that spends quota, never leaves them in the
sidecar's environment, and the doctor prints set/unset instead of a value.
Troubleshooting
Start with browser_doctor. The tool and the CLI run the same self-check; each problem line
carries the command that fixes it.
browser-use-mcp doctorA profile is already in use. The message names the profile and
--profile: stop the other server, or give this one its own--profile <name>. Two servers driving one browser profile is the one configuration the server refuses on purpose.Attach mode cannot find the browser. This is the default mode: open
chrome://inspect/#remote-debuggingin the Chrome you use and allow remote debugging, correct--cdp-endpoint, or start the server with--mode launchfor a dedicated browser. The doctor reportsattach mode drives …with the reason. On macOS, allowing this app Full Disk Access is what lets it read your Chrome's profile.The engine is not installed yet. The first use installs it into the state root; run
browser-use-mcp install(ornpx -y @ricardochen1996/browser-use-mcp@latest install) to do it eagerly, orbrowser_doctorwithinstall: truefrom the agent. Behind a proxy, setHTTPS_PROXYfor the process that runs the server.Jev … NOT READY. SetTYPESAFE_API_KEY(or use--jev-decider chatwithTEXT_MODEL_*). The browser tools do not need it.No tools in the client. The client's
env/argsdid not reach the server, or it was not restarted. Run the same command in a terminal and read stderr; a configuration error exits with code2and names the field.Chrome asks "Allow remote debugging?". Something started a second CDP client. Approve that one prompt once, never retry, and use
browser_evalinstead of another driver.browser_eval('document.body')returns{}. A DOM node cannot cross the CDP boundary by value. Return something serialisable instead, for exampledocument.body.innerTextorJSON.stringify(document.body.getAttribute('class')).
Security notes
Page content is untrusted data. Text the table quotes is something to read, never an instruction to follow. The server never executes anything a page returns on the agent's behalf.
browser_evalis code execution by design. It runs one expression in the page, over the session's own connection, with no user gesture. Withdraw it with--no-evalfor a surface where model output can never become code; the rest of the tools still work.The HTTP transport has no authentication. Bind it to loopback (the default). Any non-loopback bind is logged as a warning; only expose it on a trusted network or behind a tunnel you control.
Keys stay out of logs and tools. The doctor prints only
set/unset; credentials are handed to the sidecar per model-spending request and are not inherited by unrelated calls.The default mode drives your own Chrome, logins included — that is what attach mode is for. Use
--mode launchwhen an agent should work in an isolated browser whose profile lives under the state root instead.One connection, one driver. Do not start another CDP client against the same browser; Chrome approves each connection separately and two drivers race each other.
License and attribution
This project is built on dsh-browser-use
(MIT): sidecar/bridge.py is vendored from it, and the action-space rendering, the freshness rule,
the one-connection rule and the direct-mode tool descriptions follow it. The browser engine is
jev-ultrafast (MIT), bundled as a pinned wheel;
browser access is browser-harness (MIT). The
design and rationale are in docs/architecture.md.
Development
npm test # fast unit tests (node --test)
npm run test:e2e # real headless Chrome through the real MCP protocol
# (stdio, HTTP, attach mode, Jev intent against a loopback stub,
# and a hand-written JSON-RPC client)
npm run test:e2e:local # the same suites on this machine, inside a temporary state root with a
# --no-sandbox Chrome wrapper (works in sandboxes; `-- http attach` picks suites)
npm run release:check # manifest + changelog + the exact packed file list
npm run release:pack # build the tarball, verify it and record its integrity in dist/
npm run doctor # the CLI self-checkThe default suites spend no model calls and need no credentials; the e2e tests install the engine
into a test state root on their first run. npm run test:e2e:local supplies its own
BROWSER_USE_MCP_TEST_HOME, BH_RUNTIME_DIR and BROWSER_USE_MCP_TEST_CHROME, so it needs no
environment setup and leaves no browser or daemon behind.
CI runs the unit matrix on Node 22.19 and 24 plus the release gate for every push and pull request;
the real-browser e2e job runs on main and for a release. Each e2e suite is retried once when it
fails on timing (the failure is annotated first), while a unit test is never retried: that is a
defect, not a flake. Release history is in CHANGELOG.md.
Releases are tagged vX.Y.Z on main; the release workflow
validates the annotated tag against package.json, reruns CI (unit plus real-browser e2e), publishes
to npm with provenance, and creates the GitHub Release with the verified tarball attached. It accepts
either an NPM_TOKEN repository secret (an automation or publish-capable granular token) or npm
Trusted Publishing: name this repository and .github/workflows/release.yml as the package's
trusted publisher and the OIDC token of the job is used instead. An already-published version is
skipped, so a re-run only refreshes the GitHub Release. Bump the version, add its CHANGELOG.md
section, then git tag -a vX.Y.Z -m "vX.Y.Z" and push the tag.
Available Tools
9 toolsbrowser_actAct on the pageADestructive
Run one operation on one target from an observation: CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT. CLICK, TYPE_TEXT, and SELECT take a target index from that observation; TYPE_TEXT also takes the text. SCROLL_UP, SCROLL_DOWN, and WAIT take no target. You may instead omit operation and target and give an intent: the policy chooses the operation and target on that observation and runs it. A TYPE_TEXT with an intent and no text gets its value from the text model. Both spend model quota; --jev-decider says whether Jev or the text model answers.
Inputs: observation (required), text, intent, target, +1 more.
browser_closeClose the tabADestructive
Close the tab this session owns and stop its daemon. The browser this session attached to is never closed: other sessions may still be driving it.
Inputs: no named parameters.
browser_consoleRead page diagnosticsARead-only
Read what the page reported since the last read: console messages, uncaught exceptions, and failed or 4xx/5xx requests. Each read drains the buffer, so read it after reproducing a problem.
Inputs: no named parameters.
browser_doctorSelf-checkA
Report what the browser tools need and whether it is there: the Python interpreter, the engine and browser-harness versions, the managed environment, the browser that would be launched, the attach target, the configuration in use, and the fix for anything missing. Call it first when browser work fails. With install: true it builds a missing engine environment first and waits for that install.
Inputs: install.
browser_evalEvaluate JavaScriptADestructive
Evaluate one JavaScript expression in the page this session owns and return what it produced: a string as itself, any other value as JSON, capped so one dump cannot crowd out the conversation. Use it for a programmatic read the indexed action space cannot express, or a one-off DOM operation. It runs on this session's one CDP connection: never start a second client — a raw websocket, a puppeteer/playwright script, another browser-harness daemon — because Chrome 144+ asks "Allow remote debugging?" once per connection and two drivers race each other on the same page. The expression gets no user gesture, a thrown error comes back as text, and it produces no observation: call browser_page before the next browser_act.
Inputs: expression (required), timeout_ms.
browser_goalRun a goalADestructive
Hand one goal to the browser policy in its own tab and return the trace it produced. The policy chooses operations and targets by itself and spends model quota — --jev-decider says whether Jev or the text model answers; the page this session already has open is left untouched.
Inputs: url (required), goal (required).
browser_openOpen a pageA
Open a page in the browser this MCP session owns and return its indexed action space. The session reuses that browser and its logins across calls; the previous tab is closed first.
Inputs: url (required).
browser_pageRead the pageARead-only
Read the current page again: the same indexed action space under a new observation number. Use it after the page changes on its own, or after a refused action.
Inputs: no named parameters.
browser_screenshotScreenshot the viewportARead-only
Capture the visible viewport as an image. Target boxes and page structure are not drawn into it.
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
Tools mostly target distinct browser operations: open, re-observe, act, evaluate, screenshot, console, goal, close, and doctor are separable. The main overlap is browser_act's intent mode versus browser_goal, both policy-driven model actions, though goal is scoped to its own tab and an overall objective.
All tools use a consistent browser_ prefix, making them easy to recognize as one family. Suffixes mix nouns (browser_page, browser_screenshot, browser_console) and verbs (browser_open, browser_close, browser_act), which is a minor deviation but still readable and predictable.
Nine tools is well-scoped for a browser automation server. Each tool covers a meaningful part of the browser-control lifecycle without obvious redundancy or filler.
The surface covers opening, observing, acting, evaluating JavaScript, screenshotting, console inspection, autonomous goals, closing, and diagnostics. Minor gaps exist around explicit navigation/history controls such as back, forward, or direct URL navigation separate from browser_open, but core workflows are covered.
Maintenance
Related MCP Connectors
Control a real browser from AI agents: navigate, click, type, screenshot, read the page.
Stealth web browser for agents: search, fetch, click, download and type in persistent MCP sessions.
Turn any webpage into a structured action manifest — clickable, fillable, submittable elements.
Turn any public website into an MCP server for agents to search, read and navigate.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server for vision-first browser automation that annotates interactive elements with numbered markers, allowing AI agents to control any webpage by simply referencing element numbers.12MIT
- AlicenseAqualityBmaintenanceEnables AI agents to drive a Chromium browser over MCP, reading pages as a numbered list of controls and performing actions like clicking, filling forms, and asserting page state without screenshots or API keys.1052 PyPI25MIT
- AlicenseAqualityBmaintenanceEnables AI agents to drive a Chromium browser through MCP, with persistent sessions, compact page snapshots, guarded actions, batched operations, and explicit result verification.16MIT
- AlicenseAqualityCmaintenanceEnables coding agents to drive a real, indexed Chrome browser over MCP stdio, navigating pages, observing numbered interactive elements, and performing click, type, and select actions without the server itself calling any model.5MIT