The Best Browser Agent MCP Servers (2026)

If you want to hand a browser task off and get the answer back, use our Browser Use Cloud MCP server. One call starts a hosted agent on a cloud browser, and you don't need a model key. If you want it free and local, our open-source MCP server has a full-agent tool that runs on your own OpenAI key. Outside Browser Use, Hyperbrowser is the only server in my full round-up with whole-task agents as MCP tools. agent-browser has an opt-in chat tool for short instructions.

We make Browser Use and Browser Harness, so they come first. Competitor facts are from their own repos, docs and pricing pages, checked October 18, 2026.

Delegate or drive

• Drive. The server exposes clicks, typing and page reads. Your agent plans every step and reads every page itself. Playwright MCP, Chrome DevTools MCP and Browser Harness work like this.
• Delegate. The server exposes one tool that takes a goal in plain words. A second agent, with its own model, runs the browser and returns the result. Your agent never sees the pages.

Driving is expensive in context. In our matched eval (100 BU Bench V2.1 tasks, Codex with GPT-6 Luna, one run per task), four driving tools used 2.1M to 6.7M median input tokens per task, all of it in the coding agent's context. Browser Harness ran as its CLI and skill, not the MCP server, and every tool used the same fresh Browser Use cloud browser. Delegating moves that work to the browser agent, so your agent reads the task, a few status checks and the answer. None of the delegating servers below were in that eval, so I won't give you a number for the savings.

1. Browser Use Cloud MCP

This is the one I'd use for anything long, repetitive or parallel. It's a hosted MCP server at https://api.browser-use.com/v3/mcp that runs the Browser Use agent on our cloud browsers. There are no click or type tools, just seven session tools: run_session, send_task, get_session, get_session_messages, stop_session, list_sessions and list_browser_profiles.

run_session takes a task of up to 50,000 characters, starts an API V3 session (the agent plus a cloud browser) and returns right away. Your agent then polls get_session for status, step count, output, cost and a live URL. Each poll is a tool call, but it returns a status, not a page. Pass output_schema and the output comes back as JSON in that shape. With keep_alive: true the session stays open after the task, and send_task sends a follow-up to the same browser, with its state and files. You pick the model per task with model; the live server offers 11, including gemini-3-flash, gpt-5.4-mini, claude-sonnet-5 and claude-opus-4.8. Leave it out and you get an account default.

The browser is our hardened Chromium fork with stealth on by default. Sessions go through a US residential proxy unless you say otherwise; proxy_country takes any country code, and null turns the proxy off. For logins, list_browser_profiles shows your saved cloud profiles and profile_id starts the task already logged in. You create profiles in the dashboard or sync them from your local Chrome. To see what the agent did, open the live URL, or call get_session_messages for every step with the agent's reasoning. list_sessions shows recent runs with status and cost. Recording is on our REST API, not the MCP server.

New projects can run 10 sessions at once. $100 paid unlocks 50, and spend tiers go up to 1,000. Ten parallel tasks is just a loop of run_session calls.

Install.

claude mcp add -t http -H "Authorization: Bearer YOUR_API_KEY" browser-use https://api.browser-use.com/v3/mcp

Cursor, Windsurf and Claude Desktop configs: docs.

Price. Browser time is almost free: a 10-minute run is about a third of a cent. You pay for tokens and proxy traffic. Pay as you go (pricing):

• Browsers: $0.02 per browser-hour, billed by the minute, one-minute minimum.
• Model tokens: provider price plus 20%.
• Residential proxy: $5/GB, on by default. With the proxy off, direct traffic is $0.20/GB.

Now the honest part. It runs API V3, not V4. Our own docs say V3 "trades accuracy for speed and lower cost than V4", and GPT-6 Luna, the V4 default, is not in the MCP model list. You can't step in mid-task with a click, and it can't use the Chrome on your laptop, only a cloud profile. If you point it at an internal or staging site, pass proxy_country: null so you don't pay residential proxy rates for nothing.

I'd use it whenever the task is more than a few pages and your agent doesn't need to look at them, or when you want ten of them at once. For a new integration where accuracy matters most, our docs say to pick API V4, so I'd call V4 directly instead of going through MCP.

2. Browser Use open-source MCP

This is the free one. It's the open-source browser-use library (MIT) run as a local MCP server over stdio. Fifteen of its 16 tools are direct control: navigation, clicks, typing, scrolling, tabs, page state, HTML, screenshots and extraction. The sixteenth, retry_with_browser_use_agent, takes a task in plain words and runs a full browser-use agent end to end.

It launches a local Chrome or Chromium over CDP with its own persistent profile, not your everyday Chrome. The window is visible by default, so you can watch it; BROWSER_USE_HEADLESS=true hides it. For the step tools, browser_get_state returns the page as JSON: URL, title, tabs, scroll size and a numbered list of interactive elements with their text, placeholder and link. Clicks and typing target those numbers, and browser_click also takes x/y pixel coordinates. Only browser_extract_content calls a model; the other step tools don't.

The agent tool runs up to 100 steps by default and takes an allowed_domains list. It runs in its own browser, separate from the tab your step tools were driving, and closes when done. Its tool description calls it a last resort. For long tasks I'd reach for it first.

The model is yours. In practice that means an OpenAI key, an OpenAI-compatible endpoint, or AWS Bedrock with MODEL_PROVIDER=bedrock. The docs also mention an Anthropic key, but the server code doesn't read it; on the OpenAI path, without OPENAI_API_KEY the agent tool fails. The default config it writes on first run uses gpt-4.1-mini, and on Bedrock that config model wins, so also set BROWSER_USE_LLM_MODEL to a Bedrock model ID and install with --from 'browser-use[cli,aws]' to get the AWS SDK.

Install.

claude mcp add browser-use -- uvx --from 'browser-use[cli]' browser-use --mcp

Set OPENAI_API_KEY in the server's environment. It needs Python 3.11 or newer.

Price. Free. You pay your model provider for the agent tool and for extraction. No Browser Use charge.

It has no stealth, managed proxies or CAPTCHA help; those are Cloud features. One server process holds one browser session for the step tools, and idle sessions close after 10 minutes. Anonymous telemetry is on by default; set ANONYMIZED_TELEMETRY=false to turn it off.

Where it beats Cloud: the browser runs on your machine, so it reaches sites on localhost, your VPN or staging that a cloud browser can't. You choose the model endpoint, and there's no per-GB proxy bill. I'd use it for exactly that: local and internal sites, or when you don't want a cloud bill at all. For anything bot-protected or parallel, I'd use Cloud.

3. Hyperbrowser MCP

This is the most interesting non-Browser Use option, and the one I'd be most careful with. Hyperbrowser's MCP server is a Node server (MIT) with 10 tools. Three are agents: browser_use_agent, openai_computer_use_agent and claude_computer_use_agent. browser_use_agent runs the open-source browser-use agent, hosted by Hyperbrowser. The MCP server doesn't set its model; Hyperbrowser picks that on their side. The other two run OpenAI's computer-use agent and Claude computer use. The rest are one-call web jobs (scrape_webpage, crawl_webpages, extract_structured_data, search_with_bing) and profile tools.

Each agent tool takes a task, a maxSteps cap (default 25, max 100) and returnStepInfo. The call starts a job on Hyperbrowser's cloud and blocks until it finishes, so there's no polling loop. You get the final result as JSON, and step details only if you ask. That's also all you see: Hyperbrowser's API has a live view, but this server doesn't expose it. Stealth, proxies, CAPTCHA solving and a saved profile go in sessionOptions, all off by default.

Install. Their README config:

{ "mcpServers": { "hyperbrowser": { "command": "npx", "args": ["-y", "hyperbrowser-mcp"], "env": { "HYPERBROWSER_API_KEY": "YOUR-API-KEY" } } } }

Don't pass the key as a command argument like another README example does; the server only reads the env var.

Price. Browser time is $0.10 per hour. The Browser Use agent costs $0.02 per step, so a run at the default 25-step cap costs up to $0.50 in step fees, plus browser time. The computer-use agents bill per model token. Free plan: 5,000 credits and one concurrent session. Startup is $30 a month with 25 sessions, Scale $100 with 100. CAPTCHA solving and proxies need a paid plan (pricing).

The problem is maintenance. The last npm release, 1.0.25, was on April 13, 2025, and the last commit on May 23, 2025. Open issue #22 reports it fails six requirements of the 2026-07-28 MCP spec, though it passes the 2025-11-25 spec. Issue #14, "Not working", is from November 2025 and still open.

Where it beats us: one key, three agent backends, including OpenAI's computer-use agent and Claude computer use. No other server here gives you those behind one MCP key. Crawling up to 100 pages or pulling schema-shaped JSON from a wildcard URL set is one call; our Cloud MCP needs a written-out task.

I'd test it before relying on it. If the computer-use agents are why you're here, I wouldn't build anything new on this MCP server. Their README says the API supports a superset of the server's features, so I'd use the API directly.

4. agent-browser chat

This only makes sense if you already use agent-browser. agent-browser is Vercel Labs' Rust browser CLI (Apache-2.0) with an MCP mode. Its default core profile is 29 step tools, so by default it's a driving tool. agent_browser_chat ("Run a single-shot natural-language browser instruction") only appears when you add the debug profile or use all (156 tools).

Under the hood the MCP tool calls the CLI's chat command with --json. Chat turns your instruction into agent-browser commands, one command per tool call, runs them and returns the AI response. It runs against agent-browser's browser: a local headless Chrome by default, or a cloud browser from a provider with -p, including Browser Use with -p browseruse. Each MCP call waits two minutes by default; timeoutMs raises it. The docs don't say how many steps one instruction can take. The model goes through the Vercel AI Gateway: you need AI_GATEWAY_API_KEY, the default model is anthropic/claude-sonnet-4.6, and AI_GATEWAY_MODEL changes it. To watch it, there's a local dashboard on port 4848 with its own chat tab, plus video recording commands.

Install.

npm install -g agent-browser && agent-browser install

Then add {"command": "agent-browser", "args": ["mcp", "--tools", "core,debug"], "env": {"AI_GATEWAY_API_KEY": "..."}} to your MCP client config.

Price. Free. You pay the gateway for tokens.

Vercel frames chat as a single instruction, not a long autonomous task. Our eval only covered agent-browser's step tools (56.3, a tie with Browser Harness within noise, same setup as above), so it says nothing about chat.

I'd use it to hand agent-browser a short instruction without leaving it. For a real multi-step task, I'd delegate to Cloud, or to the open-source agent tool, which runs up to 100 steps by default.

What about Browserbase, Kernel and Steel?

Browserbase's MCP server sits in the middle. act, observe and extract each take one step in plain words ("click the login button"), and Stagehand's model (Gemini 2.5 Flash Lite by default, paid by Browserbase on the hosted endpoint) turns it into page actions. Your agent still plans every step but never reads raw pages. Kernel and Steel have no task-level tool. All three are in the full round-up.

Comparison

When your coding agent should delegate

I'd delegate when:

• The task is long or repetitive. Twenty pages of form filling don't belong in your coding agent's context.
• You want many at once. Ten parallel sessions is a loop of run_session calls.
• You want structured output. Pass output_schema, get JSON back.
• Your agent can't run a browser. A remote or sandboxed agent only needs HTTP.

I'd drive when:

• You need your own logged-in Chrome. A delegated agent works in a cloud profile. Browser Harness drives the Chrome you already use.
• Your agent needs to see the page. Debugging your own app, checking a layout, reading a console error.
• The task is a few clicks. A second agent is overkill.

Both work together: drive Browser Harness for the one page your agent needs to look at, fire off run_session for the fifty it doesn't. Every driving server, including Playwright MCP and Chrome DevTools MCP, is in the full round-up.