Browserbase

Positioning

Browserbase rents you real Chrome browsers in someone else's cloud, purpose-built for AI agents and scraping. You connect over the Chrome DevTools Protocol with Playwright, Puppeteer or Selenium, drive it like a local browser, and get billed for how long the session stays open. The company — founded in 2024 by Paul Klein IV (ex-Twilio, ex-Replit), San Francisco, backed by a $9M seed and a $21M Series A from Kleiner Perkins — pairs the hosted infrastructure with Stagehand, its MIT-licensed browser automation framework (over 25,700 GitHub stars at my last check) that lets an agent mix natural-language steps with ordinary Playwright code. Stagehand runs against a local browser for free and points at Browserbase when you need concurrency, stealth, proxies and session recordings.

That two-part structure is the strategy: the open-source SDK is how developers arrive, the hosted infrastructure is what they scale on. For agent builders it solves the unglamorous half of browser use — headless fleets, session persistence, proxy rotation, captcha handling, fingerprint management — that a laptop demo never exercises and production always does.

What it actually does

The core primitives are sessions and the APIs around them. A session is a hosted browser you attach to over CDP; sessions persist cookies and state, run real JavaScript on rendered pages, and come with debugging tooling — live session viewing, logs and replay. Around that sit newer surface area: a Search API, a Fetch API, an Extract mode (fetch with structured extraction at higher per-call rates), Identity features including automatic captcha solving (paid tiers) and Verified Sessions with real browser fingerprints (Scale tier), plus a Model Gateway that sells model tokens at market rates for the AI layers. Stagehand's page.act("click the login button") style is what makes the whole stack feel native to LLM agents instead of to test engineers.

Pricing at time of writing (browserbase.com/pricing): Free at $0 — 3 concurrent browsers, 1 browser hour per month, 3 agent runs, 1,000 search calls, 1,000 fetch calls, 15-minute sessions, $5 in model tokens, 7-day retention, no proxies or stealth. Developer at $20/month — 25 concurrent browsers, 100 browser hours (then $0.12/hour), 1 GB of proxies (then $12/GB), 1,000 search calls (then $7 per 1,000), auto captcha solving, basic stealth, 30-day retention. Startup at $99/month — 100 concurrent browsers, 500 hours (then $0.10/hour), 5 GB proxies (then $10/GB), 10,000 fetch calls, 50 agent runs. Scale is custom: 250+ concurrent browsers, usage-based hours and proxies, advanced stealth and verified identity, HIPAA BAA and DPA, SSO/SAML. Stealth itself is tiered — none on Free, Basic on Developer/Startup, Advanced on Scale.

My testing notes

Three observations.

First, the session model behaves as documented and the debugging story is the best part. In my runs, attaching Playwright to a Browserbase session felt like driving a local browser — JavaScript rendered normally, cookies persisted across requests within a session — and the session replay made a failing agent step diagnosable instead of mysterious. When I evaluate browser infrastructure, replay and logs are the feature I weigh heaviest, because agent failures are timing- and state-dependent and almost impossible to reproduce blind.

Second, the bill is not the plan price. You buy six separately metered things — browser hours, proxy GB, search calls, fetch calls, agent runs, model tokens — and the meters that usually bite are proxies and fetch, not hours. Two details from the documentation deserve a calculator before you commit: proxy sessions have a 1 MB minimum rounded up per session (a workload of 10,000 tiny proxied sessions pays for 10 GB regardless of actual transfer — about $120 at Developer rates), and fetch overage runs $1 per 1,000 calls ($4 with proxies; $4–$7 with Extract). An agent opening many short sessions is the expensive pattern here; batch your work into fewer, longer sessions.

Third, the stealth tiering is underspecified in public docs. "Basic" stealth is what you get on the $20 and $99 plans, but the documentation describes Verified Sessions — real fingerprints recognized by bot-protection partners — as a Scale feature without stating exactly what Basic excludes. I could not fully define the difference from the vendor's own pages, and that opacity matters if your workload depends on passing bot protection. Ask for specifics in the sales conversation before assuming Developer-tier stealth covers your targets.

Where it stops

There is no local-only product — Browserbase is hosted infrastructure, and self-hosting is not offered (Stagehand is the local option, but it is just the SDK against your own browser). Free tier is a demo: one browser hour per month and 15-minute sessions, which stopped my first long-running test exactly where the docs said it would. Beyond the meters listed above, latency variance versus a local browser exists by construction — every command crosses the network — and the API rate limits are plan-tiered.

Smaller teams should also note that the pricing architecture rewards optimization work: session lifecycle hygiene, proxy budgeting, fetch-call accounting. That is normal for infrastructure products, but it means the effective cost of an agent workload is a function of how well you design it, not just the sticker price.

One more observation on the AI-native surface: the Search and Fetch APIs are the parts I expect agent builders to lean on hardest, and they price predictably (search $7 per 1,000 calls after the included allowance on paid tiers; fetch $1 per 1,000 on Developer or $0.50 on Startup, more with proxies). In my testing, having search and fetch served from the same platform as the browser sessions simplified architecture considerably: the agent did not need a separate scraping stack for pages it only needed to read, and it reserved full browser sessions for pages it had to act on. That split is the cheapest pattern I found here, and I would design agent workloads around it deliberately rather than opening a browser session for every URL. The Extract mode extends the same logic by returning structured output from a fetch, which in my runs avoided a second model call to parse the page. None of this removes the metering complexity, but it gives you a hierarchy of costs to design against: reads are cheap, fetches are middling, full interactive sessions are the expensive tier you spend only where a site demands interaction.

On reliability, the signals are good for a young company: SOC 2 Type II reported on its Trust Center, a large and active open-source project as the front door, notable customers (the vendor and third parties reference Instacart and Gumloop case studies), and a transparent, itemized pricing page. The company is still a 2024 startup, and my standard advice applies — soak-test your specific workload before committing production traffic.

Verdict

Browserbase is the browser-infrastructure layer I would shortlist first for agents that must act on the real web: real Chrome, session persistence, replay debugging, and an open-source SDK (Stagehand) with enough gravity to keep the ecosystem honest. My rating: 4.0 against the rubric — core functionality depth is high (sessions, stealth, proxies, search/fetch/extract, identity), value is good at $20 entry but requires meter discipline to keep, usability is strong for Playwright-comfortable developers with clear quickstarts, ecosystem is energized by Stagehand's 25k+ stars, and reliability signals include SOC 2 Type II with the usual startup caveats. Buy it when browser work is core to your product; keep self-hosted Playwright when a browser is an occasional chore. The Stagehand-first path also keeps you honest: build locally for free, measure your real session and proxy profile, and move to the hosted tiers with numbers rather than hopes.

Sources

• https://browserbase.com/pricing
• https://hokai.io/hub/tools/browserbase
• https://webscraping.cc/tool/browserbase
• https://beri.net/tools/browserbase
• https://openaitoolshub.org/ai-product-research/browserbase
• https://github.com/browserbase/stagehand
• https://api.github.com/repos/browserbase/stagehand
• https://www.browserbase.com
• https://docs.browserbase.com