How to Run Thousands of Browser Agents in Parallel (2026 Guide)

Solari runs thousands of browser agents in parallel: up to 100,000 concurrent browsers on the Enterprise plan (plans and pricing) and a session create of 8 ms on Steel's open-source benchmark. Browser agents that run fine on ten sessions often fail at a thousand, because the provider starts returning 429 errors at its concurrency cap and slow session starts leave workers idle while the queue grows.

The fix is a cloud browser API with a concurrency cap above your peak load, sessions that start in milliseconds, and a worker loop that queues jobs when it reaches the cap instead of retrying. Solari was built for exactly that workload.

What a Parallel Browser Fleet Needs

A fleet of browser agents needs four things from its infrastructure: a concurrency cap above your peak, fast session start, isolation between sessions, and logins that survive across runs. Solari provides all four from one API. Self-hosted Chromium can give you the last two with enough work; the first two are why most teams move to a hosted provider.

Each agent gets its own Solari session, started by API, driven with Playwright or any CDP client, and released when the job ends. The sessions guide puts the default plainly: "Every option is opt-in. The default is a fast headless browser with no profile, recording, proxy, or stealth." At fleet size that default matters, because each option becomes a choice per job rather than a cost on every session.

Isolation comes from the platform. Solari runs each session in a Cloud Hypervisor microVM with a dedicated kernel (pricing page), so one agent's crash or bad page never reaches its neighbours.

How Many Concurrent Browsers Each Provider Allows

Solari publishes the largest cap in this group: 100,000 concurrent browsers on Enterprise (plans and pricing). Self-serve plans top out between 100 and 150 concurrent browsers across the five providers below, and fleets in the thousands move to a custom plan everywhere.

Kernel says its Enterprise plan offers "high-volume concurrency" without a number (Kernel pricing). Every vendor here runs a fleet of a hundred well; Solari's published Enterprise cap is the one sized for a peak in the thousands.

Why Session Start Time Matters at Fleet Size

Solari creates a session in 8 ms and averages 199.9 ms end to end on Steel's open-source browserbench (PR #4, 5,000 runs). At thousands of agents, start time is paid on every job, so a slow create shows up as idle workers and a longer queue.

The medians break down as create 8 ms, connect 24 ms, goto 155 ms and release 2 ms. The release number matters as much as the create: a slot in your concurrency cap frees only when the session closes.

Against the README averages on Steel's open-source browserbench, Solari is about 4x faster than Kernel, about 4.5x faster than Steel, about 14.8x faster than Browserbase and about 40x faster than Anchor. The PR is open, and any team can rerun the benchmark on its own account.

How to Set Up a Parallel Fleet on Solari

Solari's SDK covers the fleet pattern in a few calls: run a worker pool sized to your plan's cap, open one session per job, close it in a finally block, and queue when the cap is reached. Five rules cover most fleets.

1. Size the pool to the cap. On Professional, 150 workers keep every browser slot busy; on Enterprise the same code scales by changing one setting.

2. One session per job, closed in finally. launch() opens and connects in one call, and close() "shuts it down and cleans up, so it's safe to call from a finally block" (sessions). If you call sessions.create() directly, use releaseAndWait() before reading a replay URL.

3. Treat 429 as a queue signal. The errors page explains that ConcurrencyLimitExceeded "is not retryable, and no SDK retries it", because "a slot only frees when you pause or kill a session." A worker that receives it should wait for one of its own jobs to finish, not loop.

4. Retry only transient failures. The same page lists 502, 503 and 504 as the retryable class, and the browser client already retries them once. Everything in the 4xx range will fail the same way until you change the request, the plan or the resource state.

5. Sign in once with profiles. A profile "saves your login, your cookies and site data" and is attached by profileId (profiles). It seeds the session's default context, so use session.context rather than browser.contexts()[0]. Professional includes 500 profiles; Team and Enterprise are unlimited.

If your agents also run code they generate, a Solari sandbox comes from the same account and API key, so the browser fleet and the code runners share one bill.

What It Costs to Run Browser Agents at Scale

Solari bills browsers at $0.07 per hour on Professional, $0.05 on Team and $0.005 on Enterprise, charged while a session is open (plans and pricing). The cost of a fleet is browser hours multiplied by the hourly rate, so closing sessions promptly is the biggest saving. Credits refill each month, and there is no end-of-month overage charge.

For peers: Browserbase says its Startup plan bills $0.10 per browser hour past the included hours (Browserbase pricing). Steel says its Scale plan bills $0.08 per browser hour (Steel pricing). Hyperbrowser says browser usage is $0.10 per hour (Hyperbrowser pricing). Kernel publishes per-second rates by browser type rather than an hourly figure (Kernel pricing). Against the hourly rates Browserbase, Steel and Hyperbrowser publish, Solari's Professional rate is lower than all three, and the Team and Enterprise rates widen the gap.

Limits to Plan Around

Solari publishes every cap per plan, so a fleet can be planned to the session. Stealth sessions run on their own cap, counted in addition to the browser cap: 10 on Starter, 50 on Professional and 75 on Team and Enterprise (plans and pricing). Proxies and captcha solving run on stealth sessions, so that cap covers proxied sessions too, and Enterprise's 100,000 applies to standard sessions.

Solari sessions run up to 24 hours on Professional and without a time limit on Team and Enterprise. Recording is opt-in per session and captures input values by default, so leave it off for a session that types a secret.

Where Each Fits

Running thousands of browser agents comes down to a cap that covers your peak, a session start measured in milliseconds, a worker loop that queues on 429, and profiles so each agent starts signed in. Browserbase is the more established vendor with the larger ecosystem; Solari is the younger company and moves faster on speed and price, with the largest published concurrency cap in the table and the fastest end-to-end time on Steel's open-source benchmark. Read how Solari was built, the companion piece on Browserbase alternatives, and the sessions guide, then start your first hundred agents on Solari's Professional plan and move to Enterprise when the queue tells you to.

FAQ QUESTIONS:

1. How many concurrent browser sessions can Solari run?

2. What happens when a browser agent fleet hits its concurrency limit?

3. Do stealth sessions count against the concurrent browser cap?