Browserbase alternatives, without the strawman

Where Browserbase is still the right answer

Read this half first. If any of it describes your team, the rest of the page is not an argument for switching — it is context for a decision you have already made correctly.

Session control, exits and identity, line by line

Browserbase cells are quoted from their public documentation. Anything their docs do not state is marked rather than guessed.

One balance, or a meter per resource

A single scrape run touches search, a browser, an extraction and a store. The real question is how many separate quotas that trips before it finishes.

Browserbase’s published plans meter resources independently: browser hours carry a per-plan included quantity and their own overage rate, proxy GB carry a separate allowance and a separate per-GB rate, and model tokens are billed pay-as-you-go on top of both. That is a reasonable design for a platform assembling several products — Browserbase describes itself as a complete agent platform spanning Browsers, Search & Fetch, Agent Identity, Functions, Model Gateway and Stagehand — and it makes each product’s cost legible on its own. It also means a pipeline that leans hard on one resource can exhaust that allowance while the others sit unused, and that forecasting a job means forecasting each line separately.

Wayfern has one fungible credit and every stage debits it. An open page costs 8 credits an hour with a 60-second minimum per page. A scraped, extracted or crawled page costs 1 credit; a live search costs 2 credits per provider results page; a screenshot costs 5; a brand profile costs 10. Residential bytes are metered live at 320 credits per GB and datacenter egress is free. Re-running an extraction over pages already cached costs nothing, so iterating on a schema is free.

The practical consequence is where you spend your attention. With a meter per resource you tune each stage against its own ceiling. On one balance you tune the run as a whole and the only question is total spend — which also means a stage that suddenly gets expensive shows up as one number moving rather than one quota quietly emptying.

What each platform decides to charge for

Model, not price. Compare the shapes and then check both rate cards yourself.

Browserbase charges a monthly platform fee that carries an allowance of each metered resource, then bills overage per unit: browser hours and proxy GB each have their own included quantity and their own rate ($0.12/hr and $12/GB beyond the Developer allowance, $0.10/hr and $10/GB beyond Startup’s), model tokens are pay-as-you-go, and data retention is a plan attribute (7 days on the lower tiers, 30 on Startup). Two capability decisions sit inside that model rather than beside it: CAPTCHA solving and stealth are not included on the free tier, and the strongest anti-detection tier is offered on Scale, which is quoted by sales. So the anti-detection question and the procurement question arrive together.

Wayfern charges a monthly fee that grants credits — Developer $19/mo for 1,520 credits and 20 concurrent open pages; Business $99/mo for 9,000 credits and 100 concurrent open pages; Scale $499/mo for 46,000 credits and 400 concurrent open pages — and every billable action debits the same balance. Grant credits expire at the end of the period; separately bought credit packs do not and roll over. Nothing about detection resistance is gated by tier: the same browser build runs on every plan.

Two mechanics are worth knowing before you model a bill. Every page you open is billed for at least 60 seconds, so ten thousand two-second page opens cost the same as ten thousand one-minute ones — batch work into a held session rather than reconnecting per URL. And residential bandwidth is the item that moves fastest: 320 credits per GB, metered per byte from the container’s own counters, so an image-heavy target routed through a residential exit will dominate a session-hour bill. Route through the free datacenter exit until a target actually forces you off it.

The honest gap: Browserbase publishes a $0 tier and Wayfern does not. The cheapest way onto Wayfern is Developer at $19 a month. If your evaluation process needs to run real traffic before any card is entered, that is a genuine reason to start there.

Porting a session: from a create call to a connection

If your automation is already Playwright or Puppeteer, the port is the connect line and the session lifecycle around it. If it is Selenium, it is a rewrite — Wayfern speaks CDP only.

On Browserbase you create a session with the Create Session API — projectId, browserSettings, proxies, region, timeout, keepAlive — and then attach a client to it. Session options are decided at creation time, in the request body.

On Wayfern there is nothing to create. You open the CDP WebSocket, and the options that would have been a request body are query parameters on that URL: the link token, and the residential exit selectors. A country is what turns residential routing on; without it the session uses the free datacenter exit. The gateway has already opened a browser context for you, so take contexts()[0] rather than creating one.

Billing starts at the first page, not at connect, and each page carries a 60-second minimum — so a long-lived connection that opens pages sparingly is the cheap shape, and reconnecting per URL is the expensive one.

import { chromium } from "playwright";

// Before (Browserbase): create a session via the Create Session API with
// projectId / browserSettings / proxies / region, then attach a client to it.
// After (Wayfern): the connection IS the session — no create call.

const ws = new URL("wss://browser.wayfern.com/ws");
ws.searchParams.set("token", process.env.WAYFERN_LINK_TOKEN);

// Residential exit selectors. `country` is required to route residentially at
// all; omit every one of these to stay on the free datacenter exit.
ws.searchParams.set("country", "US");        // ISO-3166, from /api/proxy/locations
ws.searchParams.set("region", "NY");         // optional
ws.searchParams.set("city", "new york");     // optional
ws.searchParams.set("isp", "verizon");       // optional
ws.searchParams.set("session", "run-42");    // optional: sticky exit for this run

const browser = await chromium.connectOverCDP(ws.toString());
const context = browser.contexts()[0];       // the gateway already opened it
const page = await context.newPage();        // billing starts here, 60s minimum

await page.goto("https://example.com");
console.log(await page.title());

await browser.close();                       // closes the session and the meter

Questions people ask before they switch