Afina

Download app

AppleWindows
EN
BlogGuides and Tutorials

November 15, 2026

Browserbase Review 2026: Persistent Sessions, CDP, Concurrency, and Alternatives

Browserbase workflow with CDP sessions and local profiles

Browserbase is a cloud platform for launching and managing Chromium browser sessions, used for code-based automation through its API and CDP. It suits testing, data collection, and agent workflows without requiring a team to maintain its own browser cluster. In real projects, you need to account for session duration, concurrency, authentication persistence, proxy traffic, and the behavior of the target website.

The short answer to “is Browserbase any good?” is yes, when a team needs managed cloud browsers, fast provisioning, and session observability. The platform supports Playwright, Puppeteer, and Selenium; the differences between them are covered in a separate framework comparison. Still, Browserbase does not replace an architecture built around persistent isolated profiles in every use case.

The most important distinction is between a short-lived automation job and a long-lived digital identity. The first calls for a fresh browser, an API, and a job queue. The second depends on cookies, localStorage, a stable proxy, and session management across runs. Browserbase should be evaluated at this boundary, not on the strength of one successful demo.

What tasks does Browserbase handle?

Browserbase handles the infrastructure work associated with Chromium. Instead of deploying containers, monitoring memory, updating the browser, and collecting logs, a team creates a session through the API, receives a connectUrl, and connects its usual automation client.

The platform works well when the browser is needed only for the duration of an operation. A run opens a page, performs actions, returns a result, and ends. Developers do not have to maintain a fleet of virtual machines or separately build live view, session recording, and network logging.

Typical use cases include:

  • E2E testing of JavaScript applications in a clean environment
  • collecting data from client-rendered pages
  • browser agents built with Playwright or Stagehand
  • automating forms and internal web systems
  • running page checks in parallel across several regions

A full browser is often unnecessary for simple HTML retrieval. Test a regular HTTP request or Fetch API first, and reserve Chromium for pages that require JavaScript, authentication, or actual DOM interaction. This can reduce costs substantially.

Browserbase is best understood as BaaS, or Browser as a Service. The service provides the browser runtime, while the business logic remains in your code. Selectors, waits, retries, data validation, and error handling do not disappear.

How do sessions, Contexts, and CDP connections work?

A Browserbase session is an individual Chromium run, while a Context can preserve supported browser state between runs. Without reusing a Context, a new session normally starts without previous cookies or storage data. To attempt to restore an authenticated state, create a Context and launch sessions with its ID and persist: true. Saving browser data alone does not guarantee that the login will survive: the server may terminate the session, the token may expire, or the site may require the device to be verified again.

Context is designed to retain browser state between runs, including cookies and web storage data. The exact data restored and the synchronization limits should be checked against the documentation and tested for your workflow. Do not assume that every profile component, including cache, is restored without exception. After a session ends, make sure Context synchronization has completed before opening another session with the same identifier. Check the current SDK documentation for the exact sequence and timing.

Testing persistent Browserbase sessions with Context and persist true

This resembles a saved browser profile but is not identical in how it is used. Context holds application state, while every session remains a new cloud run. The site may also invalidate a token, request MFA, or end authentication when network or behavioral signals change.

CDP, or Chrome DevTools Protocol, controls Chromium and exposes diagnostic data. CDP messages can travel over WebSocket. After creating a session, Browserbase returns a connectUrl. Playwright connects with connectOverCDP, Puppeteer uses connect, and Selenium receives a separate remote address.

A minimal Playwright test follows this sequence:

  1. create a Context with the Browserbase SDK
  2. launch the first session with persist: true
  3. connect Playwright to session.connectUrl
  4. sign in to a test website
  5. close the browser and wait for Context synchronization
  6. create a second session with the same Context
  7. verify the authenticated state and a control value in localStorage

Do not end the test when “the dashboard opened.” Record the cookie value, a control storage key, the URL after login, and whether MFA was requested again. That is how you distinguish genuine Context restoration from a page that merely happened to remain open.

Browserbase and Stagehand: when is an agent approach useful?

Stagehand is a browser automation tool that uses AI models and can work with Browserbase. Unlike Playwright scripts, where developers usually define locators and action sequences explicitly, an agent approach can interpret instructions and decide what to do on a page dynamically. This helps when interface structure changes frequently or a workflow is difficult to express as rigid rules.

Agent automation does not guarantee a correct result. It can add latency and model costs, so critical actions need explicit validation. For stable forms and predictable pages, regular Playwright is often simpler and cheaper.

How can you test Browserbase without drawing false conclusions?

When testing Browserbase, measure session provisioning, CDP connection, page loading, and the business action separately. A single end-to-end duration does not reveal the source of a delay. Ten repetitions are useful for an initial check, but a reliable p95 estimate needs a much larger sample, such as at least 100 runs under comparable conditions.

Prepare a small test environment with predictable pages. Do not use a production account or a site whose rules prohibit automation. This material is provided for informational and educational purposes only.

Run the test in this order:

  1. record the Browserbase region and the region of your runner
  2. measure the API response time for session creation
  3. measure CDP connection setup separately
  4. open a control page with waitUntil: "domcontentloaded"
  5. wait for a specific selector instead of a fixed delay
  6. repeat the run at least ten times for an initial check, and collect a larger sample, preferably 100 or more runs, to estimate p95
  7. calculate the median, p95 for a sufficient sample, and the successful completion rate
  8. repeat the series with the required number of parallel sessions

The median describes a typical run, while p95 marks the boundary within which roughly 95% of measurements fall. In a queue of hundreds of jobs, the slowest runs may determine when the entire batch finishes. If nine sessions complete in 20 seconds and the tenth takes two minutes, the average will not show how slow the worst run was.

Store completion codes, the failed step, and the URL separately. A navigation timeout, a CDP refusal, and a business selector error are different failure classes. Each needs a different response: recreate the session, reconnect, or update the locator.

Browserbase stability metrics for ten parallel runs

This type of dashboard immediately shows where time is being lost. Without it, a team might spend a week optimizing Playwright even though the delay happens before the browser connection is established.

Add your own run_id to the metadata of every run. It lets you connect a business job to its session, orchestrator logs, and browser recording. Without that key, investigating a batch failure becomes a manual search through dozens of similar videos.

It helps to divide metrics into three levels:

LevelMetrics
Infrastructuresession creation time and CDP connection
Browsernavigation, DOMContentLoaded, network errors, and proxy usage
Businesswhether the required file was received, the form was saved, or a valid dataset was returned

A successful session status does not guarantee that the business job succeeded. The browser may close correctly after the script reads an empty container or a login page instead of the report.

Add result checks for:

  • the expected value
  • the number of rows
  • a control marker on the page

These checks expose runs that are technically successful but fail to return the required result.

To compare Browserbase with local Chromium, run the same series under identical conditions:

  • from the same runner
  • with the same code
  • under the same network conditions

Do not change the framework, proxy, and environment at the same time. The result will show the sum of the differences but explain none of them.

Report vendor claims separately from your own results. Documentation can confirm that a feature or limit exists, but it cannot predict performance from your data center. A competitor's test cannot be transferred directly either, because it is affected by:

  • runner region
  • test date
  • website
  • proxy
  • page waiting strategy

A useful test record includes:

  • SDK version
  • date
  • plan
  • Browserbase region
  • location where the code ran
  • test scenario hash

If p95 increases a month later, this information will help explain what changed. Without it, the two runs are not comparable.

Define acceptance criteria for each scenario before testing. For example:

  • at least 98% successful runs
  • p95 below 35 seconds
  • no more than one retry
  • a fixed maximum cost per thousand results

The decision then becomes technical rather than emotional.

Include a negative test as well:

  • deliberately terminate CDP
  • make the page respond more slowly than the timeout
  • return an unexpected DOM
  • exceed your own queue limit

The system should finish the job with an exact code, release the session, and retain the failure reason.

How should timeouts and concurrency be evaluated?

Browserbase concurrency is the number of browsers active at the same time, not the speed of an individual workflow. According to the figures cited in this article as of October 20, 2026, the plans allow 3 concurrent browsers on Free, 25 on Developer, 100 on Startup, and 250 or more on Scale. Check these values again before purchasing because plan terms can change.

The API allows a session duration from 60 seconds to 21,600 seconds, or up to six hours. The keepAlive option keeps a session running after the client disconnects on eligible plans. This is useful for a brief reconnection, but it does not remove the upper timeout.

Browserbase timeout layers and parallel session queue

The session region also affects the result. Total latency depends on the location of the automation code, cloud browser, proxy, and target website, so proximity to only one component does not guarantee the fastest execution. Based on the figures cited here, the API lists US West, US East, Central Europe, and Singapore. Choose a region closer to the target site or the workflow dependencies, then measure. The shortest distance from your runner does not always produce the lowest total job time.

A production queue needs four separate limits:

  • navigation timeout for opening the page
  • action timeout for a click or an element wait
  • job timeout for the entire business workflow
  • session timeout at the Browserbase level

Set these limits according to the operations rather than a universal order: navigation can sometimes take less time than a single action. For one workflow, for example, you might allow 15 seconds for an action, 30 for navigation, 120 for the job, and 180 for the session. The overall job time must cover every stage and leave enough session time for logging and resource cleanup.

Do not send every job through Promise.all when the batch is larger than the plan limit. Use a semaphore or a fixed-width queue. With a limit of 25, start with 15-20 concurrent runs, measure p95, and only then increase the load. The spare capacity is needed for retries and manual debugging.

Failed retries also consume browser minutes and proxy traffic. Add exponential backoff and cap the number of attempts.

Retries are appropriate for temporary failures when the operation can safely run again:

  • CDP disconnect
  • temporary 5xx response
  • timeout while creating a session

Not every 5xx response or CDP disconnect means that the business operation did not happen. Before retrying an action that changes data, check its result or use an idempotency mechanism. A selector error will not usually disappear after five identical runs.

The queue must account for backpressure. If incoming traffic creates 50 jobs per second while the browser pool completes 20, simply increasing concurrency only postpones the problem.

Measure:

  • queue length
  • waiting time of the oldest queued job
  • retry count

When a threshold is exceeded:

  • temporarily stop accepting new jobs
  • or move lightweight operations to the HTTP layer

For long workflows, place checkpoints after irreversible actions:

  • login
  • file upload
  • form submission

A complete restart may duplicate an operation. Resume the job from the last confirmed state when the business system supports idempotency.

Browser region, proxy, and IP persistence

The browser launch region does not necessarily match the geography of the exit IP when traffic goes through a proxy. For authenticated workflows, verify whether the required geography and network exit persistence can be maintained between sessions. Even a restored Context does not guarantee that a login will survive if the site reacts to an IP change or other risk signals. Address pinning and proxy configuration depend on the service's current features and plan.

Which plan components determine the real cost?

The real cost of Browserbase depends on the subscription, billable browser time, metered proxy traffic, and reruns. Proxy traffic rises with large images, video, repeated resource downloads, and additional attempts. You also need to distinguish traffic that passes through managed Browserbase proxies from other network costs. According to the plan figures available when this article was prepared, Developer costs $20 per month and includes 100 browser hours, while Startup costs $99 and includes 500 hours. Additional browser time costs $0.12 and $0.10 per hour, respectively.

Browserbase plans with browser hours and proxy traffic

Managed proxies are billed separately. Developer includes 1 GB, with additional traffic at $12 per GB. Startup includes 5 GB, then costs $10 per GB. The Free plan provides one browser hour for testing a basic workflow.

It is better to calculate the budget before launch:

monthly cost = plan + additional browser hours + additional proxy GB + external services

Example: 60,000 jobs per month at an average duration of 45 seconds equal 750 browser hours. If additional attempts amount to 15% of the initial 60,000 runs and last just as long on average, consumption increases to 862.5 hours before manual debugging is counted. This is not the same as a 15% probability that every attempt fails and is retried until successful. Pages with large images can also make proxy traffic more expensive than browser time.

Do not put the marketing estimate “several thousand jobs per 100 hours” into your budget without testing it. The figure depends on the duration of the actual job. An authenticated portal with several transitions, report downloads, and MFA is nothing like spending two minutes reading one page.

For an initial estimate, calculate three scenarios. They do not replace measurement, but they show which variable affects the bill most.

ScenarioDuration per jobRetriesMain cost driver
check one page20-40 secondsup to 5%browser hours
authenticated portal2-5 minutes10-20%time, Context, and MFA
collect data from media-heavy pages1-3 minutesdepends on siteproxy traffic

In the first scenario, saving ten seconds has a noticeable effect across a large batch. In the second, repeated login and manual intervention cost more. In the third, blocking images, video, and fonts may change the economics more than a cheaper browser hour.

Browserbase cost calculation for hours retries and proxy traffic

Calculate the cost of a successful job, not the cost of an attempt. If 82 of 100 runs produce a result, divide all expenses by 82. This metric provides a fair comparison between Browserbase, an in-house cluster, and local profiles even when their pricing structures differ.

The simplest way to reduce costs is not to open a browser when HTTP is enough. Filter lightweight requests through Search or Fetch, block unnecessary resources, close the session as soon as the result is available, and do not retry deterministic errors.

What are the other cloud alternatives to Browserbase?

If you specifically need remote browsers, compare Browserbase not only with local profiles but also with other BaaS platforms. Browserless, for example, provides managed browsers and automation APIs. Other cloud services may differ in framework support, connection methods, and billing. Check current prices and limits immediately before choosing.

CriterionBrowserbaseBrowserlessSelf-hosted Chromium in the cloud
Browser provisioningmanaged servicemanaged serviceself-managed deployment
IntegrationAPI, CDP, automation toolsAPI and browser connections, depending on productdepends on your implementation
State persistenceContext, subject to verified limitsverify the mechanism for the selected plan and APIfully controlled by the team
Concurrencydepends on plandepends on plandepends on resources and queue
Diagnosticssession viewing and recording toolsverify available tools and limitscustom logging and monitoring
Costsplan, browser time, and proxy trafficcurrent billing modelresources, maintenance, and proxies

Compare solutions with the same test workflow using p95, successful job rate, diagnostic convenience, and cost per successful result. Without that test, there is no universal winner.

How does Browserbase differ from local isolated profiles?

Browserbase and a local profile environment solve different infrastructure problems. Browserbase provides elastic cloud browsers and observability. A local antidetect profile focuses on a long-lived environment with a controlled fingerprint, cookies, proxy, and repeated access to the same browser context.

CriterionBrowserbaseLocal isolated profiles
Primary modelmanaged cloud sessionspersistent profiles on your infrastructure
ConnectionAPI and remote CDPlocal API, CDP, or built-in automation
Scalingplan concurrency limitCPU, RAM, and queue limits
State between runsContext with persistdata stored in the profile
Observabilitylive view, replay, network and console logsdepends on the product and custom logging
Cost modelsubscription, hours, and proxy trafficlicense, hardware, proxies, and maintenance
Best use caseshort cloud jobs and agentslong-running work with separate identities

The choice is not simply a feature comparison. If a job runs for two minutes, does not need to return to the same identity, and experiences sharp traffic peaks, managed BaaS is often more practical. If every account must retain its state, IP logic, and fingerprint for months, a persistent profile provides a more predictable model.

A hybrid option is also possible. Public pages and one-off checks can run in cloud BaaS, while authenticated processes with a long lifecycle remain in isolated profiles. An orchestrator routes each job to the appropriate environment according to its risk type and expected duration.

Hybrid architecture using Browserbase and local profiles

An in-house Chromium cluster provides the most control, but it also leaves the team responsible for:

  • updating images
  • memory leaks
  • container balancing
  • video recording
  • log collection

At low load, this may appear cheaper on the infrastructure bill. The calculation often changes once engineering time is included.

Managed BaaS removes this operational work but adds a dependency on an external API, pricing plan, and provider regions. A critical process therefore needs a clear response to service downtime:

  • pause jobs
  • move them to a backup environment
  • terminate them with an explicit error code

Local profiles have a different weak point. Concurrency is constrained by physical resources, and a poorly configured queue can overload the machine.

You need:

  • CPU and RAM limits
  • active browser controls
  • a restart plan after process failure

Security of Contexts and session recordings

Access to sensitive data is a separate issue that demonstrations often overlook. Context may contain:

  • cookies
  • authentication tokens
  • localStorage
  • IndexedDB

Do not store a Browserbase API key in the repository or expose it to client-side code. Use a secrets manager, separate projects for different environments, and the least privileges required in the surrounding infrastructure.

Live view and session recordings are valuable for debugging, but they can capture personal data or content from an internal system.

The source pricing data for this article lists the following retention periods. Verify them against the official pricing page and retention policy before publication:

PlanRetention period
Free7 days
Developer30 days
Startup30 days

Compare the retention period with your company policy and confirm the current terms before production use.

Do not write passwords to a regular log. Mask the following before sending telemetry:

  • authorization headers
  • tokens
  • email addresses
  • form fields

If a step code and a screenshot after failure are enough for an investigation, a full network dump may be unnecessary.

For manual intervention, create a short-lived workflow:

  1. an operator receives access to a specific session
  2. the operator performs one action
  3. control returns to the automation

Do not post permanent live-view links in a shared chat. After the intervention, verify that the session is closed and that secrets did not enter the artifacts.

When automating with Puppeteer, monitor technical signals as well as the business result. The guide to CDP leaks and Puppeteer detection explains why a successful connection does not guarantee identical behavior on every website.

When should you choose Browserbase for a production workflow?

Choose Browserbase when the value of managed infrastructure exceeds the cost of browser hours and proxies. This is particularly visible in a small team, where maintaining a custom cluster takes developer time away from the product.

Before deciding, run a controlled series using your own workflow. Measure the full lifecycle rather than only startup: creation, CDP, authentication, execution, retries, logging, and closure. Then compare p95 and the cost of one thousand successful jobs, not one thousand attempts.

Browserbase is a good fit when:

  • workflows are short and easy to repeat
  • load has peaks that are inconvenient to handle locally
  • the team needs live session viewing and recordings without building them separately
  • existing code already uses Playwright, Puppeteer, or Selenium
  • authentication can be restored through Context without conflicting signals

Another environment is more suitable when:

  • you need a persistent profile with a long lifecycle
  • the budget is sensitive to browser hours or large volumes of proxy traffic
  • the workflow depends on a stable fingerprint and network parameters
  • data processing must remain on your own machine
  • the team already knows how to maintain Chromium and a job queue

Afina is one example of a local solution: it provides isolated profiles and a local REST API. Launching a profile returns a wsEndpoint that Puppeteer or Playwright can connect to, while the profile state remains on infrastructure controlled by the user. A detailed example appears in the guide to the Afina API and REST automation.

This example does not mean that one product or approach is universally better. Disposable cloud sessions and persistent local profiles have different economics. Select the model according to identity lifespan, data requirements, and the cost of a successful run. When working with APIs, it also helps to agree in advance on what the team means by an API, session, and profile.

Download

FAQ — Frequently Asked Questions

Is Browserbase good for browser automation?

Yes. Browserbase is convenient for managed cloud sessions, parallel runs, and CDP connections. The final assessment depends on job duration, authentication requirements, and budget.

Does Browserbase preserve authentication between sessions?

Yes. It uses Context with persist: true, although a site may still end the session because of token expiry, MFA, or changed login signals.

How do you connect Playwright to Browserbase?

Create a session with the SDK and pass session.connectUrl to chromium.connectOverCDP(). After connecting, use the usual Playwright methods.

What is the Browserbase session duration limit?

The API accepts a timeout from 60 seconds to six hours. The practical limit should match the plan and workflow.

How many concurrent browsers does Browserbase support?

The number depends on the plan: the plans cited here provide 3, 25, 100, or at least 250 concurrent browsers. Check the current terms before launch.

How much does Browserbase cost in 2026?

Paid plans start at $20 per month, with possible additional charges for browser hours and proxy traffic. Verify prices before purchasing.

How is Browserbase different from an antidetect browser?

Browserbase focuses on managed cloud sessions and agent automation. An antidetect browser focuses more on persistent isolated profiles and fingerprint control.

What are the alternatives to Browserbase?

Alternatives include an in-house Chromium cluster, another BaaS, or a local isolated-profile environment. The choice depends on concurrency, session lifespan, and data requirements.

Related terms

Continue reading onAutomation scripts — Browser profiles | Afina Browser
Oleksandr Volovyk

I am a Web3 marketing specialist and Marketing Manager at Afina, responsible for community growth, partnerships, onboarding, and user acquisition. I build promotion through trust, direct communication, and real product value.

I entered Web3 through hands-on practice — spending several years in airdrop hunting, testnets, and active participation in numerous blockchain projects and communities. Through this experience, I witnessed market hype cycles, project failures, liquidations, and successful launches, gaining a deep understanding of user psychology, buying behavior, and the difference between real value and market noise