Browserbase Pricing Explained, and Cheaper Cloud Browsers for AI Agents

Short answer: Browserbase has four plans: Free ($0, 1 browser hour, 3 concurrent browsers), Developer ($20 a month, 100 hours, 25 concurrent), Startup ($99 a month, 500 hours, 100 concurrent) and a custom Scale plan. Extra hours cost $0.12 on Developer and $0.10 on Startup. Steel charges $0.08 to $0.10 per browser hour, and Cloudflare Browser Run includes 10 hours a month on Workers Paid, then $0.09 an hour. The hourly rate is rarely what decides your bill, though. Concurrency, session length, proxy bandwidth and CAPTCHAs usually do, and if your agent only needs to read pages, you may not need a browser session at all.

Prices are each provider's published list rates in October 2026; sources are at the end.

First, what is a "browser hour"?

It's exactly what it sounds like: one hosted Chrome running for one hour, whether it is busy or sitting on a login page waiting for your code to wake up. Every provider here meters time, so the single most expensive line of code in browser automation is the one you forgot to write: browser.close().

Browserbase meters by the minute with a one-minute minimum per session. Its own rule of thumb is that a typical scrape runs under two minutes, so 100 hours covers roughly 3,000 page-level tasks.

How Browserbase pricing works

Each plan bundles allowances, then charges overage:

• Browser hours: 1 on Free, 100 on Developer, 500 on Startup. Overage is $0.12 an hour on Developer and $0.10 on Startup.
• Concurrency: 3, 25 and 100 browsers at once. Startup also caps session creation at 50 a minute, so ramping from zero to 100 browsers takes about two minutes.
• Proxies: none on Free, 1 GB on Developer, 5 GB on Startup, then billed per GB (around $12 per GB on Developer).
• Session length: 15 minutes on Free.
• Search, Fetch and Extract APIs: separate meters. Search overage is $7 per 1,000 calls; Fetch is $1 per 1,000 ($4 with proxies); Extract is $4 per 1,000 ($7 with proxies).

Rule of thumb. Pick the plan by peak concurrency, then check the hours. Hours are easy to buy more of. Concurrency is a wall.

What it actually costs

Three workloads, priced on published rates before proxies and CAPTCHA solving:

What that table politely hides:

• Concurrency decides your plan more than hours do. At 500 hours a month, Developer looks cheaper than Startup ($68 against $99), but it stops at 25 browsers at once. If a nightly batch has to finish before breakfast, you're on Startup whatever the hours say. Steel's Launch plan allows 10 concurrent sessions, and Cloudflare charges $2 a month for each concurrent browser beyond 10.
• Proxies can outweigh browser time. Sites that block datacenter IPs need residential proxies, billed per GB. A modern page can easily weigh 2–5 MB with images and scripts, so 100,000 page loads can mean hundreds of GB. At $6–$12 per GB, that line can be bigger than the browser-hour line.
• CAPTCHAs are billed per thousand solves, and hard targets throw a lot of them.
• Minute minimums punish tiny sessions. A 10-second check billed as a full minute costs six times what it "should."

A quick proxy sanity check

Say each session loads 10 pages at 3 MB each, through residential proxies:

Blocking images, fonts and media in your automation code is often the biggest single saving available. In Playwright:

page.route("**/*", lambda route: route.abort()
           if route.request.resource_type in ("image", "media", "font")
           else route.continue_())

The alternatives

Steel

Steel is an open-source browser API you can also self-host.

• Launch: $30 of one-time credit (about 300 browser hours, valid 90 days), then $0.10 an hour, 10 concurrent sessions, 15-minute sessions.
• Scale: $250 a month including $100 of usage, $0.08 an hour, 100 concurrent sessions, one-hour sessions and dedicated IPs.
• Enterprise: 1,000+ concurrent sessions of up to 24 hours.
• Extras: proxies from $6 per GB, CAPTCHA solves from $1 per 1,000.

The self-hosting option is the real draw: if you'd rather run the fleet yourself, the code is there.

Cloudflare Browser Run

Cloudflare's Browser Run, formerly Browser Rendering, runs headless Chrome on Cloudflare's network.

• Free: 10 browser minutes a day and 3 concurrent browsers.
• Workers Paid: 10 hours a month included, then $0.09 an hour, plus $2 a month for each concurrent browser beyond 10, averaged over the month.
• Quick Actions (screenshot, PDF, markdown, scrape) bill browser time only.

It is the cheapest per hour here at volume. The catches: it lives inside Workers, and proxies and CAPTCHA solving aren't bundled, so hard targets need extra plumbing.

Others worth a look

• Browser Use Cloud: hosts the open-source Browser Use agent framework.
• Hyperbrowser and Anchor Browser: both aimed at AI agents.

Their pricing models differ enough (pure metering, bundles, per-session pricing) that you should price each against your own session length and concurrency.

browserfoundry

browserfoundry leases a disposable stealth Chrome with one call, POST /api/v2/browsers/lease, handed over in under a second. Two modes:

• cdp (default) returns a wsEndpoint for Playwright, Puppeteer or raw DevTools.
• mcp returns an MCP endpoint with about 37 browser tools, so an agent can drive the browser directly without you writing automation code.

Set proxy: "auto" and the lease gets a dedicated residential IP that stays the same for the whole session, which keeps logins and carts from tripping "new location" checks. All state (cookies, storage, fingerprint) is wiped on release, so nothing leaks between jobs.

Pricing: 5 credits per started minute, plus 1 credit per 15 MB of bandwidth, settled at release. Leases need a paid plan. Depending on the plan, that's about $0.24 to $0.72 per browser hour. That's more per hour than the others above. The difference is bandwidth: 1 credit per 15 MB works out to roughly $0.05 to $0.16 per GB, against $6 to $12 per GB for proxies elsewhere. So browserfoundry is the expensive option for long, idle sessions and the cheap one for short, heavy sessions through residential IPs.

import os, requests
from playwright.sync_api import sync_playwright

lease = requests.post(
    "https://api.keirolabs.cloud/api/v2/browsers/lease",
    headers={"Authorization": f"Bearer {os.environ['KEIRO_API_KEY']}"},
    json={"mode": "cdp", "proxy": "auto"},
    timeout=30,
).json()

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(lease["wsEndpoint"])
    page = browser.contexts[0].new_page()
    page.goto("https://example.com/login")
    print(page.title())
    browser.close()
# then release it: DELETE /api/v2/browsers/lease/{id}, so the minutes stop

And for pages that only need rendering: POST /api/v2/browsers/fetch spins up a fresh stealth browser, runs the page's JavaScript, returns markdown, HTML, text or links, and throws the browser away. 2 credits flat per page, no lease to manage. Renders that time out at 45 seconds are refunded.

Do you need a cloud browser at all?

Often not. A full session is the most expensive way to get a web page into an agent. You need one when the agent has to:

• log in, click, type or fill forms
• wait for content that appears after user actions
• get through flows that only work in a real browser

The pattern that keeps bills sane: search first, extract second, and lease a browser only for the few pages that need interaction. See the ways to turn a URL into markdown and what web search costs inside the LLM APIs.

Connecting Playwright to any remote browser

Every provider here gives you a CDP WebSocket URL per session. Your existing Playwright code connects to it instead of launching Chrome locally:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(CDP_URL)  # from your provider
    context = browser.contexts[0] if browser.contexts else browser.new_context()
    page = context.new_page()
    try:
        page.goto("https://example.com/login", timeout=30_000)
        print(page.title())
    finally:
        browser.close()  # always, even when the page throws

Five ways to burn money on cloud browsers

1. Forgetting to close sessions. Use try/finally, and set a session timeout on the provider side as a backstop.
2. Loading every image through a residential proxy. Block images, media and fonts unless you need them.
3. Using a browser to read static HTML. A plain HTTP request or an extraction API is 10–100× cheaper.
4. Sizing on hours instead of concurrency. You'll discover the concurrency wall at 2 a.m., mid-batch.
5. One browser per page. Reuse a session for pages on the same site; opening a fresh one each time pays the startup cost and the minute minimum again.

How we put this together

Plans and rates come from each provider's own pages as published in October 2026: Browserbase pricing and plan docs, Steel's pricing and limits, Cloudflare Browser Run pricing, and browserfoundry's pricing and API docs. Workload and proxy costs are arithmetic on those list prices, before taxes, with the page weights stated. Prices change, so check the live pages before you commit; we update this post when they move.