7 Cloud Browsers for AI: 2026 Comparison

What a Cloud Browser for AI Actually Is

A cloud browser for AI is a Chrome instance on a provider’s server that an agent drives over CDP or an MCP endpoint, so pages load and clicks happen without your laptop staying awake. Four things decide whether it works and what it costs: browser hours, proxy traffic, profile persistence and clean shutdown. Feature pages rarely mention the last two.

How These Seven Were Compared

Six criteria, weighted toward what fails in production:

• Price per browser hour and how it is rounded — whole minutes, 30-second units or accumulating runtime.
• Proxy cost per gigabyte, the line item that surprises people.
• Session lifecycle — how long a cold browser takes to become usable.
• Persistence — whether cookies survive between runs, and whether a resume keeps the live session.
• Shutdown — what happens when your script dies mid-task.
• Integration — CDP, MCP, self-hosting, or none of the three.

Prices come from vendor billing pages in early November 2026. Vendors publish their own comparison tables too, usually on sites they picked, so treat those as a sanity check rather than a ranking. For the machinery underneath — the Chrome process, the CDP endpoint, the profile directory — see this explainer on the headless browser for AI agents.

7 Cloud Browsers for AI, Ordered by What Breaks First

Ordered roughly by how quickly I would put one in front of a production agent. Send.win sits last because it solves a different problem, and the entry says so.

1. Browser Use Cloud — cheapest hour, real proxy metering

Browser Use began as an open-source browser agent library under the MIT licence, with about 119k GitHub stars; Cloud is the managed version. It charges $0.02 per browser hour, hands you a CDP endpoint that Playwright or Puppeteer attaches to, and scales concurrency from 10 to 1,000 browsers by lifetime spend. Credits start at $5 and do not expire, and eligible Google, GitHub or Microsoft sign-ups get a starter credit.

• Pros: Lowest hourly rate here by a wide margin; residential proxy at $5/GB across 195+ countries, or $0.20/GB for direct traffic and your own proxy. Timezone and locale follow the exit IP.
• Cons: Residential IPs are not guaranteed sticky — in a 20 October 2026 test three of five browsers held one IP for 40 minutes. Browser time also rounds up to whole minutes with a one-minute minimum.

Best for: cost-sensitive runs on mostly text pages. Weighing a profile manager against an agent runtime? The Send.win vs Browser Use breakdown covers the split.

2. Browserbase — managed, predictable, priced accordingly

Browserbase charges $0.10 to $0.12 per browser hour with residential proxy at $10 to $12 per GB, and a session lifecycle measured at 877 ms. It was not self-hosted in the October 2026 comparison, which is the trade: less control, fewer moving parts.

• Pros: Predictable per-hour pricing on a platform you do not operate yourself.
• Cons: Five to six times Browser Use’s hourly rate, with residential traffic at roughly double.

Best for: teams that want a managed provider and will pay $10+/GB for residential egress.

3. Browserless — the self-hosting option with a traffic trap

Browserless runs $0.18 to $0.24 per browser hour and supports self-hosting, which makes it the obvious pick when data cannot leave your own infrastructure. Proxy traffic is billed at 6 units per megabyte, though, so bandwidth adds up fast: a 100-browser run is estimated at $3,168.

• Pros: Self-hosting available, with familiar tooling for teams already running a browser fleet.
• Cons: Highest hourly rate in this list, and per-megabyte proxy billing punishes image-heavy pages.

Best for: teams with existing infrastructure and a compliance reason to keep browsing in-house.

4. Steel — cheaper than Browserless, slower to start

Steel sits at $0.08 to $0.10 per browser hour with proxy at $6 to $10 per GB, and it is self-hostable. The trade-off is startup: a 3,509 ms session lifecycle, the slowest in the published data, means a cold browser takes over three seconds before your agent does anything useful.

• Pros: Self-hosting plus a low hourly rate, with mid-range proxy pricing.
• Cons: Slow cold starts hurt fan-out jobs that open a fresh browser per task.

Best for: batch work where a three-second start is invisible.

5. Kernel — fastest start, widest price band

Kernel quotes $0.06 to $0.48 per browser hour, does not meter proxies, and posts the fastest lifecycle at 318 ms. That suits high-concurrency jobs where latency, not bandwidth, is the constraint — and the range means your rate depends on the configuration you choose.

• Pros: 318 ms lifecycle makes short, numerous tasks viable; proxy traffic is not a separate meter.
• Cons: The spread from $0.06 to $0.48 is wide enough that you need a quote for your own load shape.

Best for: latency-sensitive fan-out with many short-lived browsers.

6. Cloudbrowser.tv — persistent profiles with a human in the loop

Cloudbrowser.tv is an invitation-only private preview built around persistent, isolated Chrome profiles rather than throwaway sessions. Free covers one browser-hour per UTC month and one concurrent browser; Basic is $20/month for 250 hours and 10 concurrent; Pro is $99/month for 1,250 hours and 100 concurrent, with overage at $0.08 or $0.06 per hour. It supports CDP, a permission-controlled Live View, pause and resume, and forking from a paused source.

• Pros: Persistent profiles plus a Live View a person can use to watch or take over; low overage rates.
• Cons: Runtime accumulates across browsers — ten browsers at 30 minutes bills five browser-hours — and closing the viewer or CDP client does not stop the meter, as the Cloudbrowser.tv billing docs state.
• Cons: Browsers auto-pause after five minutes without a connected agent or Live View by default, and resuming restarts Chrome, so external sessions may expire.

Best for: workflows where a person signs in, checks a result or takes over mid-task — if you can get an invite.

7. Send.win — isolated profiles for the people working alongside AI

Send.win is not an agent runtime and does not pretend to be one. It is a browser profile manager: each profile keeps its own cookies, storage, sessions, fingerprint settings and proxy. The cloud browser runs those profiles on Send.win’s server in Helsinki, Finland, so you can reach a client account from any device with nothing to install; the Sendwin Browser desktop app does the same job locally on Windows, macOS and Linux.

Its place in an AI workflow is on the human side. If your team uses assistants inside the browser — drafting, summarising, research, checking what an agent produced — across a dozen accounts you own or manage, the hard part is not starting a Chrome process. It is keeping each account’s cookies, proxy exit and fingerprint settings separate, and letting a colleague pick up the same signed-in profile without a password changing hands.

• Pros: Residential proxies included on Pro and Team with metered bandwidth, plus bring-your-own HTTP/SOCKS5; timezone, locale, WebRTC and geolocation follow the proxy exit IP automatically.
• Pros: Share a profile with a paid teammate and it opens already signed in; share live cloud sessions; cloud sync carries logins across devices. Up to 50 profiles can be open at once on both plans.
• Cons: No API, SDK, headless mode or Playwright, Puppeteer and Selenium integration on any plan, so it cannot run unattended agents.
• Cons: No free trial of the desktop app; the cloud demo gives 10 minutes a day, and Pro starts at $19/month.

Best for: agencies, support and QA teams doing browser work across many authorised accounts — not for scripted automation. Pro is $19/month or $83.88/year ($6.99/month) for 150 profiles, 5 GB of proxy bandwidth, 6 seats and 20 saved cloud sessions; Team is $49/month or $251.88/year ($20.99/month) for 500 profiles, 20 GB and 16 seats. Extra bandwidth is $6/GB, extra profiles $0.05 each.

Where the Bill Actually Goes

The table below covers the seven above plus four more options that come up in the same evaluations.

Hourly rates are the least interesting number on the page. In a published Browser Use cost example, 10,000 one-minute page loads with 2 MB pages over residential proxy came to about $3.33 of browser time and $100 of proxy traffic. Traffic was 97% of the bill. If your agent opens pages with images, fonts and video posters, optimising the hourly rate is optimising the wrong variable.

Three levers move that number: strip assets the agent does not read, send requests direct at $0.20/GB where a site does not require residential egress, and cache pages you revisit. Metering quirks decide the rest. Browser Use rounds up to whole minutes with a one-minute minimum, CloudBrowser AI bills one usage unit per 30 seconds of browser time per tab, and Cloudbrowser.tv accumulates runtime across every browser you have open.

Persistent Profiles, Logins and IP Stickiness

Persistence is the feature people assume works and then discover does not. A persistent profile stores cookies and storage on the provider’s disk, so a signed-in session can survive between runs. It does not guarantee a live session: Cloudbrowser.tv says outright that saved logins can still expire or need reauthentication, and that resuming a paused browser restarts Chrome, which can drop external sessions attached to it.

The second failure mode is network. Managed residential pools rotate, and sticky assignments are best-effort — in the 20 October 2026 test, three of five Browser Use browsers held one IP for 40 minutes, which means two did not. That matters because sites commonly bind a session to client properties including the IP address, a practice OWASP recommends for session protection. Change the exit IP mid-task and the site has a legitimate reason to invalidate the session; your agent sees a login wall and reports a vague failure.

The fix is process, not a better tool. Pin one country or region for the whole task, keep the same proxy for the life of the session, store the storage state next to the task record, and treat re-authentication as a normal branch with a human escalation path. Cloudbrowser.tv offers a permission-controlled Live View for that escalation, CloudBrowser AI includes a live remote desktop on every plan so someone can step in, and Send.win’s contribution is quieter — a shared profile opens already signed in for a paid teammate. For the wider picture on separating sessions, the cloud browser isolation guide goes deeper.

Shutdown, Timeouts and Concurrency

Closing a Playwright or CDP connection does not stop a hosted browser. It keeps running, keeps billing and keeps its concurrency slot until you call the provider’s stop endpoint. Cloudflare Browser Run adds a second cap on top of hours: $2.00 per concurrent browser above 10 on Workers Paid, whose free tier gives 10 minutes a day and 3 concurrent browsers.

const { chromium } = require('playwright');

// Replace these two with your provider's own session API.
async function startCloudSession() {
  const res = await fetch('https://api.example-provider.com/v1/sessions', { method: 'POST' });
  if (!res.ok) throw new Error(`Session start failed: ${res.status}`);
  return res.json(); // must include { id, wsEndpoint }
}

async function stopCloudSession(id) {
  await fetch(`https://api.example-provider.com/v1/sessions/${id}/stop`, { method: 'POST' });
}

async function runTask() {
  const session = await startCloudSession();
  const browser = await chromium.connectOverCDP(session.wsEndpoint);
  const context = browser.contexts()[0] ?? (await browser.newContext());
  const page = await context.newPage();

  try {
    await page.goto('https://example.com', { waitUntil: 'domcontentloaded' });
    // ...agent work...
  } finally {
    await browser.close();              // detaches your client only
    await stopCloudSession(session.id); // this is what ends billing
  }
}

runTask().catch(function (err) {
  console.error(err);
  process.exitCode = 1;
});

Run through this list before an agent touches a real account:

1. Wrap every session in try/finally with an explicit stop call, including on timeout and on failure.
2. Set a hard maximum runtime per task and a reaper job that stops anything older than it.
3. Record session ID, task ID, proxy region and start time where your team can read them.
4. Check your concurrency ceiling — Browser Use scales 10 to 1,000 by lifetime spend; Cloudbrowser.tv caps at 1, 10 or 100 by plan.
5. Confirm the auto-pause default and whether it applies to your plan; Cloudbrowser.tv pauses after five minutes of inactivity.
6. Test the failure path: kill the script and verify the browser actually stopped.

If you are wiring an assistant to a browser instead of writing the driver yourself, the Playwright MCP server setup shows how a tool-exposing endpoint replaces most of this code — the stop call still has to exist somewhere.

Matching the Provider to Your Workload

The decision usually comes down to one dominant constraint:

• Bandwidth-heavy pages: fix traffic before you shop on hourly rate — strip assets, or route non-sensitive requests direct at about $0.20/GB.
• Many short tasks: Kernel’s 318 ms lifecycle beats a cheaper hour that takes three seconds to start.
• Data cannot leave your network: Steel or Browserless, self-hosted.
• A person must sign in or take over: Cloudbrowser.tv’s Live View, or CloudBrowser AI’s remote desktop on every plan.
• An assistant calls the browser: an MCP endpoint — CloudBrowser AI’s remote MCP server exposes 20 browser tools, the shortest path from ChatGPT or Claude to a real page.
• Your team does the browser work itself: Send.win, a browser profile manager built for people rather than agents — pair it with one of the runtimes above when you also need agent tasks.

Run Cloud Browser For Ai in the Cloud With Send.win

Send.win’s cloud browser runs isolated browser profiles on a server in the EU — open a clean session from any device without installing anything:

• Instant cloud sessions – launch an isolated browser in seconds, no local install
• Isolated profiles – separate cookies, storage and fingerprint settings per session
• Cloud sync & profile sharing – pick up the same profiles on the desktop app (Windows, macOS, Linux) or share them with your team
• Residential proxies included – on Pro and Team, with timezone and locale matched to the proxy

You can try it right now: the Send.win demo browser opens an isolated cloud session directly in this browser tab. Paid plans start at $19/month, with a 7-day money-back guarantee on your first card purchase — see pricing.

Two footnotes on currency. A list that still recommends ChatGPT Atlas is out of date: OpenAI launched it on 21 October 2025 and it stopped working on 9 August 2026, with agentic browsing moving into the ChatGPT desktop app and its own cloud browser on paid plans in supported regions, excluding Free and Go. And some providers, Lexmount among them, publish no list prices at all, letting you run a real task on a free project allowance before you commit.

Frequently Asked Questions

What is a cloud browser for AI agents?

A cloud browser for AI is a hosted Chrome instance that an agent controls over CDP or an MCP endpoint instead of running on your machine. The provider keeps the browser process, the profile storage and the network egress; you get a connection URL and a bill for browser hours plus proxy traffic. CloudBrowser AI exposes it through an MCP server with a fixed set of browser tools, while Browser Use Cloud, Browserbase, Steel and Hyperbrowser hand you a CDP endpoint you drive yourself.

How much does a cloud browser for AI cost?

Browser time ranges from $0.02 per hour on Browser Use Cloud to roughly $0.24 on Browserless, with Browserbase, Steel, Kernel, Hyperbrowser and Anchor in between. Proxy traffic is the bigger lever, running $5 to $12 per GB for residential bandwidth. Flat plans exist too: CloudBrowser AI is $25 a month for 250 browser hours and 10 concurrent browsers after a seven-day trial.

Can a cloud browser stay signed in to a website?

Partly. Persistent profiles keep cookies and storage on the provider’s disk, so a session can survive between runs, but saved logins still expire and resuming a paused browser restarts Chrome. Sticky residential IPs are best-effort as well: in an October 2026 test only three of five Browser Use browsers kept one IP for 40 minutes. Build re-authentication into the flow as a normal branch.

Do I still need Playwright or Puppeteer?

Yes, if you are writing your own tasks. Browser Use Cloud, Browserbase, Browserless, Steel and Hyperbrowser give you a CDP endpoint that Playwright, Puppeteer or a similar library connects to, and your script owns the logic. You skip those libraries only with a no-code route such as an MCP server with prebuilt browser tools, or a vendor agent that accepts a plain-language task.

Which cloud browser works with ChatGPT or Claude?

Assistants reach a cloud browser in two ways: a remote MCP server such as CloudBrowser AI’s, which exposes browser tools the assistant can call, or a browser the assistant ships itself. ChatGPT’s cloud browser runs on OpenAI’s side and is listed on paid plans in supported regions, excluding Free and Go. Do not plan around ChatGPT Atlas, which stopped working on 9 August 2026.

What happens if I forget to stop a cloud browser?

It keeps billing and keeps holding a concurrency slot until you stop it through the provider’s API, even if your script crashed an hour earlier. Where concurrency caps are tied to lifetime spend, a few orphans can block the runs you need. Some providers auto-pause — Cloudbrowser.tv pauses after five minutes without a connected agent or Live View — but do not rely on that as your only safeguard.

Does closing the CDP connection stop the meter?

No. Closing the Playwright or CDP connection detaches your client; the hosted browser keeps running, keeps billing and keeps its slot. The only reliable stop is the provider’s own stop or terminate call, placed in a finally block so it fires on errors and timeouts as well as on success.

Can I use Send.win to run an AI agent?

No. Send.win is built for people working in the browser, not for agents to drive, and it offers no developer interface on any plan. It is a browser profile manager — isolated profiles with their own cookies, proxy and fingerprint settings, as a desktop app for Windows, macOS and Linux or as a cloud browser. Run your agents on one of the runtimes above and use Send.win for the human work around them, with accounts you own or are authorised to manage.

Related Products & Resources

• Download
• Demo Browser
• Pricing
• Fingerprint Checker
• Canvas Fingerprint Test