Browserbase vs Kernel
Both sell cloud browsers for AI agents. Browserbase wraps Chrome sessions of up to 6 hours in a wider platform with Search, Fetch, Functions and hosted Agents, while Kernel runs each Chromium on its own unikernel, bills memory by the second and charges nothing while a browser sits in standby.
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 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 (Authenticated Fetch reads logged-in pages without a browser), short TypeScript Functions, Runtime (sandboxed environments that back the hosted Agent shell), a Model Gateway and hosted Agents that work from a plain language goal. It is a browser platform, not a general VM: your code gets the browser, and the Agent gets a shell in a short-lived runtime, not root on a machine. This page compares where the two overlap, which is agents that browse.
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 VM, a Linux environment with a shell and root exec. Headless browsers use 1, 2 or 4 GB of memory. Headful browsers use 8 or 16 GB and have Live View and a computer controls API. On Start-Up and Enterprise, GPU-accelerated headful browsers use 4 or 8 vCPU. Around the browsers 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. This page compares where the two overlap, which is agents that use a browser.
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. “23rd cheapest of 356” means 22 of the other 355 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 | Kernel: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither is built for builds and tests: a Browserbase session has no shell, and a Kernel browser has a shell and root exec but no documented container runtime and no disk that stays after deletion. | 172nd of 365, with limits $1,255 a month | 130th of 365, with limits $873 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives all month hits Browserbase's 6-hour session cap, and a Kernel browser's own files go when it is deleted (you copy them out with the file API); boat keeps the disk and has no session cap once auto-stop is off (paid plans; default 1 hour). | 286th of 361, with limits $3,699 a month | 325th of 361, with limits $7,684 a month | 6th cheapest of 361 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month | 267th of 336, with limits $382 a month | 280th of 336, with limits $543 a month | 189th of 336, 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 above both Startup limits (100 on Browserbase, 150 on Kernel), and each user gets a browser, not a machine. | 245th of 349, with limits $1,099 a month | 295th of 349, with limits $2,620 a month | 3rd cheapest of 349 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 259th of 349, with limits $5,049 a month | 286th of 349, with limits $12,083 a month | 39th of 349, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 346th of 359, with limits $449 a month | 255th of 359, with limits $390 a month | 10th cheapest of 359 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month | 245th of 374, with limits $152 a month | 260th of 374, with limits $222 a month | 2nd cheapest of 374 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 264th of 371, with limits $96 a month | 159th of 371, with limits $33 a month | 19th cheapest of 371 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Kernel fits computer use with headful Chromium, Live View and a computer controls API, while a Browserbase session is driven through CDP and Stagehand; boat streams a 60fps desktop for any Linux app. | 199th of 367, with limits $416 a month | 39th cheapest of 367 $1,878 a month | 7th cheapest of 367 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both fit, with Browserbase at 23rd and Kernel at 35th; boat ranks 7th because the same VM that runs Chromium can also run the agent's code. | 23rd cheapest of 356 $449 a month | 35th cheapest of 356 $1,014 a month | 7th cheapest of 356 $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, Browserbase with Fetch and Search APIs that skip the browser for simple pages, Kernel with proxies that cost nothing extra. | 59th cheapest of 343 $537 a month | 70th cheapest of 343 $735 a month | 6th cheapest of 343 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month This is where both shine: Browserbase ranks 12th and Kernel 17th, with stealth, residential proxies and CAPTCHA solving that boat does not have. | 12th of 327, with limits $9,799 a month | 17th of 327, with limits $11,850 a month | 73rd of 327, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Kernel ranks 131st against Browserbase's 259th, and boat ranks 6th with a full VM per run that can be forked. | 259th of 351, with limits $291 a month | 131st of 351, with limits $720 a month | 3rd cheapest of 351 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
Key features
| Feature | Browserbase | Kernel | boat |
|---|---|---|---|
| Kind of product | Managed headless Chrome sessions, plus Search, Fetch, Functions, a Model Gateway and hosted Agents | A managed Chromium browser per session, with an app runtime for your agent code | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Isolation | 1 browser per VM in its own subnet; the VM is destroyed after each session | Each browser on its own Unikraft-based unikernel; cold starts under 20 ms | Full VM with its own kernel; vCPUs are shared, not dedicated cores |
| Machine size | vCPU and RAM per browser not published | 1, 2 or 4 GB headless, 8 or 16 GB headful; GPU tiers 4 or 8 vCPU; vCPU for non-GPU browsers not published | 4 vCPU / 8 GB by default; up to 16 vCPU / 32 GB on the $100 plan or higher |
| Shell access | None in a browser session; hosted Agents and Functions get a shell in a short-lived runtime | SSH into the browser VM, and process exec with an as_root option | SSH and root on every machine |
| Docker and nested virtualization | No Docker or /dev/kvm documented in sessions, Functions or the Agent runtime | A unikernel VM built around Chromium, with a Linux shell and root exec; no container runtime or /dev/kvm documented | Docker, systemd and /dev/kvm on every machine |
| Session length | 6 hours on Developer and Startup, 6+ hours on Scale, 15 minutes on Free | Deleted after its timeout, which you can set up to 72 hours; standby while idle | No cap once auto-stop is off (paid plans); auto-stop defaults to 1 hour and can be set up to 30 days |
| Files after a session | A Context keeps the browser profile; the Downloads API keeps downloaded files | The browser is deleted after its timeout (up to 72 h); profiles keep cookies, storage and browser state; you copy other files out with the file API | The disk is saved every minute and at each stop, and kept at least 14 days after a stop; memory, processes and /tmp are not saved |
| Idle and wake | No pause; a keepAlive session keeps billing until you release it | Standby after 5 seconds idle with a memory snapshot and no usage charge | Stop and resume by API; a stopped sandbox has no compute charge; resume reboots from the disk |
| Fork | No fork; a new session starts fresh or loads a Context | No fork; browser pools keep fresh browsers warm | Fork a running sandbox from its last 1-minute snapshot (writes from the last minute can be missing) |
| Browser and computer use | Chrome with live view, session replay and logs; Stagehand act, extract and observe | Headful Chromium with Live View, a computer controls API, CDP and session replays; GPU-accelerated browsers on Start-Up | 60fps desktop and Chromium, computer use on any app, embeddable stream |
| Bot detection | Residential proxies in 200+ countries, CAPTCHA solving on paid plans, Verified browsers on Scale | Stealth mode with a Kernel proxy and a CAPTCHA solver; ISP, residential and mobile proxies at no extra charge (fair use) | Datacenter IPs and Chromium; no CAPTCHA solving |
| Reaching the machine | CDP connect URL and live view links only; no ports to host on | No public URLs for VM ports documented; tokenized CDP and Live View URLs, and SSH -L/-R port forwarding | HTTPS URLs for up to 50 ports, token-protected; raw TCP to the sandbox IP (IPv6 only on some sandboxes; the IP changes at each resume) |
| Agents and keys | Hosted browser Agent with its own built-in tools; Model Gateway for OpenAI, Anthropic and Google; 1Password sign-in; Secrets in Functions | You deploy your agent code as a Kernel app (Claude Agent SDK template); vaults fill logins into pages, where page scripts can read them | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API; optional paid credentials proxy for model providers and custom HTTPS APIs |
| Regions | Oregon, Virginia, Frankfurt and Singapore | us-east, eu-west and ap-southeast; region choice from the Start-Up plan | Germany, Finland and France; you cannot pick a region; no US or Asia region |
Every feature Battleships tracks (43)
| Feature | Browserbase | Kernel | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | No documented way | No documented way | Yes |
| Nested virtualization | No documented way | No documented way | Yes |
| Root | No documented way | Yes | Yes |
| Systemd | No documented way | Not published | Yes |
| Desktop GUI | No documented way | Yes | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No documented way | Yes | Yes |
| SSH | No documented way | Yes | Yes |
| Persistent disk | No documented way | No documented way | Yes |
| Pause/resume | No documented way | Yes | Yes |
| Automatic snapshots | No documented way | Yes | Yes |
| Fork/clone | No documented way | No documented way | Yes |
| Live fork (no pause) | No documented way | No documented way | Yes |
| Memory fork | No documented way | No documented way | No documented way |
| Custom image (Docker or snapshot) | No documented way | Yes | Yes |
| ≥24 h sessions | No documented way | Yes | Yes |
| Idle auto-stop | Yes | Yes | No documented way |
| Wake on request | No documented way | Yes | No documented way |
| HTTPS preview URLs | No documented way | No documented way | Yes |
| Raw TCP inbound | No documented way | Not published | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | Yes | No documented way |
| Secret proxy | Yes | No documented way | Yes |
| Secret proxy for any API | No documented way | No documented way | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No documented way | No documented way | Yes |
| MCP server | Yes | Yes | No documented way |
| GPU | No documented way | Yes | No documented way |
| Windows | No documented way | No documented way | No documented way |
| Arm64 | No documented way | Not published | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | No documented way | No documented way | No documented way |
| Open source | No documented way | Yes | No documented way |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Not published | No documented way | Yes |
| Audit logs | Not published | Yes | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | Yes | Yes | No documented way |
| EU data residency | Yes | Yes | No documented way |
| Zero data retention | Yes | Yes | Yes |
Performance
There is no comparable measurement. Browserbase and Kernel are not in the public benchmarks we use, and neither publishes the vCPU or RAM behind a browser session, so we cannot say which is faster. For reference, boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15 in StarSling's run of 3 October 2026 (run 37073680030). Every boat sandbox in that run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Kernel publishes cold starts under 20 ms for its unikernels; boat is not in the public start-time benchmark.
V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Browserbase and Kernel are not in the public benchmarks we use, so we cannot say which is faster.
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. Start limits, per-start fees and plan minimums are in the price, boat's included.
| Scenario | Browserbase, a month | Kernel, 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 | $99 · Startup · with limits | $5 · Free / Developer · 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 | $34 · Free / Developer · 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 | $625 · Start-Up · 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 | $1,230 · Start-Up · 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,537 · Start-Up · with limits | $8,800 · $2000/mo · with limits |
Browserbase: 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. Proxy data is extra after 1 GB or 5 GB ($12 or $10 per GB). Scale has no public price.
Kernel: Kernel bills $0.0000166667 per GB-second of memory while a browser is active: $0.06 an hour for a 1 GB headless browser and $0.48 for an 8 GB headful one. GPU browsers cost $2.88 or $5.76 an hour and need Start-Up. Standby and Kernel proxies cost nothing extra, and plans of $0, $30 and $200 a month include $5, $10 and $50 of usage.
Kernel: You pick a monthly plan from $20. The plan price comes back as VM time for that month: $20 is about 555 hours of a 4 vCPU / 8 GB sandbox, billed per second. The $20 plan runs 100 sandboxes at once and includes 12 starts a minute, 60 an hour and 200 a day. Create, fork and resume each count as one start; a resume onto the kept machine does not count. Extra starts cost $0.03 to $0.07 each, up to 1,200 a day, and starts above that fail. A stopped sandbox uses no machine time and keeps its disk for at least 14 days. Saved snapshots above the included count and the AI credentials proxy still cost money.
Limits in those scenarios
The table prices both as browser sessions with no published vCPU count and no disk that stays, so none of them is a 4 vCPU / 8 GB machine with a 50 GB disk. Browserbase also stops sessions at 6 hours on self-serve plans, which rules out the workday and always-on agent. Concurrency bites next: 100 at once on Browserbase Startup and 150 on Kernel Start-Up (standby and pool browsers count), so 300 sandboxes for your users and 1,000 short jobs at once need Browserbase Scale or Kernel Enterprise, with no public price. On boat the 1,000-job burst does not fit either: on the $2,000 plan, starts above 90 a minute cost extra, starts above 270 a minute fail with 429, and boat never queues a start.
| Scenario | Browserbase | Kernel | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None for this scenario |
| One agent that never stops |
|
| None for this scenario |
| 50 agents in parallel |
|
| None for this scenario |
| Sandboxes for your users |
|
| None for this scenario |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Browserbase when
you want one platform for web agents: Chrome sessions plus Search, Fetch, Functions and hosted Agents, Stagehand, Verified browsers for strict bot walls, and regions in the US and Singapore.
- More than a browser. Useful when simple lookups need no browser at all: Search and Fetch APIs, Functions and hosted Agents sit next to the sessions.
- Stagehand and Verified browsers. Useful if you want an open source SDK with act, extract and observe, and Verified browsers on Scale for strict bot walls.
- Regions on every paid plan. Useful if your users are in the US or Asia: sessions run in Oregon, Virginia, Frankfurt or Singapore, picked per session.
Use Kernel when
your browsers sit idle a lot or run for long stretches: free standby with memory kept, browsers that live up to 72 hours, SSH and root exec in the browser VM, GPU browsers, and stealth with proxies that cost nothing extra.
- Free standby with memory kept. Useful if agents sit idle between steps: after 5 seconds idle a Kernel browser stops charging and comes back with its pages loaded.
- A shell in the browser VM. Useful when the agent needs to run a command next to the browser: Kernel offers SSH and process exec with root.
- Browsers that live up to 72 hours. Useful for long browsing jobs: a Kernel browser lives until its timeout, which you can set up to 72 hours, while Browserbase stops at 6 hours on self-serve plans.
Where boat fits
Browserbase and Kernel both sell a browser, not a machine. If what you are really running is agents that browse and then also install, build, test or host something, boat gives each one a full Linux VM with Chromium on a desktop, a disk kept at least 14 days after a stop and coding agents built in. For stealth scraping behind bot walls, either of them is the better tool, and an agent on boat can call them over CDP.
A whole machine with Docker
A Browserbase session gives no shell, and a Kernel browser has a shell but no documented Docker or /dev/kvm. An agent that has to run docker compose or a dev server needs a second provider, plus file copying between the two.
Files that stay and a fork
Browserbase rebuilds its VM after every session and Kernel deletes the browser after its timeout; both carry over a browser profile, and you copy other files out yourself. boat keeps the disk, snapshots it every minute and can fork a running sandbox to try two paths.
Hosting, agents and keys outside
Neither gives a public URL for a port: you get CDP and live view links, plus SSH port forwarding on Kernel. boat gives HTTPS URLs on up to 50 ports, ships Claude Code and Codex you drive from outside, and its optional paid credentials proxy keeps model and custom API keys outside the sandbox.
Use boat when your agent browses and also works: installs, builds, Docker and dev servers on a full VM with a disk kept across stops, a 60fps desktop with Chromium, HTTPS on 50 ports and coding agents built in. Compare it one to one: boat vs Browserbase and boat vs Kernel.
boat's own limits
- Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
- Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
- A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
- Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
- boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
- Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
- Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
- Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source
Questions people ask
Is Kernel cheaper than Browserbase?
In most scenarios, yes, though both are priced as browser sessions with no disk. One agent running all month comes to $34 on Kernel against $122 on Browserbase, and 50 agents in parallel to $625 against $841. Kernel's standby is free, so mostly idle browsers cost even less. For 300 sandboxes for your users, both go past their self-serve concurrency and need a sales plan. boat comes to $26 and $317 for a 4 vCPU / 8 GB VM that keeps its disk.
Which is faster, Browserbase or Kernel?
There is no comparable measurement. Neither is in the public benchmarks we use, and neither publishes the vCPUs behind a standard browser. Kernel publishes cold starts under 20 ms for its unikernels.
Can Browserbase or Kernel run Docker?
Not documented on either. A Browserbase session gives you Chrome over CDP, and its Agent and Functions run in a short TypeScript runtime. Kernel gives SSH and root exec in its browser VM but documents no container runtime. Every boat sandbox has root, Docker, systemd and /dev/kvm.
How long can a session run on each?
Browserbase sessions last up to 6 hours on Developer and Startup and 15 minutes on Free. A Kernel browser is deleted after its timeout, which you can set up to 72 hours, and goes to free standby while idle. On boat, auto-stop defaults to 1 hour; you can turn it off on a paid plan, and boat keeps the disk at least 14 days after a stop.
Which is better for scraping sites that block bots?
Both are built for it. Browserbase has residential proxies in 200+ countries, CAPTCHA solving and Verified browsers on Scale, and Kernel has stealth mode with a Kernel proxy, a CAPTCHA solver and proxies at no extra charge. boat runs Chromium on datacenter IPs and solves no CAPTCHAs.
Can I use boat with Browserbase or Kernel?
Yes. An agent on a boat sandbox can open a Browserbase or Kernel browser over CDP and keep its code, files and tools on the boat VM. That puts protected browsing on them and the rest of the work on a machine that keeps its disk.
Try boat
Install the CLI, then run boat new.
7-day free trial