Browserless is a broad platform with a real free tier and six engines — here is the shape of work it is not built for, and what Wayfern does with that work instead.
Browserless does several things Wayfern does not do at all. Switching platforms to escape one constraint and losing three capabilities is a downgrade, so read this first.
Stay if the engine matters. Browserless documents six browsers — Chromium, a genuine Chrome build carrying proprietary codecs, a hardened Stealth build, Firefox, WebKit and Edge — and Wayfern is Chromium only. Stay if you want interfaces above raw browser code: BrowserQL lets you write GraphQL mutations (click, type, solve, proxy, liveURL, mapSelector, markdown) instead of imperative automation, and the stateless REST surface covers one-off work including /performance, which returns Lighthouse SEO, accessibility and speed metrics as JSON. Its documented CAPTCHA enum also reaches places Wayfern’s solve API does not: DataDome, PerimeterX, Akamai, AWS WAF, mtcaptcha, Yandex. And it has a free tier — $0, 1,000 units a month, no card — so you can test before you pay, which Wayfern does not offer.
Look at Wayfern when the run is long, the logged-in identity has to survive all of it, and you would rather derive the bill than model it. Browserless sets maximum session length by plan tier, from 1 minute on Free to 60 minutes on Scale, and rehydrates state from authenticated profiles capped at 2 MB across 50 origins. Wayfern publishes no per-plan session ceiling: the session is the socket, billed at 8 credits per open-page hour with a 60-second minimum, and it ends when you close it or when the balance runs out. Residential exit geo is chosen on that same URL, and residential bandwidth is metered per byte rather than bundled into an abstract unit.
Not what each costs — what each counts. Both are published, and they count different things, which is why a like-for-like table would be fiction.
Browserless meters in units. A plan bundles a monthly unit allowance with a concurrency limit, a maximum session length, a storage retention window and a per-unit overage rate. Billed annually, that is: Free at $0 for 1,000 units, 2 concurrent browsers, 1-minute sessions and 1-day storage; Prototyping at $25/month for 20,000 units, 15 concurrent (+5 boost), 15-minute sessions, 7-day storage and $0.0020 per extra unit; Starter at $140/month for 180,000 units, 40 concurrent (+10), 30-minute sessions, 30-day storage and $0.0017 overage; Scale at $350/month for 500,000 units, 100 concurrent (+20), 60-minute sessions, 90-day storage and $0.0015 overage; Enterprise is custom. The pricing page states annual billing saves 30% against monthly without displaying the monthly rate, so the month-to-month figure has to be inferred.
Wayfern meters in one fungible credit, and every billable action debits the same balance. An open page costs 8 credits per hour with a 60-second minimum bill per page. Residential egress costs 320 credits per GB, metered from the container’s own byte counters on a five-second sample rather than estimated. Datacenter egress is free. A CAPTCHA solve is 1 credit and is debited only after the solve succeeds. The Web Data endpoints price per unit of work: 1 credit per scraped page, 1 per successful page, 5 per capture, 1 per uncached source page.
The practical difference is what you have to model. A unit abstracts several dissimilar resources behind one number, so forecasting spend means learning the per-feature unit cost of each endpoint you use. A Wayfern forecast is arithmetic on two quantities you already know: how many page-seconds your run holds open and how many bytes it pulls through a residential exit. Plans buy the balance — Developer at $19/month grants 1,520 credits and 20 concurrent sessions, with the ladder running 20 / 100 / 400 concurrent up to Scale — and non-expiring credit packs top it up.
Where Browserless is straightforwardly better on this axis: it publishes a per-unit overage rate for every paid self-serve tier and gives you a free tier to validate on. Wayfern has neither. There is no free plan — starting a session requires an active subscription or a positive credit-pack balance — so the cheapest way in is Developer at $19/month.
Top: a run split into stateless calls, each starting from a browser that kept nothing from the last one. Bottom: one CDP socket held open for the whole run, so cookies and the live DOM survive from the login to the last page.
Browserless can draw both halves of that picture, and it says so plainly: BaaS v2 is a WebSocket you connect Puppeteer or Playwright to with persistent sessions, the REST endpoints are one-shot and stateless, and BrowserQL is a declarative layer over the same managed browsers. Nothing here is a limitation of the interface.
The constraint is time. Maximum session length is a plan attribute — 1 minute on Free, 15 on Prototyping, 30 on Starter, 60 on Scale — so a run that outlives its tier has to be decomposed into calls that each begin with an empty browser, or rehydrated from an authenticated profile. Profiles are a genuinely good feature: they capture cookies with their HttpOnly, Secure and SameSite attributes, localStorage for every origin touched, and IndexedDB stores, and restore into an isolated working copy when you pass ?profile= on a launching request. They are also bounded — 2 MB of state, 50 origins, 5 IndexedDB databases per origin, 1,000 entries per object store, removed after 30 unused days — and Chromium-family only, with the /reconnect/* endpoints rejecting ?profile= outright.
Wayfern only draws the bottom half. There is no REST call that creates a session; opening the WebSocket to wss://browser.wayfern.com/ws with a link token IS the session, and it lives until you close the socket. A mid-session meter re-checks the balance every 30 seconds and terminates a session that can no longer pay, which is the only clock on it. Concurrency is the plan cap (20 / 100 / 400 sessions), enforced globally rather than per process, and a gateway browser is never shared across links or across different residential exits.
The cost of only drawing the bottom half is real and worth stating: Wayfern’s gateway has no profile store. State lives in the session you are holding. When you close it, the logged-in identity goes with it, and the next run authenticates again. If your workload is many short visits that must each look like a returning user, Browserless’s profiles do something Wayfern currently does not.
Every Browserless cell is read from its own published docs. Cells the docs do not cover are marked rather than guessed.
| Capability | Wayfern | Them |
|---|---|---|
| Browser engines | Chromium only, driven with Playwright or Puppeteer over CDP. | Chromium, Chrome (with proprietary codecs), Stealth, Firefox, WebKit and Edge — though Firefox, WebKit and Edge are Playwright-only and have no stealth build. |
| Interfaces | One CDP WebSocket, plus a REST Web Data API (scrape, crawl, map, extract, screenshot, brand, styleguide, fonts) and a captcha endpoint. | Three: BaaS v2 over WebSocket, stateless REST endpoints, and BrowserQL GraphQL mutations over HTTPS. |
| Session length | No per-plan ceiling; billed per second at 8 credits/hour with a 60s minimum, ended by the 30s balance check. | A plan attribute: 1 minute on Free, 15, 30, then 60 minutes on Scale. |
| Saved logged-in state | None on the gateway — state lives in the open session and is gone when the socket closes. | Authenticated profiles capture cookies, localStorage and IndexedDB, restored with ?profile=; capped at 2 MB and 50 origins, deleted after 30 unused days. |
| Exit control | Residential exit selected per connection on the same socket URL (country, region, city, ISP, sticky session id), validated against the live catalog served at `GET /api/proxy/locations`. | Built-in residential and datacenter networks with country and city targeting, sticky exits via proxySticky, and bring-your-own proxies that consume no proxy units. |
| Bandwidth billing | Residential egress metered per byte at 320 credits/GB on a five-second sample; datacenter egress free. | Proxy usage consumes units; a per-GB residential rate is not published. (not published) |
| CAPTCHA coverage | Eight anti-captcha task types — reCAPTCHA v2, v2 Enterprise and v3, hCaptcha, Turnstile, FunCaptcha, GeeTest, image-to-text — proxyless only, 1 credit charged on success. | The BQL solve enum documents far more, including Cloudflare, DataDome, PerimeterX, Akamai, AWS WAF, GeeTest, FunCaptcha, mtcaptcha and Yandex. |
| OS / device identity | Fingerprint refresh takes an OS (Windows, macOS, Linux) with timezone, language and lat/long overrides — a service-account API, not exposed on self-serve plans. | emulationOs accepts windows, macos, linux and android with device slugs; no iPhone, iOS or Safari persona, fixed at session creation, and silently inert on plain /chromium and /chrome routes. |
| Beyond the browser | Crawl with webhooks (1 credit/successful page), sitemap-first URL discovery, schema extraction, brand, styleguide and font reports. No Lighthouse endpoint. | /crawl walks a whole site asynchronously with depth and path filters, /performance returns Lighthouse metrics as JSON, plus /search, /unblock, /function and /export. |
For BaaS v2 code the move is one URL. Both platforms are CDP over a WebSocket authenticated by a token in the query string, so `connectOverCDP` / `puppeteer.connect` and every line of page-level automation after it stay exactly as they are. On Wayfern the exit geo and sticky-session id ride on that same URL, so there is no separate proxy configuration step.
REST work has close equivalents: /content and /scrape map onto POST /api/v1/scrape, /screenshot onto POST /api/v1/screenshot, and /crawl onto POST /api/v1/crawl, which returns a job id immediately and reports through polling or signed webhooks. Wayfern adds map, extract, brand, styleguide and fonts on the same envelope, each returning the credits it debited. Scraping stays at 1 credit per page.
What does not port: every BrowserQL mutation, /function, /unblock, /export, /download, the Lighthouse /performance endpoint, and anything targeting Firefox, WebKit or Edge. Declarative BQL flows become imperative Playwright on a held session; the Firefox and WebKit targets have no equivalent at all, and for some teams that alone settles the question.
import { chromium } from "playwright";
// Before — Browserless BaaS v2: token in the query string.
// const browser = await chromium.connectOverCDP(
// `wss://${BROWSERLESS_HOST}/chromium?token=${process.env.BROWSERLESS_TOKEN}`,
// );
// After — Wayfern: same call, different origin. The socket IS the session,
// and the residential exit is chosen on the same URL.
const browser = await chromium.connectOverCDP(
"wss://browser.wayfern.com/ws?token=" + process.env.WAYFERN_LINK_TOKEN +
"&country=US&session=run-42",
);
// Unchanged from here down.
const page = await browser.contexts()[0].newPage();
await page.goto("https://example.com");Only the connect string. Wayfern speaks CDP over a WebSocket with the token in the query string, so `chromium.connectOverCDP()` and `puppeteer.connect()` both work and everything after the connection is ordinary Playwright or Puppeteer. The exception is engine coverage: Wayfern runs Chromium, so any suite pinned to Browserless’s Firefox, WebKit or Edge targets does not move.
No. Browserless profiles are a stored artifact on their side — cookies, localStorage and IndexedDB restored with ?profile= — and Wayfern’s gateway has no profile store to import them into. State lives in the session you hold open, so a Wayfern run authenticates and then does its work inside that one socket. If short repeated visits from a persistent identity are your pattern, this is the strongest reason to stay put.
You stop buying units and start buying credits, and the meter becomes literal. An open page costs 8 credits an hour with a 60-second minimum, residential bandwidth costs 320 credits per GB metered from real byte counters, datacenter egress is free, and a captcha solve is 1 credit charged only when it succeeds. Session-heavy work with modest bandwidth is the profile that benefits; unit-cheap one-shot REST calls are not obviously better off.
Not on Wayfern. Starting a session needs an active subscription or a positive credit-pack balance, so the entry point is Developer at $19/month for 1,520 credits and 20 concurrent sessions. Browserless does have one: $0, 1,000 units a month, 2 concurrent browsers, 1-minute sessions, no card required. If evaluating without a card is a requirement, start there.
Wayfern exposes a solve endpoint covering eight proxyless anti-captcha task types (reCAPTCHA v2, v2 Enterprise and v3, hCaptcha, Turnstile, FunCaptcha, GeeTest, image-to-text) at 1 credit per successful solve, and you apply the returned token in your own page code. Browserless’s BQL solve mutation is invoked inside the flow and its documented enum spans a wider set, including Cloudflare, DataDome, PerimeterX, Akamai and AWS WAF. For targets behind those specific vendors, check their coverage before moving.
Browser sessions, the Web Data API, search and captcha solving all draw on one credit balance. Start on any of them.