Pricing
What Browserbase Pricing Looks Like at 10 to 1,000 Hours
Browserbase bills browser hours and proxy GB, with a one-minute floor per session. Here's what 10, 100 and 1,000 hours cost on Developer or Startup.
I would start with Browserbase Developer for the first two workloads below and choose Startup for the larger proxy-heavy example. The difference is the complete time-plus-bandwidth bill: Startup is not automatically cheaper just because the workflow uses more browser hours.
First define billed lifetime. Browserbase meters browser time by minute and managed proxy traffic by rounded MB, with per-session minimums; keep-alive idle time counts until release or timeout. Raw task duration is therefore not the same budgeting input as billed browser hours. Plan billing, keep-alive, cost guidance.
Short on time?
Here's my take
- 10 hours, proxy disabled
- Developer: $20
- The documented monthly base covers this hypothetical billed workload if the session/concurrency limits fit.
- 100 hours, 3 managed-proxy GB
- Developer: $44
- The two GB above its included one add $24 to the $20 base.
- 1,000 hours, 10 managed-proxy GB
- Startup: $199
- The complete example is $37 below Developer; excluded product/model costs still matter.
Prices verified . USD list-price arithmetic checked 11 November 2026. Workloads are hypothetical billed inputs, not actual invoices or capacity tests.
What does Browserbase cost? #
| Plan | Monthly base | Included browser hours | Included managed proxy | Overage rates | Concurrency / session limit |
|---|---|---|---|---|---|
| Free | $0 | 1 | 0 GB (proxies start at Developer) | Do not infer paid entitlement | 3 concurrent; 15 minutes |
| Developer | $20 | 100 | 1 GB | $0.12/hour; $12/GB | 25 concurrent; configured paid timeout |
| Startup | $99 | 500 | 5 GB | $0.10/hour; $10/GB | 100 concurrent; configured paid timeout |
| Scale | Custom | Quote | Quote | Quote | Verify selected organization scope |
Sources: Browserbase pricing and plan documentation, checked 11 November 2026. Free has no proxy allowance; the proxy docs open managed proxies from Developer up. Paid session timeout can be configured from 60 to 21,600 seconds; that is separate from concurrency and included hours. Timeout docs, session reference.
Why billed hours can exceed task time #
I would use billed browser hours, not an assumed number of successful tasks. The docs specify minute/MB granularity and one-minute/one-MB minima per session. The proxies page says usage after the 1 MB minimum rounds to the nearest MB, but I found no stated rounding direction for minutes. I therefore do not apply an invented ceiling rule beyond the documented floor. Plan billing, proxies, cost optimization.
For 1,000 fresh 20-second sessions, the one-minute floor gives at least 1,000 billed minutes, about 16.67 hours, rather than the raw 5.56 hours of task duration. This is a hypothetical minimum calculation, not a measured invoice or an estimate of usable task capacity.
Keeping a session alive preserves a cost-bearing lifetime until release or timeout. I would release sessions the application owns and record the end state instead of assuming that finishing a script stops billing. Keep-alive, session management, release reference.
How do you calculate Browserbase cost? #
Let H mean billed browser hours after session floors, rounding and idle lifetime; let G mean billed managed-proxy GB after applicable per-session floors and MB rounding. Proxy-disabled scenarios set G to zero rather than pretending that every session uses a managed proxy.
My documented-rate monthly calculation is:
- Developer: $20 + $0.12 × max(H − 100, 0) + $12 × max(G − 1, 0).
- Startup: $99 + $0.10 × max(H − 500, 0) + $10 × max(G − 5, 0).
Sources: pricing, plans and cost guidance, checked 11 November 2026. Taxes, model/provider bills, other Browserbase products and external proxies are excluded; the required limits must also fit.
| Hypothetical billed workload | Developer | Startup | My base recommendation |
|---|---|---|---|
| 10 hours; managed proxy disabled | $20 | $99 | Developer if the required limits fit |
| 100 hours; 3 managed-proxy GB | $44 | $99 | Developer at these documented inputs |
| 1,000 hours; 10 managed-proxy GB | $236 | $199 | Startup for this proxy-heavy case |
| 1,000 hours; managed proxy disabled | $128 | $149 | Developer remains lower in this counterexample |
The rows do not claim measured pages/hour, agent success or workload concurrency. They show why the proxy component can change the cheaper plan. Other managed browsers use different units, so compare them in their own terms: Cloudflare Browser Run pricing adds averaged concurrency to hours, and Bright Data Browser API pricing bills bandwidth.
What does a small 10-hour job cost? #
At ten billed hours with managed proxy disabled, Developer’s example bill is $20 monthly. Free’s one included hour does not cover that workload, and Startup adds a larger base without reducing this total. Pricing, checked 11 November 2026.
I would still check session length, creation rate and required parallelism before treating the plan as a fit. A monthly total within the allowance does not establish that the application can create every requested session at once.
What if you add proxy traffic? #
At 100 billed hours and three managed-proxy GB, Developer totals $44. Its browser allowance covers H; two GB above the included one add 2 × $12 = $24 to the $20 base. Startup’s example remains its $99 base. Plan rates.
I would measure the actual managed-proxy traffic after permission and account setup before committing to a forecast. A task count alone does not tell me how much bandwidth the pages and browser interactions consume.
When does Startup beat Developer? #
At 1,000 billed hours and ten managed-proxy GB, Startup totals $199 against Developer’s $236. Developer is $20 + 900 × $0.12 + 9 × $12; Startup is $99 + 500 × $0.10 + 5 × $10. Current prices.
The counterexample matters: at the same 1,000 hours with managed proxy disabled, Developer is $128 and Startup $149. I would not turn the proxy-heavy row into a universal claim that upgrading saves money above a browser-hour threshold.
Can you open all your sessions at once? #
Browserbase’s concurrency applies organization-wide, while new-session creation has its own rate limit. The documented creation limits are 5/25/50/150+ per minute for Free/Developer/Startup/Scale, and a 429 can reflect either limit. Concurrency guide.
I would check peak active sessions and new-session bursts separately from the monthly bill. The usage endpoints expose browser minutes and proxy bytes, but no account totals were retrieved for this article. Usage measurement, project usage.
Paid allocations lead to overage charges rather than a spending cutoff. I would keep explicit release, lifetime limits and usage alerts in the operating plan; this research did not verify a separate configurable hard cap. Plans. If steady high usage makes running your own fleet tempting, self-hosted vs managed headless browsers lists the work that comes with it.
What isn’t covered by browser hours? #
Models and Browserbase’s other products aren’t in the browser-hour allowance, so I would price browser infrastructure and inference separately. Browserbase’s pricing has Search, Fetch (with a paid Extract add-on) and agent-run allowances with their own quotas, while Model Gateway token billing is separate from the browser-hour allowance. Current plan docs say hosted Functions are free on every plan, and pricing labels Runtime included; this does not make browser, proxy or model usage free. Pricing, Gateway overview, plan inclusions.
That is why a Stagehand setup is not a free hosted-browser or model package. The Browser Use versus Stagehand guide separates the control model and purchase paths; this article budgets the Browserbase browser/proxy component only.
Contexts preserve browser state, so I would also define credential handling and state retention before keeping sessions reusable. Contexts.
Which plan details don’t add up? #
Developer retention differs across public pages: pricing says 30 days while plan docs say seven. The session reference also retains a Hobby name alongside the current plan labels. I would not promise either retention term or infer account eligibility from that legacy name. Pricing, plan docs, session reference.
ZDR documentation distinguishes enterprise arrangements from per-session log/record flags. Those switches do not remove every upload, download, context or LLM-provider artifact, so the actual contract and data path still matter. ZDR docs, terms.
So which plan fits you? #
I would pick Developer for the ten-hour/no-proxy and 100-hour/three-GB examples, subject to the required session and creation limits. I would pick Startup for the illustrated 1,000-hour/ten-GB case, while preserving the counterexample where browser time alone leaves Developer lower.
Use Browserbase alternatives, Browserbase versus Browserless and Browserbase versus Steel for other billing models. The agent browser hub connects the choices without treating a successful connection as a measured task result.
FAQ #
Is Browserbase’s free plan just a trial? #
The published Free plan lists one browser hour monthly, three concurrent sessions and a 15-minute session cap. I did not verify account eligibility or a live quota. Pricing.
Does spending stop when the paid allowance runs out? #
The plan docs describe overages. Treat included hours and proxy GB as allocations, not a verified spending cutoff. Plan billing.
Does a keep-alive browser close when my script ends? #
I would explicitly release sessions the application owns and verify their end state. Keep-alive lifetime is billed until release or timeout. Keep-alive docs.
Does Stagehand include the model bill? #
Do not assume that. The Browserbase model path has separate inference billing; the exact framework/provider configuration also matters. Gateway docs.
Sources
20 sources, accessed .
Official pricing, docs, changelogs and status pages 20
- Browserbase: pricing
- Browserbase: account/billing/plans
- Browserbase: optimizations/cost/measuring usage
- Browserbase: platform/browser/long sessions/timeouts
- Browserbase: platform/browser/long sessions/keep alive
- Browserbase: platform/identity/proxies
- Browserbase: optimizations/concurrency/overview
- Browserbase: platform/browser/getting started/manage browser session
- Browserbase: platform/browser/core features/contexts
- Browserbase: platform/model gateway/overview
- Browserbase: changelog
- Browserbase: status
- Browserbase: optimizations/cost/cost optimization
- Browserbase: account/billing/plan management
- Browserbase: reference/api/create a session
- Browserbase: reference/api/update a session
- Browserbase: reference/api/get project usage
- Browserbase: welcome/quickstarts/playwright
- Browserbase: account/enterprise/zero data retention
- Browserbase: terms of service
Last updated: 13 October 2026. Researched and drafted with AI tools; human editorial review and publication approval are pending.
