Anchor Browser vs Browserless
Anchor Browser gives each session a headful Chromium in its own VM, with managed logins, proxies and hosted agents, and lets sessions run as long as you set. Browserless is a browser API with headless Chrome, Firefox and WebKit, sessions of up to 60 minutes, and an open source core you can run yourself.
The companies and products
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.
Browserless
Browserless calls itself a cloud browser automation platform: managed headless browsers you connect to with one line of code.
You point existing Puppeteer, Playwright or Selenium code at a Browserless WebSocket URL, or use BrowserQL, its GraphQL language with stealth and CAPTCHA solving, REST endpoints for screenshots, PDFs and scraping, and an MCP server. Sessions are short (2 to 60 minutes by plan), and only the browser profile can be kept between them. It is a browser product, 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.
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. “28th cheapest of 367” means 27 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 | Anchor Browser: price rank | Browserless: 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 shell or Docker, and Anchor's own docs send agent code to a separate sandbox, so builds and tests fit bochka. | 180th of 367, with limits $2,000 a month | 170th of 367, with limits $1,771 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that runs all month hits Browserless's 60-minute cap, and Anchor erases its VM after each session; bochka keeps the whole disk. | 71st of 366, with limits $1,845 a month | 297th of 366, with limits $6,170 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 | 325th of 345, with limits $2,171 a month | 267th of 345, with limits $350 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 Anchor's Growth cap of 200 and Browserless's Scale annual cap of 100, and each one would be a browser, not a machine. | 283rd of 361, with limits $2,000 a month | 264th of 361, with limits $1,490 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 | 298th of 360, with limits $12,510 a month | 279th of 360, with limits $8,600 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 | 357th of 364, with limits $2,000 a month | 247th of 364, with limits $350 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 | 284th of 377, with limits $500 a month | 241st of 377, with limits $140 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 a disk that stays, which neither browser session has. | 222nd of 368, with limits $42 a month | 336th of 368, with limits $350 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 Both act inside a browser only; bochka streams a full Linux desktop at 60fps, so a computer-use agent can open any app. | 173rd of 369, with limits $500 a month | 141st of 369, with limits $350 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: Browserless ranks 19th and Anchor Browser ranks 28th, and bochka ranks 7th because the same agent also gets a shell, files and code next to Chromium. | 28th cheapest of 367 $560 a month | 19th cheapest of 367 $350 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; Browserless adds REST endpoints for screenshots, PDFs and scraping, and Anchor adds managed logins with MFA. | 50th cheapest of 346 $500 a month | 47th cheapest of 346 $478 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 here and Browserless ranks 20th: both bring stealth, CAPTCHA solving and residential proxies, while bochka uses datacenter IPs. | 5th of 338, with limits $6,175 a month | 20th of 338, with limits $17,150 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 | 334th of 360, with limits $2,000 a month | 247th of 360, with limits $350 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 | Anchor Browser | Browserless | bochka |
|---|---|---|---|
| What a session is | A headful Chromium in its own VM, erased when the session ends | Headless Chrome, Firefox or WebKit in a Docker container that shares the host kernel | A full Linux VM with its own kernel and root, with Chromium and a desktop inside, on dedicated AMD Ryzen 9 9950X hosts |
| Shell, code and Docker | No shell; from Growth you can run TypeScript snippets against the page | No shell or SSH; you drive the browser over CDP, BrowserQL or REST | SSH, any language, Docker, systemd and nested virtualization (/dev/kvm) |
| Browser engines | Chromium, headful | Chrome, Firefox and WebKit, headless | Chromium on a 60fps Linux desktop |
| Session length | 180 minutes by default with no upper limit if you raise it; ends after 5 idle minutes by default | 2 minutes on Free, 15 on Prototyping, 30 on Starter, 60 on Scale; custom on Enterprise | No cap on paid plans; a stopped sandbox costs nothing and keeps its disk |
| What is kept between sessions | Profiles keep cookies, local storage and cache, and up to 10 volumes keep files | Persisted sessions keep cookies, localStorage and cache for 1 to 90 days by plan; a new browser process starts on reconnect | The whole disk, saved every minute and on stop; fork a running sandbox |
| Stealth and CAPTCHAs | CAPTCHA solving from Starter, full stealth Chromium on Growth, unique fingerprints on Enterprise | BrowserQL stealth with fingerprint mitigations and CAPTCHA solving | Chromium on datacenter IPs; no fingerprint rotation or CAPTCHA solving |
| Proxies | Residential proxies with country and city targeting, sticky IPs, or your own proxy | Built-in residential and datacenter proxies; your own proxy on paid plans; city targeting on Scale | None managed; you can run your own proxy client inside the VM |
| Logging in to sites | Managed identities with MFA keep logins across sessions, from Starter | A live URL hands the session to a person for a login or 2FA step; 1Password fills logins into the page | Your agent logs in itself; bochka switches AI credentials to another account when credits run out |
| Ready-made web tools | Send a task in plain words to a hosted agent, or run versioned automation tasks | REST endpoints for screenshots, PDFs and scraping, and an MCP server | None built in; any tool you install runs on the VM |
| Agents | Hosted browser agents (browser-use, OpenAI, Gemini and Anthropic computer use) with human-in-the-loop and webhooks | Agent Run API in beta, up to 15 minutes and 60 steps per turn | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Keeping secrets from the agent | Secret values are hidden from the model and typed into the page | 1Password integration fills logins without the value reaching your code | Credentials proxy: real keys never enter the sandbox, for any HTTPS API |
| Reaching the machine | Only the CDP socket and the live view URL | Regional WebSocket and HTTPS endpoints and short-lived live URLs; no ports to host on | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Running it yourself | Your own cloud or on-premise on Enterprise | Open source core under SSPL-1.0 you can run with Docker; commercial use needs a paid license | Hosted only |
| Regions | US by default; EU, Asia and Australia on Growth; any region on Enterprise | San Francisco, London and Amsterdam; New York on private fleets | EU only (Germany, Finland and France) |
Every feature Battleships tracks (43)
| Feature | Anchor Browser | Browserless | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | No | Not published | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | No | No | Yes |
| Persistent disk | Yes | No | 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 | Not published | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | No | No | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | 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 | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | Yes | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | No | 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 | Not published | Not published | Yes |
Performance
There is no comparable measurement for either one. Anchor Browser and Browserless sell browser time and do not publish the CPU or memory behind a session, and neither is in the CPU benchmark. bochka scored 26.69 runs per second on the hpc-sandbox-benchmarks 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. Anchor Browser and Browserless 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 | Anchor Browser, a month | Browserless, 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 | $7 · Free · with limits | $350 · Scale annual · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $42 · Free · with limits | $350 · Scale annual · 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 | $500 · Team · with limits | $1,026 · Scale annual · 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 | $2,000 · Growth · with limits | $410 · Scale annual · 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 | $2,510 · Growth · with limits | $1,400 · Scale annual · with limits | $2,000 · $2000/mo · with limits |
Anchor Browser: Anchor Browser bills $0.05 per browser-hour, counted to the nearest minute, plus $0.01 for each browser created, paid from credits worth $1 each. Plan fees (Starter $50, Team $500, Growth $2,000) become credits, and traffic is extra: $8 per GB through its proxy or $0.20 per GB direct.
Browserless: Browserless bills in units: one unit is up to 30 seconds of a connected browser, and a reconnect starts a new block. Plans include 20,000, 180,000 or 500,000 units a month, then $0.0020 to $0.0015 a unit, proxy traffic and CAPTCHA solves use the same units, and annual billing is 30% lower.
Browserless: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. 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 general machine and both sell a browser session with no shell and no published size. Browserless's 60-minute cap on Scale and its lack of a disk that stays rule out the workday agent, the always-on agent and the 50-agent fleet, and Anchor has no Docker for the fleet. Concurrency caps at 200 browsers on Anchor's Growth and 100 on Browserless's Scale annual, so 300 sandboxes for your users and 1,000 short jobs at once need Enterprise on both. bochka fits four scenarios; at 1,000 short jobs at once its $2,000 plan queues the starts.
| Scenario | Anchor Browser | Browserless | 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 Anchor Browser when
your agents need long browser sessions on sites with logins, MFA and bot checks, with residential proxies, sticky IPs and hosted browser agents handled for you.
- Long sessions in their own VM. For jobs that run for hours: sessions last 180 minutes by default, can be raised with no upper limit, and each gets its own VM.
- Logins handled for you. For agents working inside web apps with no API: managed identities with MFA stay logged in across sessions.
- More regions and sticky IPs. For sites that check location: residential proxies down to the city, sticky IPs, and regions in Asia and Australia on Growth.
Use Browserless when
you want a browser API on short sessions with Chrome, Firefox and WebKit, quick REST screenshots and PDFs, stealth for sites that block bots, or a Docker image you can run yourself.
- Run it on your own machines. For browsers that must stay inside your network: the open source core runs from one Docker image, with a license for commercial use.
- Three browser engines. For tests and scrapers that need more than Chromium: headless Chrome, Firefox and WebKit from the same service.
- One call for common jobs. For quick web tasks: REST endpoints return screenshots, PDFs and scraped content without writing a script.
Where bochka fits
Anchor Browser and Browserless both sell a browser, not a machine, and they are better than bochka at getting past bot checks. 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. You can also keep a protected browser on Anchor or Browserless and run the rest of the agent on bochka.
A whole machine around the browser
Neither gives your agent a shell, and Anchor's own docs say to run agent code in a separate sandbox. That means a second service to pay for and wire up, with every download crossing between the two.
Work that is still there tomorrow
Anchor erases its VM after each session and Browserless ends sessions at 60 minutes on Scale; both keep only profiles or volumes. bochka saves the whole disk every minute, stops for free, and can fork a running sandbox.
Coding agents and keys kept outside
Anchor types secrets into the page and Browserless's beta agent stops at 15 minutes and 60 steps a turn. bochka ships Claude Code and Codex you drive from outside, and its credentials proxy keeps real keys out of the sandbox.
Use bochka when your agent does more than browse: it needs a shell, files, Docker, a desktop or a server next to the browser, and it has to keep its work between runs. Compare it one to one: bochka vs Anchor Browser and bochka vs Browserless.
Questions people ask
Is Anchor Browser cheaper than Browserless?
It depends on the job. For one agent on workdays Anchor comes to $7 against $350, and for 50 agents in parallel $500 against $1,026. For 300 sandboxes for your users Browserless is lower at $410 against $2,000, and for 1,000 short jobs at $1,400 against $2,510, though neither fits any of these as a general machine.
Which is faster, Anchor Browser or Browserless?
There is no comparable measurement. Neither publishes the CPU or memory behind a browser session, and neither is in the CPU benchmark. bochka scored 26.69 runs per second at 4 vCPU / 8 GB.
Can Anchor Browser or Browserless run Docker?
No. Anchor gives a browser with no shell, plus TypeScript snippets against the page from Growth, and Browserless gives a browser over CDP, BrowserQL or REST. You can run the Browserless Docker image on your own server, but that is your machine. Every bochka sandbox has root, SSH, Docker, systemd and /dev/kvm.
How long can a session run on each?
Anchor sessions last 180 minutes by default and you can raise that with no upper limit, but the VM is erased at the end. Browserless allows 2 minutes on Free up to 60 on Scale, with custom limits on Enterprise. bochka has no session cap on paid plans and keeps the disk when you stop.
Which is better at getting past bot checks?
Both are built for it, with stealth, CAPTCHA solving and residential proxies. Anchor adds managed logins with MFA, sticky IPs and unique fingerprints on Enterprise, while Browserless offers BrowserQL with fingerprint mitigations and datacenter proxies too. bochka runs Chromium on datacenter IPs and solves no CAPTCHAs.
Can I self-host Anchor Browser or Browserless?
Browserless has an open source core under SSPL-1.0 that you can run with Docker, and commercial use needs a paid license. Anchor offers your own cloud or on-premise only on Enterprise, through sales. bochka is hosted only.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs Anchor Browser
- bochka vs Browserless
- Browserbase vs Anchor Browser
- Browser Use vs Anchor Browser
- Steel vs Anchor Browser
- Hyperbrowser vs Anchor Browser
- Kernel vs Anchor Browser
- Anchor Browser vs Notte
- Anchor Browser vs Scrapeless
- Anchor Browser vs Zenrows
- Browserbase vs Browserless
- Browser Use vs Browserless