The Best Cloud Browser MCP Servers (2026)

If you want your agent to hand a whole web task to a cloud browser, I'd use the Browser Use Cloud MCP server: one run_session call runs a full browser agent on a stealth browser, browser time is $0.02 per hour, and new projects run 10 at once. If you want your agent to control every step itself, the table below says which server fits.

We make Browser Use, so it comes first. None of these servers were in our coding-agent eval, so there are no scores here, only what each vendor documents, checked October 18, 2026.

This post is about the MCP layer: what your agent can call and what it costs. For the browsers themselves (CDP access, session speed, stealth tests, compliance) read our browser infrastructure comparison. For servers that drive your own Chrome, like Browser Harness and Playwright MCP, see the full MCP round-up.

TL;DR

What Changes When the Browser Is in the Cloud

You get parallel browsers, proxies and CAPTCHA handling. You lose your own Chrome: none of these five can use your local tabs or logins, so logins live in a cloud profile.

The bigger split is the shape of the tools:

• Whole tasks. Browser Use Cloud takes a task in plain words and runs an agent on our side. Hyperbrowser does the same for its hosted agents, plus one-call scrape, crawl and extract.
• Plain-word steps. Browserbase runs one step per call through Stagehand and a small model.
• Raw steps. Kernel (Playwright code, CDP, mouse and keyboard) and Steel (accessibility tree with element refs) let your agent do every click.

With step tools, every page your agent reads goes into its context. With task tools it reads a result. That's how they're built, not something we measured here.

The Servers

1. Browser Use Cloud MCP

The Browser Use Cloud MCP server is hosted at https://api.browser-use.com/v3/mcp. It speaks streamable HTTP with an API key header, so there's nothing to install.

run_session takes a task in plain words and creates a session: a sandbox with the Browser Use agent and a cloud browser. The agent works the task on our side. The call returns right away, and your agent polls get_session for status, output, step count, a cost breakdown and a live URL you can watch. Two params matter most: output_schema gets you JSON back in that shape, and model picks one of 11 models. Leave model out and you get an account default.

The other five tools:

• send_task sends a follow-up to a session started with keep_alive, with the same browser state and files.
• get_session_messages returns the agent's steps and reasoning.
• stop_session stops the current task or the whole sandbox.
• list_sessions lists recent sessions with status and cost.
• list_browser_profiles lists your cloud profiles for logged-in tasks.

One thing to know: MCP sessions run on API V3, the previous version of our agent API. V4 is the current one, and the one our docs recommend for new integrations. They say V3 trades accuracy for speed and lower cost. V4's default model, GPT-6 Luna, isn't one of the 11 MCP models.

The browser is our hardened Chromium fork with stealth on by default: per-session fingerprints, banner blocking, help with Cloudflare and PerimeterX. A US residential proxy is on by default. proxy_country takes any ISO country code across 195+ countries, and null turns the proxy off. Logins come from cloud profiles holding cookies, local storage and login state: the agent lists them with list_browser_profiles and passes one as profile_id. workspace_id adds file storage that persists across sessions.

I'd use this when the agent needs the answer, not the pages: research, form fills, checks across many sites, anything I want to run 10 or 100 at once. It's also the easy pick for remote or sandboxed agents that can't launch a browser at all. I wouldn't use it when my agent has to look at a page and decide each click. That's what step tools are for.

Pricing is pay as you go (pricing). Browsers cost $0.02 per browser-hour, billed by the minute with a one-minute minimum. Model tokens are provider cost plus 20%. Residential proxy traffic is $5/GB, direct traffic $0.20/GB. No subscription, $5 minimum top-up. Concurrency is shared by agents and browsers and grows with total spend: 10 at $0, 50 at $100, 250 at $1,000, 500 at $5,000, 1,000 at $25,000.

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

What I'd watch:

• Polling isn't free for your agent. Every get_session poll is a tool call in its context, so have it poll sparingly, not in a tight loop.
• If accuracy matters more than speed and cost, V4 over our REST API is the better path today.
• No step control and no raw CDP. To drive our cloud browsers step by step, use Browser Harness as a CLI with start_remote_daemon, same $0.02 per hour. Its MCP server only covers local Chrome.
• Our docs list automatic CAPTCHA solving for V4 runs and standalone browsers. I wouldn't count on it for V3 MCP sessions yet.
• The default residential proxy bills per GB, so pass proxy_country: null for staging or internal sites.
• Some things are REST-only, not in MCP: a per-run cost cap, your own model key, recording, custom proxies. Our EU region in Frankfurt is a separate V4 endpoint, and the MCP docs list only the default one.

2. Browserbase MCP

The Browserbase MCP server is hosted at https://mcp.browserbase.com/mcp and built on Stagehand, Browserbase's MIT automation framework. It has six tools: start and end for the session, navigate, act ("click the login button"), observe (list actionable elements) and extract.

Each act, observe or extract call runs one Stagehand step: a model turns your words into page actions. The default is Gemini 2.5 Flash Lite, which Browserbase pays for on the hosted server. Other models need your own key. Tools return JSON, with no screenshot or snapshot tool, so your agent trusts Stagehand's read of the page. That keeps raw pages out of your agent's context, but it's still one step per call and your agent plans the task.

I'd use it if I already had Browserbase contexts, proxies and replays set up and wanted my agent to keep step-level control without reading raw pages. Our task-level server doesn't offer that middle ground. I wouldn't pick Browserbase just for this server: without a snapshot tool, the agent can't check what Stagehand actually did.

Browserbase recommends the hosted endpoint. The local @browserbasehq/mcp npm package (Apache-2.0, 3.0.0 from March 2026) still drives Browserbase cloud browsers, but the repo behind it is archived.

Logins persist in Contexts (cookies, local storage, IndexedDB, session storage, encrypted at rest). You set them with --contextId and --persist, which the docs list as local server flags. The hosted URL takes keepAlive, proxies and verified.

On pricing, the plans differ a lot:

• Free: 1 browser hour, 15-minute sessions, 3 concurrent browsers, no CAPTCHA solving or stealth.
• Developer, $20/month: 100 hours, then $0.12 per hour. 25 concurrent browsers. 1 GB of proxy traffic, then $12/GB. CAPTCHA solving and basic stealth.
• Startup, $99/month: 500 hours, then $0.10 per hour. 100 concurrent browsers. 5 GB of proxy traffic, then $10/GB. Same CAPTCHA solving and basic stealth.
• Scale, custom: 250+ concurrent browsers, advanced stealth and Verified Agents.

claude mcp add --transport http browserbase "https://mcp.browserbase.com/mcp?browserbaseApiKey=YOUR_BROWSERBASE_API_KEY"

What I'd watch:

• The hosted API key sits in the URL query string, so it ends up wherever your client config goes.
• Boolean params must be the exact strings "true" or "false".
• For npx, the source also requires BROWSERBASE_PROJECT_ID, which the setup docs leave out.
• Proxies are on or off. I found no country option in the MCP config.
• Contexts are documented only as local flags, so on the hosted server I'd test persistence before relying on it.

3. Kernel MCP

Kernel's MCP server is MIT, and Kernel runs it at https://mcp.onkernel.com/mcp with OAuth (org-wide or one project) or a Bearer API key.

Every Kernel browser is Chromium in its own unikernel VM, isolated at the hypervisor, with anti-detection defaults. Kernel claims about 30 ms p50 to create one. Browsers are headful by default. Your agent drives them three ways:

• execute_playwright_code runs Playwright TypeScript inside the browser's VM, with up to 8 named executors per browser.
• browser_repl is a persistent Node.js runtime in the VM with Playwright, Patchright, raw CDP, files, processes and network. The README calls it "unrestricted VM code execution, not a sandbox."
• computer_action sends OS-level mouse, keyboard and screenshots instead of CDP, which Kernel says can lower bot-detection signals.

The README lists 27 tools, or 33 with vaults. Most manage the platform: profiles, proxies, browser pools, replays, files, apps and credentials. The one I'd call out is Managed Auth. Kernel runs the login and saves it to a profile, and in its MCP App flow, credentials and MFA never pass through the model.

I'd use Kernel when my agent already writes Playwright and I want a shell next to the browser. Our MCP server has nothing like Managed Auth or the vault tools. I wouldn't use it for agents that pause for long stretches between steps, because of the idle timeout below.

Kernel bills per second of active runtime: $0.06/hour headless, $0.48/hour headful, $2.88/hour with GPU (Start-Up and up). Browsers go to standby 5 seconds after the last CDP or live view activity and stop billing. Kernel's proxies are unmetered. The plans:

• Developer, free: $5 of usage a month, 5 concurrent browsers.
• Hobbyist, $30/month: $10 of usage, 10 concurrent browsers, configurable proxies (ISP, residential, mobile).
• Start-Up, $200/month: $50 of usage, 150 concurrent browsers, your own proxies, regional browsers (same rate as the US default) and GPU.
• Enterprise: custom.

Stealth mode adds an ISP proxy and a CAPTCHA solver for reCAPTCHA and Cloudflare challenges, on every plan including Developer. Profiles keep cookies, local storage, open tabs and Chromium prefs, encrypted per org.

claude mcp add --transport http kernel https://mcp.onkernel.com/mcp

Then run /mcp once in Claude Code to sign in.

What I'd watch:

• The default inactivity timeout is 60 seconds. An agent that pauses longer loses the browser unless it sets timeout_seconds (up to 72 hours).
• Standby stops billing but still holds a concurrency slot, and Developer only has 5.
• Headless is 8x cheaper but has no live view or replays, and Kernel notes some bot detectors catch it.
• browser_repl is real code execution in the VM. Contained per VM, but treat it like giving the agent a shell.
• The tool list is big, and only self-hosted deployments can trim it.
• The hosted server doesn't work with how Claude Free users add MCP servers.

4. Steel MCP

The Steel MCP server is MIT and drives Chrome on Steel Cloud over raw CDP, with no Playwright underneath. It works in two modes:

• Read first. steel_scrape, steel_screenshot and steel_pdf start no browser session.
• Interactive. steel_snapshot and steel_find read the accessibility tree and assign @eN refs. Then steel_act clicks, types, fills or scrolls by ref and reports what changed.

Page text arrives marked untrusted, with hidden text stripped and credentials redacted. You get 16 tools by default, or only the three read tools with STEEL_PROFILE=scrape.

The standout is steel_session_handoff. A person gets exclusive control for a login, CAPTCHA, payment or local file, the agent waits, then re-reads the page. Login walls and CAPTCHAs can trigger it on their own, and on MCP Apps hosts like Claude the live browser renders inside the chat. Saved profiles and managed credentials come through steel_session_options without cookies, passwords or TOTP secrets entering the model's context.

I'd use Steel when a person has to be in the loop: logins with MFA, CAPTCHAs the solver can't do, payments. With our server a person can watch the live URL, but there is no handoff tool. That's a real gap on our side.

Steel's pricing has three plans:

• Launch, pay as you go: $30 one-time credits. $0.10 per browser-hour, $10/GB proxy traffic, CAPTCHA solves $3 per 1,000, read tools $5 per 1,000. 10 concurrent sessions, 15-minute sessions. CAPTCHA solving and Steel's proxies need a $10 paid balance.
• Scale, $250/month: $100 of credits a month. $0.08 per browser-hour, $6/GB proxy, CAPTCHA $1 per 1,000, read tools $5 per 1,000. 100 concurrent sessions, 1-hour sessions.
• Enterprise, custom: 1,000+ concurrent sessions, sessions up to 24 hours, and the Stealth browser.

The solver handles reCAPTCHA v2/v3 and Turnstile. DataDome, Imperva and Amazon WAF are detected, not solved. Managed proxies target 200+ countries.

It also runs against self-hosted steel-browser with STEEL_LOCAL=true and no key. That gets you one session at a time, and no managed proxies, profiles or CAPTCHA solving.

claude mcp add steel -e STEEL_API_KEY=your-steel-api-key -- npx -y github:steel-dev/steel-mcp-server

What I'd watch:

• It's not on npm, so npx github: builds main (3.0.0) on first run, which takes about a minute. The Claude Desktop bundle on GitHub Releases is still 2.0.1.
• The read tools start no session but aren't free: $5 per 1,000 calls.
• Launch's 15-minute cap matches the server's default timeout, so long handoffs need Scale.
• The server caps live sessions at 10 per key by default (STEEL_MAX_SESSIONS).
• The inline live view needs an MCP Apps host. Elsewhere you open the viewer_url yourself.

5. Hyperbrowser MCP

Hyperbrowser's MCP server is built around whole jobs. Each tool starts a cloud job through the Hyperbrowser SDK and blocks until it's done:

• scrape_webpage returns one page as markdown, HTML, links or a screenshot.
• crawl_webpages does the same for up to 100 pages.
• extract_structured_data returns JSON against your schema, with wildcard URLs allowed.
• search_with_bing runs a search.
• Three hosted agents, browser_use_agent, openai_computer_use_agent and claude_computer_use_agent, take a task and run up to 100 steps.
• Three tools create, list and delete profiles.

What's missing: no navigate, click or snapshot tool, no live view, no handoff. It runs locally over stdio and reads HYPERBROWSER_API_KEY from the environment.

I'd use it for pulling data from lots of pages. For 100 pages, one crawl call is simpler than a task per page, and three agent backends behind one key make it easy to compare them. I wouldn't build anything long-lived on it without pinning the version and testing it in my client first, because the server hasn't shipped a release since April 2025.

Hyperbrowser prices everything in credits at $0.001 each. Browser time is $0.10 per hour and proxy traffic $10/GB. A scraped page is $0.001, or $0.01 with a proxy. AI extraction is $30 per million output tokens. The Browser Use agent is $0.02 per step plus browser time, and the OpenAI and Claude agents bill per token. The plans:

• Free: 5,000 credits, 1 concurrent session.
• Startup, $30/month: 30,000 credits, 25 concurrent sessions.
• Scale, $100/month: 100,000 credits, 100 concurrent sessions.
• Enterprise, custom: 1,000+ concurrent sessions and ultra stealth.

Proxies and CAPTCHA solving need a paid plan. Stealth is opt-in per call through sessionOptions (useStealth, useProxy, solveCaptchas). There's no proxy country field, and Hyperbrowser defaults the country to US. Profiles save cookies, storage and cache.

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

What I'd watch:

• It's stale. The last npm release, 1.0.25, was April 2025, there are no commits since May 2025, and an open issue says it fails six requirements of the 2026-07-28 MCP spec.
• Stealth, proxy and CAPTCHA solving are all off by default on every call, so a blocked page may just mean your agent forgot to ask.
• The MCP writes profile changes back by default, the opposite of the API default.
• The README shows the key as an argument, but the server only reads it from the environment.
• The LICENSE says MIT, package.json says ISC.

Comparison Table

Concurrency is by plan, lowest tier first. Prices are list prices before plan credits, checked against each vendor's pricing page, docs and repo on October 18, 2026. For how these providers' browsers did on our stealth benchmark and session speed tests, see the browser infrastructure comparison.

Before you commit, run the same three real tasks on your top two and compare the bill per finished task, not per browser-hour.