BrowserDo
BrowserDo is an MCP server that lets an AI agent control a real Embiody browser on Windows to browse, inspect, and interact with web pages.
Check browser readiness and first-install progress.
Navigate pages, go back/forward, reload, stop loading, and wait for pages to settle.
Create, select, close, show, minimize, and mute browser windows and tabs.
Take snapshots of one or many tabs, with numbered actionable elements, optional screenshots, and whole-page reading.
Click, type, press keys, select editable text, scroll, hover, drag, and answer popup bubbles/dialogs.
Read up to 10 web pages in background tabs and return their text and links.
Batch multiple browser actions in one call and get a fresh snapshot back.
Hand a tab to a human for passwords, captchas, or payments, then resume automation.
Run whole web tasks autonomously with an optional configured vision model, report progress, and stop tasks.
Work in the background using the user’s signed-in Embiody profile, with tools defaulting to the frontmost window/tab.
Drives adidas.com like a real shopper would: the agent browses and acts on product pages in the background without being stopped by the site's bot checks.
Reads apple.com pages, including whole-page snapshots of its text and actionable elements, at a fraction of the token cost of other browser-automation approaches.
Reads edition.cnn.com pages in full, returning the whole page's text and numbered elements rather than just the visible screen.
Reads and navigates github.com pages, producing compact whole-page snapshots with each actionable element numbered for the agent to click or type into.
Shops and browses target.com on the user's behalf without tripping the site's anti-bot protection, since the agent works inside the user's own browser.
Works through Uber Help flows such as disputing a charge, handing the tab to the user for a sign-in code and then resuming automation where they left off.
Browses and acts on walmart.com in the background at full speed, getting past bot checks that stop conventional automation tools.
Reads whole Wikipedia pages, returning the page text plus numbered elements as a compact snapshot, and can read just the screen it is working on.
BrowserDo
Website: embiody.com/browserdo

Built for AI agents. Shared with people.
Embiody is a Windows browser your AI agent works in, in the background and at full speed, while you keep using your PC and can step in at any time. BrowserDo is the MCP server that connects your agent to it. Add it to Claude Code, Claude Desktop, Codex, Cursor, VS Code or Gemini CLI, and your agent can browse, click, type and read pages, including sites you are signed in to.
Why BrowserDo
Each point below has a short clip recorded on real sites. The side-by-side ones run the same task at the same moment through Playwright MCP and BrowserDo, from one Claude Code session.
1. Works in the background at full speed, and leaves your screen to you
Chrome and Embiody countdowns in a background tab, behind a window and minimized. Click for the 38-second clip.
Pages run at full speed in background tabs, background windows, minimized windows and hidden windows. Your agent does not need the browser in front of you, so you keep using your computer while it works, and it can work in a dozen tabs at once.
Ordinary Chrome slows down pages you are not looking at. In our test, a browser window was completely covered by another window for 7 minutes:
Timers | A countdown on the page | |
Embiody, front tab | 10 per second throughout | on time |
Embiody, background tab | 10 per second throughout | on time |
Chrome, front tab | slowed down after 12 seconds | 355 seconds behind |
No launch flags are needed for this. One limit: a page opened while its window is minimized may come back without a screenshot; its text and element numbers are still there.
2. Works where bots get blocked — because it isn't one
Walmart, Target, adidas and realtor.com stop Playwright MCP with a bot check; Embiody goes straight through. Click for the 24-second clip.
Your agent works in your own browser, on your behalf, so sites with anti-bot protection treat it the way they treat you. We also signed in to an account on a site protected by a leading commercial bot-detection service, the kind that usually stops automation tools.
3. Sees the whole page and clicks the right thing
On nytimes.com a privacy overlay swallows Playwright MCP’s click; BrowserDo gives the agent only the overlay’s buttons, so it closes it first. Click for the 28-second clip.
Elements covered by a popup or overlay get no number, so the agent can't click something you can't see.
Content inside embedded frames from other sites, such as payment forms and sign-in boxes, can be read and clicked.
Long pages are read whole, not only the part on screen.
An element off screen is scrolled into view before it is clicked.
Clicks land where they should across multiple monitors and at any display scaling.
Every element number belongs to one snapshot. A number from an older snapshot is refused before anything is clicked, instead of hitting whatever took its place.
4. You can see what the agent is doing
The "AI-controlled tab" badge, then the highlighted border and the agent’s own cursor. Click for the 15-second clip.
A tab the agent is working in shows a virtual mouse pointer, a frame around the page and a marker on the tab. Open it any time to watch.
5. You and the agent share one tab
Disputing a charge on Uber Help: the agent hands you the tab for the sign-in code, then takes it back. Click for the 38-second clip.
The agent fills in the forms; you step in for the sign-in code, the captcha or the payment, then hand the tab back, and the agent picks up where you left off. If you click or type in a tab the agent is working in, you are asked whether to take it over. The agent asks before it touches a tab of yours.
6. Fewer tokens for the whole page

The browser engine itself boils each page down for the agent: its text, plus every element the agent can act on, numbered. On Wikipedia, GitHub, CNN, ESPN and Apple, a whole-page snapshot took 37% of the tokens of Playwright MCP's (o200k tokenizer, same 1600×1000 viewport, November 2026), and the agent can read just the screen it is working on.
7. Several steps in one call
Real speed: the agent fills 4 form fields in 2.5 seconds with one call. Click for the 3-second clip.
browser_batch runs several actions (clicks, typing, key presses) in a row and returns a fresh
snapshot of the page, so the agent needs fewer round trips and fewer tokens. A step can wait for
a text to appear and aim at the element showing it ("type, wait for the suggestions, click the
second one" in one call), and the snapshot can be cut to the lines that changed.
8. Reads the page itself, not a summary
A JB Hi-Fi search page: Claude Code’s built-in fetch gets a browser warning and 0 products; BrowserDo reads all 18 with prices. Click for the 30-second clip.
browser_read_pages returns the page's own text, links included, from pages built by scripts and
from sites you are signed in to. It can stand in for Claude Code's WebFetch, which fetches the page
without running its scripts and hands back a short model-written summary.
9. Sees the browser's own popups
McDonald’s store finder asks for your location: Playwright MCP’s agent never sees the prompt; BrowserDo reports it and the agent allows it once. Click for the 30-second clip.
Permission bubbles, menus, Save As dialogs, "Leave site?" prompts and alerts are reported in every snapshot, with the ways each one can be answered.
10. Current engine, signed releases
Built on Chromium 156. The installer carries the digital signature of SELECTIOUS PTY LTD, which BrowserDo verifies before running it, and the browser updates itself, checking the signature of every update.
Related MCP server: Echo
Requirements
Windows 10 or 11, 64-bit (Embiody is Windows only for now)
Node.js 20 or newer. Check with
node -v. Without it, BrowserDo fails to start (Claude Code shows "Failed to connect"). Install it withwinget install OpenJS.NodeJS.LTS, then restart your client.The Embiody browser, version 0.9.0.3 or newer: installed automatically the first time BrowserDo starts. That is a download of about 140 MB and takes a few minutes; your client can use BrowserDo at once, and until the browser is ready each tool replies with the progress. With an older one, BrowserDo opens the browser's update page and asks you to restart the browser and BrowserDo once it has updated (details).
No API key is needed. Your agent drives the browser with its own model.
Install
BrowserDo runs as npx -y browserdo-mcp. Pick your client and follow only that section; the others
are for other clients.
Claude Code
claude mcp add browserdo -- npx -y browserdo-mcpAdd --scope project to share it with your team through .mcp.json, or --scope user to use it
in every project.
Claude Desktop
Edit %APPDATA%\Claude\claude_desktop_config.json:
{
"mcpServers": {
"browserdo": {
"command": "npx",
"args": ["-y", "browserdo-mcp"]
}
}
}Codex
codex mcp add browserdo -- npx -y browserdo-mcpOr add to ~/.codex/config.toml:
[mcp_servers.browserdo]
command = "npx"
args = ["-y", "browserdo-mcp"]Cursor
Add to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (one project):
{
"mcpServers": {
"browserdo": {
"type": "stdio",
"command": "npx",
"args": ["-y", "browserdo-mcp"]
}
}
}VS Code
Run MCP: Add Server from the Command Palette, choose Command (stdio) and enter
npx -y browserdo-mcp. Or add to .vscode/mcp.json:
{
"servers": {
"browserdo": {
"type": "stdio",
"command": "npx",
"args": ["-y", "browserdo-mcp"]
}
}
}Gemini CLI
Add to ~/.gemini/settings.json (all projects) or .gemini/settings.json (one project):
{
"mcpServers": {
"browserdo": {
"command": "npx",
"args": ["-y", "browserdo-mcp"]
}
}
}Other MCP clients
Add a local (stdio) MCP server in your client's settings, with command npx and arguments
-y browserdo-mcp. Most clients take it in this shape:
{
"mcpServers": {
"browserdo": {
"command": "npx",
"args": ["-y", "browserdo-mcp"]
}
}
}The skill
The browserdo skill tells your agent when and how to use these tools, for example to search
with BrowserDo instead of a built-in search tool. BrowserDo installs it the first time it starts
(see Privacy). To install it on its own, for example before adding BrowserDo, run
npx skills add zhaijunlong/browserdo -g (the skills command needs Node.js 22.20 or newer and Git). An
agent that has the skill but not the tools offers to add BrowserDo for you.
Then ask your agent to do something on the web:
Find me a direct flight from Sydney to Melbourne next Wednesday morning and show me the three cheapest options.
Tools
Each tool is one browser action. windowId and tabId are optional everywhere; leave them out
and the frontmost window and tab are used.
Tool | What it does |
| The page as one line per element, each actionable element with a number, plus the page position, URL, title, any popups in the way and a |
| Read up to 10 pages at once in background tabs and get their text, with links as footnotes. |
| Several actions on one tab in a row, then a fresh snapshot (whole, only the changes, or none). A step can aim by text at what an earlier one made appear, and may be skipped when it fails. Stops at the first failure otherwise. |
| Act on an element by its number and the |
| Hover; press, carry and release. Drag works sliders, canvases and reorderable lists. |
| Getting around. |
| Windows. |
| Tabs. |
| Answer a permission bubble or dialog. |
| Hand the tab to a person for a password or captcha, then take it back. |
| Whether the browser is ready, or how far its first install has got. |
Settings
Set these in the env block of your client's config, or put them in a config file (copy
browserdo.config.example.yaml to browserdo.config.yaml next to where the server runs, or pass
--config <path>). Environment variables win over the config file.
Variable | What it does |
|
|
|
|
| Launch your own Embiody build, on a separate profile, instead of the installed one. |
| Give the agent a separate profile folder instead of your own Embiody; BrowserDo then starts a browser of its own on it. |
| The model for |
The example config file explains the rest: fallback models, timeouts, how long to let pages
settle. --transport sse serves MCP over HTTP at http://127.0.0.1:3000/sse instead of stdio; it
answers this machine only.
Privacy
BrowserDo has no telemetry, usage statistics or error reporting.
Downloads: the first time it starts without Embiody installed, it downloads the installer from GitHub, or from a mirror if GitHub can't be reached. The installer carries the digital signature of SELECTIOUS PTY LTD; BrowserDo checks it before running the installer and refuses one that is unsigned or signed by anyone else.
Updates: when your client starts BrowserDo with
npx, npm checks the npm registry for the latest version when it starts BrowserDo. That request is made by npm, not by BrowserDo.Your model: only
browser_run_tasksends anything to a model, and only to the endpoint you configure. The browser tools return pages to your own agent.On your computer: a debug log at
%LOCALAPPDATA%\Embiody\BrowserDo\logsrecords the URLs visited and the steps taken, never page content or your task. It keeps at most three 5 MB files. Snapshots are not saved unless you setEMBIODY_SAVE_SNAPSHOTS=1.Skill files: when it starts, BrowserDo puts its skill in
~/.claude/skills/browserdo(read by Claude Code),~/.agents/skills/browserdo(Codex, Cursor, Gemini CLI) and~/.copilot/skills/browserdo(GitHub Copilot in VS Code), each only when such an agent is installed. It never replaces a skill of the same name that it did not put there, keeps its own up to date, and does not put one back once you delete it. The Claude plugin carries the skill itself, so with the plugin it leaves~/.claude/skillsalone.Your profile: the agent works in your own Embiody, in its Default profile, so it can use the sites you are signed in to there. Other Embiody profiles are not used, and neither are other browsers on your computer, such as Chrome or Edge. To keep the agent apart, set
EMBIODY_USER_DATA_DIRto a folder of its own.
See the privacy policy and the Embiody end-user license agreement.
Optional: browser_run_task
If you would rather hand over a whole task than drive the browser step by step,
browser_run_task runs it inside BrowserDo with a vision model of your choice (any
OpenAI-compatible endpoint), and keeps the screenshots out of your agent's context.
"env": {
"EMBIODY_VLLM_ENDPOINT": "<your-openai-compatible-endpoint>",
"EMBIODY_VLLM_MODEL": "<your-vision-model>",
"EMBIODY_VLLM_API_KEY": "<your-api-key>"
}Parameter | Notes |
| Required. The task, in plain language. |
| Pass both to continue an earlier task in the same tab. |
| Default 12. |
| Default false. |
| Your answer to the question a previous run stopped on, when your client can't ask you mid-task. |
When the task needs you, it asks. A step only you can do, like a password or a code sent to you,
hands you the tab first and continues once you say you're done. In clients that support
questions during a task (tasks.requests.elicitation.create, as in Claude Code), the question
appears in your conversation; elsewhere the task ends with the question, and you answer by calling
it again with humanReply.
browser_stop_task stops a running task at the end of its current step.
Keep your API key out of files that get committed. If your client can expand environment
variables in its config, use that; otherwise keep the key in a config file outside the repository
and point at it with --config.
Notes
Claude Code keeps old tool definitions in a conversation. After BrowserDo is upgraded, start a new conversation to see new tools and parameters.
BrowserDo speaks MCP protocol version
2025-11-25and negotiates down to older versions.
Development
npm install
npm run build
npm test # 902 tests
npm run test:fast # unit and module tests onlySee test/README.md for the test layout.
License
BrowserDo is licensed under the Apache License, Version 2.0; see LICENSE. The Embiody browser it installs is covered by the Embiody EULA.
Available Tools
31 toolsbrowser_batch
Run several page actions on one tab in a row, then get a fresh snapshot back — one call instead of one per step; worth it for a single action too. Steps aim with the numbers of one snapshot. For something an earlier step makes appear (a suggestion list, a menu), wait for it with browser_wait forText, then aim with find instead of emsn: {"tool": "browser_click", "args": {"find": {"text": "Bluetooth headphones"}}}. Stops at the first failure, unless the step says onFail: skip (a banner that may not show). After a step the browser says changed the page, the later steps that aim by number are not run; waits and finds still are.
Inputs: actions (required), tabId, snapshot, windowId, +1 more.
browser_clickA
Click an element by its number (emsn) from the latest snapshot. The kernel asks the page where that element is right now and refuses if it has gone, moved out of reach, or is covered by something else — it does not pretend to succeed. Passing x/y instead skips all of that checking, so prefer emsn.
Inputs: snapshotId (required), x, y, emsn, +4 more.
browser_close_popup_bubbleA
Answer the popup blocking a tab (permission bubbles, dialogs). browser_take_snapshot reports which popups are open and what each one accepts. When unsure use dismiss: it refuses without writing a decision into the browser profile, where it would outlive the task.
Inputs: tabId, action, windowId.
browser_close_tabC
Close a tab.
Inputs: tabId, windowId.
browser_close_windowA
Close a browser window and every tab in it. Other windows are unaffected. To close a single tab use browser_close_tab.
Inputs: windowId (required).
browser_dragA
Press on something, carry it somewhere, let go. The one gesture a click cannot make, so this is for sliders, panning a canvas, split bars and lists that reorder. Give the destination exactly one way: toEmsn (with toX and toY for a spot inside it), or toX and toY, or dx and dy. Both ends must already be on screen — the far end is not scrolled into view, so scroll first.
Inputs: snapshotId (required), x, y, dx, +10 more.
browser_get_window_info
List every browser window and its tabs, with the windowId and tabId of each. When the person says a page is already open, call this to find its tab and work there rather than opening it again: they may have got it to a state that takes steps to reach.
Inputs: no named parameters.
browser_go_backA
Go back one step in this tab's history. browser_get_window_info reports whether a tab can go back; calling this when it cannot will fail.
Inputs: tabId, windowId.
browser_go_forwardB
Go forward one step in this tab's history.
Inputs: tabId, windowId.
browser_input_text
Type text into an element by its number (emsn), or into whatever has focus when no emsn is given. Fails, typing nothing, when the field does not take focus. Also sets a dropdown (SELECT, or its label): text is the option exactly as listed in its options; and a date (YYYY-MM-DD), time (HH:MM), date and time (YYYY-MM-DDTHH:MM), month (YYYY-MM), week (YYYY-Www) or colour (#rrggbb) field, without opening a picker. Use this rather than clicking a SELECT: its list is not in snapshots. To edit a text field or editable area (a mail body, a rich-text editor) in the middle, give one of before / after / replace / at with its emsn. Copy the words from its snapshot value as they are written there: \n for a line break, ¤ escapes kept; ‸ (the caret) and ⟦⟧ (the selection) are ignored. Not found, or found in several places without occurrence: nothing is typed and the places are listed. The text is read back afterwards and the reply quotes the changed lines; if they differ (the editor reformatted it), it fails saying the text was typed. Without these, text goes in at the caret; the element is clicked first unless focus is already in it. Text is typed key by key, about 50 characters a second: a few thousand take a minute or more, and the call waits for it.
Inputs: text (required), snapshotId (required), at, emsn, +8 more.
browser_minimizeA
Minimize one of your windows (every tab in it yours), to keep it out of a person's way while you work in it. Pages in it keep running at full speed and snapshots keep working. browser_show brings it back.
Inputs: windowId (required).
browser_moveA
Hover the pointer over an element, for a menu or a tooltip that only appears under it. Whatever appears is not numbered until you take a fresh snapshot, so hover first, then snapshot, then act. The reply says where the pointer ended up.
Inputs: snapshotId (required), x, y, emsn, +2 more.
browser_new_tabB
Open a new tab. Returns the new tabId.
Inputs: url, windowId, timeoutMs, waitUntil, +1 more.
browser_new_windowB
Open a new browser window. Returns the new windowId.
Inputs: url, incognito, hideWindow.
browser_press_keyA
Press keys, in order, where focus is: Escape closes a dialog on the page, Tab moves to the next field, ArrowDown/Enter pick from a suggestion list, End or arrows move the caret before browser_input_text without emsn types there, Control+Z undoes. Not for typing text. Refused, nothing pressed: copy/cut/paste, and the browser's own shortcuts (use browser_close_tab, browser_reload and so on). Replies once the page has handled the last key; it does not say what the keys did, so snapshot to see. A list highlighted under the pointer counts arrows from that item, which a snapshot does not show: to pick a given item, click it.
Inputs: keys (required), snapshotId (required), emsn, tabId, +2 more.
browser_read_pagesA
Read web pages; use it instead of a built-in fetch tool (WebFetch): it returns the page's own text, not a summary, including pages built by scripts and sites the person is signed in to. Each URL opens in a background tab of an existing window, the whole page is read and the tab closed again, so nothing is left open. Returns each page's text with no element numbers — to act on a page, open it with browser_new_tab instead. Links are marked [^3], with the addresses after the text. Each page gives up to 15000 characters and says how to read on. One page failing does not fail the others. Not for search results URLs: engines often answer those with a captcha, so search by typing into the engine's own search box.
Inputs: urls (required), from, maxChars, windowId, +1 more.
browser_reloadA
Reload the tab. Element numbers from before the reload are void afterwards.
Inputs: tabId, windowId.
browser_run_taskA
Carry out a whole web task in a real browser and report what happened. This takes minutes, not seconds, and reports progress as it goes. Describe the task in plain language; it works out the steps itself. If it hits a login, a captcha or a payment screen it stops and hands the browser to the person, then picks up where it left off once they are done. Needs a vision model configured (EMBIODY_VLLM_*); for a small job you can drive the browser yourself with browser_take_snapshot / browser_click / browser_input_text instead, which needs no model.
Inputs: task (required), tabId, history, windowId, +7 more.
browser_scrollA
Scroll. Give deltaY (how far; positive is down, as scrollTop counts) or toY (where to end up; 0 is the top, 999999 the bottom), not both; deltaX / toX are the horizontal ones. What scrolls is whatever is under the pointer: to scroll a pane that scrolls on its own (a mail list, a results panel), give its emsn; emsn -1 scrolls the whole page, only when the snapshot's page position line offers it. Replies once the scroll is at rest, saying when it moved less than asked (at the end, or the page took the wheel); coordinates are void after a scroll, so take a fresh snapshot to see where you are.
Inputs: x, y, toX, toY, +10 more.
browser_select_editable_textA
Select words in a text field or editable area (a mail body, a rich-text editor), as a person drags over them, so a toolbar button (bold, colour, link) acts on them next: a click on it can follow in the same batch. Nothing else changes, except that a click giving it focus stays. Give one of select, from with to, or all. Copy the words from the element's snapshot value as for browser_input_text's before/after. The reply quotes the lines the selection is on, marked ⟦…⟧. Refused, nothing selected: not found, or in several places without occurrence (the places are listed); an end inside a picture, a list number or an @mention; across table cells where the editor keeps a selection in one cell (select cell by cell); over a picture with its own editable caption (click the picture instead); a password, read-only or disabled field.
Inputs: emsn (required), snapshotId (required), to, all, +6 more.
browser_select_tabC
Bring a tab to the front of its window.
Inputs: tabId (required), windowId (required).
browser_set_audio_mutedC
Mute or unmute a tab.
Inputs: muted (required), tabId, windowId.
browser_showA
Bring a window on screen. Windows driven by an agent are often hidden or off screen, so show one before asking a person to look at it.
Inputs: windowId (required), toState.
browser_start_human_controlA
Hand the tab to a person so they can use the real keyboard and mouse on it. Required for anything only a person can do — a password, a code sent to them, a captcha, proving who they are — because while the agent drives the tab their physical input does not reach the page at all. The window is brought on screen. While the person has it, every command on that tab fails except browser_take_snapshot, which is how you tell when they are done. Call browser_stop_human_control to resume.
Inputs: tabId, windowId, showWindow.
browser_status
Say whether the browser is ready, without doing anything in it. On first use BrowserDo downloads and installs the Embiody browser, which takes a few minutes; until then every other tool replies with the progress instead of acting, and this one reports it.
Inputs: no named parameters.
browser_stop_human_controlA
Take the tab back and resume automating it. A handover the agent started can be ended freely; if the person took the tab over themselves, they are asked first and may refuse.
Inputs: tabId, windowId.
browser_stop_loadingA
Stop the page loading in this tab, like the browser's stop button. This is about page loading only. To stop a running browser_run_task, use browser_stop_task.
Inputs: tabId, windowId.
browser_stop_taskA
Stop a running browser_run_task, by the ID that browser_run_task returned. The task stops at the end of its current step and does not resume. Optionally closes the tab or the whole browser window it was using; other windows are left alone. This is not the same as cancelling the task at the protocol level: that is advisory and may be ignored, and it cannot tidy up the browser. To stop a page loading rather than a task, use browser_stop_loading.
Inputs: taskId (required), closeTab, closeBrowserWindow.
browser_take_snapshot
Look at a tab: returns one line per element, the page position, the tab's URL and title, any popups blocking it, and a snapshotId. Every actionable element carries a number (emsn) at the start of its line; a link inside a sentence stays in it as words, number 12 — act on the number, never on pixel coordinates. Take a fresh snapshot after anything that changes the page, to see what it became: elements that appear have no number until then. Says so when the page is a PDF, a browser error page or a crashed tab, each of which makes the obvious next move useless. Give tabIds to look at several tabs in one call; each comes back with its own snapshotId. Marks on a line: collapsed (in a closed section: open it first), modal (the page outside it takes no clicks), hover-only (may do nothing on a click), also dblclick / drag / ... (other listeners, perhaps only tracking; the list misses some: a list item without drag may still drag, a spreadsheet cell without right_click may still take one: try it and snapshot), options (a dropdown's choices), readonly (takes no typing; clicking it often opens the page's picker), aria-readonly (the page says not to type, typing still goes in).
Inputs: tabId, format, tabIds, windowId, +5 more.
browser_wait
Wait a set time (durationMs, 100–10000 ms), or until a text is on the page (forText) or gone from it (gone: true): every half second the screen and about 8000px around it are read, words, names and values alike, case and spacing aside. Fails when the time runs out (timeoutMs, default 5000, at most 30000).
Inputs: gone, tabId, forText, windowId, +2 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 31 tools
Most tools target distinct actions and the descriptions explicitly disambiguate close pairs (stop_loading vs stop_task, close_tab vs close_window, press_key vs input_text). A few tools overlap in intent — navigate vs new_tab vs read_pages all 'open a page', and batch vs the individual step tools — but descriptions keep them separable.
Every tool uses the browser_ prefix with snake_case, and most follow browser_<verb>_<noun> (close_tab, take_snapshot, input_text). The verb-only variants (reload, wait, scroll, show, minimize) are still unambiguous and consistent within the scheme.
31 tools is heavy for the 3-15 sweet spot, though browser automation genuinely has many distinct capabilities and batch consolidates some. Still, there are many niche gestures (drag, move, select_editable_text) that push the surface beyond comfortable scope.
The surface covers navigation, tabs/windows, snapshots, clicking, typing, keys, scrolling, history, popups, human handover and task orchestration — a near-complete automation lifecycle. Minor gaps exist (e.g. download/file handling, visual screenshots, cookie management) but core workflows are fully supported.
Maintenance
Related MCP Connectors
Official Browserless MCP server: browser automation, scraping, screenshots and PDFs for AI agents.
Web scraping, browser automation, screenshots and AI data extraction for AI agents via MCP.
Search, read, and act on the web. The Stophy MCP server for agents.
Web search API and MCP server for developers building AI agents.
Related MCP Servers
- AlicenseAqualityBmaintenanceMCP server that lets AI agents drive your real Chromium browser with your existing signed-in sessions, providing visible, local, and inspectable automation for tasks like navigation, clicking, typing, and form filling.252Apache 2.0
- AlicenseNot gradedqualityBmaintenanceLocal browser MCP server that lets AI assistants control a real desktop browser via tools like navigate, snapshot, and search_web.MIT
- AlicenseAqualityAmaintenanceMCP server for AgentGo, a real Chromium browser for AI agents: compact page outlines with stable refs, diff-only replies after each action, real mouse and keyboard input, the agent's own signed-in accounts, and human approval for payments. MIT.111MIT
- AlicenseNot gradedqualityCmaintenanceA local Streamable HTTP MCP server that lets several AI agents drive your real, logged-in Chrome at once, each isolated in its own background tab group without stealing focus. It exposes browser tools for navigating, reading pages, filling forms, signing in via Bitwarden, and handing steps back to the user.MIT