Hyperbrowser vs Browserless
Both rent you a cloud browser with stealth, proxies and CAPTCHA solving. Hyperbrowser adds Firecracker sandboxes for code and browser sessions of up to 12 hours, while Browserless keeps to the browser, with sessions of up to 60 minutes, Firefox and WebKit, and a core you can run yourself.
The companies and products
Hyperbrowser
Hyperbrowser calls itself the AI agents' gateway to the internet: cloud browsers, sandboxes, web data APIs and browser agents behind one API and one credit balance.
Its main product is a cloud Chrome session you drive with Playwright or Puppeteer, with stealth mode, residential proxies, CAPTCHA solving, saved profiles and recordings. Next to it Hyperbrowser sells Sandboxes, Firecracker VMs on Ubuntu 24.04 that live up to 24 hours, with memory snapshots, volumes and outbound rules, plus Fetch, Scrape and Search APIs and hosted browser agents. It is a browser and web data platform more than a general sandbox, so this page compares where it overlaps with bochka: agents that browse, and agents that run code.
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. “20th cheapest of 367” means 19 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 | Hyperbrowser: 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 A coding agent needs a shell, Docker and a disk: Browserless gives a browser only, Hyperbrowser's sandboxes have a shell but no documented Docker and lose their disk on stop, so builds fit bochka. | 136th of 367, with limits $1,206 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 lives on its machine all month hits Hyperbrowser's 24-hour sandbox lifetime or Browserless's 60-minute session cap; bochka has no session cap on paid plans. | 255th of 366, with limits $3,650 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 | 244th of 345, with limits $246 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 | 245th of 361, with limits $1,029 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 | 262nd of 360, with limits $4,972 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 | 253rd of 364, with limits $400 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 | 238th of 377, with limits $120 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 has to keep its files and processes, which neither browser product does; bochka keeps its disk and costs nothing while stopped. | 240th of 368, with limits $73 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, Hyperbrowser with hosted computer-use models and Browserless with computer-use integrations, while bochka streams a 60fps Linux desktop where an agent can use any app. | 144th of 369, with limits $360 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 All three fit: Hyperbrowser and Browserless give a stealth cloud browser over CDP, and bochka gives Chromium on a full VM where the same agent can also run code. | 20th cheapest of 367 $360 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 at startup scale; Hyperbrowser sells Fetch and Scrape APIs per page, and Browserless has REST endpoints for screenshots, PDFs and scraping. | 32nd cheapest of 346 $366 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 Hyperbrowser ranks 11th and Browserless 20th here, since both come with residential proxies, stealth and CAPTCHA solving, while bochka uses datacenter IPs and solves no CAPTCHAs. | 11th of 338, with limits $9,750 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 Hyperbrowser ranks 33rd against Browserless at 247th, because its sandboxes let many short code runs start next to the browser; bochka ranks 2nd with a full VM per attacker. | 33rd of 360, with limits $356 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 | Hyperbrowser | Browserless | bochka |
|---|---|---|---|
| Kind of product | Cloud Chrome sessions first, plus Firecracker sandboxes and fetch, scrape and search APIs | Managed headless browsers, plus BrowserQL, REST APIs and an MCP server | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Isolation | Firecracker VM per sandbox; browser session isolation technology not published | Browsers in Docker containers that share the host kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Browsers | Chrome, driven with Playwright or Puppeteer over CDP | Chrome, Firefox and WebKit, driven with Puppeteer, Playwright, Selenium or BrowserQL | Chromium on a 60fps desktop, with browser control and an embeddable stream |
| Session length | Browsers up to 12 hours; sandboxes up to 24 hours from VM start | 2 minutes on Free, 15 on Prototyping, 30 on Starter, 60 on Scale | No cap on paid plans; you set the time to live |
| Files after a session | A stopped sandbox is gone; files survive on a mounted volume or in a memory snapshot | Persisted sessions keep cookies, localStorage and cache for 1 to 90 days by plan | The disk persists, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Shell access | Exec, process and PTY terminal APIs in sandboxes; sudo user; no SSH | The browser only, over CDP, BrowserQL or REST; no shell or SSH | SSH and root on every machine |
| Docker and nested virtualization | Docker builds images on your machine; Docker or /dev/kvm inside a sandbox is not documented | Not offered in a session | Docker, systemd and /dev/kvm on every machine |
| Snapshots and fork | Memory snapshot of a running sandbox, then start many new sandboxes from it | No fork; many sessions can start from one saved browser profile | Fork a running sandbox with its disk; no memory snapshots |
| Bot detection | Stealth mode, residential proxies and CAPTCHA solving on paid plans; ultra stealth on Enterprise | BrowserQL stealth with fingerprint mitigations, CAPTCHA solving, residential and datacenter proxies | Datacenter IPs and Chromium; no CAPTCHA solving |
| Reaching the machine | HTTPS URL per exposed sandbox port through a shared regional proxy; no raw TCP or own IP | Fixed regional WebSocket and HTTPS endpoints and short-lived live URLs; no ports to host on | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Agents | Hosted HyperAgent, Browser Use and computer-use models; sandbox images with the Claude Code or Codex CLI, run through exec | Its own browser agent (Agent Run API, beta), up to 15 minutes and 60 steps per turn | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Keys are passed in as environment variables to the process | 1Password integration fills logins into the page without the value reaching your code | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out |
| Self-hosting | Hosted only | Open source core under SSPL-1.0 runs as a Docker image on your machines; commercial use needs a license | Hosted only |
| Regions | us-central, us-east, us-west and europe-west; asia-south on Enterprise and Select plans | San Francisco, London and Amsterdam; New York on private fleets | EU only (Germany, Finland and France) |
Every feature Battleships tracks (43)
| Feature | Hyperbrowser | Browserless | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | 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 | No | No | Yes |
| Pause/resume | No | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Not published | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | 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 | Not published | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | 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 | No | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | Not published | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for either one. Neither Hyperbrowser nor Browserless was in StarSling's public CPU benchmark, and neither publishes the vCPU or RAM behind a browser session, so there is nothing to set against bochka's 26.69 runs per second at 4 vCPU / 8 GB. Hyperbrowser publishes start times of under 50 ms for sandboxes and under 500 ms for a ready browser.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Hyperbrowser 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 | Hyperbrowser, 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 | $16 · 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 | $73 · 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 | $792 · Scale · 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 | $450 · Scale · 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 | $994 · Scale · with limits | $1,400 · Scale annual · with limits | $2,000 · $2000/mo · with limits |
Hyperbrowser: Everything spends one credit balance at $0.001 a credit: browsers cost $0.10 a browser-hour plus $10 per GB of proxy data, and sandboxes $0.045 per vCPU-hour plus $0.015 per GiB-hour. Startup ($30) and Scale ($100) turn their fee into monthly credits, and extra credits are bought by hand or by auto-reload.
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, proxy traffic and CAPTCHA solves use the same units, and annual billing is 30% lower and adds concurrency.
Browserless: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
None of the table's scenarios fit Hyperbrowser or Browserless as described, because both prices are for a browser session with no published size and no disk that stays. Browserless also stops at 60 minutes on Scale, which rules out the workday agent, the always-on agent and the 50-agent fleet. Both stop at 100 sessions at once on their top self-serve plan, so 300 sandboxes for your users and 1,000 short jobs at once need Enterprise. On bochka, the 1,000-job burst is the one that does not fit: bursts above 90 starts a minute are queued, and it needs more starts per day than the top plan allows.
| Scenario | Hyperbrowser | 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 Hyperbrowser when
your agent needs long stealth browser sessions, short code sandboxes started from memory snapshots, or fetch and search APIs on one credit balance, with regions across the US.
- A sandbox for code next to the browser. Useful when a browsing agent also runs short code: Firecracker sandboxes up to 32 vCPU, started from memory snapshots, on the same bill.
- Long browser sessions. Useful for browsing jobs that run for hours: a Hyperbrowser browser can stay open up to 12 hours, against 60 minutes on Browserless Scale.
- Web data without a browser. Useful when you only need page content: Fetch, Scrape and Search APIs bill per page or query from the same credit balance.
Use Browserless when
your agent needs short headless sessions on Chrome, Firefox or WebKit, REST screenshots and PDFs, a person to step into a live session, or a browser core you can host yourself.
- Run it on your own machines. Useful if browsers must stay inside your network: the Browserless core is open source and runs as a Docker image you host.
- Three browser engines and ready REST calls. Useful for testing across engines or quick jobs: Chrome, Firefox and WebKit, plus REST endpoints for screenshots, PDFs and scraping.
- Hand a session to a person. Useful when a login or 2FA step needs a human: a live URL lets someone finish it before the script carries on.
Where bochka fits
Hyperbrowser and Browserless are browser products, and if your agent only needs the web, one of them is the right pick. If what you are really running is agents that browse and then also clone repos, run containers and keep working for days, bochka gives each one a full VM with Chromium on a desktop inside. You can also keep a Hyperbrowser or Browserless session for stealth browsing and run the rest of the work on bochka.
A full VM with Docker and /dev/kvm
A Browserless session is a browser only, and Hyperbrowser's sandboxes do not document Docker or /dev/kvm inside. An agent that runs docker compose or an emulator needs a second provider, and files moving between the two.
Runs as long as the task and keeps its disk
Hyperbrowser sandboxes end after 24 hours and lose their disk unless you use a volume or snapshot; Browserless sessions end after 60 minutes and keep only a browser profile. On bochka the disk is saved every minute and stops are free.
Coding agents driven from outside, keys kept outside
On either product you write your own harness around the session and keep model keys in your code or environment variables, where a prompt-injected agent can read them. bochka ships Claude Code, Codex and more with a steer API and a credentials proxy.
Use bochka when your agent browses and also works: installs, builds, Docker and dev servers on a full VM that keeps its disk and runs as long as the task takes, with coding agents and a key proxy built in. Compare it one to one: bochka vs Hyperbrowser and bochka vs Browserless.
Questions people ask
Is Hyperbrowser cheaper than Browserless?
In most of the table's scenarios Hyperbrowser comes out lower: 50 agents in parallel at $792 against $1,026, and 1,000 short jobs at once at $994 against $1,400. Browserless is lower for sandboxes for your users, $410 against $450. Neither fits these scenarios as described, since both are browser sessions with no disk.
Which is faster, Hyperbrowser or Browserless?
There is no comparable measurement: neither was in StarSling's public CPU benchmark, and neither publishes the machine size behind a browser. Hyperbrowser publishes start times of under 500 ms for a ready browser. bochka scores 26.69 runs per second at 4 vCPU / 8 GB.
Can Hyperbrowser or Browserless run Docker?
A Browserless session gives you a browser, not a shell, though you can run the Browserless Docker image on your own server. Hyperbrowser uses Docker on your machine to build sandbox images, and its docs do not describe Docker inside a sandbox. Every bochka sandbox runs Docker, systemd and /dev/kvm.
How long can a session run on each?
Hyperbrowser browsers run up to 12 hours and its sandboxes up to 24 hours from VM start. Browserless sessions run 2 minutes on Free up to 60 minutes on Scale, with custom limits on Enterprise. bochka has no session cap on paid plans and keeps the disk when you stop.
Can I self-host Hyperbrowser or Browserless?
Browserless can be self-hosted: its core is open source under SSPL-1.0, and commercial use needs a paid license. Hyperbrowser is a hosted service, and so is bochka.
Can I use bochka with Hyperbrowser or Browserless?
Yes. An agent on a bochka sandbox can open a Hyperbrowser session over CDP or connect to Browserless over WebSocket, and keep its code, files and tools on the bochka VM. That puts stealth browsing on the browser service and the rest of the work on a machine that keeps its disk.
Try bochka
Install the CLI, then run bochka new.
Product preview