What Browserbase Pricing Actually Covers
Browserbase pricing is a base subscription plus metered usage. The self-serve tiers are Free at $0, Developer at $20/mo and Startup at $99/mo, with a sales-led Scale tier above them. Each tier bundles a monthly allowance of browser hours, proxy bandwidth and API calls, and anything past that allowance bills at published overage rates — $0.12 per browser hour on Developer, $0.10 on Startup.
📌 TL;DR Executive Summary
- Core Takeaway: Developer is $20/mo and Startup $99/mo. Past the included allowance you pay $0.12 or $0.10 per browser hour, $12 or $10 per GB of proxy bandwidth, and $7 per 1,000 Search calls.
- Key Risk/Challenge: Browser hours are wall-clock time with a one-minute minimum, so short or abandoned sessions still bill, and per-minute session creation caps turn retries into HTTP 429 responses instead of throughput.
- Recommended Solution: Measure session length and peak concurrency first, set hard timeouts, enable proxies per session rather than globally, and use a profile manager such as Send.win when a person, not code, is the one signing in.
Browserbase Plans at a Glance
Browserbase sells capacity, not seats. Each plan is one organisation with a pool of concurrent browsers, a monthly hour allowance and metered add-ons. The cards look simple; the rows underneath decide your bill.
| Line item | Free | Developer | Startup | Scale |
|---|---|---|---|---|
| Monthly price | $0 | $20 | $99 | Custom |
| Concurrent browsers | 3 | 25 | 100 | 250+ |
| Session creations per minute | 5 | 25 | 50 | 150+ |
| Included browser hours | 1 | 100 | 500 | Usage-based |
| Overage per browser hour | — | $0.12 | $0.10 | Contract |
| Maximum session length | 15 minutes | 6 hours | 6 hours | Not published |
| Included proxy bandwidth | None | 1 GB | 5 GB | Custom |
| Proxy overage per GB | — | $12 | $10 | Contract |
| Agent runs included | 3 | 15 | 50 | Custom |
| Search calls included | 1,000 | 1,000 | 1,000 | Custom |
| Search overage per 1,000 | — | $7 | $7 | Contract |
| Fetch overage per 1,000 | — | $1 | $0.50 | Contract |
Scale is negotiated: 250+ concurrent browsers, 150+ session creations per minute, usage-based hours, custom agent-run and Search/Fetch volumes, plus a HIPAA BAA, a DPA, SSO/SAML and invoice billing. If you need any of that, the self-serve prices stop being the comparison.
When Developer Stops Being Cheaper Than Startup
The $79 gap between the tiers is harder to close than the cards suggest. On hours alone, Developer’s $0.12 rate is just $0.02 above Startup’s $0.10, and Startup’s first 500 hours are prepaid. Solve both formulas and Developer stays cheaper until roughly 2,050 browser hours a month: $20 plus 1,950 overage hours at $0.12 is about $254, the same as $99 plus 1,550 hours at $0.10.
Proxy bandwidth moves that line hard. Add 12 GB of proxy traffic and Startup is the cheaper option past roughly 240 browser hours, because the eleventh gigabyte costs $12 on Developer and $10 on Startup, and Startup includes five gigabytes instead of one. The tier decision is rarely about hours; it is about gigabytes and concurrency.
Where It Sits Next to Steel.dev and Browser Use
The alternatives price differently rather than cheaper. Third-party listings put Steel.dev at $29 to $499 in monthly credits depending on tier, so you prepay capacity you may not use. Browser Use is an open-source library you run yourself, which moves the cost from a subscription to the compute and maintenance you supply.
This comparison of Browserbase alternatives covers how credit-based models behave in practice. For budgeting, Browserbase is the only one of the three with a published per-browser-hour overage rate, which makes its bill the easiest to forecast from a session log — and the easiest to overspend on if you ignore the one-minute minimum.
How Browser Hours Are Counted Under the Hood
A browser hour is wall-clock time: one live cloud browser running for sixty minutes. It is not CPU time, page loads or tokens. The meter starts when the session is created and stops when it closes or hits the plan’s maximum length.
Two mechanics change the arithmetic. Every session has a minimum runtime of one minute, so a session you discard after four seconds still bills a full minute. Sessions are also capped — 15 minutes on Free, six hours on Developer and Startup — so a long job splits into several sessions, each paying its own minimum. The concurrency documentation states both rules.
Minutes per session, not sessions per day, is therefore the number that drives your bill. A workflow averaging 40 seconds and one averaging four minutes differ sixfold in cost at identical volume, and only the second reflects what the hour allowance was sized for.
Browserbase treats hours and proxy bandwidth as allocations rather than limits: passing them does not block you, it moves you to pay-as-you-go rates. That is convenient in production and dangerous in testing, because a runaway loop produces an invoice instead of an error. Set a hard session timeout in your own code and treat every session that reaches it as a bug.
Concurrency, Rate Limits and the 429 Wall
Concurrency is how many browsers can be alive at once: 3 on Free, 25 on Developer, 100 on Startup, 250+ on Scale. It is a separate throttle from the session creation rate, which caps new sessions per minute at 5, 25, 50 and 150+. Exceed that and the API returns HTTP 429 with a retry-after header telling you when to try again.
Concurrency is assigned per organisation, not per project. Add a second project on Developer and the default split is 24 browsers to the first and 1 to the second. You can change the split in dashboard settings; until you do, an entire project appears starved for no visible reason.
Creation rate also governs ramp speed. Startup allows 50 creations a minute, so filling 100 concurrent sessions from cold takes about two minutes. If your workload is bursty, a retry loop against a 429 will not speed that up; a queue with a paced release will.
Proxy Bandwidth: Opt-In, Best-Effort and Metered
Built-in proxies are off by default. A session created without flags leaves from Browserbase’s own network, not a residential address. Set proxies to true and you get a managed residential pool covering 200+ countries, with country, US state and city targeting.
Routing is best effort, which matters for accuracy and for cost. With the bare flag, Browserbase aims for a US route but may fall back to a nearby country such as Canada. Ask for a specific country or city in the session options instead; otherwise a test that assumes a US exit IP can quietly run from somewhere else, and every byte still bills.
Bandwidth is metered by volume, not request count. Developer includes 1 GB then charges $12 per GB; Startup includes 5 GB then $10 per GB; Free has no proxy access. Image-heavy pages, video and large JSON responses burn gigabytes faster than request logs suggest, so a fetch-heavy job can cost more in bandwidth than in browser hours.
If you are comparing per-GB rates across providers, this breakdown of residential proxy prices explains why the rate is only half the story — the other half is how much of your traffic is media you never needed to load.
Search, Fetch, Extract and Agent Runs
These line items sit outside the browser-hour meter, and they are the ones most often missing from a budget built on hours alone.
- Search: 1,000 calls included on Developer and Startup, then $7 per 1,000. Rate limited to 2 requests per second per project on every self-serve plan.
- Fetch: $1 per 1,000 calls on Developer, $0.50 on Startup, $4 per 1,000 with proxies. Limited to 5 requests per second per project; returns markdown or JSON and caps output at 5 MB.
- Extract: $4 per 1,000 pages, or $7 per 1,000 with proxies.
- Agent runs: 3 on Free, 15 on Developer, 50 on Startup, custom on Scale, with no published overage rate — treat the cap as a ceiling and get a quote before planning past it.
- Model Gateway: $5 of model tokens bundled on Free; on paid tiers, tokens bill at market price pay-as-you-go.
How Send.win Helps With Browserbase Pricing
Send.win is a browser profile manager for professionals and teams: every account gets its own isolated browser profile.
- Isolated profiles – separate cookies, storage and sessions per profile
- Fingerprint protection – each profile keeps its own consistent browser fingerprint, so profiles never share one browser identity
- Desktop app + cloud browser – native app for Windows, macOS and Linux, or run profiles in the cloud with no install
- Residential proxies included – on Pro and Team, with timezone and locale matched to the proxy
- Team sharing – share a signed-in profile with a teammate without sharing the password
Try the free cloud demo — no install — or download the desktop app. Paid plans start at $19/month, and your first card purchase is covered by a 7-day money-back guarantee (see pricing).
The proxy multiplier is the one to watch. Fetch with proxies costs four times the base rate, and Extract goes from $4 to $7 per 1,000. That is a fair price for the capability, but it belongs in the forecast next to browser hours rather than on the first invoice.
A Worked Monthly Bill on the Developer Plan
Take a realistic month for a small team: 300 sessions a day, each averaging four minutes, against sites they operate or are authorised to use.
| Line item | Monthly usage | Billable beyond plan | Rate | Cost |
|---|---|---|---|---|
| Base plan | — | — | — | $20.00 |
| Browser hours | 600 hours | 500 hours | $0.12/hour | $60.00 |
| Proxy bandwidth | 4 GB | 3 GB | $12/GB | $36.00 |
| Search calls | 4,000 | 3,000 | $7 per 1,000 | $21.00 |
| Fetch calls | 20,000 | 20,000 | $1 per 1,000 | $20.00 |
| Agent runs | 12 | 0 (15 included) | — | $0.00 |
| Total | $157.00 |
Two things follow. The base fee is under 13% of the bill, so the plan price is not the budget. Browser hours and proxy bandwidth together account for about 61%, which makes session duration and asset weight the two levers worth pulling before you consider upgrading.
Now scale the same workload to 2,000 hours and 12 GB of proxy traffic. On Startup, 1,500 overage hours at $0.10 come to $150 and 7 GB of overage bandwidth at $10 to $70, so $99 + $150 + $70 = $319 before Search and Fetch. The same month on Developer costs $20 + $228 in hours + $132 in bandwidth = $380. Almost all of that $61 saving comes from the proxy rate and the included gigabytes, not from the hourly rate.
Who Feels Browserbase Pricing — and Who Should Not Be Paying It
The model fits one buyer precisely: an engineering team whose code drives browsers. An agent that opens sessions, navigates, extracts and closes is exactly what browser hours, concurrency and Search/Fetch credits were designed to meter. An agency running scheduled checks across client sites fits too, because the work is programmatic and the volume is measurable.
It fits badly when a person is the one logging in. If your day goes on client ad accounts, storefronts or support inboxes you are authorised to manage, concurrency, session minutes, agent runs and Fetch credits are capacity you never call. You would pay for an API surface you do not use, and every login would still be manual. That is a mismatch between the meter and the work, not a fault in the product. For what the other kind of work costs, see this browser isolation cost analysis.
No tooling changes which accounts you may use. Platforms set their own rules on multiple accounts: Amazon requires approval for an additional seller account, and Meta routes agency work through Business Manager roles. Browserbase does not change that, and neither does anything else.
A Pre-Purchase Checklist
- Measure session duration. Pull the median and 95th percentile from a week of logs, then apply the one-minute minimum to everything shorter.
- Count peak concurrency, not daily totals. Ten thousand sessions a day is cheap if eight run at once and expensive if eighty do.
- Check your burst shape against the creation cap. A nightly job that fires 200 sessions at once hits the 25-per-minute limit on Developer and waits eight minutes.
- Decide which sessions need a residential exit. Internal staging checks usually do not, and each one you skip saves $12 or $10 per gigabyte.
- Forecast Search, Fetch and Extract separately. Multiply expected calls by $7, $1 or $4, and $4 or $7 — the proxy multiplier belongs in the maths.
- Price the next tier before buying add-ons. At high proxy volume, Startup’s included gigabytes usually cost less than Developer overage.
- Check whether the workload is human at all. If a person logs in, a profile manager is the cheaper and more accurate tool.
Common Mistakes That Inflate the Bill
- Leaving sessions open after the job finishes. Idle browsers bill wall-clock time exactly like busy ones.
- Ignoring the one-minute minimum. Ten thousand three-second sessions cost 166 hours, not eight.
- Retrying 429s in a tight loop. The retry-after header tells you when to come back; hammering it produces more rejections, not more browsers.
- Assuming concurrency is per project. The default 24/1 split on a second project looks like a bug and is a setting.
- Enabling proxies globally. It raises bandwidth spend and multiplies Fetch and Extract rates by four and 1.75.
- Budgeting only browser hours. Search, Fetch, Extract and model tokens are separate meters on the same invoice.
- Quoting third-party cost figures as fact. Several comparison sites list hidden costs and contract minimums the vendor does not publish; treat those as unverified and ask sales.
Where Send.win Fits
Send.win is a browser profile manager for people who log into accounts they own or are authorised to manage. Each profile keeps its own cookies, storage, sessions, fingerprint settings and proxy, so one client’s session never bleeds into the next. It runs two ways: Sendwin Browser, a Chromium-based desktop app for Windows 10/11, macOS 12+ and Linux, and a cloud browser hosted in Helsinki, Finland, that opens from any device with nothing installed.
It is a different category, not a cheaper tier of the same one. Send.win is built around a person opening a profile and signing in by hand; Browserbase is built around code that drives a browser on its own. If your workload is programmatic, Browserbase is the right shape for it and Send.win is not a substitute.
The cost structure follows that difference: flat per plan rather than metered per minute. Pro is $19/mo, or $83.88/yr ($6.99/mo), with 150 saved profiles, 5 GB/month of residential proxy bandwidth and 6 seats; Team is $49/mo, or $251.88/yr ($20.99/mo), with 500 profiles, 20 GB/month and 16 seats. Up to 50 profiles can be open at once on either plan, bring-your-own HTTP or SOCKS5 proxies run alongside the included pool, and timezone, locale, WebRTC and geolocation follow the proxy exit IP automatically — which removes the per-session geolocation work described above.
For teams, sharing is the practical difference: share a profile with a paid teammate and it opens already signed in, with no password changing hands, and live cloud sessions can be shared the same way. There is no free trial of the desktop app; the cloud demo gives you a short hands-on look first. If you are still mapping the category, this roundup of multi-login tools compared sets profile managers beside metered cloud browsers.
🏆 Send.win Verdict
Browserbase pricing rewards teams whose code opens browsers. If you can measure session minutes and concurrency, the metered model is honest and forecastable, and the one-minute minimum is easy to design around once you know it exists. It rewards nobody else. When the work is a person signing into accounts you own or manage, a flat per-profile plan beats a per-hour meter, because there is no hour to meter and no 429 to queue behind. Send.win is that tool — per-profile fingerprint protection, residential proxies and profile sharing — for work a person does by hand, not for code-driven jobs.
See Send.win plans — Pro from $19/mo with 150 profiles and 5 GB of proxy bandwidth, or try the free cloud demo first.
Frequently Asked Questions
How much does Browserbase cost per month?
Free is $0, Developer $20/mo and Startup $99/mo, with a custom-priced Scale tier above them. Each fee covers an allowance of browser hours, proxy bandwidth and API calls; usage past that allowance bills at overage rates, so a production month costs more than the plan price.
Is there a free Browserbase plan or trial?
There is a Free plan rather than a time-limited trial: 3 concurrent browsers, 1 browser hour, 15-minute sessions, 3 agent runs and 1,000 Search plus 1,000 Fetch calls. It has no proxy access, so anything that depends on a residential exit needs a paid tier.
What is a browser hour and how is it billed?
Sixty minutes of wall-clock time for one live cloud browser session, metered from creation to close. Every session has a one-minute minimum, so short sessions still bill. Developer includes 100 hours then charges $0.12 each; Startup includes 500 then charges $0.10.
Does Browserbase charge extra for proxies?
Yes, twice. Bandwidth is metered — 1 GB included on Developer then $12/GB, 5 GB on Startup then $10/GB, none on Free — and proxies also raise Fetch to $4 per 1,000 calls and Extract to $7. Proxies stay off unless you enable them per session.
Why do my Browserbase sessions return HTTP 429?
You are exceeding the session creation rate: 5 per minute on Free, 25 on Developer, 50 on Startup, 150+ on Scale. The response carries a retry-after header telling you when to try again. Pace the queue rather than retrying immediately, and check the per-project concurrency split.
Are Search, Fetch and agent runs included or extra?
Each plan includes an allowance, then meters them separately from browser hours. Search is $7 per 1,000 past the included 1,000 calls, Fetch is $1 or $0.50 per 1,000 by tier with proxies at $4, and agent runs are capped at 3, 15 or 50 with no published overage rate.
How does Browserbase compare with Steel.dev and Browser Use?
Different billing models rather than lower prices. Third-party listings put Steel.dev at $29 to $499 in monthly credits, so you prepay capacity; Browser Use is open source, but you supply and maintain the compute yourself.
Can I use Send.win instead of Browserbase?
No — they solve different problems. Browserbase runs browsers for code that drives them. Send.win is a browser profile manager where a person signs into accounts they own or are authorised to manage, on the desktop app or in the cloud browser. If your work is programmatic, Browserbase is the tool for it.