Browserbase pricing

About

Browserbase is browser-agent infrastructure: it gives AI agents full, real headless browser sessions plus the surrounding stack — web Search and Fetch APIs, an agent-identity layer, a runtime for deploying agents, and a model gateway — all behind a single API key. The pitch is that teams building browser agents otherwise have to assemble and operate their own stack (browsers, proxies, anti-bot identity, model access, observability) before writing a line of agent logic; Browserbase collapses that into one platform with live view, logs, and session replay for debugging.

The company serves developers and AI-native teams building agents that browse and act on the web — use cases span data extraction from sites without APIs, GTM and sales tooling, healthcare portal automation, supply chain, tax, and legal workflows. It reports 800,000 weekly SDK downloads, 35M+ monthly sessions, and 2,000+ concurrent browsers available per instance, with customers including teams like Amplitude. Browserbase is also the company behind the open-source Stagehand SDK, which is how agents drive its browsers and reach models.

Founded in January 2024 by solo founder Paul Klein IV, Browserbase raised quickly into the agent-infrastructure wave: a $6.5M seed, a $21M Series A in October 2024 (Kleiner Perkins and CRV), and a $40M Series B in June 2025 at a $300M valuation — $67.5M total in roughly 15 months, with angels including Stripe’s Patrick Collison and Vercel’s Guillermo Rauch. By the Series B the company reported more than $3M in revenue, 1,000+ customers, 20,000+ developer signups, and 50M browser sessions run in 2025.

Competitively, Browserbase sits in the emerging “agent infrastructure” category alongside scraping/automation platforms and the headless-browser cloud, but differentiates on being a complete, security-certified stack (SOC 2 Type II, HIPAA-ready) rather than a single primitive. Its pricing reflects that platform framing: instead of charging per seat, it charges for the resources agents actually consume — browser compute time and API calls.

Pricing summary : How Browserbase meters browser hours and API calls

Browserbase uses a freemium + hybrid model — a flat monthly plan fee that bundles quotas, then usage-based metering on the dimensions agents consume. There are four plans (Free $0, Developer $20/mo, Startup $99/mo, and custom Scale), each with a larger included pool and lower overage rates as you move up.

The metered dimensions are:

1. Browser hours — actual compute time an agent spends driving a browser. Free includes 1 hour, Developer 100, Startup 500; overage is $0.12/browser hr on Developer and $0.10/browser hr on Startup (Scale is fully usage-based).
2. Search API — 1,000 requests included on every plan; overage is $7 per 1,000 requests on Developer and Startup.
3. Fetch API — 1,000 calls included (10,000 on Startup); overage is $1/1k calls ($4/1k with proxies), with Extract calls at $4/1k ($7/1k with proxies); Startup’s marginal Fetch rate drops to $0.5/1k.
4. Proxies — 1 GB included on Developer, 5 GB on Startup, billed by bandwidth beyond that.
5. Model tokens — the bundled Model Gateway includes $5 of tokens free; paid plans bill tokens pay-as-you-go at market price under unified billing.

What makes this different: Browserbase prices the compute an agent burns, not the human operating it — there are no per-seat fees anywhere in the lineup, and even model spend folds into the same metered invoice. See how this compares across the hybrid pricing model and browser-hour billing theme pages.

Pricing by product

Browserbase platform (self-serve plans)

Browserbase platform (Scale / Enterprise plan)

Usage-based overage rates (beyond included quota)

Sales motions across products: PLG / self-serve for Free, Developer, and Startup; sales-led for the custom Scale (Enterprise) plan.

Hidden costs : What heavy browser-agent workloads actually cost

The advertised $20 and $99 headlines cover a fixed quota; real production workloads add metered usage on top. Two representative examples:

A scaling agent team on the Startup plan

Beyond the included pools, the metered dimensions — especially Search at $7/1k and model tokens — can roughly double the headline plan fee at moderate production volume, the kind of AI bill-shock multi-dimensional metering invites.

A prototyping developer staying inside Developer-plan quotas

A developer who stays inside the quota pays close to the sticker price — the metering only bites once an agent runs at production scale.

Want to estimate your own Browserbase bill? Use the Browserbase pricing calculator to model your monthly cost based on browser hours, Search/Fetch calls, proxies, and model tokens.

Pricing evolution : From single-primitive browser cloud to bundled agent platform

Browserbase moved fast from a single-primitive browser cloud to a bundled agent platform, and its metering surface widened along the way — from consumption-priced browser sessions at launch, to browser-hour quotas, to per-call Search and Fetch APIs layered on top, to a Model Gateway that folds LLM tokens into the same invoice. The company is barely two years old (founded January 2024), so the pricing history is short but eventful, tracking the funding milestones that scaled the product.

Cadence

Tracked range: 2024 Q2–2026 Q2. Funding and product-launch dates are corroborated by press and the company blog; tier-level overage rates are taken from the captured pricing page. Tier dollar figures for the 2024–2025 period are not independently confirmed and are intentionally left blank rather than guessed.

Notable changes

• 2024-06 — Public launch on a consumption-priced browser cloud for AI agents (VentureBeat exclusive; HN Show, 2024-06-06).
• 2024-10 — $21M Series A co-led by Kleiner Perkins and CRV, ~9 months after a $6.5M seed, funding the cloud headless-browser product.
• 2025-01 — Stagehand open-source SDK released; its HN launch drew 326 points / 86 comments (2025-01-08), seeding the developer base that drives Browserbase browsers.
• 2025-06 — $40M Series B at a $300M valuation (~4x the Series A, total raised $67.5M) alongside the Director launch; consumption-based pricing carried forward at production scale.
• 2026-03-11 — Fetch API launched at $1/$4/$7 per 1k calls, adding per-call Search/Fetch metering on top of browser hours — the same rates shown on today’s pricing page (browserbase.com/blog/fetch-api).
• 2026-06-02 — Current four-plan lineup captured: browser-hour overage at $0.12/hr (Developer) and $0.10/hr (Startup), Search at $7/1k, and a bundled Model Gateway with $5 of free tokens (browserbase.com/pricing).

What’s unique : Browser-hour metering and a bundled model gateway

1. Pricing the compute, not the seat. Browserbase has no per-user fee anywhere in its lineup. It meters “browser hours” — the actual time an agent drives a browser — which aligns cost with an agent’s workload rather than headcount. This is the natural value metric for agent infrastructure, where one developer might orchestrate thousands of concurrent sessions.

2. A model gateway folded into one invoice. The same API key that launches browsers also reaches major LLMs through Stagehand at market token price, with $5 of tokens included free. Bundling model spend into the infrastructure invoice removes a second vendor relationship and makes the platform a one-stop bill for the whole agent stack.

3. Quota-then-overage tiering that lowers marginal rates as you climb. Browser-hour overage drops from $0.12/hr (Developer) to $0.10/hr (Startup), and Startup’s marginal Fetch rate halves to $0.5/1k. The plan fee effectively buys a better unit price, nudging growing workloads upward — a classic usage-based packaging lever.

4. Compliance and identity gated to the Scale plan. HIPAA BAAs, DPAs, SSO/SAML, advanced “Verified Agents” identity, and invoice billing are reserved for the custom Scale plan, giving the sales team a clear enterprise upsell distinct from the self-serve tiers.

Strengths & weaknesses

Billing UX : Quotas, live session debugging, and unified model billing

• Per-plan included quotas — each plan shows explicit included pools (concurrent browsers, browser hours, Search calls, Fetch calls, proxies) so the buyer sees what’s free before overage begins.
• “Compare plans” feature matrix — the pricing page renders a full side-by-side table of Concurrency, Browser Hours, Search/Fetch API rates, RPS limits, captcha solving, data retention, Model Gateway, and Stealth Mode across all four tiers.
• Model Gateway with unified billing — model token usage is metered through the same Browserbase API key and rolled into one invoice rather than billed by a separate model provider.
• Live view, logs, and session replay — every browser session ships with live view, logs, and replay so teams can audit exactly what consumed browser hours.
• Invoice billing (Scale) — the enterprise plan supports invoice/procurement billing instead of credit-card-only, called out explicitly for the Scale tier.
• Usage guidance copy — the page contextualizes the browser-hour unit (“a typical web scrape runs in under 2 minutes; 100 hours is roughly 3,000 page-level tasks”) to help buyers right-size a plan.

Strategic wins : Why Browserbase’s metering choices work

1. Choosing browser hours as the value metric

By billing the compute time an agent spends in a browser, Browserbase ties revenue directly to customer success — more automation means more hours means more revenue, with no seat ceiling. This is the textbook value-metric selection for infrastructure where one buyer drives enormous fan-out.

2. A free tier that proves the whole stack

Including 1 browser hour, 1,000 Search/Fetch calls, and $5 of model tokens lets a developer build an end-to-end agent before paying. This freemium on-ramp lowers the activation barrier for a category where buyers need to see an agent work before committing.

3. Bundling model access to widen the moat

Folding LLM access into the platform via the Model Gateway makes Browserbase stickier than a pure browser-cloud — the API key becomes the single integration point for browsers, search, fetch, and models, raising switching costs as discussed in our coverage of agentic workflow cost optimization. The open-source Stagehand SDK is the wedge that makes this stick: its 2025-01-08 launch drew a 326-point, 86-comment Hacker News thread, building a developer base that defaults to Browserbase’s billed browsers and Model Gateway as the path of least resistance — the same open-core flywheel we cover in open-source monetization.

4. Gating compliance to create a clean enterprise tier

Reserving HIPAA, DPAs, SSO/SAML, and advanced identity for Scale gives the sales team a concrete, high-value upsell that self-serve customers can’t unlock on their own, keeping the PLG and sales-led motions cleanly separated.

Areas to improve : Bill predictability and rate transparency

1. Make the multi-dimensional bill easier to forecast

With browser hours, Search, Fetch, Extract, proxies, and model tokens all metered separately, customers can’t easily predict a monthly bill. A built-in cost estimator or a “projected overage” widget in the dashboard — like the calculators we advocate in usage-based billing — would reduce bill shock.

2. Publish the model-token rates

Tokens are billed “at market price,” but the page never states the actual per-model rate. Surfacing a per-model token table (as the providers in our AI token pricing tracker do) would remove a guessing step for buyers budgeting agent workloads.

3. Simplify the Fetch pricing matrix

Fetch has base, with-proxy, and Extract variants at $1/$4/$7 per 1k, which is hard to parse at a glance. Consolidating into a clearer two-axis grid (operation type x proxy on/off) would make the most-used API easier to reason about.

4. Add an annual or commitment discount

The public page shows only monthly plans with no commitment incentive. Introducing an annual prepay or a committed-use discount would reward predictable workloads and improve revenue visibility, a lever explored in our usage-based pricing for AI SaaS coverage.

5. Tie reliability to the value metric

Because Browserbase bills the actual compute an agent burns, failed page loads still consume browser hours — so reliability is a billing concern, not just an SLA one. A competitor benchmark (Anchor, 2025-08-28) publicly claimed a “29% failure rate on basic page loads” for Browserbase; whether or not that figure holds, billing for compute that didn’t produce a result is a credibility risk for a consumption model. Surfacing success-rate metrics in the dashboard, or crediting hours spent on failed loads, would align the meter more tightly with delivered value.

Community signal, documented: Pricing-specific backlash is minimal — no Hacker News pricing thread crosses the 50-point trust-event bar, and Browserbase-specific Reddit threads were not retrievable at the time of writing. The loudest community signals are product-adjacent: the 326-point Stagehand launch (positive) and the competitor-published reliability critique (negative). No public pricing walk-back, refund episode, or pricing apology was found.

Key takeaways

1. Price the workload, not the user. Browserbase proves that for agent infrastructure, a compute-time metric (browser hours) aligns revenue with value far better than per-seat fees when one buyer drives massive fan-out.
2. Bundle adjacent spend to deepen the moat. Folding model tokens into the same API key and invoice turns a single primitive into a platform and raises switching costs without raising the headline price.
3. Use a real free tier to de-risk evaluation. Including model tokens in the free plan lets buyers validate an end-to-end agent before paying — critical when the product only proves its value once it runs.
4. Lower marginal rates as customers climb. Dropping overage rates on higher plans (browser hours $0.12 to $0.10, Fetch $1 to $0.5/1k) nudges growing workloads to upgrade rather than churn.
5. Gate compliance, not features, for enterprise. Reserving HIPAA, SSO, and invoice billing for the custom tier creates a clean sales-led upsell without crippling the self-serve product.

UBP implications

1. Compute-time metering is becoming the default for agent infra. Browser hours join CPU-hours and GPU-hours as a workload-aligned unit; expect more agent platforms to bill the resource an agent consumes rather than the human operating it.
2. Unified billing across infra + model spend is a differentiator. As agent stacks fragment across browsers, search, and models, the platform that consolidates them into one metered invoice wins on both stickiness and buyer simplicity.
3. Multi-dimensional metering trades predictability for fairness — and capital lets you price for land-grab. Browserbase’s surface widened from browser sessions (2024) to browser hours, then to per-call Fetch/Search (2026): each dimension adds precision but another line item to forecast, so the platforms that pair granular metering with strong in-product cost visibility will keep churn low. With a $40M Series B at a $300M valuation behind it, a venture-backed agent-infra player can keep entry tiers cheap and free quotas generous to win the category, setting aggressive reference prices the rest of the market must answer.

Sources

• Browserbase pricing page (accessed 2026-06-02)
• Browserbase enterprise / Scale plan page (accessed 2026-06-02)
• Browserbase documentation (accessed 2026-06-02)
• Browserbase docs — plans, pricing & usage limits (accessed 2026-06-02)
• Browserbase blog — Fetch API launch & pricing (accessed 2026-06-02)
• Browserbase changelog (accessed 2026-06-02)

Bottom line

Browserbase prices browser-agent infrastructure the way the workload actually behaves: a free tier to prove the stack, two self-serve plans at $20 and $99, and a custom Scale tier, all sitting on top of usage-based metering for browser hours, Search/Fetch calls, proxies, and model tokens — with no seat fee anywhere. The model is clean and value-aligned; its main cost is bill predictability across so many metered dimensions.

Want to compare Browserbase against other agent-infrastructure pricing? Browse the pricing blueprint.

Pricing timeline : Major events on a vertical axis

Each milestone below corresponds to a public pricing change, product launch, or material adjustment. Major events use a filled marker; minor adjustments use a faded one.

Four-plan structure: Free, Developer, Startup, Scale

Jun 2026

Browserbase prices browser-agent infrastructure across a free tier, a $20/mo Developer plan, a $99/mo Startup plan (most popular), and a custom Scale plan, each bundling browser-hour and API quotas with usage-based overage on browser hours ($0.12/hr Developer, $0.10/hr Startup), Search ($7/1k), Fetch, proxies, and model tokens. (browserbase.com/pricing, captured)

Fetch API launches with $1/$4/$7 per 1k pricing

Mar 2026

Shipped the Fetch API for retrieving page content without a full browser session, priced $1/1k (HTML), $4/1k (markdown/Extract) and $7/1k (JSON/Extract with proxies) — the rates that appear on the current pricing page. This broadened metering beyond browser hours to per-call Search/Fetch dimensions. (browserbase.com/blog/fetch-api, 2026-03-11)

$40M Series B at $300M valuation; Director launch

Jun 2025

Series B of $40M led by Notable Capital at a $300M valuation (~4x the Series A), total funding $67.5M. Launched Director, a natural-language automation tool for non-technical users. Disclosed >$3M revenue, 1,000+ customers, 20,000+ developer signups, 50M browser sessions in 2025; pricing remained consumption-based. (Upstarts; Contrary Research)

Stagehand open-source SDK — how agents drive the browser and reach models

Jan 2025

Released Stagehand, an open-source AI browser-automation SDK that became the integration path for agents to drive Browserbase browsers and later reach LLMs via the Model Gateway. The Stagehand HN launch drew 326 points / 86 comments (2025-01-08).

$21M Series A — scaling the browser-cloud primitive

Oct 2024

Series A of $21M co-led by Kleiner Perkins and CRV (Okta Ventures participating), funding the cloud headless-browser product. Pricing stayed consumption-based on browser sessions/hours; no public tier table verified from archives for this period. (Outset Capital; pulse2)

Public launch: consumption-priced headless browsers for AI agents

Jun 2024

Browserbase launched publicly as 'headless browsers built for AI agents,' charging on a consumption basis for cloud browser sessions. Founded Jan 2024 by solo founder Paul Klein IV. (VentureBeat launch coverage; HN Show, 2024-06-06)