/ 13 min read / Hussien Hussien

What Is Browser as a Service (BaaS)? A Developer's Guide

Browser as a service is managed Chromium infrastructure your automation connects to over CDP, replacing browser fleet operations.

A Playwright script that passes on a laptop often fails on live sites because the browser fingerprint, the network, or the login state differs. Browser as a service exists to close that gap.

The engineering time spent keeping browsers healthy, rotating proxies, and solving CAPTCHAs is time not spent on the agent itself. This guide defines BaaS, breaks down its components, compares managed and self-hosted approaches, and gives criteria for deciding when it fits.

The technical components of BaaS platforms

Managing browser state and proxies

Browser state in a BaaS context means cookies, local storage, session storage, and IndexedDB. A session context is a captured copy of that state, saved so a later session can reuse it. When you run automation against real sites, this state determines whether a login persists between runs.

Proxy rotation breaks state because a session cookie tied to one IP address fails when the IP changes. A login that works on run one fails on run two because the browser appears to be a different user.

BaaS platforms handle this with three options. Stored credentials let the browser fill login forms without putting a password in the prompt. Captured session context preserves authentication state, so a browser starts already signed in. Persistent profiles hold a snapshot of the browser's full User Data Directory, up to 300 MB, and are deleted after 30 idle days. A saved profile does not guarantee a valid login, because sites invalidate sessions for their own reasons.

The Steel session context documentation covers how to capture and reuse authentication state.

Anatomy of a managed browser stack

A managed browser platform layers five components. The browser runtime executes Chromium in isolation, and the proxy layer routes traffic through residential or datacenter IPs.

The CAPTCHA solver clears challenges automatically. The session store persists state between runs, and the observability layer records what happened.

When a run fails, the error at the top can come from any of these layers, so diagnosis has to tell a proxy failure from a site block.

The team still owns the agent, the scheduler, and the place the workflow code runs. BaaS removes the browser infrastructure work, not the product work.

Scaling browser fleets, managed versus self-hosted

Hidden costs of self-hosting browsers

Self-hosted Playwright works and keeps full control. The costs appear later, and they include proxy health checks, CAPTCHA solver integration, session cleanup, and capacity planning.

Building browser infrastructure creates a second product the team did not plan to ship. The pain starts when concurrency moves from a few sessions to dozens, because each layer needs monitoring, retries, and failure recovery.

Managed browser service responsibilities

A managed service owns browser provisioning, proxy routing, CAPTCHA solving, and session isolation. It does not own the agent's logic, the scheduler, or the workflow code.

The trade-off is per-usage billing. Steel's Launch plan has no monthly fee. It bills $0.10 per browser hour, $10/GB for proxy bandwidth, and $3 per 1,000 CAPTCHA solves, as of November 2026 per Steel's pricing page. CAPTCHA solving and Steel proxies on Launch require a $10 paid deposit that goes toward usage, and free credits do not count toward it.

Comparing BaaS and self-hosted costs

The table below compares self-hosted Playwright with Steel's Launch plan. The comparison is illustrative, not a universal cost model, because actual spend depends on session length, bandwidth, and CAPTCHA frequency.

ComponentSelf-hosted PlaywrightSteel Launch
Platform fee$0$0
Browser hour rateInfrastructure cost only$0.10
Proxy managementTeam owns$10/GB managed
CAPTCHA solvingTeam integrates$3 per 1,000 solves
Concurrency scalingTeam buildsUp to 10 concurrent sessions on Launch, scaling to 1,000+ through a plan change
ObservabilityTeam buildsLive viewer and recordings

Self-hosting has no platform fee but needs engineering time for browser pools, proxy rotation, CAPTCHA solvers, and session health. Managed BaaS bills for what it operates.

Essential capabilities for browser automation

Maintaining login state across sessions

The Credentials API stores credentials server-side and fills the login form for the agent. The model can sign in without receiving the password.

The Credentials API documentation covers storage and injection with exact-origin matching, and the Credentials API overview documents namespaces and TOTP.

How BaaS handles site fingerprinting

Headless Chromium with stock fingerprints is easy for bot protection to spot. Sites check for inconsistencies between the user agent, the WebGL renderer, and the browser's behavior.

Steel's approach layers defenses. Every session launches with a consistent browser fingerprint and runs headful under a real display server instead of headless Chrome, so rendering and GPU behavior match a normal desktop.

On Enterprise, sessions can run on Steel's Chromium fork, which patches fingerprint surfaces inside the engine instead of through injected JavaScript.

Run automation only on sites and accounts you are authorized to use.

How managed CAPTCHA solving works

CAPTCHAs appear unpredictably and stall multi-step runs. A workflow that clears three steps can stop on the fourth because a challenge appeared.

Managed platforms handle this two ways. Automatic solving clears common challenges without human input, and the interactive live view lets a person take over for challenges that resist automation.

CAPTCHA solves bill per 1,000, not per session, so a run that encounters no challenges pays nothing for the capability.

Handling proxy health and rotation

A failed proxy tunnel ends the session. Managed proxies get health checks and retries, so a failed connection routes through a working IP. Customer-supplied proxies get no resilience layer, so a failed tunnel ends the run.

Proxy bandwidth bills per GB, and the rate depends on your plan. As an illustrative example, a run that pulls 50 MB at the Scale rate of $6/GB costs $0.30 in proxy bandwidth before any browser time.

Observability for browser sessions

Diagnosing a failed run means telling a proxy failure from a site block, a browser crash, or an agent logic error. The tools are a live viewer for watching runs in real time, recordings for reviewing past sessions, and agent traces for a timeline of actions. Session signals like bot_detection_triggered and captcha_encountered make block rates queryable.

Steel keeps recordings, logs, and session files for 7 days on Launch and 14 days on Scale. After that, only basic session metadata remains, such as the session ID and when it ran. The agent traces video below shows how a recorded session becomes a timeline the team can read and replay.

Integrating managed browsers with Playwright scripts

Migrating local scripts to BaaS

A Playwright launch call becomes a connect call over CDP. The code below connects to a Steel session, navigates, and releases in a finally block.

Python
from steel import Steel
from playwright.sync_api import sync_playwright

client = Steel()
session = client.sessions.create()

try:
    with sync_playwright() as playwright:
        browser = playwright.chromium.connect_over_cdp(session.websocket_url)
        context = browser.contexts[0]
        page = context.pages[0] if context.pages else context.new_page()
        page.goto("https://example.com")
        # agent logic here
        browser.close()
finally:
    # always release, or the session bills until its timeout
    client.sessions.release(session.id)

Runtime requirements are Node.js 20+ or Python 3.10+, and the example reads the API key from STEEL_API_KEY. The Playwright integration guide covers the full setup.

Using BaaS with agent libraries

Frameworks that connect over CDP, such as Browser Use, Stagehand, LangGraph, and the OpenAI Agents SDK, run on top of Steel, and the integrations documentation shows the connection pattern. They are complements, not competitors, because frameworks supply the agent logic and Steel supplies the browser. The hosted MCP server is the fastest way to give any MCP client a browser, with no integration code.

The connection is over CDP, so existing scripts change only how they connect. The Puppeteer integration guide shows the same pattern for a different library.

Managing session persistence and cleanup

The session lifecycle is create, connect, navigate, release. A session ends after 5 minutes by default (300,000 ms in the SDKs), and you can raise the timeout when you create the session.

The maximum session length for each plan is on the pricing page. Setting inactivity_timeout releases an idle session early, but the default is the plain session timeout.

Sessions bill until released, so a finally block is required. The code example above shows the pattern. Unreleased sessions continue billing until the session timeout ends them.

Switching from self-hosted to browser as a service

Scaling agent throughput with BaaS

Concurrency scales by plan, and what breaks at scale is capacity planning, session cleanup, and health monitoring.

A multi-step workflow multiplies the success rates of its layers. As an illustrative example, if each layer succeeds 95% of the time, a five-step workflow succeeds about 77% of the time. Managed layers reduce the failure modes the team must debug.

Retesting after site changes

A challenge can surface at any step and stall an otherwise healthy run. Anti-bot defenses evolve continuously, so retest a workflow after major changes to a target site.

Troubleshooting unstable agent runs

Failure modes include proxy failure, site block, browser crash, and agent logic error.

SymptomLikely causeCheck
Session ends immediatelyProxy failureSession signals for proxy_connection_failed
Login page appearsExpired or missing session stateRecording to confirm the profile or session context loaded
Blank pageBrowser crashRecording for the point where rendering stopped
Wrong data returnedAgent logicAgent traces for action sequence

When to run your own browser fleet

When self-hosting gives needed control

Self-hosting is right when the team needs full control over the browser binary, the network, and the deployment. Triggers include strict data residency, custom browser builds, or a target site that requires specific network conditions. The trade-off is that the team owns the maintenance.

Managing internal browser infrastructure

Self-hosting involves Docker deployment, proxy configuration, CAPTCHA solver integration, and session cleanup. Steel Local runs 1 concurrent session, which suits development and testing.

Steel Local and Steel Cloud share the session model, but not all features. The Steel GitHub repository has the self-host documentation.

Build vs. buy decision criteria

BaaS fits when the team's differentiator is the agent, not the browser. Self-hosting fits when the team has browser infrastructure expertise, a specific need for control, and targets that are easy to scrape or interact with. If target sites use antibot measures, keeping up with them quickly becomes its own job.

CriterionBuildBuy
Team expertiseBrowser infrastructure experienceAgent logic focus
Data residencyStrict requirementsFlexible
Concurrency needsOne browser, single threaded, low volume10-1,000+ sessions
Cost toleranceEngineering timeUsage-based billing

Evaluation checklist for your BaaS decision

Verify BaaS performance on real sites

Steel ran this benchmark over the create, connect, navigate, and release loop, 5,000 runs per provider on AWS us-east-1 in November 2025, against google.com on default settings. Steel averaged 894ms. Benchmarks on default settings against one site do not predict performance on your target sites, so test with your own workflow.

The benchmark methodology and raw data are published.

Forecast your monthly BaaS spend

The meters are browser hours, proxy bandwidth, CAPTCHA solves, and Browser Tools calls. Browser Tools calls are metered requests to Steel's prebuilt endpoints, such as scrape and screenshot, that run a browser task without a dedicated session. Forecast spend by applying your expected session length, data volume, and challenge frequency to each meter, using the same arithmetic as the proxy bandwidth example above.

Reviewing vendor lock-in risks

Lock-in risks include a proprietary session model, no self-host path, and plan-gated features. Steel's answer is an Apache 2.0 licensed browser server, a documented self-host path through Steel Local, and a clear list of what runs on Steel Cloud only, such as the Credentials API and global file storage.

Distinguishing cloud and self-hosted

FeatureSteel LocalSteel Cloud
Concurrency110 on Launch, 100 on Scale, 1,000+ on Enterprise
StealthLimitedBuilt-in, Chromium fork on Enterprise
CAPTCHA solvingNoneSupported
ProxiesBring your ownManaged plus customer-supplied
CredentialsNot supportedCredentials API
FilesFiles API (session files only)Files API

Steel Local gives you one session and the parts you wire yourself, which is enough to develop and test against. Everything that makes a production workflow hold at scale, from managed proxies to saved credentials, lives on Steel Cloud.

Start with the Launch plan at steel.dev. No credit card needed to start.

Frequently asked questions

What's the difference between browser as a service and web scraping APIs?

BaaS gives your code a full Chromium browser to control over CDP, so logins, forms, and multi-step workflows run under your own logic, and one-call endpoints cover simple scrape, screenshot, and PDF tasks. Scraping APIs take a URL and return extracted data inside the vendor's pipeline, which limits stateful, multi-step work.

Can I keep logins persistent across sessions in BaaS?

Yes, through the Credentials API, captured session context, or persistent profiles. Session context replays cookies, local storage, session storage, and IndexedDB from the previous run, and profiles persist the full browser state for longer-lived identities. A saved profile does not guarantee a valid login, because sites invalidate sessions on their own schedule.

Does browser as a service guarantee I won't get blocked?

No. Stealth and managed proxies reduce blocks on most sites, and results on a specific site are never guaranteed. Anti-bot defenses evolve continuously, so a workflow that passes one round of testing needs a retest after major site changes. Test on your own targets with free credits before committing.

How does pricing work for managed browser platforms?

Most platforms in this category bill by usage. Steel's Launch plan carries no monthly fee. Browser hours run at $0.10, proxy bandwidth at $10 per GB, and CAPTCHA solves at $3 per 1,000, as of November 2026 per [Steel's pricing page](https://steel.dev/pricing). Enabling CAPTCHA solving or Steel-managed proxies requires a $10 upfront deposit, which applies to your usage charges.

Can I switch from BaaS back to self-hosted later?

With Steel, yes. The browser server is Apache 2.0 licensed and self-hostable through Steel Local, and the session model is shared between Cloud and Local, so your scripts keep running on your own infrastructure if you switch. Some features, like the Credentials API and global file storage, run on Steel Cloud only. The same open standards also mean moving to Steel from self-hosted Playwright is mostly a connection URL change, so the path works in both directions.

Key terms glossary

Browser as a service (BaaS): A managed fleet of isolated Chromium browsers that automation code connects to over the Chrome DevTools Protocol. See Intro to Steel.

Session: A single browser instance with its own state, billed per browser hour until released. See the session lifecycle documentation.

Profile: A snapshot of the browser's full User Data Directory, covering auth, cookies, extensions, credentials, and browser settings, reused across sessions. See the Profiles API.

Session context: A snapshot of browser state, including cookies, local storage, session storage, and IndexedDB, replayed into the next session. See the auth context cookbook.

Credentials API: A way to store credentials and fill login forms without including passwords in prompts. See the Credentials API overview.

Stealth: A set of fingerprint, network, and identity layers that reduce bot detection. See stealth and proxies.

Proxy bandwidth: The data transferred through a proxy, billed per GB. See stealth and proxies.

CDP: Chrome DevTools Protocol, the standard connection for Playwright and Puppeteer. Selenium connects over WebDriver instead. See Steel and Selenium.

Browser Tools: Steel's prebuilt API endpoints for one-off browser tasks, such as scrape and screenshot, billed per call. See Browser Tools.

Related posts