Browserbase vs Anchor Browser
Both rent you a cloud Chromium in its own VM that is thrown away after each session. Browserbase builds a developer stack around it (Stagehand, Search, Fetch, replays) with sessions of up to 6 hours, while Anchor Browser leans on managed logins, stealth and hosted agents, with sessions you can stretch as long as you like.
The companies and products
Browserbase
Browserbase calls itself the complete platform to build and deploy agents that browse and interact with the web like humans: browsers, search, fetch, functions, model access and identity behind one API key.
Its core product is a headless Chrome session you drive over CDP with Playwright, Puppeteer or its open source Stagehand SDK, with proxies, CAPTCHA solving, saved browser profiles (Contexts), live view and session replays. Around it sit Search and Fetch APIs, short TypeScript Functions that run next to the browser, a Model Gateway and hosted Agents that work from a plain language goal. It is a browser platform, not a general sandbox: you get a browser, not a shell or root on the machine, so this page compares where the two overlap, which is agents that browse.
Anchor Browser
Anchor Browser is cloud browser infrastructure for AI agents: managed Chromium sessions you control over CDP or a REST API, plus a hosted browser agent.
Anchor Browser is a different kind of product from bochka. Each session is a headful Chromium in its own VM that is erased when the session ends, and you drive it with Playwright or Puppeteer, with mouse and keyboard calls, or by sending a task in plain words to its hosted agent. It adds managed logins with MFA, residential proxies, stealth and CAPTCHA solving, and its own docs tell you to run your agent's code in a separate sandbox and connect to the browser over CDP.
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “24th cheapest of 367” means 23 of the other 366 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | Browserbase: price rank | Anchor Browser: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither gives a coding agent a shell, Docker or a disk to build on, and Anchor Browser's own docs send agent code to a separate sandbox, so builds fit bochka. | 140th of 367, with limits $1,255 a month | 180th of 367, with limits $2,000 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Anchor Browser does better than Browserbase here because its sessions have no upper time limit, but both erase the machine at the end, and bochka keeps the whole disk. | 259th of 366, with limits $3,699 a month | 71st of 366, with limits $1,845 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month | 270th of 345, with limits $382 a month | 325th of 345, with limits $2,171 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month 300 sandboxes at once is past Browserbase Startup (100) and Anchor Browser Growth (200), and each one is a browser, not a machine. | 250th of 361, with limits $1,099 a month | 283rd of 361, with limits $2,000 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 264th of 360, with limits $5,049 a month | 298th of 360, with limits $12,510 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 349th of 364, with limits $449 a month | 357th of 364, with limits $2,000 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month | 244th of 377, with limits $152 a month | 284th of 377, with limits $500 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs SSH and files that stay, which neither browser session offers, so this fits bochka. | 251st of 368, with limits $96 a month | 222nd of 368, with limits $42 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Anchor Browser's mouse and keyboard calls and Browserbase's Stagehand both act inside a browser; bochka streams a 60fps Linux desktop where an agent can use any app. | 159th of 369, with limits $416 a month | 173rd of 369, with limits $500 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both are built for this and land close together (Browserbase 24th, Anchor Browser 28th), while bochka ranks 7th because the same agent also gets a shell, Docker and a disk next to Chromium. | 24th cheapest of 367 $449 a month | 28th cheapest of 367 $560 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month Both fit startup-scale bots; Browserbase adds Search and Fetch APIs for pages that need no browser, and Anchor Browser adds volumes that keep files between sessions. | 55th cheapest of 346 $537 a month | 50th cheapest of 346 $500 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month Anchor Browser ranks 5th and Browserbase 13th for bot-protected sites, since both bring residential proxies and CAPTCHA solving; bochka runs Chromium on datacenter IPs and does not solve CAPTCHAs. | 13th of 338, with limits $9,799 a month | 5th of 338, with limits $6,175 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 229th of 360, with limits $291 a month | 334th of 360, with limits $2,000 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Can't run it | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Browserbase | Anchor Browser | bochka |
|---|---|---|---|
| What you get | Headless Chrome sessions over CDP, plus Search, Fetch, Functions, a Model Gateway and hosted Agents | Headful Chromium sessions over CDP or REST, plus hosted browser agents and versioned automation tasks | A full Linux VM with its own kernel and root, with a desktop and Chromium inside |
| Isolation | 1 browser per VM in its own subnet; the VM is destroyed after each session | A dedicated VM per browser session, erased when the session ends | Full VM on dedicated AMD Ryzen 9 9950X hosts; the disk stays |
| Shell, code and Docker | No shell on the browser VM; Functions run TypeScript next to the browser for up to 900 seconds | No shell; from Growth you can run TypeScript snippets against the page | SSH, any language, Docker, systemd and /dev/kvm on every machine |
| Session length | 15 minutes on Free, 6 hours on Developer and Startup, 6+ hours on Scale | 180 minutes by default, with no upper limit if you raise it; ends after 5 idle minutes by default | No cap on paid plans; you set the time to live |
| State after a session | Contexts keep the browser profile (cookies, localStorage, IndexedDB) | Profiles keep cookies, local storage and cache, and up to 10 volumes keep files | The whole disk is saved every minute and on stop; a stopped sandbox costs nothing |
| Fork | No fork; a new session starts fresh or loads a Context | No fork; a new session starts fresh or loads a profile | Fork a running sandbox with its disk |
| Browsers at once | 3 on Free, 25 on Developer, 100 on Startup, 250+ on Scale | 5 on Free, 25 on Starter, 50 on Team, 200 on Growth, 500+ on Enterprise | No session cap on paid plans; up to 600 starts an hour on the top plan |
| Stealth and CAPTCHAs | CAPTCHA solving on paid plans; Verified browsers with real fingerprints on Scale | CAPTCHA solving from Starter; full stealth Chromium on Growth; unique fingerprints on Enterprise | Chromium on datacenter IPs; no CAPTCHA solving |
| Proxies | Residential proxies in 200+ countries; 1 GB or 5 GB included, then $12 or $10 per GB | Residential proxies with country and city targeting and sticky IPs at $8 per GB, or your own proxy | None managed; you can run your own proxy client inside the VM |
| Logins and identity | Contexts keep logins across sessions for weeks or months | Managed identities with MFA keep logins across sessions, from Starter | Your agent logs in itself; AI credentials can switch to another account when credits run out |
| Developer tools | Open source Stagehand SDK (act, extract, observe), live view and session replays with logs | Embeddable live view, mouse, keyboard and screenshot calls, and a hosted MCP server | Embeddable 60fps desktop stream, SSH, and a prompt, steer and events API for coding agents |
| Agents | Its own hosted browser Agent from a plain language goal, with built-in tools only | Hosted browser agents on several computer-use models, with human-in-the-loop and webhooks | Claude Code, Codex, OpenCode and more preinstalled, driven from outside |
| Hosting | CDP connect URL and live view links only; no ports to host on | Only the CDP socket and the live view URL | HTTPS URLs for up to 50 ports, token-protected; raw TCP; own IP |
| Regions | Oregon, Virginia, Frankfurt and Singapore, picked per session | Ohio by default; Frankfurt, Asia and Australia on Growth; your own cloud on Enterprise | EU only (Germany, Finland and France) |
Every feature Battleships tracks (43)
| Feature | Browserbase | Anchor Browser | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | No | No | Yes |
| Systemd | No | No | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | No | No | Yes |
| Persistent disk | No | Yes | Yes |
| Pause/resume | No | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | No | No | Yes |
| ≥24 h sessions | No | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | No | No | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Not published | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
There is no comparable measurement for either one. Browserbase and Anchor Browser sell browser time, do not publish the CPU or memory behind a session, and are not in StarSling's CPU benchmark. bochka scored 26.69 runs per second on its Node.js test at 4 vCPU / 8 GB.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Browserbase and Anchor Browser have no published run in this suite yet, so there is no like-for-like number to compare.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.
| Scenario | Browserbase, a month | Anchor Browser, a month | bochka, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $99 · Startup · with limits | $7 · Free · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $122 · Startup · with limits | $42 · Free · with limits | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $841 · Startup · with limits | $500 · Team · with limits | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $499 · Startup · with limits | $2,000 · Growth · with limits | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $1,049 · Startup · with limits | $2,510 · Growth · with limits | $2,000 · $2000/mo · with limits |
Browserbase: Plans include browser hours: 100 on Developer ($20) and 500 on Startup ($99), then $0.12 or $0.10 per browser hour, billed by the minute with a one-minute minimum. Proxy data is extra after the included 1 GB or 5 GB, and Search, Fetch and Agents calls have their own allowances.
Anchor Browser: Anchor Browser bills $0.05 per browser-hour plus $0.01 for each browser created, paid from credits worth $1 each that plan fees turn into (Starter $50, Team $500, Growth $2,000). Proxy traffic is $8 per GB, direct traffic $0.20 per GB, and AI tasks are priced per step.
Anchor Browser: Plans start at $20 a month and the whole fee is usage credit, spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
None of the five scenarios fits either one as written, because each asks for a 4 vCPU / 8 GB or 2 vCPU / 4 GB machine and both sell a browser of unpublished size with no shell or disk that stays. Browserbase's 6-hour session cap rules out the workday and always-on agent, while Anchor Browser can run longer but still erases the VM. Concurrency bites next: 300 sandboxes for your users is past Browserbase Startup (100) and Anchor Browser Growth (200). bochka fits four scenarios; at 1,000 short jobs at once it queues starts above 90 a minute.
| Scenario | Browserbase | Anchor Browser | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Browserbase when
you write your own browser automation and want Stagehand, Search and Fetch APIs, session replays and browsers in Oregon, Virginia, Frankfurt or Singapore.
- A developer stack around the browser. For teams writing their own browser code: open source Stagehand, Search and Fetch APIs, and replays of every session.
- Regions in the US, Europe and Asia. For users or target sites in the US, Europe or Asia: Oregon, Virginia, Frankfurt and Singapore, picked per session.
- Lots of hours in a small plan. For steady browser work: Startup includes 500 browser hours and 100 browsers at once for $99 a month.
Use Anchor Browser when
the hard part is staying logged in and getting past bot checks, when sessions run past 6 hours, or when you would rather send a task to a hosted agent.
- Logins handled for you. For agents working inside web apps with no API: managed identities with MFA stay logged in across sessions.
- Sessions as long as the job. For long browser jobs: sessions default to 180 minutes, and you can raise that with no upper limit.
- Hosted agents and files that stay. For teams that send a task and want a result: hosted agents, webhooks, human-in-the-loop and up to 10 volumes for files.
Where bochka fits
Browserbase and Anchor Browser both sell a browser, not a machine. If what you are really running is agents that browse and then also write code, run Docker, keep files or serve an app, bochka gives each one a full Linux VM with Chromium and a desktop inside. For sites with strong bot checks, either of them still does that part better, and an agent on bochka can call them over CDP.
The browser and the work on one machine
Browserbase Functions stop after 900 seconds with no storage, and Anchor Browser's docs send agent code to a separate sandbox. Either way you pay a second provider and move every download between the two. bochka has root, Docker and /dev/kvm next to Chromium.
Nothing wiped when the session ends
Both erase the browser VM after each session; Browserbase keeps only a profile, and Anchor Browser a profile plus volumes, so installed tools start over. bochka saves the whole disk every minute and on stop, and can fork a running sandbox.
Coding agents and keys kept outside
Browserbase's Agent has fixed built-in tools, and Anchor Browser types secrets into the page. bochka ships Claude Code, Codex and others you drive from outside, and its credentials proxy keeps real keys out of the sandbox for any HTTPS API.
Use bochka when your agent does more than browse: it needs a shell, Docker, a desktop or a server next to Chromium, and has to keep its files between runs. Compare it one to one: bochka vs Browserbase and bochka vs Anchor Browser.
Questions people ask
Is Browserbase cheaper than Anchor Browser?
It depends on the scenario. Anchor Browser is lower for one agent running all month ($42 against $122) and for 50 agents in parallel ($500 against $841), while Browserbase is lower for 300 sandboxes for your users ($499 against $2,000). Neither fits these as a general machine, and bochka comes to $26, $317 and $200.
Which is better at getting past bot checks?
Both bring residential proxies and CAPTCHA solving. Anchor Browser ranks 5th for mass scraping against Browserbase's 13th, with full stealth Chromium on Growth and proxies at $8 per GB. Browserbase saves its Verified browsers for the Scale plan.
How long can a session run on each?
Browserbase sessions end after at most 6 hours on Developer and Startup, and 15 minutes on Free. Anchor Browser defaults to 180 minutes but lets you raise that with no upper limit. Both erase the VM afterwards; a bochka sandbox has no session cap on paid plans and keeps its disk.
Can Browserbase or Anchor Browser run Docker or a shell?
No. Browserbase gives you Chrome over CDP, with Functions that run TypeScript for up to 900 seconds, and Anchor Browser runs TypeScript snippets against the page from Growth. Every bochka sandbox has root, SSH, Docker, systemd and /dev/kvm.
Which is faster?
Neither publishes the CPU or memory behind a session, and neither is in the CPU benchmark, so there is no fair speed number. bochka scored 26.69 runs per second at 4 vCPU / 8 GB.
Can I use either one from a bochka sandbox?
Yes. An agent on bochka can open a Browserbase or Anchor Browser session over CDP for bot-protected pages, and keep its code, files and tools on the bochka VM. Anchor Browser's docs describe this setup of a sandbox plus a remote browser.
Try bochka
Install the CLI, then run bochka new.
Product preview