Steel vs Notte
Steel and Notte both give your agent a cloud Chrome through an API, not a machine. Steel is an open-source browser runtime with proxies you turn on when you need them, while Notte turns on residential proxies and captcha solving for every session and adds its own browser agent.
The companies and products
Steel
Steel is an API that runs fleets of cloud browsers for AI agents: you create a session, connect Puppeteer, Playwright or Selenium, and release it when done.
Each Steel session is a headful Chromium in a VM in Steel's cloud, driven over CDP or through a computer-use input API, with a live viewer you can embed. Around it Steel sells managed proxies, CAPTCHA solving, saved browser profiles, a credentials vault that signs in for the agent, a files API and readable traces. It is a different kind of product from bochka: a managed browser, not a general sandbox, so this page compares where the two overlap, which is agents that use a browser.
Notte
Notte is a cloud browser platform for AI agents: you start hosted Chrome sessions through an API, SDK, CLI or MCP server.
Each Notte session is a hosted browser you control over CDP, Playwright or Notte's own actions, with residential proxies, captcha solving and a consistent fingerprint on by default. Around it Notte sells a task-driven browser agent, vaults for passwords, personas with their own email and phone number, and Python Functions that turn a browser script into an API endpoint. It is a different kind of product from bochka: a browser service, not a general sandbox, so this page compares the two where they overlap, which is agents that use the web.
- Backing
- Explore the preview
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. “25th cheapest of 367” means 24 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 | Steel: price rank | Notte: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither Steel nor Notte has a shell, Docker or a disk that keeps installed state, so a coding agent can only use them as its browser. | 124th of 367, with limits $1,115 a month | 44th of 367, with limits $121 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant hits Steel's 1 hour cap on Scale or Notte's 300 minute cap on Startup, and has to start fresh sessions again and again. | 238th of 366, with limits $3,070 a month | 99th of 366, with limits $365 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 | 264th of 345, with limits $333 a month | 220th of 345, with limits $100 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 more than the 100 browsers both Steel Scale and Notte Startup allow, and each user gets a browser, not a machine. | 244th of 361, with limits $990 a month | 195th of 361, with limits $105 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 | 257th of 360, with limits $4,150 a month | 222nd of 360, with limits $500 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 | 348th of 364, with limits $400 a month | 227th of 364, with limits $100 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 CI needs a shell, Docker and a known CPU size, and neither browser service offers these, so both are a compromise here. | 239th of 377, with limits $120 a month | 230th of 377, with limits $100 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 241st of 368, with limits $73 a month | 255th of 368, with limits $100 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 Steel and Notte drive a browser only, so agents that need a whole desktop or other apps fit bochka's 60fps Linux desktop better. | 148th of 369, with limits $367 a month | 76th of 369, with limits $100 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: Notte ranks 2nd with stealth on by default, Steel ranks 25th with proxies you add, and bochka ranks 7th with Chrome on a full VM next to the agent's code. | 25th cheapest of 367 $470 a month | 2nd cheapest of 367 $100 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 At startup scale Notte comes to $100 a month in our model against $540 on Steel, and bochka ranks 6th by running the scraper, its queue and its database on one VM. | 56th cheapest of 346 $540 a month | 7th cheapest of 346 $100 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 Both browsers beat bochka for sites that block bots at scale: Notte ranks 2nd and Steel ranks 9th, with residential proxies and captcha solving that bochka does not have. | 9th of 338, with limits $7,950 a month | 2nd of 338, with limits $975 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 | 220th of 360, with limits $242 a month | 143rd of 360, with limits $100 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 | Steel | Notte | bochka |
|---|---|---|---|
| Kind of product | A managed Chromium browser per session, driven over CDP or a computer-use input API | A hosted browser session driven over CDP, Playwright or Notte's own actions | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Isolation | Each session is a headful Chromium in a VM, per the docs; VM type not named | Isolation model not published | Every sandbox is a full VM with its own kernel |
| Session length | 15 minutes on Launch, 1 hour on Scale, 24 hours on Enterprise | 15 minutes on Free, 120 on Developer, 300 on Startup, custom on Enterprise | No session cap on paid plans |
| Browsers at once | 10 on Launch, 100 on Scale, 1,000+ on Enterprise | 5 on Free, 25 on Developer, 100 on Startup, custom on Enterprise | Many sandboxes at once, each its own VM; starts are limited per minute, hour and day by plan |
| Getting past bot checks | Datacenter IPs by default; residential proxies, CAPTCHA solving and dedicated IPs on paid plans; stealth browser on Enterprise | Residential proxies, captcha solving and a matching Chrome fingerprint on by default on every plan | Datacenter IPs; bring your own proxy or captcha service |
| What survives a session | Files API keeps session files in org storage; profiles keep cookies and logins | Fresh browser each session; an opt-in profile keeps cookies, local storage and session storage | The whole disk, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Shell, Docker and your own code | No shell; you reach the browser through CDP and the REST API | No shell; Python Functions with a run() entry point, called by API, webhook or schedule | SSH, root, systemd, Docker and /dev/kvm on every machine, any language |
| Fork | No fork; a new session can start from a saved profile or session context | No session fork; a Function can be forked as a copy of its code | Fork a running sandbox, browser and files included |
| Live view and computer use | Embeddable live view with human takeover, a computer-use input API, mobile mode and traces | Embeddable live view through a short-lived signed URL; browser only | 60fps Linux desktop and Chromium, computer use and browser control, embeddable and recordable |
| Agents | A CLI, skills and an MCP server give your coding agent a Steel browser; the agent runs elsewhere | Notte's own browser agent you start with a task, plus an MCP server for agents outside | Claude Code, Codex, OpenCode and more inside the VM, driven from outside with a prompt, steer and events API |
| Secrets and identities | Credentials API (beta) signs in for the agent without showing it the password | Vaults fill passwords, cards and 2FA codes; personas with their own email and phone | AI credentials proxy: real API keys stay outside the sandbox, for model providers and any HTTPS API |
| Reaching it from outside | No inbound ports; a CDP websocket and a live view URL | No open ports; a signed live-view URL per session | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Open source and self-hosting | steel-browser runtime is Apache-2.0, runs in Docker; Steel Outpost runs inside your network | Agent framework and SDKs under SSPL-1.0; hosted cloud is not open; on-premise and your own cloud on Enterprise | Managed cloud only |
| Where it runs | us-east only; proxy location sets the visible IP | Session region not published; built-in proxies exit in the US unless you pick a country | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Steel | Notte | 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 | No | No | Yes |
| Pause/resume | No | 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) | No | Not published | Yes |
| ≥24 h sessions | Yes | Yes | 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 | No | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Not published | No |
| Self-hosting | Yes | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | Yes | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | No | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either. Steel and Notte do not publish how many vCPUs a browser session gets and were not in StarSling's public CPU benchmark, where bochka did 26.69 runs per second at 4 vCPU / 8 GB. Steel says a session starts in under a second; for browsing work, speed depends mostly on the sites, the proxy and the model.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Steel and Notte 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 | Steel, a month | Notte, 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 | $250 · Scale · with limits | $100 · Startup · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Scale · with limits | $100 · Startup · 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 | $784 · Scale · with limits | $100 · Startup · 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 | $510 · Scale · with limits | $100 · Startup · 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 | $950 · Scale · with limits | $100 · Startup · with limits | $2,000 · $2000/mo · with limits |
Steel: Steel bills browser hours by the minute, rounded up: $0.10 an hour on the free Launch plan and $0.08 on Scale, which costs $250 a month and includes $100 of usage. Proxy bandwidth ($10 per GB on Launch, $6 on Scale), CAPTCHA solves and browser tools are billed on top.
Notte: Notte's plan fee ($20 on Developer, $100 on Startup) comes back as credits that expire each cycle, spent on browser sessions at $0.01 an hour, Functions, model tokens and residential proxies at $10 per GB. Proxies are on by default, so traffic is billed per GB unless you turn them off.
Notte: 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
Neither Steel nor Notte fits any scenario in the table, because each one needs a machine with a disk, Docker or runs of many hours, and both sell a browser session of unpublished size. Runs longer than an hour need Steel's Scale plan, which still stops each session at 1 hour, while Notte's Startup plan stops at 300 minutes. Both cap you at 100 browsers at once on those plans, so 300 sandboxes for your users or 1,000 jobs at once need Enterprise on either. On bochka the 1,000-job burst does not fit either: bursts above 90 starts a minute are queued, and it needs more starts a day than the top plan allows.
| Scenario | Steel | Notte | 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 Steel when
you want an open-source browser you can host yourself, human takeover and traces, browsers in the US, and proxies only on the sites that need them.
- Open-source browser you can host. Useful if browsers must run on your own machines: steel-browser is Apache-2.0, runs in Docker, and Steel Outpost runs inside your network.
- Human takeover and traces. Useful if people watch or step into runs: the live view lets a person take over, with mobile mode and readable traces.
- Proxies only when you want them. Useful if most sites you visit do not block bots: sessions use datacenter IPs unless you turn on residential proxies.
Use Notte when
your agents browse sites that fight bots and you want stealth on by default, a browser agent, personas and vaults, and sessions up to 300 minutes on Startup.
- Stealth on from the start. Useful if your agents browse sites that block bots: residential proxies, captcha solving and a matching fingerprint are on by default.
- Ready-made browsing tools. Useful if you want browsing handled for you: a task-driven browser agent, personas with email and phone, and scheduled browser Functions.
- Longer sessions on cheaper plans. Useful for runs over an hour: Developer allows 120 minutes and Startup 300, where Steel's Scale plan stops at 1 hour.
Where bochka fits
Steel and Notte are both browser services, so the choice between them is about proxies, tools and session limits. If what you are really running is an agent that browses and also works, writing code, building in Docker or keeping files for days, look at bochka. It gives each agent a full Linux VM with Chromium and a desktop on it.
A whole machine, not only a browser
Neither Steel nor Notte gives you a shell: Steel is reached through CDP and an API, Notte adds Python Functions. Anything that is not browsing needs a second machine you wire up, keep alive and move files to.
No session cap, and a disk that stays
Steel's Scale plan cuts runs at 1 hour and Notte's Startup plan at 300 minutes. Profiles carry over cookies and logins, but installed tools, running work and anything in memory start over at every cut.
Coding agents and a desktop built in
Both services drive a browser only. Steel's MCP server lends a browser to an agent you host, and Notte's agent browses rather than writes code. bochka runs Claude Code or Codex next to a 60fps desktop, driven from outside.
Use bochka when the agent does more than browse: it writes and runs code, uses Docker, keeps its disk between runs, works for hours with no session cap, or needs a desktop and coding agents on one VM. Compare it one to one: bochka vs Steel and bochka vs Notte.
Questions people ask
Is Steel cheaper than Notte?
Usually not. Notte's browser time is $0.01 an hour against $0.08 to $0.10 on Steel, and in our model browser-use agents come to $100 a month on Notte against $470 on Steel, with bochka at $200. Notte turns residential proxies on by default at $10 per GB, so heavy traffic adds up unless you turn them off.
Which is faster, Steel or Notte?
Neither publishes the machine size behind a session, and neither was in StarSling's CPU benchmark, so there is no number to compare. Steel says a session starts in under a second. For browsing, speed depends mostly on the sites, the proxy and the model.
Can Steel or Notte run Docker?
No. Both give you a cloud browser with no shell, so there is nowhere to run Docker or an agent's own code; Notte's Python Functions run a browser script, not a container. On bochka each sandbox is a full VM with Docker, systemd and /dev/kvm.
How long can a session run on Steel and on Notte?
Steel stops sessions after 15 minutes on Launch, 1 hour on Scale and 24 hours on Enterprise. Notte stops them after 15 minutes on Free, 120 on Developer, 300 on Startup and a custom limit on Enterprise. bochka has no session cap on paid plans.
Are Steel and Notte open source?
Steel's browser runtime, steel-browser, is open source under Apache-2.0 and runs in Docker. Notte's agent framework and SDKs are source-available under SSPL-1.0, but its hosted cloud is not; on-premise is an Enterprise option.
Can I use Steel or Notte from a bochka sandbox?
Yes. A bochka sandbox has open internet, so an agent inside it can call Steel's or Notte's API and keep its code, files and tools on the bochka VM. That sends hard-to-reach pages to a proxied browser and keeps the rest of the work on a machine with a disk that stays.
Try bochka
Install the CLI, then run bochka new.
Product preview