Wayfern vs Browserbase

The answer in three paragraphs

Read this before the feature table

A comparison page that takes four screens to admit where the competitor wins is a sales deck. Here is the fork, first.

One balance, or four meters

How each product counts, rather than what it costs — the counting model is what survives a price change.

Wayfern runs a single fungible credit. Plans grant credits monthly — Developer at $19/mo (1,520 credits, 20 concurrent pages), Business at $99/mo (9,000 credits, 100 concurrent pages), Scale at $499/mo (46,000 credits, 400 concurrent pages) — and every billable action debits the same balance: 8 credits per open-page hour (floored at 60 seconds per page), 320 credits per GB of residential egress, 1 credit per scraped page, 1 credit per captcha solve. Datacenter egress costs nothing. Non-expiring top-up packs sit behind the grant (1,000 for $12.50, 5,000 for $55, 20,000 for $200) and are spent only after the monthly grant is gone, so an unusual week does not need a plan change.

Browserbase counts several things separately. Its published pricing puts browser hours, Search calls, Fetch calls and proxy gigabytes on their own meters, each with a plan-included allowance and its own overage rate: Developer at $20/month includes 100 browser hours then $0.12/browser hour, 1,000 Search calls then $7 per 1,000, 1,000 Fetch calls then $1 per 1,000, and 1GB of proxies then $12/GB. Startup at $99/month moves those to 500 browser hours at $0.10, 10,000 Fetch calls and 5GB of proxies at $10/GB. There is a real advantage in that: a workload that is all browser-hours and no bandwidth pays a browser-hour price, and the free tier means the first evaluation costs nothing.

The practical difference shows up on bandwidth-heavy work. Wayfern debits residential bytes continuously from the same balance the browser time comes out of, so the two trade against each other inside one budget; Browserbase draws bandwidth from a separate per-GB allowance that overflows at its own rate. Neither is cheaper in the abstract — it depends entirely on whether your bytes or your hours dominate, and both publish the numbers you need to work that out.

The exit path, and who decides it

Wayfern picks the exit per attempt: a Web Data call leaves through the free datacenter exit and is retried through a metered residential exit only when the first attempt is classified as blocked.

On Wayfern the routing decision is made late. Every Web Data endpoint takes proxy: auto | datacenter | residential plus an optional ISO-3166 exit country, and auto is the default — the page runs on the datacenter exit, and only a failure carrying the blocked sentinel earns one retry through a residential exit. Any other failure is surfaced immediately rather than paid for twice. Held CDP sessions express the same targeting in the connect URL: country, region, city, isp and a sticky session id, each validated against the upstream catalog before a browser is spawned, and a session that asks for a geo the deployment cannot provide is refused at connect rather than quietly given a different exit.

The meter is bolted to the container, not to the request. A sidecar inside the browser container exposes raw rx/tx byte counters; the manager polls them every five seconds, debits the delta, advances its baseline only once that debit is durable, and terminates the session after three consecutive billing failures. A residential session whose byte counters cannot be reached is refused outright, because an unmeterable session would stream bandwidth nobody can be charged for. That is why the residential rate is per-GB-as-consumed rather than a bundle: there is a live counter behind it.

Browserbase makes the decision earlier and, in one respect, more expressively. Proxies are configured on the Create Session call — its own managed residential pool (proxies defaults to false), your own HTTP/HTTPS proxies, or a list of proxies with domain-pattern rules, where "Proxies are applied in the order they are listed, meaning the first matching rule is used for each request." Geolocation takes a required country plus optional state and city over built-in proxies the docs say cover 201 countries, and custom proxies performing TLS interception can reference an uploaded PEM CA certificate. Per-domain routing has no equivalent on Wayfern, and that is a genuine gap on our side. The trade-off runs the other way too: left as proxies: true, the docs note it "makes a best-effort attempt to use a US-based proxy" and may route through a nearby country such as Canada, and the built-in pool is sourced from third-party providers that restrict banking, government, streaming, ticketing, webmail and gambling domains, with restrictions that vary by session and change over time.

Feature by feature, against the docs

The Wayfern column is what the code in this repository does. The Browserbase column is what its own published documentation states, checked before this page shipped.

Repointing a Playwright script

If your code already talks CDP, the move is a URL change: create no session, mint a link token, and put the exit selectors in the query string. Everything after connectOverCDP() is unchanged, because both ends are the same protocol.

What does not port: a Selenium script has nowhere to land, since Wayfern exposes no WebDriver endpoint. Neither does a context id — there is no Wayfern equivalent to re-attach, so a flow that resumed a logged-in Browserbase context has to log in inside the run. And captcha handling stops being automatic: solveCaptchas has no counterpart on a driven session, so a challenge becomes an explicit call to POST /api/captcha/solve with the sitekey you scraped off the page.

import { chromium } from 'playwright';

// Before: create a session through the Browserbase SDK, then drive the
// CDP endpoint it hands back. Proxy, region, stealth and captcha options
// were all decided in that create call.

// After: Wayfern. There is no create call — the link token IS the
// session, and the exit is selected on the connect URL itself.
const endpoint = new URL('wss://browser.wayfern.com/ws');
endpoint.searchParams.set('token', process.env.WAYFERN_LINK_TOKEN!);
endpoint.searchParams.set('country', 'DE');    // residential exit; omit for datacenter
endpoint.searchParams.set('city', 'Berlin');   // region / city / isp all optional
endpoint.searchParams.set('session', 'run-42'); // sticky exit for the whole run

const browser = await chromium.connectOverCDP(endpoint.toString());
const page = await browser.newPage();
await page.goto('https://example.com');

// Closing is what stops the clock: open-page time bills at
// 8 credits/hour with a 60s minimum per page, and the
// residential meter samples the container every 5 seconds until then.
await browser.close();

Questions that actually decide this one