Kernel vs Zenrows
Kernel and Zenrows both hand your agent a remote Chromium over CDP. A Kernel browser runs on its own unikernel, can stay up for hours and goes free on standby, while a Zenrows session runs on rotating residential IPs and closes after at most 15 minutes.
The companies and products
Kernel
Kernel is browser infrastructure for web agents and automations: you create cloud Chromium browsers from its API and drive them over CDP.
Each Kernel browser is Chromium on its own Unikraft-based unikernel, headless (1 GB) or headful (8 or 16 GB) with Live View and a computer controls API. Around it Kernel sells stealth mode with proxies and a CAPTCHA solver, saved browser profiles, managed logins, session replays and an app runtime for your agent code. It is a different kind of product from boat: a managed browser, not a general sandbox, so this page compares where the two overlap, which is agents that use a browser.
Zenrows
Zenrows calls itself web data infrastructure built for agents and applications: APIs that fetch, extract, crawl and browse protected websites.
Browser Sessions (formerly Scraping Browser) is a remote Chrome you connect to over a WebSocket and drive with Puppeteer or Playwright through the Chrome DevTools Protocol. Each session runs on rotating residential IPs and closes after 1 to 15 minutes. It is a different kind of product from boat: a managed browser for scraping and web tasks, not a machine you get a shell on, so this page compares where the two overlap, which is browser and web agents.
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. “38th cheapest of 369” means 37 of the other 368 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 | Kernel: price rank | Zenrows: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither browser can build or test code: Kernel documents no Docker or disk that stays, Zenrows has no shell at all, and boat gives a full VM with Docker. | 98th of 367, with limits $873 a month | 59th of 367, with limits $448 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that works all month needs files that stay; Kernel keeps only cookies and storage in a profile, Zenrows keeps nothing past 15 minutes, and boat keeps its disk. | 203rd of 366, with limits $2,033 a month | 126th of 366, with limits $833 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 | 266th of 345, with limits $347 a month | 232nd of 345, with limits $166 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 Kernel's Start-Up limit of 150 browsers, and on both each user gets a browser rather than a machine. | 228th of 361, with limits $768 a month | 203rd of 361, with limits $361 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 | 246th of 360, with limits $3,133 a month | 229th of 360, with limits $1,111 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 | 252nd of 364, with limits $390 a month | 230th of 364, with limits $166 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 | 259th of 377, with limits $222 a month | 221st of 377, with limits $83 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 144th of 368, with limits $33 a month | 232nd of 368, with limits $58 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 Kernel fits with Live View and a computer controls API, Zenrows is a compromise with no desktop stream, and boat streams a 60fps desktop where the agent can use any Linux app. | 38th cheapest of 369 $1,878 a month | 93rd of 369, with limits $166 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: Zenrows brings residential IPs, Kernel brings stealth mode, saved profiles and no 15-minute cap, and boat puts Chromium on a full VM where the agent can also run code. | 21st cheapest of 367 $366 a month | 5th cheapest of 367 $166 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 browsers fit startup-scale scraping; Zenrows adds residential IPs and its Fetch and Crawl APIs, Kernel adds stealth mode and a CAPTCHA solver, and boat runs your own scrapers and queues on one machine. | 45th cheapest of 346 $443 a month | 18th cheapest of 346 $227 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 Kernel fits mass scraping best of the three: its proxies are not charged and it solves CAPTCHAs, while Zenrows meters bandwidth at 25,000 credits per GB and boat has no residential proxies of its own. | 4th of 338, with limits $6,000 a month | 70th of 338, with limits $1,791 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 Red teaming needs a whole machine an agent can attack; Kernel gives SSH into a browser VM, Zenrows only a remote tab, and boat a full VM per run. | 61st of 360, with limits $293 a month | 149th of 360, with limits $115 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 | Kernel | Zenrows | boat |
|---|---|---|---|
| Kind of product | A managed Chromium browser per session, with an app runtime for your code | A remote Chrome session, part of a web data service with Fetch, Extract, Crawl and Batch APIs | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Isolation | Every browser runs on its own Unikraft-based unikernel | Isolation technology not published | Every sandbox is a full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Session length | Stays alive while something drives it; deleted after an idle timeout you can set up to 72 hours | 1 to 15 minutes, 3 by default, then the session closes | No cap on paid plans; you set the time to live |
| Machine size | 1 GB headless, 8 or 16 GB headful; vCPU count not published | CPU and memory not published | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB by plan |
| Files after a session | Browser is deleted; profiles keep cookies, storage and browser state, not files | Session closes and frees its resources; no saved state documented | Disk snapshots every minute and on stop; a stopped sandbox costs nothing and keeps its disk |
| Idle and wake | Standby after 5 seconds idle with a memory snapshot and no usage charge | No standby; the session closes at its time to live | Stop and resume by API; resume reboots from disk |
| Shell, root and Docker | SSH and process exec with an as_root option; no container runtime or /dev/kvm documented | No shell; browser control over CDP only | SSH, root, systemd, Docker and /dev/kvm on every machine |
| Desktop and computer use | Headful Chromium with Live View, a computer controls API and session replays | No desktop stream; screenshots and page actions through CDP or MCP tools; viewport and user agent changes blocked | 60fps desktop with Chromium and computer use, embeddable in your app |
| Outbound IPs | ISP proxy in stealth mode, plus datacenter, residential and mobile proxies, not charged; bring your own on Start-Up | Over 55 million residential IPs in 190+ countries, rotating, with country targeting; bandwidth billed | Traffic leaves from EU data centers; bring your own proxy if you need other IPs |
| CAPTCHAs and anti-bot | Stealth mode solves reCAPTCHAs and Cloudflare challenges | Anti-bot bypass on its APIs; Browser Sessions cannot solve CAPTCHAs | None built in; you run your own tools |
| Scraping APIs and MCP | MCP server; browser profiles, managed logins and browser pools | Fetch, Extract, Crawl and Batch APIs on one credit balance, and an MCP server with browser tools | No MCP server; agents drive the sandbox through the API and CLI |
| Coding agents | A Claude Agent SDK app template that installs Claude Code when you deploy | Tools for your agent to call; no agent runs inside Zenrows | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Reaching the machine | No inbound ports; tokenized CDP and Live View URLs, and SSH port forwarding | None; you connect out to a shared Zenrows endpoint | HTTPS URLs for up to 50 ports, token-protected; raw TCP |
| Where it runs | us-east, eu-west and ap-southeast; region choice from the Start-Up plan | Primarily hosted on DigitalOcean, no region to choose; proxy exits worldwide | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Kernel | Zenrows | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | No | No | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | 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 | Yes | No | No |
| HTTPS preview URLs | No | No | Yes |
| Raw TCP inbound | Not published | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | Not published | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
There is no comparable measurement for either browser. Neither Kernel nor Zenrows publishes the vCPUs behind a session, and neither was in StarSling's public CPU benchmark, where boat did 26.69 runs per second at 4 vCPU / 8 GB. Kernel does publish cold starts under 20 ms for its unikernels.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Kernel and Zenrows 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 | Kernel, a month | Zenrows, a month | boat, 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 | $5 · Free / Developer · with limits | $2,499 · Scale S5 (annual) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $34 · Free / Developer · with limits | $2,499 · Scale S5 (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 | $625 · Start-Up · with limits | $2,499 · Scale S5 (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 | $420 · Start-Up · with limits | $2,499 · Scale S5 (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 | $747 · Start-Up · with limits | $2,499 · Scale S5 (annual) · with limits | $2,000 · $2000/mo · with limits |
Kernel: Kernel bills $0.0000166667 per GB-second of memory while a browser is active, so a 1 GB headless browser costs less per hour than an 8 GB headful one. Standby and proxies are free, and plans of $0, $30 and $200 a month include $5, $10 and $50 of usage.
Zenrows: Zenrows sells monthly credit plans shared by all its products. A browser session costs 5 credits a minute plus bandwidth at 25,000 credits per GB, and plan credits expire at each renewal.
Zenrows: Plans start at $20 a month, and the whole fee becomes usage credit spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Neither browser fits any scenario on this page, because none of them is only a browser task. Zenrows closes every session after at most 15 minutes, so even its Scale S5 annual plan at $2,499 a month cannot hold an eight-hour agent, and it keeps no disk. Kernel's prices are for a 1 GB headless browser with no disk that stays, and Start-Up caps it at 150 browsers at once, so 300 user sandboxes or 1,000 short jobs need Enterprise. On boat, only the 1,000-jobs burst does not fit: bursts above 90 starts a minute are queued.
| Scenario | Kernel | Zenrows | boat |
|---|---|---|---|
| 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 Kernel when
your agent only needs a browser but needs it for a long time: stealth scraping behind CAPTCHAs, saved logins, session replays, Live View, or browsers in the US or Asia that cost nothing while idle.
- Browsers that last and idle for free. For agents that work for hours: a Kernel browser has no 15-minute cap and costs nothing on standby with its pages kept.
- Stealth and CAPTCHA solving included. For bot-protected sites: stealth mode routes through an ISP proxy and solves CAPTCHAs, and Kernel does not charge for proxies.
- Live View, replays and saved logins. For teams that watch and debug agents: Live View, a computer controls API, session replays and saved profiles come ready.
Use Zenrows when
your agent opens protected pages for a few minutes at a time from residential IPs in many countries, or when you want Fetch, Crawl and Extract APIs and an MCP server rather than a long browser session.
- Residential IPs in 190+ countries. For scraping by country: over 55 million residential IPs rotate on every request, and you pick the country.
- A whole web data toolbox. For data teams: Fetch, Extract, Crawl and Batch share one credit balance with the browser, and an MCP server hands them to agents.
- Short visits billed by the minute. For quick page visits: a session costs 5 credits a minute and closes on its own, and the free plan needs no card.
Where boat fits
Kernel and Zenrows are both managed browsers, not sandboxes. If what you are really running is agents that browse and then do the work, such as installing tools, building code or keeping files for days, boat gives each one a full Linux VM with Chromium and a 60fps desktop inside. For stealth scraping at volume, Kernel or Zenrows can still sit next to it.
A whole machine, not one browser
Neither Kernel nor Zenrows documents Docker, and Zenrows has no shell at all. An agent that needs to install packages, run a dev server or build has to use a second machine, and you wire the two together yourself.
Files that stay, and a fork of a running sandbox
A Kernel browser keeps only cookies and storage in a profile once deleted, and a Zenrows session keeps nothing. boat saves the disk every minute, stops for free and can fork a running sandbox to try two paths at once.
Coding agents and keys kept outside
boat ships Claude Code, Codex and more inside, driven from outside, and its credentials proxy keeps real keys out of the machine for any HTTPS API. Kernel's vaults type logins into the page, where page scripts can read them; Zenrows documents no key proxy.
Use boat when your agent browses as part of real work: staying logged in for hours, keeping downloads and files, running code and Docker next to Chromium, or being watched on a 60fps desktop. Compare it one to one: boat vs Kernel and boat vs Zenrows.
Questions people ask
Is Kernel cheaper than Zenrows?
For the long-running scenarios on this page, Kernel's prices are far lower: one agent running all month comes to $34 on Kernel against $2,499 on Zenrows, which still does not fit because of its 15-minute cap. For short visits, Zenrows bills 5 credits a minute and Kernel bills per GB-second, so it depends on how long and how big each session is. boat comes to $26 for that always-on agent.
Which is faster, Kernel or Zenrows?
There is no comparable CPU measurement for either, since neither publishes the vCPUs behind a session. Kernel publishes cold starts under 20 ms. boat did 26.69 runs per second at 4 vCPU / 8 GB in StarSling's benchmark.
Can a Zenrows or Kernel session run longer than 15 minutes?
A Zenrows session closes after 1 to 15 minutes, 3 by default. A Kernel browser stays alive while something drives it and is deleted after an idle timeout you can set up to 72 hours. boat has no session cap on paid plans.
Can Kernel or Zenrows run Docker?
No. A Kernel browser is a single-purpose unikernel for Chromium with SSH but no documented container runtime, and Zenrows gives you a browser over CDP with no shell. On boat each sandbox is a full VM with Docker, systemd and /dev/kvm.
Which one solves CAPTCHAs?
Kernel's stealth mode solves reCAPTCHAs and Cloudflare challenges. Zenrows Browser Sessions cannot solve CAPTCHAs, though its Fetch API has anti-CAPTCHA features. boat solves none and runs on datacenter IPs.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial