Browserbase vs Browserless for browser agents.
Browserbase is a managed browser platform for agents. Browserless offers cloud plans and a self-hosted Docker image. Both connect Playwright and Puppeteer.
Browserbase bills browser time by the minute. Its paid plans start at $20 monthly. Browserless bills 30-second units. Paid plans start at $35 monthly, or $25 billed annually.
Choose Browserless when you must self-host. Choose Browserbase for hosted agents and Stagehand. Price one real workload on both first.
The short version
Neither platform guarantees dependable outcomes. Your workload determines the better contract.
What is the difference between Browserbase and Browserless?
Browserbase starts with managed sessions. Browserless starts with several browser interfaces. Both can run existing automation code.
Deployment creates the clearest divide. Browserless publishes cloud and Docker options. Browserbase says it offers no on-prem deployment.
Control preferences shape later costs. Broader interfaces require more operating choices. Managed conventions reduce some infrastructure choices.
Begin with one real workflow. Mark every required execution surface. Then assign each operational owner.
SourcesBrowserbase pricingUsing a browser sessionBrowserless API comparisonBrowserless open-source deployment
Compare the actual platform contracts.
Both platforms expose remote browser sessions. Both document Playwright and Puppeteer connections. Neither connection proves workflow parity.
Browserbase returns a session connection URL. Browserless exposes WebSocket and HTTP surfaces. Browserless also publishes BrowserQL and BAP.
Each interface carries different coupling. Standard library calls remain more portable. Proprietary workflows require deliberate exit plans.
Inventory calls before choosing. Separate browser control from surrounding services. Count every vendor-specific state transition.
| Factor | Browserbase | Browserless | Decision test |
|---|---|---|---|
| Remote control | Create a session, then connect through its returned URL. | Connect through WebSocket endpoints or use HTTP endpoints. | Run the same Playwright task through each connection contract. |
| API breadth | Browsers, Agents, Search, Fetch, Functions, and identity are documented. | BAP, BrowserQL, BaaS v2, and REST are documented. | List which surfaces the application actually needs. |
| Library fit | Playwright, Puppeteer, Selenium, and Stagehand paths are documented. | Playwright and Puppeteer paths are documented. | Confirm a Selenium path before moving WebDriver suites. |
| Hosted agent path | Agents and an MCP server are first-party platform surfaces. | An MCP browser agent is documented and one-shot by default. | Decide whether your application or vendor owns reasoning. |
| Deployment | Managed cloud. The pricing FAQ rules out on-prem deployment. | Cloud, open-source Docker, and enterprise Docker paths exist. | Assign patching, scaling, storage, and incident ownership. |
Documented platform contracts, verified October 30, 2026.
SourcesUsing a browser sessionBrowserless API comparisonBrowserbase pricingBrowserbase MCP setupBrowserless MCP serverBrowserless browser agentBrowserless open-source deployment
How much do Browserbase and Browserless cost?
Browserbase sells monthly plans with included browser hours. Overage costs $0.12 or $0.10 per hour. Each session bills at least one minute.
Browserless sells monthly unit allowances. One unit covers up to 30 seconds. Reconnects start a fresh unit. Annual billing lowers prices and raises concurrency.
Retention also differs by plan. Browserless keeps sessions and replays 1 to 90 days. Browserbase's pricing page lists 30 days on Developer. Its plans doc lists 7 days. Confirm retention before storing evidence there.
Free tiers carry tight limits. Browserbase Free caps sessions at 15 minutes. Browserless Free rejects requests past 1,000 units.
| Factor | Price | Included usage | Concurrent browsers | Session cap |
|---|---|---|---|---|
| Browserbase Free | $0 | 1 browser hour | 3 | 15 minutes |
| Browserbase Developer | $20 monthly | 100 hours, then $0.12 per hour | 25 | 6 hours |
| Browserbase Startup | $99 monthly | 500 hours, then $0.10 per hour | 100 | 6 hours |
| Browserbase Scale | Custom | Usage-based hours | 250-plus | 6-plus hours |
| Browserless Free | $0 | 1,000 units | 2 | 2 minutes |
| Browserless Prototyping | $35 monthly, or $25 billed annually | 20,000 units, then $0.0020 each | 5 monthly, 10 annual | 15 minutes |
| Browserless Starter | $200 monthly, or $140 billed annually | 180,000 units, then $0.0017 each | 30 monthly, 40 annual | 30 minutes |
| Browserless Scale | $500 monthly, or $350 billed annually | 500,000 units, then $0.0015 each | 80 monthly, 100 annual | 60 minutes |
Published plans, verified October 30, 2026.
SourcesBrowserbase pricingBrowserbase plansBrowserless pricing
Normalize costs with three workloads.
The vendors publish different billing units. Browserbase meters browser time by minutes. Browserless meters thirty-second browser units.
Browserless also converts proxy traffic into units. Browserbase prices proxy bandwidth separately. Direct plan-price comparisons obscure this difference.
Use identical session traces. Preserve failures, retries, and idle waits. Apply current plan rules afterward.
Run together, the traces need about 92 Browserbase hours. Developer includes 100 hours and 1 GB of proxy traffic. Browserless needs 14,000 to 22,000 units. Prototyping includes 20,000.
The worksheet formulas produce comparable inputs. They do not predict final invoices. Negotiated credits remain outside this worksheet.
| Factor | Workload trace | Browserbase input | Browserless input | Hidden sensitivity |
|---|---|---|---|---|
| Short extraction burst | 1,000 sessions, 20 seconds each, no managed proxy. | 1,000 one-minute minimums, about 16.7 browser hours. | 1,000 units, because 20 seconds rounds up to one unit. | Session minimums dominate more than average runtime. |
| Interactive agent run | 100 sessions, 12 active minutes, 8 idle minutes each. | 2,000 connected minutes, about 33.3 browser hours. | 40 units per session, 4,000 units in total. | Idle waiting remains billable while browsers stay open. |
| Traffic-heavy research | 500 sessions, 5 minutes, 4 MB managed traffic each. | About 41.7 browser hours plus 2,000 MB of proxy traffic. | 5,000 time units plus 4,000 to 12,000 proxy units. | Traffic can outweigh browser runtime for either vendor. |
Worked inputs from published meters, October 30, 2026.
SourcesBrowserless pricing
Separate live sessions from saved state.
Live continuity and saved identity differ. Browserbase contexts persist browser data across sessions. Browserless offers several persistence mechanisms.
Browserless standard reconnection preserves a running browser. Its persisted sessions can survive browser restarts. Authenticated profiles provide another reusable snapshot.
Browserbase contexts preserve cookies and application storage. Persistence requires the context configuration. Context reuse follows session closure and synchronization.
Test state transitions explicitly. Record creation, detach, reconnect, persist, and deletion. Never infer one mechanism from another.
| Factor | Browserbase contract | Browserless contract | Verification artifact |
|---|---|---|---|
| Live disconnect | Keep Alive supports reconnecting to eligible sessions. | Standard Sessions use a reconnect command for Puppeteer. | Capture disconnect time, reconnect time, and restored page state. |
| Cross-session state | Contexts store cookies and application data for later sessions. | Authenticated Profiles capture reusable cookies and browser storage. | Verify cookies, local storage, and server-side login validity. |
| Lifecycle setup | Context identifiers attach during session creation. | Browserless persistence varies between reconnect, Session API, and profiles. | Document the exact primitive used by every workflow. |
| Expiry response | Applications must detect invalid website sessions and reauthenticate. | Saved browser state cannot guarantee website-session validity. | Force expiry, then record detection and recovery behavior. |
State ownership and lifecycle boundaries.
SourcesUsing a browser sessionBrowserless session managementContextsAuthenticated profiles
Do Browserbase and Browserless support MCP?
Both vendors document hosted MCP servers. Browserless also documents a local npx server. Browser work stays on vendor or self-hosted browsers.
Browserbase exposes session-oriented browser actions. Its tools include navigation, actions, observation, extraction, and lifecycle controls. Explicit session identifiers support reattachment.
Browserless pairs one stateful tool with eight stateless tools. Its browser agent is one-shot by default. Multi-turn work must opt in on the first call.
Compare tool contracts carefully. Count model turns and browser starts. Track which component stores active-session identity.
| Factor | Browserbase | Browserless | Owner question |
|---|---|---|---|
| Hosted transport | A hosted Streamable HTTP endpoint takes an API key. | Hosted HTTP supports OAuth, headers, or token parameters. | Which credential path fits the client? |
| Stateful navigation | Session identifiers target or reattach browser actions. | The browserless_agent tool keeps a browser only when asked. | Where does active-session identity live? |
| Kept sessions | A keepAlive parameter is available on the endpoint. | Kept agent sessions close after 15 idle minutes. | Who closes sessions when the task ends? |
| Bounded retrieval | Extract operates within a Browserbase browser session. | Stateless tools open, complete, and close their browser work. | Does each request need continuing state? |
| Local process | The cited setup page covers the hosted endpoint. | An npx package runs locally and calls cloud or self-hosted browsers. | Does local transport imply local execution? |
MCP ownership matrix for this pair.
SourcesBrowserbase MCP setupBrowserless MCP serverBrowserless browser agentBrowserless unit consumption
Compare evidence, not dashboard adjectives.
Browserbase documents logs, metrics, live inspection, and replays. Browserless documents request logs and session replays. The artifacts answer different questions.
Request logs explain API lifecycle events. Visual replays explain browser behavior. Network and console evidence supports deeper debugging.
Browserbase keeps recordings up to 30 days. Downloaded MP4 files outlast that window. Browserless replay works on every plan, including Free.
Define one failed-run packet. Include identifiers, timestamps, browser evidence, and costs. Confirm both platforms can assemble it.
| Factor | Browserbase evidence | Browserless evidence | Required proof |
|---|---|---|---|
| Request identity | Session identifiers anchor inspection and retrieval. | Replay records connect through each recorded session. | One identifier must connect application and vendor records. |
| Visual sequence | Session Inspector and replay expose browser activity. | Interactive replay captures DOM changes and user interactions. | The packet should show the final successful action. |
| Network context | Inspector surfaces network requests and responses. | Interactive replay includes recorded network requests. | Capture response status and target endpoint safely. |
| Usage evidence | Dashboard usage supports plan and allocation review. | The usage dashboard reports units and durations. | Attach measured usage to every failed-run sample. |
Failure evidence checklist.
SourcesObservabilityBrowserless session replayBrowserbase plansBrowserless unit consumption
Can you self-host Browserless or Browserbase?
Browserless publishes an open-source Docker deployment. Its core image includes common libraries and REST endpoints. Advanced capabilities differ by edition.
Self-hosting transfers important work. Teams own capacity, upgrades, storage, monitoring, and access. An image started without a token leaves endpoints unauthenticated.
Browserless also sells a commercial self-hosting license. Review license terms before closed-source use.
Browserbase positions its browser platform as managed. Its pricing FAQ rules out on-prem deployment. Large enterprises can ask about private cloud options.
Price every responsible team. Include on-call time and upgrades. Include incident evidence and capacity planning.
| Factor | Managed Browserbase | Browserless Cloud | Browserless Docker | Named owner |
|---|---|---|---|---|
| Browser patching | Vendor-managed | Vendor-managed | Customer-managed | Platform engineering |
| Capacity and queues | Plan limits and vendor platform | Plan limits and vendor platform | Container sizing and queue settings | Reliability engineering |
| Data persistence | Contexts use managed storage | Managed session and profile storage | Mounted volumes and customer storage | Security engineering |
| Feature parity | Evaluate selected Browserbase plan | Evaluate selected Browserless plan | Open-source features differ from cloud | Product engineering |
Deployment responsibility assignment.
SourcesBrowserbase pricingBrowserless open-source deploymentBrowserbase plansContextsBrowserless session management
SourcesBrowserless pricing
Migrate the connection boundary first.
Both vendors support familiar automation libraries. That makes a controlled adapter trial possible. It does not guarantee identical behavior.
Keep task logic unchanged initially. Replace session creation and connection code. Disable optional vendor features during baseline runs.
Next compare state behavior. Then compare failure evidence. Finally apply plan and traffic costs.
A rollback path reduces switching fear. Preserve the prior adapter temporarily. Remove it only after acceptance.
- 01
Freeze one representative task
Pin inputs, targets, selectors, timeouts, and expected outputs.
- 02
Isolate session creation
Place vendor creation and connection behind one narrow adapter.
- 03
Run clean-state trials
Use fresh sessions without profiles, routing, or special modes.
- 04
Add saved-state trials
Persist one login, expire it, then measure recovery.
- 05
Compare failure packets
Force one timeout and one browser-side application error.
- 06
Price recorded traces
Apply current meters to measured runtime and traffic.
SourcesUsing a browser sessionContextsObservabilityBrowserless API comparisonBrowserless session managementBrowserless session replay
Consider Legba only for narrower needs.
Legba publishes an agent skill, HTTP sessions, and hosted MCP. Its hosted browser runs on Legba's infrastructure. A person can take control, then hand it back.
Remote CDP, Playwright, and Puppeteer attachment remain undocumented. Do not plan a drop-in migration. The hosted browser needs a paid Legba plan.
Broader infrastructure buyers should verify both vendors. Agent builders needing human handoff can inspect Legba. Validate one reversible workflow first.
FAQs.
Is Browserless a Browserbase replacement?
Which vendor supports self-hosting?
What do Browserbase and Browserless cost?
Which billing model is simpler?
How long can each session run?
Do both vendors support MCP?
Can Playwright code move between them?
How should teams test persistence?
References
- 01Using a browser sessionBrowserbase
- 02ContextsBrowserbase
- 03ObservabilityBrowserbase
- 04Browserbase MCP setupBrowserbase
- 05Browserbase plansBrowserbase
- 06Browserbase pricingBrowserbase
- 07Browserless pricingBrowserless
- 08Browserless API comparisonBrowserless
- 09Browserless unit consumptionBrowserless
- 10Browserless session managementBrowserless
- 11Authenticated profilesBrowserless
- 12Browserless session replayBrowserless
- 13Browserless MCP serverBrowserless
- 14Browserless browser agentBrowserless
- 15Browserless open-source deploymentBrowserless
- 16