Solari vs Browserbase: Migration, Speed and Price

The renewal notice arrived in the same week the agent team added another nightly job to the queue. Nobody wanted to touch the session code that had taken months to get right, so the planning doc asked a narrow question: what would moving actually change?

Migrating from Browserbase to Solari is an import change and a key change. Solari ships a Browserbase compatibility package that keeps the familiar session, context, live view and recording calls, and it raises a clear error for any option it does not map instead of quietly doing something different. This guide compares the two platforms, walks through the switch, and covers what speed and price look like once it is done.

Solari and Browserbase at a Glance

The two platforms overlap on cloud browsers and differ on what sits around them, so the comparison starts with the shape of each.

Solari

Core capabilities. Solari runs cloud browser sessions, AI sandboxes and computer desktops from one account and one API. Browsers are driven over the Chrome DevTools Protocol from Playwright, Puppeteer or any client that speaks it, and profiles keep a login between runs. An agent that needs to run code next to its browser does it without a second vendor.

Pricing and plans. Solari's plans start with a Free plan carrying $3 of monthly credits, then Starter at $20 a month and Professional at $200 a month, where the plan fee covers the same amount of usage. Professional browsers run at $0.07 an hour with up to 150 concurrent browsers, and there is no end-of-month overage charge. For a team past the free tier, the bill follows the hours a fleet actually uses rather than a bundle.

Who it's best for. Platform engineers who run web agents in production and want session speed, persistent logins and code execution under one bill. It also suits teams that expect to add sandboxes or desktops to the same pipeline later.

Browserbase

Core capabilities. Browserbase pairs its browsers with Search and Fetch APIs, a model gateway and Stagehand, its own SDK for browser agents. It supports Playwright, Puppeteer and Selenium. Teams built around Stagehand get the framework and the infrastructure from the same vendor.

Pricing and plans. Browserbase says its Free plan includes 1 browser hour, its Developer plan is $20 a month with 25 concurrent browsers and $0.12 per browser hour after the included hours, and its Startup plan is $99 a month with 100 concurrent browsers and 500 browser hours before $0.10 per hour. Captcha solving is included from Developer up. A team that outgrows the Startup bundle pays the overage rate on every extra hour.

Trade-off. Bundled hours make a steady workload easy to budget. A workload that spikes pays the overage rate past the bundle, so the monthly figure moves with demand.

With the two platforms side by side, the next question is what the move itself touches.

How the Migration Works

The switch is designed to leave existing code where it is. The Browserbase migration guide installs a single package, @solarisdk/browserbase-compat for Node or solari-browserbase-compat for Python, and the code changes its import and its API key.

The Node version of the change reads like this:

import Browserbase from "@solarisdk/browserbase-compat"
import { chromium } from "playwright-core"

const bb = new Browserbase({ apiKey: process.env.SOLARI_API_KEY })
const session = await bb.sessions.create()
const browser = await chromium.connectOverCDP(session.connectUrl)

import Browserbase from "@solarisdk/browserbase-compat"
import { chromium } from "playwright-core"

const bb = new Browserbase({ apiKey: process.env.SOLARI_API_KEY })
const session = await bb.sessions.create()
const browser = await chromium.connectOverCDP(session.connectUrl)

import Browserbase from "@solarisdk/browserbase-compat"
import { chromium } from "playwright-core"

const bb = new Browserbase({ apiKey: process.env.SOLARI_API_KEY })
const session = await bb.sessions.create()
const browser = await chromium.connectOverCDP(session.connectUrl)

The connectUrl is a plain CDP websocket, so Playwright's connectOverCDP, Puppeteer, Stagehand and browser-use all attach without a client version to pin. Only keys that start with slr_ are used; a Browserbase key left in the environment is skipped and never sent anywhere. Keep the URL private, since the session id inside it is the credential.

Once the session connects, the remaining work sits in the options a team passes to it.

What Changes After the Switch

Most Browserbase options map directly, and a few change their defaults. Proxies with geolocation become a managed proxy in the chosen country, state or city on the stealth browser, and allowedDomains becomes an egress allowlist on the Team and Enterprise plans. Captcha solving and session recording are both off unless the code passes true, where Browserbase turns captcha solving on by default.

Contexts become Solari profiles that carry cookies and localStorage. The saved login comes back in Playwright's storageState format, so a new context created with that state opens signed in. Recording returns a DOM-event log a few seconds after release, read with sessions.recording.retrieve, and the viewport is set from the automation client with page.setViewportSize.

Any option the package does not map raises SolariCompatUnsupported, and each package's COMPAT.md lists every difference. Running the existing test suite against the package shows exactly which lines to adjust, and after that the numbers are what remain.

Speed and Price After the Move

With the code moved, speed and price are what the team notices next. On Steel's open-source benchmark, across 5,000 runs whose results sit in an open pull request, Solari averaged 199.9 ms end to end and is about 14.8x faster than Browserbase. For an agent that opens a fresh session per task, that time comes off every step that waits on a browser.

On price, Solari is about 2x cheaper than Browserbase per browser hour at list price. Because Solari bills for the time a session runs rather than in bundled hours, the cost tracks the fleet's real usage. Those two results frame the decision that follows.

Recap: Which One to Choose

To recap, the move is a package install and a key swap, the options map with a few changed defaults, and the result is faster sessions at a lower hourly price. Choose Solari when session speed, cost per browser hour and sandboxes or desktops in the same account matter. Stay with Browserbase when Stagehand, its Search and Fetch APIs or Selenium sit at the centre of the pipeline. Browserbase is the more established vendor with the larger ecosystem; Solari is the younger company and moves faster on speed and price.

Get Started With Solari

The first step is to install the compat package, swap in a Solari key and run the existing Browserbase test suite against it. Solari is the faster and cheaper home for that same code, with sessions created in 8 ms on the benchmark above. Start free on Solari and the Free plan's credits cover the first migrated runs.