bochka vs Remote Browser
Remote Browser is a browser API: hosted Chromium sessions with stealth fingerprints, proxy egress and saved profiles, each in its own Kubernetes pod that closes when it goes idle. bochka gives each agent one full Linux VM with root, Docker and a disk that persists, plus a 60fps desktop with Chromium and coding agents you drive from outside.
Where bochka stands out
A whole machine, not only a browser
Every bochka sandbox is a full VM with its own kernel, root, SSH, systemd, Docker and nested virtualization, on dedicated AMD Ryzen 9 9950X hosts, with Chromium on a desktop inside it. A Remote Browser session is one Chromium in a Kubernetes pod that your code reaches over CDP, with no shell on the pod.
Files that stay, snapshots and fork
A bochka sandbox keeps its disk, with snapshots every minute and on stop, so a stopped sandbox costs nothing and comes back with its files. You can fork a running sandbox to try two paths from the same point. A Remote Browser session saves only its browser profile, and closes after its idle time.
Coding agents you drive from outside, keys kept outside
bochka ships Claude Code, Codex, OpenCode and other agents in each sandbox, and you prompt, steer and follow them through one API with an event stream. The 60fps desktop lets them use any app, not only a browser. bochka's credentials proxy keeps real API keys outside the sandbox for model providers and any HTTPS API.
The companies and products
bochka
bochka.xyz runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.
You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
Remote Browser
Remote Browser calls itself the browser, served as an API: a hosted Chromium runtime for AI agents and browser automation.
You create a session through its API, get back a CDP websocket URL and a live viewer URL, and drive the browser with Playwright, Puppeteer, Selenium, browser-use or a coding agent skill. Every session runs stealth by default, can route traffic through residential, mobile or datacenter proxies, and can load a saved profile with cookies and logins. It is a browser product, not a general sandbox: you get a Chromium over CDP, not a shell on a 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. “3rd cheapest of 367” means 2 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 | bochka: price rank | Remote Browser: 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, and a Remote Browser session gives a Chromium pod only, so builds and tests fit bochka. | 3rd cheapest of 367 $634 a month | 230th of 367, with limits $2,953 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs files and processes that stay, and Remote Browser keeps only a browser profile between sessions. | 5th cheapest of 366 $657 a month | 329th of 366, with limits $8,940 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month | 186th of 345, with limits $2,000 a month | 299th of 345, with limits $814 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month | Cheapest of 361 $209 a month | 300th of 361, with limits $2,570 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 34th of 360, with limits $2,000 a month | 296th of 360, with limits $12,248 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 10th cheapest of 364 $200 a month | 280th of 364, with limits $978 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs need a shell, Docker and often /dev/kvm, which bochka has and a browser pod does not. | 4th cheapest of 377 $86 a month | 264th of 377, with limits $292 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box has to keep its files and processes, and a Remote Browser session closes when idle with only its profile saved, so this fits bochka. | 18th cheapest of 368 $26 a month | 285th of 368, with limits $176 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Remote Browser streams and controls the browser viewport only, while bochka streams a 60fps Linux desktop where an agent can use any app, not only Chromium. | 6th cheapest of 369 $200 a month | 228th of 369, with limits $896 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both fit: Remote Browser gives a stealth Chromium over CDP with saved profiles and human takeover, and bochka gives Chromium on a full VM where the same agent can also run code. | 7th cheapest of 367 $200 a month | 110th of 367, with limits $978 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month Both work at startup scale; Remote Browser adds residential and mobile proxies with country routing, and bochka adds a disk to keep what the scraper collects. | 6th cheapest of 346 $90 a month | 114th of 346, with limits $1,192 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month Remote Browser's stealth fingerprints and proxy pools are built for sites that block bots, while bochka uses datacenter IPs, but 10 browsers at once on Developer is a hard ceiling for mass runs. | 71st of 338, with limits $1,800 a month | 296th of 338, with limits $23,885 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 2nd cheapest of 360 $200 a month | 290th of 360, with limits $590 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 |
| 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 |
Key features
| Feature | bochka | Remote Browser |
|---|---|---|
| Kind of product | A full Linux VM per sandbox, with a desktop and Chromium inside | Hosted Chromium sessions over CDP, with stealth, proxies, profiles and a live viewer |
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | One Chromium per Kubernetes pod, isolated by NetworkPolicy |
| What the agent can touch | The whole machine: root, SSH, any package, any process | The browser over a CDP websocket, plus the viewer and takeover channel |
| Docker and nested virtualization | Docker, systemd and /dev/kvm on every machine | Not offered; a session is a single Chromium pod |
| Files after a session | The disk persists, with snapshots every minute and on stop; a stopped sandbox costs nothing | Only the browser profile carries over: cookies, storage, tabs and history |
| Fork | Fork a running sandbox with its disk | No fork; a new session starts fresh or loads a saved profile |
| Idle sessions | Runs until you stop it or its time to live ends; no session cap on paid plans | Closed after a per-plan idle time with no CDP traffic (the profile URL example uses 5 minutes); a ping keeps it open |
| Browser and computer use | 60fps desktop and Chromium, computer use on any app, embeddable stream | Live viewer of the browser, human takeover, and protocol-level recordings for replay |
| Bot detection | Datacenter IPs and stock Chromium; no stealth fingerprints | Stealth on by default: anti-detect fingerprints, banner blocking, residential, mobile and datacenter proxies with country routing |
| Reaching the machine | HTTPS URLs for up to 50 ports, token-protected; raw TCP; own IP | CDP websocket and viewer URL only; no ports to host on |
| Parallel sessions | 100 sandboxes at once from the $20 plan, up to 2,000 on higher plans | 1 active browser on Free, 10 on Developer; hour packs do not raise it |
| Agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | A skill that points your own Codex or Claude at the CDP URL; Hermes and OpenClaw installers |
| Keeping keys out of the sandbox | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out | Not offered; the skill keeps the CDP URL, which holds the API key, as a secret in the agent's environment |
| Regions | EU only (Germany, Finland and France) | fra1 or auto in the docs; the homepage says 14 regions with no published list; proxies can exit from a chosen country |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | No SOC 2 report published |
Every feature Battleships tracks (43)
| Feature | bochka | Remote Browser |
|---|---|---|
| Full VM (own kernel) | Yes | No |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | No |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| SSH | Yes | No |
| Persistent disk | Yes | No |
| Pause/resume | Yes | No |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Not published |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | No |
| Raw TCP inbound | Yes | Not published |
| Public IPv4 | No | No |
| Egress allowlist | No | No |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No |
| MCP server | No | No |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Yes |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Not published |
| SSO | No | No |
| SOC 2 | No | No |
| HIPAA | No | No |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement. Remote Browser was not in StarSling's public CPU benchmark, and it does not publish the vCPU or RAM behind a session, so there is no number to set against bochka's 26.69 runs per second at 4 vCPU / 8 GB. Its own benchmark page describes a method for startup timing rather than a CPU test.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Remote Browser has 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 | bochka, a month | Remote Browser, 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 | $20 · $20/mo | $36 · Developer · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $176 · Developer · with limits |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $317 · $20/mo × 3 seats | $1,938 · Developer · with limits |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $200 · $100/mo × 2 seats | $1,100 · Developer · with limits |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · $2000/mo · with limits | $2,448 · Developer · with limits |
bochka: 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.
Remote Browser: Remote Browser bills browser-hours, the time a session is alive, whether or not it is busy. Developer is $4.90 a month with 30 hours included, and more time comes in one-time packs of 20 hours for $4.90; it caps usage instead of billing overage, and proxy bandwidth has no published price.
Limits in those scenarios
The Remote Browser prices in the table are for a browser session with no published size and no disk that stays, so none of them is a 4 vCPU / 8 GB machine, and Remote Browser fits no scenario in the table. Concurrency bites first: Developer allows 10 browsers at once and hour packs do not raise it, so 50 agents in parallel, sandboxes for your users and 1,000 short jobs at once are out of reach on the published plans. 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 | bochka | Remote Browser |
|---|---|---|
| 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 Remote Browser when
your agent only needs the web: a stealth Chromium over CDP, residential or mobile proxies routed by country, saved logins with human takeover for 2FA, and a small bill for a few browser hours a month.
- Stealth and proxy egress. Useful for sites that block bots: anti-detect fingerprints by default, and residential, mobile or datacenter proxies routed by country.
- Logins and human takeover. Useful for logged-in web work: a human finishes 2FA once in the live viewer, and the profile keeps the login for later runs.
- A small bill for occasional browsing. Useful if you only need a browser now and then: a free hour each month, and 20-hour packs without a subscription.
Use bochka when
your agent browses and also works: installs, builds, Docker and dev servers on a full VM that keeps its disk, runs as long as the task takes, and comes with coding agents and a key proxy built in.
- A whole machine, not only a browser. An agent that reads a page and then has to clone a repo, run docker compose or start a dev server needs a second machine next to Remote Browser, and has to move files between the two.
- Files that stay, snapshots and fork. Downloads, notes and scripts an agent makes during a Remote Browser run are gone when the pod closes, so your code has to copy them out over CDP before the idle timer ends.
- Coding agents you drive from outside, keys kept outside. With Remote Browser you run the agent and its harness yourself somewhere else, and its model keys and the CDP URL, which carries your API key, sit in that agent's environment.
Questions people ask
Is bochka cheaper than Remote Browser?
In all five scenarios on this page, bochka comes out lower, for example $317 against $1,938 for 50 agents in parallel and $26 against $176 for one agent that never stops. The table sets a 4 vCPU / 8 GB bochka VM against a Remote Browser session with no published size, and none of the Remote Browser rows fits, mostly because of the 10-browser cap. For a few browser hours a month, its Free plan and $4.90 packs cost less.
Can Remote Browser run Docker or a shell?
No. A Remote Browser session is one Chromium in a Kubernetes pod, reached over a CDP websocket and a viewer channel, with no shell access documented. Every bochka sandbox has root, SSH, Docker, systemd and /dev/kvm.
How long can a Remote Browser session run?
It publishes no fixed maximum, but a session closes after a per-plan idle time with no CDP traffic, and the profile URL example sets 5 minutes. Your code can keep it open with a ping, and only the profile survives when it closes. bochka has no session cap on paid plans and keeps the disk when you stop.
Does bochka have stealth fingerprints or residential proxies like Remote Browser?
No. bochka runs stock Chromium on datacenter IPs. For sites that block bots, Remote Browser's anti-detect fingerprints and residential or mobile proxies are built for that.
Can I use bochka and Remote Browser together?
Yes. An agent on a bochka sandbox can create a Remote Browser session and connect to it over CDP with Playwright, and keep its code, files and tools on the bochka VM. That puts stealth browsing on Remote Browser and the rest of the work on a machine that keeps its disk.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention. bochka runs only in the EU, with a zero data retention option.
Start a sandbox
Install the CLI, then run bochka new.
Product preview