Scrapybara vs Browserbase for agentic workflows

The Scrapybara vs Browserbase decision has become the cleanest fork in the road for any team building agentic workflows in 2026. Both are managed cloud platforms designed for AI agents to drive real browsers and operating systems. They overlap on the surface and diverge significantly in philosophy. Browserbase is a browser cloud, period. Scrapybara is a virtual desktop cloud that happens to include a browser.

That difference shows up everywhere. This guide compares both platforms through the lens of an engineer building a scraping or research agent in 2026, with code, benchmarks, and a clear picture of which one fits which problem.

What each platform actually is

Browserbase gives you a Chromium browser session over a Playwright-compatible WebSocket endpoint. You write Playwright or Stagehand code, you connect to a managed session, you scrape. The platform handles fingerprinting, proxies, CAPTCHA solving, and observability. Browser-only.

Scrapybara gives you a full Ubuntu desktop in the cloud with a browser, a terminal, a file system, and X11. Your agent can launch any application, not just a browser. The platform exposes a Computer Use API directly compatible with Anthropic’s Claude Computer Use and OpenAI’s Operator.

If your agent only needs the web, Browserbase is the leaner choice. If your agent needs to download a file, manipulate it in a desktop application, or run a CLI tool, Scrapybara is the only real option.

Pricing in 2026

Both are usage-based but with different units.

Browserbase:

Scrapybara:

A like-for-like comparison: 1000 sessions averaging 3 minutes each.

Scrapybara is meaningfully cheaper on compute. Browserbase costs more but includes residential proxies, CAPTCHA solving, and the Stagehand framework as native primitives.

Mental model in one sentence each

Scrapybara is “give me a Linux box my agent can drive.” Browserbase is “give me a Chrome tab my agent can drive.”

If you find yourself wishing the agent could apt install ffmpeg and then run a CLI tool on a downloaded video, Scrapybara fits. If you find yourself wishing the agent could click around five sites and emit JSON, Browserbase fits.

Setup speed

Both platforms ship in minutes.

Browserbase:

import { Browserbase } from "@browserbasehq/sdk";
import { chromium } from "playwright";

const bb = new Browserbase({ apiKey: process.env.BROWSERBASE_API_KEY! });
const session = await bb.sessions.create({ projectId: process.env.BROWSERBASE_PROJECT_ID! });
const browser = await chromium.connectOverCDP(session.connectUrl);
const page = browser.contexts()[0].pages()[0];

await page.goto("https://example.com");
console.log(await page.title());

await browser.close();

Scrapybara:

from scrapybara import Scrapybara

client = Scrapybara(api_key="scrapy_...")

instance = client.start_ubuntu()
instance.bash(command="echo hello")
instance.computer.screenshot()  # returns base64 PNG of the desktop
instance.browser.start()
instance.browser.goto("https://example.com")
title = instance.browser.evaluate("document.title")
print(title)

instance.stop()

Browserbase ships a Playwright-compatible API, so any existing Playwright code drops in. Scrapybara ships a richer API with desktop primitives, but your existing Playwright code needs adaptation.

Latency to first action

Cold-start times measured March 2026:

Browserbase wins on latency because it boots only Chromium. Scrapybara boots a whole desktop. For pure browser workloads, the latency cost on Scrapybara is real. For multi-app workloads, the latency is amortized over a longer session.

Computer Use integration

This is where Scrapybara pulls ahead for agentic workflows.

Scrapybara is built specifically as a Computer Use target. Anthropic’s Claude Computer Use API and OpenAI’s Operator both plug into Scrapybara as the underlying compute environment.

from scrapybara import Scrapybara
from anthropic import Anthropic

client = Scrapybara(api_key="scrapy_...")
instance = client.start_ubuntu()
anthropic = Anthropic()

response = anthropic.beta.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,
    tools=[{
        "type": "computer_20241022",
        "name": "computer",
        "display_width_px": 1024,
        "display_height_px": 768,
    }],
    messages=[{
        "role": "user",
        "content": "Open the browser, search Google for 'browserbase pricing', and return the first result URL."
    }],
    betas=["computer-use-2024-10-22"],
)

# loop: feed Claude's tool calls into instance.computer.* and feed back

Browserbase, by contrast, supports Computer Use only through the Stagehand agent primitive, and only for the browser. If your agent needs to open Excel, manipulate files in a terminal, or interact with desktop apps, Browserbase cannot help.

For more on Computer Use vs Operator, see our OpenAI Operator vs Anthropic Computer Use comparison.

Browser primitive depth

Where Browserbase is more polished is the browser experience. Stagehand is theirs, and it shows.

Browserbase + Stagehand:

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

const stagehand = new Stagehand({ env: "BROWSERBASE", modelName: "gpt-4o-mini" });
await stagehand.init();
const page = stagehand.page;
await page.goto("https://news.ycombinator.com");

const top = await page.extract({
  instruction: "Top 5 stories with title, score, submitter",
  schema: z.object({
    stories: z.array(z.object({ title: z.string(), score: z.number(), submitter: z.string() })),
  }),
});
console.log(top);
await stagehand.close();

Scrapybara has a browser API but no equivalent of Stagehand’s extract. You bring your own LLM extraction layer.

For the Stagehand vs Playwright story, see Stagehand vs Playwright for AI scraping.

Side-by-side comparison

The two products are complementary more than competitive. Scrapybara is the right pick when your agent needs to do anything outside a browser. Browserbase is the right pick when your work fits in a browser and you want the most polished AI-native experience.

Computer Use action loop on Scrapybara

The actual loop that drives Claude Computer Use against a Scrapybara instance is simple but worth seeing in full.

def computer_action(action_input):
    if action_input["action"] == "screenshot":
        return instance.computer.screenshot()
    elif action_input["action"] == "left_click":
        x, y = action_input["coordinate"]
        return instance.computer.left_click(x=x, y=y)
    elif action_input["action"] == "type":
        return instance.computer.type(text=action_input["text"])
    elif action_input["action"] == "key":
        return instance.computer.key(text=action_input["text"])
    # ... more actions

messages = [{"role": "user", "content": "Open the browser and search Hacker News"}]
while True:
    resp = anthropic.beta.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=4096,
        tools=[{"type": "computer_20241022", "name": "computer",
                "display_width_px": 1024, "display_height_px": 768}],
        messages=messages,
        betas=["computer-use-2024-10-22"],
    )
    if resp.stop_reason == "end_turn":
        break
    for block in resp.content:
        if block.type == "tool_use":
            result = computer_action(block.input)
            messages.append({"role": "assistant", "content": resp.content})
            messages.append({"role": "user", "content": [{
                "type": "tool_result", "tool_use_id": block.id, "content": result,
            }]})

The loop is roughly 30 lines and works for any Computer Use task. Browserbase has an analogous loop but only for browser actions.

Real production patterns

We ran two pipelines in parallel to compare.

Pipeline A: scrape Lazada and Shopee product listings, extract to Postgres. Pure browser work.

Pipeline B: download invoice PDFs from a supplier portal, extract line items with a vision model, push to a procurement system. Needs file download and PDF processing.

Pipeline A on Browserbase + Stagehand:

• Time to working code: 2 hours
• Cost per 1000 products: $6 (compute) + $4 (residential proxy) + $2 (LLM)
• Maintenance burden: low

Pipeline A on Scrapybara:

• Time to working code: 4 hours (had to wire LLM extraction layer)
• Cost per 1000 products: $4 (compute) + $4 (BYO proxy) + $2 (LLM)
• Maintenance burden: medium

Pipeline B on Browserbase: not feasible. The browser cannot natively process the downloaded PDFs.

Pipeline B on Scrapybara:

• Time to working code: 5 hours
• Cost per 1000 invoices: $9 (compute, longer sessions) + $3 (proxy) + $5 (vision model)
• Maintenance burden: medium

Detailed pipeline metrics

The pipelines above ran for 30 days each. Aggregate numbers:

Browserbase’s higher cost was offset by lower incident count. Scrapybara’s lower cost came with more operational overhead because the BYO proxy layer needed its own monitoring. The pipeline B numbers are for a fundamentally different workload (PDF processing) where Scrapybara was the only option.

Where each platform showed weakness

Browserbase’s main weakness was the proxy markup. Halfway through the test, we switched the highest-volume target to BYO proxies through the session API, which dropped the proxy cost line by roughly 60 percent. The platform supports BYO but the docs do not lead with it.

Scrapybara’s main weakness was the lack of an extraction primitive. We had to wire OpenAI structured output ourselves, which added roughly two hours of development time per new target. The Scrapybara team has hinted at native extraction primitives in 2026 H2 but as of writing it is still BYO.

Adding proxies

Both platforms support proxies, but the integration depth differs.

Browserbase ships first-party residential proxies billed at $8/GB and stealth (datacenter) at $0.30/GB. Set them at session creation:

const session = await bb.sessions.create({
  projectId: process.env.BROWSERBASE_PROJECT_ID!,
  proxies: true, // or pass an explicit proxy config
});

Scrapybara expects you to bring your own. Configure inside the instance:

instance.browser.start(proxy={"server": "http://proxy.example.com:8000", "username": "u", "password": "p"})

For ASEAN scraping where mobile carrier IPs matter, Singapore mobile proxy plugs into either platform with one config block.

Geographic coverage

Browserbase: US East, US West, EU West, APAC South (Singapore). Compute always in one of these regions; proxies cover roughly 195 countries.

Scrapybara: US East, US West, EU West. APAC region is on the roadmap as of mid-2026. For Asia-targeted scraping, latency is higher than Browserbase.

CAPTCHA story in detail

Browserbase ships built-in solvers for reCAPTCHA v2/v3, hCaptcha, and Cloudflare Turnstile, with quoted success rates of 88 to 95 percent depending on type.

Scrapybara has no built-in CAPTCHA solving. You wire 2Captcha, CapSolver, or a similar service. The integration takes maybe 50 lines of code, but it is friction the Browserbase user does not have.

For teams that scrape CAPTCHA-heavy targets (LinkedIn, Indeed, several banking portals), Browserbase’s built-in solver is a real time-saver. For targets without CAPTCHAs (most B2B SaaS apps you have legitimate credentials for), the difference is irrelevant.

Observability

Both ship session replay with video and event traces. Browserbase’s UI is more polished and the search across sessions is faster. Scrapybara’s replay shows the full desktop, which is more useful when your agent uses non-browser apps.

Both export OpenTelemetry spans for trace correlation with your existing observability stack.

Security and isolation

Browserbase sessions run in ephemeral containers with full process isolation. Cookies, storage, and any cached state are wiped at session end unless you opt into context persistence. Network egress is funneled through the platform’s IP pool by default.

Scrapybara instances are full Ubuntu VMs with disk persistence per instance ID. This is more powerful and more dangerous: a compromised agent that gets shell access on a Scrapybara instance can persist files there, install software, and reuse the state across runs. For sensitive workloads, treat Scrapybara instances as ephemeral and tear them down explicitly.

Both platforms hold SOC 2 Type II reports as of 2026 and offer DPAs for GDPR-relevant workloads. Neither is yet HIPAA-eligible, so healthcare scraping requires self-hosting.

SDKs and language ecosystem

Browserbase’s primary SDK is TypeScript. The Python SDK exists but lags by roughly one release. For TypeScript-heavy teams, the platform feels native; for Python teams, less so.

Scrapybara’s primary SDK is Python. The TypeScript SDK exists but covers fewer features. For Python-heavy teams (most data science and AI shops), this is the natural fit.

If your team is split or polyglot, Browserbase wins because its WebSocket endpoint speaks any Playwright client. Scrapybara is more SDK-locked because the Computer Use primitives are first-class only in their SDKs.

Production recommendations

Use Browserbase if:

• Your scraping is browser-only
• You want Stagehand as your AI primitive layer
• You value built-in CAPTCHA solving
• You prefer a TypeScript-first SDK

Use Scrapybara if:

• Your agent needs file system, terminal, or desktop access
• You are running Claude Computer Use or OpenAI Operator
• You want lower per-hour compute cost and BYO proxy
• You prefer a Python-first SDK

The mature pattern in 2026 is to use both: Browserbase for the high-volume browser scraping, Scrapybara for the agent workflows that go beyond the browser. They cost together about what one Browserbase Startup plan costs, and you cover both shapes of work.

For broader context on the agentic browser space, see our agentic browser revolution guide.

Decision matrix

Frequently asked questions

Can I run my own LLM extraction prompts on Scrapybara?
Yes. Scrapybara just exposes the underlying compute. Wrap your favorite LLM (OpenAI, Anthropic, local) and call it from your agent code.

Are there any Scrapybara features Browserbase has copied or is likely to copy?
Both platforms ship session replay, both ship persistent contexts. Browserbase has hinted at adding limited terminal access on Scale plans but has not shipped. Scrapybara has hinted at native extraction primitives. Convergence is happening slowly.

Does Browserbase have a Python SDK?
Yes, but the TypeScript SDK is more feature-complete. For the latest features, TypeScript is the better choice in early 2026.

Can Scrapybara run alongside other browser frameworks?
Yes. The Scrapybara browser is a real Chromium that speaks CDP. You can drive it from Playwright, Puppeteer, or any browser automation library.

What about Hyperbrowser, Steel.dev, and other competitors?
Hyperbrowser is closest to Browserbase in shape but smaller. Steel.dev sits between Browserbase and Scrapybara on capabilities. Both are valid alternatives if pricing or feature set fits better.

How does authentication work for sites that need login?
Both platforms support persistent contexts that store cookies and localStorage. Save once after manual login, reload on each session. For higher-throughput pipelines, store the context state encrypted in your secret store.

Can I expose a Scrapybara instance to the public internet?
Not directly. The instance is private to the Scrapybara network. To expose a service running on the instance, tunnel through ngrok or a similar reverse proxy from inside the instance.

What are the per-instance resource limits on Scrapybara?
Default Hobby tier: 2 vCPU, 4 GB RAM, 20 GB disk. Pro: 4 vCPU, 8 GB RAM, 50 GB disk. Scale: negotiated. For most browser-driving tasks, Pro is sufficient. For video processing or large data jobs, request a custom config.

Can either platform handle file uploads to a target site?
Both can. Browserbase exposes the standard Playwright setInputFiles API. Scrapybara supports the same plus drag-and-drop from the desktop file system.

What about secrets management?
Neither platform provides a secrets vault. Pass secrets via environment variables to your code, or pull from your own secrets manager (AWS Secrets Manager, HashiCorp Vault, Doppler) before passing to the platform.

Can I use both platforms in the same workflow?
Yes. A common pattern is to use Browserbase for the high-volume scraping leg and Scrapybara for the post-processing leg that involves file manipulation. They are complementary by design.

Common production gotchas

For Browserbase: forgetting to release sessions burns minutes; mismatched proxy and target region triggers cloaking; the LLM bill hides separately on your OpenAI account.

For Scrapybara: the desktop is a real Ubuntu so resource leaks (lingering processes, large temp files) accumulate across long-lived instances; explicitly stop instances when done; mount your file output to a known location for export rather than relying on the temp file system.

For both: session replay retention is finite. Export critical traces if you need them long-term. The platforms do not retain everything indefinitely.

Six-month verdict

After running both side by side for six months: Browserbase wins for any team where 100 percent of work is browser-based. The polish and Stagehand integration are worth the premium. Scrapybara wins for any team where even 20 percent of work goes outside the browser, because that 20 percent is otherwise blocking. The right answer for many teams is to use Browserbase as the default and reach for Scrapybara when the task explicitly needs OS access.

If you are deciding between agentic platforms, the AI modern scraping category has more reviews and head-to-head comparisons that can help anchor the decision.