Browserbase and Stagehand reviewed: rented Chrome for AI agents

Browserbase sells rented Chrome: sessions that start quickly, run behind a proxy network, and can be driven over the Chrome DevTools Protocol by Playwright, Puppeteer or Selenium. Stagehand is the SDK the same company keeps on top of it, adding three natural-language primitives to that control surface. The position taken here: this is the right pair for production browser agents that have to survive sites changing underneath them, and the wrong pair for anyone who wants a fixed monthly cost, because every interesting feature is metered separately.

It sits where an agent framework needs hands. LangChain, CrewAI and Mastra decide; Stagehand clicks. What it replaces is the in-house browser farm: a pool of headless instances, a proxy subscription, a captcha service and a session recorder, all of which Browserbase folds into one hourly rate. The competition it faces hardest is not another cloud browser but a plain Playwright suite running on a machine somebody already pays for.

What it is

Two products ship under one vendor. Browserbase is the infrastructure: managed Chromium, proxies, session recording, identity features and HTTP endpoints for search, fetch and extraction. Stagehand is the automation library, MIT-licensed, published as 4.1.0 on npm, with TypeScript, Python and Go SDKs of equal scope.

• Vendor: Browserbase, Inc.; Stagehand is maintained in the open at github.com/browserbase/stagehand under the MIT licence.
• Browser time: billed by the minute with a one-minute minimum per session; the free plan allows 15 minutes per session, paid plans 6 hours.
• Concurrency: 3 sessions free, 25 on Developer, 100 on Startup, 250+ on Scale, with session creation capped at 5, 25, 50 and 150 per minute.
• Stagehand API: act, extract and observe for model-driven steps, plus Playwright-style page and locator methods for everything that should not involve a model.
• Runtime: drives Chromium over CDP directly, with no Playwright dependency since v3, and runs its extension inside the browser since v4.
• Languages: TypeScript, Python and Go, with Node 22.18 or newer required by the npm package.
• Add-ons: a hosted MCP server, Search and Fetch endpoints, session recording, residential proxies, and a Model Gateway that bills models at market price.

How it works

A session is a Chromium instance somewhere else. The SDK opens a CDP connection to it, and since version 4 the state that used to be mirrored in the client — target tracking, frame contexts, dispatch — lives in an extension loaded next to the page, so the client reads the truth instead of a copy of it. Model calls happen only where the code asks for them: an act or extract request builds a trimmed view of the page, sends it to a model, and turns the answer into CDP commands.

The split matters for cost as much as for architecture. Deterministic steps — a selector you already know — cost nothing beyond the browser minute. Model-driven steps cost a completion each, and the vendor's caching layer exists because teams were paying for the same click twice.

The three primitives

The pitch is that a script can decide, step by step, how much of a page it understands. The documentation is explicit that the design is hybrid: natural language where the DOM is unfamiliar, code where the selector is stable.

• act("click the login button") executes one natural-language instruction and self-heals when the markup moves.
• extract(prompt, schema) returns typed data validated against a Zod or Pydantic schema rather than free text.
• observe(instruction) returns candidate actions carrying real selectors, which is also the way to keep credentials out of the prompt.
• page and locator give goto, click, fill, screenshot and frame traversal with no inference involved.

The order the documentation recommends is observe first, then act: discovery costs one completion, and the resulting action can be cached and replayed as a plain command. That is where the running cost of an agent on Browserbase actually lives — not in the browser hour, but in repeated inference on pages that have not changed.

Getting started

The quickstart runs against local Chrome with a model key of your own; swapping the browser for browserbase.launch() is the only change needed to move the same script into the cloud. The snippet below does both halves of the job: a natural-language step and a typed extraction, with a deterministic click at the end.

import { browserbase, Stagehand } from "@browserbasehq/stagehand";
import { z } from "zod/v4";

const browser = await browserbase.launch({ apiKey: process.env.BROWSERBASE_API_KEY! });
const stagehand = await Stagehand.create({ browser, cache: true });
const [page] = await browser.context.pages();

await page.goto("https://example.com/pricing");

// natural language step, answered from cache when it repeats
await stagehand.act("open the plan comparison table");

// typed extraction: validated against the schema, not just prompted
const { data } = await stagehand.extract(
  "extract every plan and its monthly price",
  z.object({ plans: z.array(z.object({ name: z.string(), price: z.string() })) }),
);
console.table(data.plans);

// deterministic step: a real selector, no model involved
await page.locator('a[href="/docs"]').click();

await stagehand.close();
await browser.close();

Note what the last two calls do: the extraction is validated against a schema, so a missing price is an exception rather than a sentence to parse, and the final click never reaches a model at all. The pattern worth copying is the ratio — inference for the parts of the page nobody has mapped, locators for the parts that are known.

Pricing

Four plans, three of them public. Browser hours, proxy bandwidth, agent runs and Search or Fetch calls each get a monthly allocation and then an overage rate; nothing is hard-capped, so a heavy month bills more rather than failing.

The arithmetic is easy to get wrong. Three hundred raw browser hours a month on Developer is $20 plus 200 hours of overage at $0.12, or $44; the same 500 hours on Startup are covered by the subscription. Proxy traffic is the second variable: 1 GB is included at Developer and 5 GB at Startup, then $12 and $10 a gigabyte respectively, which is the line that catches teams running residential IPs through login flows.

Identity and detection

Getting a browser past a site that does not want automation is a product line in its own right here, and it is tiered by plan rather than sold separately.

• Stealth: none on Free, Basic on Developer and Startup, Advanced with Verified identity on Scale.
• Captcha solving: automatic on every paid plan, absent on Free.
• Proxies: managed residential traffic is metered by the gigabyte, and a custom proxy provider can be configured instead.
• Compliance: SOC 2 on all plans; HIPAA with a BAA, a DPA and SSO only on the Scale plan.

This is the part to be sceptical about. Anti-bot defence is rented rather than solved: the tiers describe what the vendor applies, not a success rate, and the published numbers come from vendors with an interest in the answer. A comparison published by Browser Use on 21 September 2026 put Browserbase on Basic Stealth at 42% against its own 81% on one stealth benchmark, and at 70.3% against 84.8% on another. The engineering conclusion is not that Browserbase is weak, but that detection is a moving target nobody should price into a fixed SLA.

Where it shingles

The weaknesses are structural rather than incidental. Every component outside the SDK is proprietary: a year of local Stagehand still leaves no self-hosted equivalent of the proxy pool, the stealth layer, the captcha solver or the session recorder, because the free plan itself stops at 1 hour and 3 concurrent sessions. The pricing carries three meters — browser hours, proxy gigabytes and model tokens — and publishes no estimate of what a realistic agent workload costs per completed task. On-premises deployment is not offered; the documentation answers that question with regions and consulting.

Read against those, the honest summary is that Browserbase competes on operational maturity and loses on unit price: Browser Use lists browser time at $0.02 an hour against $0.10 to $0.12 of overage, a fivefold gap that only matters once the included hours run out. Playwright stays free and unbeatable when nothing in the flow needs to understand a page it has never seen.

Verdict

Buy Browserbase for the fleet and treat Stagehand as an optional layer on top of it, not as the reason to subscribe. The SDK is free to keep, the infrastructure is not, and the metering scheme rewards teams that know which steps need a model.

1. Use it when agent flows have to log in, survive redesigns and run unattended across sites nobody on the team controls.
2. Use it when the alternative is assembling proxies, captcha solving and session recording in house; those components are what the hourly rate buys.
3. Skip it when every page in the workflow is known in advance: a Playwright suite and a cheap virtual machine will be both faster and cheaper.
4. Skip it when the budget has to be fixed per task; browser minutes plus proxy traffic plus gateway tokens never total a predictable number without instrumentation.
5. Start on Developer rather than Free: 1 hour and 15-minute sessions are enough to write the script and not enough to test it.

Browserbase is browser time with the boring parts included; Stagehand is a free library that spends tokens only where it is allowed to. Judge the first on price per completed flow and the second on how few completions each flow needs.

Sources

1. Browserbase pricing — plan limits, overage rates and the capability table
2. Browserbase plans and pricing docs — browser allocations, session duration and creation caps, retention and compliance by plan
3. Stagehand documentation — the act, extract and observe primitives and the Playwright-style page API
4. Stagehand quickstart — local launch, schema-typed extraction and the swap to browserbase.launch()
5. Stagehand v4 announcement — the extension architecture, the cache rename and the measured round-trip numbers
6. Stagehand repository — MIT licence, install commands and the hosted MCP server
7. Browser Use comparison of the two vendors — the September 2026 stealth, latency and price figures used in this review
8. Browser Use pricing — browser-hour and proxy rates in the comparison table
9. Skyvern pricing — credit allowances and concurrency in the comparison table
10. Playwright — the free alternative and its MCP server and CLI