Browserbase Pricing (Sep 2026): Plans, Costs & Alternatives

Browserbase has four plans: Free ($0), Developer ($20/mo), Startup ($99/mo) and Scale (custom). Each paid plan includes a block of browser hours, then bills overage at $0.10 to $0.12 per browser hour. Proxy traffic, concurrency and stealth level also change by plan. Below is the full table as of September 2026, taken from browserbase.com/pricing. After it we compare four alternatives on their own published prices: Steel, Browser Use Cloud, Hyperbrowser and Human Browser (our product).

Short version: if you only need a remote Chrome for your own Playwright or Puppeteer script, Browserbase and the other browser-infrastructure vendors are much cheaper per hour than we are. Human Browser is a better buy only when you want a finished task: an AI agent, residential IP, captcha handling and a human who can step in, all on one prepaid bill.

Browserbase pricing as of Sep 2026

Other details from the same page: Free sessions are capped at 15 minutes. Scale adds Verified Agents, HIPAA and SSO. Browserbase also runs a Model Gateway that bills LLM calls at market price. Its open-source SDK, Stagehand, is free to use. Prices change, so treat this as a September 2026 snapshot and check browserbase.com/pricing before you buy.

What Browserbase actually costs: three workloads

These are browser-time costs only, worked out from the published rates above. Your own LLM calls and any proxy traffic beyond the included GB come on top.

• 50 browser hours a month: fits inside Developer's 100 included hours, so you pay $20.
• 300 browser hours a month: Developer is $20 + 200 × $0.12 = $44. Startup would be $99, so Developer is cheaper on time alone.
• 2,000 browser hours a month: Developer is $20 + 1,900 × $0.12 = $248. Startup is $99 + 1,500 × $0.10 = $249. The two plans cost the same on time at about 2,050 hours.

So on hours alone, Developer is the better deal for most teams. People upgrade to Startup for concurrency (100 browsers instead of 25) and for the extra proxy traffic (5 GB included, then $10/GB rather than $12/GB). If your agents are heavy on residential traffic, proxy GB can end up costing more than browser hours.

Browserbase alternatives compared (Sep 2026)

Every number here comes from the vendor's own pricing page, checked on 27 September 2026. The first four are browser infrastructure: you get a remote browser and write the automation yourself. Human Browser is different. You send a goal in plain English, and our agent runs it in a real Chrome and returns the result.

A few details the table leaves out. Steel's Launch plan needs a $10 paid deposit before you can use captcha solving and proxies; its sessions run up to 15 minutes on Launch and 1 hour on Scale, and its stealth browser is Enterprise-only. Browser Use Cloud also sells hosted agents, billed at model cost plus a 20% service fee plus browser time. Hyperbrowser bills HyperAgent and Browser Use agent steps at $0.02 per step, and computer-use models per token.

Steel

Steel bills per browser hour like Browserbase. Launch has no monthly fee and $0.10/hr; Scale is $250/mo with $100 of credits a month and $0.08/hr. Captchas on Launch cost $3 per 1,000, less than Human Browser's $5 per 1,000. The core browser, steel-browser, is open source, so you can self-host it. It is a good fit if you want Browserbase-style CDP access without a monthly plan, and your sessions stay under the 15-minute Launch cap.

Browser Use Cloud

Browser Use Cloud has the lowest listed browser price here: $0.02 per hour, pay as you go, with credits from $5. Residential proxies are $5/GB. It comes from the team behind the open-source browser-use agent library and holds SOC 2 Type II. If you run your own agent loop and want the cheapest hosted browser, start here.

Hyperbrowser

Hyperbrowser uses credits (1 credit = $0.001): browsers are $0.10/hr and proxy traffic is $10/GB. Hosted agents (HyperAgent or Browser Use) are $0.02 per step. Browser time costs about the same as Browserbase's Startup overage rate.

Human Browser: when it is the better buy

Compare on cost per finished task, not cost per browser hour.

Human Browser is not browser infrastructure. You send a goal such as “log in, open the reports page, export the CSV”. Our agent drives a real headful Chrome on a residential IP, handles captchas, and returns the result. If it gets stuck, for example on a one-time code, it asks a human. The price covers all of that:

• Browser session: $0.10 per hour, billed per second. Sessions under 30 seconds are free. Time while a human has taken over in the live viewer is not billed.
• Agent: $0.02 per step with the AI included. If you pin a model whose own cost for a step is higher, that step is billed at its cost +30%. The default model is gpt-6-luna; you can also pick gpt-6-sol, the gpt-5.x family, Claude Sonnet 4.6, Claude Haiku 4.5, Claude Opus 4.8, Kimi K2 or MiniMax for each task.
• Captcha: $0.005 per solve, across 12+ types including reCAPTCHA, hCaptcha, Cloudflare Turnstile, GeeTest, FunCaptcha and Amazon WAF. If automatic solving fails, the session can be handed to a human in the live viewer.
• Residential proxy: $4/GB, on by default, sticky for each session, 75 countries to choose from.
• No subscription: a prepaid balance with no monthly minimum and no expiry. Pay by card (including Apple Pay and Google Pay) or crypto. See the refund policy for unused funds.

What a task actually costs. Measured on our production over 132 successful customer tasks in September 2026: the median task took about 8 agent steps and 4.5 billed minutes (p25 2.0, p75 8.9). Re-priced at today's rates, the median all-in cost, including steps, browser time, residential traffic and captchas, was $0.24 per task (p25 $0.12, p75 $0.39). About 13% of those tasks met a captcha.

Compare that with Browserbase. 4.5 minutes of browser time is well under a cent on either service, so the browser itself is not where the money goes. What $0.24 buys on Human Browser is everything around the browser: the agent that decides what to click, the residential IP, the captcha, and a human fallback. With Browserbase, you build and maintain that part yourself, or through Stagehand plus your own LLM bill.

Human Browser is the better buy when:

• You want task-level results (“find X, fill Y, return Z”) and do not want to write and maintain selectors.
• Your targets need a residential IP. At $4/GB, our residential traffic is cheaper than Browserbase ($10–12/GB), Steel ($6–10/GB), Hyperbrowser ($10/GB) and Browser Use Cloud ($5/GB).
• Flows sometimes need a person, for a one-time code or an unusual challenge. Human takeover in the live viewer is included, and that time is not billed.
• Your usage is spiky and a $20, $99 or $250 monthly plan would sit unused most of the month.

Choose Browserbase, Steel, Browser Use Cloud or Hyperbrowser instead if you need raw CDP access for your own scripts, a lot of browser hours, more than 10 concurrent sessions, or compliance paperwork. Browserbase Scale offers HIPAA and SSO, and Browser Use Cloud lists SOC 2 Type II. For the full side-by-side, see Human Browser vs Browserbase, and see Human Browser pricing for every rate.

Code: a Browserbase session vs a Human Browser task

These two approaches work differently, so this is not a drop-in swap. With Browserbase you connect Playwright to a remote browser and write every step yourself. With Human Browser you describe the goal and get back the result. There is no CDP or WebSocket URL to attach to.

With Browserbase (you drive the browser)

import Browserbase from '@browserbasehq/sdk';
import { chromium } from 'playwright-core';

const bb = new Browserbase({ apiKey: process.env.BROWSERBASE_API_KEY });

async function scrapeWithBrowserbase(url) {
  // A remote Chrome session, billed by browser time
  const session = await bb.sessions.create({
    projectId: process.env.BROWSERBASE_PROJECT_ID,
    proxies: true   // Browserbase proxy: 1 GB on Developer, then $12/GB
  });

  // You drive it yourself over CDP — your script, your selectors
  const browser = await chromium.connectOverCDP(session.connectUrl);
  const page = browser.contexts()[0].pages()[0];
  await page.goto(url);
  const content = await page.evaluate(() => document.body.innerText);

  await browser.close();
  return content;
}

With Human Browser (you send a goal): A2A over curl

curl -X POST https://agent.humanbrowser.cloud/a2a \
  -H 'Authorization: Bearer hb_live_xxxx' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0", "id": 1, "method": "message/send",
    "params": {
      "message": { "role": "user",
        "parts": [{"kind":"text","text":"Open news.ycombinator.com and return the top 5 story titles as JSON."}] },
      "metadata": { "country": "us" }
    }
  }'

# The result carries a task id, metadata.session_id and metadata.viewer_url.
# Poll until the task is completed:
curl -X POST https://agent.humanbrowser.cloud/a2a \
  -H 'Authorization: Bearer hb_live_xxxx' -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tasks/get","params":{"id":"<task id from result.id>","wait_seconds":30}}'

The same call from Node

// Node 18+ (global fetch). Same A2A call as the curl above.
const A2A = 'https://agent.humanbrowser.cloud/a2a';
const headers = {
  'Authorization': 'Bearer ' + process.env.HB_TOKEN,   // hb_live_...
  'Content-Type': 'application/json'
};

async function rpc(id, method, params) {
  const res = await fetch(A2A, {
    method: 'POST', headers,
    body: JSON.stringify({ jsonrpc: '2.0', id, method, params })
  });
  return (await res.json()).result;
}

async function runTask(goal, country = 'us') {
  let task = await rpc(1, 'message/send', {
    message: { role: 'user', parts: [{ kind: 'text', text: goal }] },
    metadata: { country }                // also: profile, mobile_ua, model
  });
  console.log('Watch live:', task.metadata?.viewer_url);

  // working -> input-required (asks a human, e.g. for an OTP) -> completed | failed | canceled
  while (['submitted', 'working'].includes(task.status?.state)) {
    task = await rpc(2, 'tasks/get', { id: task.id, wait_seconds: 30 });
  }
  return task;
}

runTask('Open example.com/product/123 and return title, price and availability as JSON.')
  .then(t => console.log(t.status.state, JSON.stringify(t.artifacts ?? t.status, null, 2)));

The metadata options are country (an ISO code), profile (a named profile that keeps cookies and logins between runs), mobile_ua and model. Tasks move from working to completed, failed or canceled. They pass through input-required when the agent needs something from a human. Every response includes a viewer_url, where you can watch the session live or take it over.

Or plug it into an MCP client

Claude Code, Cursor and other MCP clients can call Human Browser as a tool. Add it as a remote MCP server, or run npx -y @virixlabs/humanbrowser mcp locally with HB_TOKEN set. See the MCP docs.

{ "mcpServers": { "humanbrowser": {
    "url": "https://agent.humanbrowser.cloud/mcp",
    "headers": { "Authorization": "Bearer hb_live_..." } } } }

How to test before you switch

1. Sign up at humanbrowser.cloud/install with an email and make a $1 first top-up by card. That is enough for about 4 typical tasks.
2. Choose one Browserbase flow that currently breaks or needs upkeep, such as a login, a form, or a site that blocks you. Write it as one plain-English goal.
3. Send it with message/send, open the viewer_url, and watch it run.
4. Compare cost per completed task, not cost per hour. Keep Browserbase for the jobs where your own script already works cheaply.

For the wider field, see the comparison of the best cloud browsers for AI agents. For agent design patterns, see browser automation for AI agents.

FAQ

Related Articles

• Human Browser vs Browserbase (2026): Pricing & Features
• Browserbase Pricing Explained: Worked Examples
• Browser Automation for AI Agents: OpenClaw + Playwright 2026
• Best Web Scraping Tools for AI Agents in 2026