Wayfern vs Multilogin

Verdict: profiles you manage, or sessions you open

Who should stay on Multilogin — and who should not

How the exit gets chosen: per profile, or per connection

Multilogin binds a proxy to a profile; Wayfern picks the exit on the connection and bills the two exit types differently. On Multilogin the proxy is part of a profile’s configuration. The platform bundles its own residential, mobile and static ISP proxies with a monthly traffic allowance, plus favourite locations and a proxy template manager, so the exit is something you set up once alongside the fingerprint and then stop thinking about.

On Wayfern the exit is chosen on the connection itself: `?country=&region=&city=&isp=&session=` on the CDP WebSocket URL, validated against a live catalog served at `GET /api/proxy/locations`. Leave `country` off and the session egresses from the datacenter, which is free. Supply it and a residential exit is provisioned for that connection alone, while a sidecar samples the container’s real rx+tx bytes every five seconds and debits them as they are spent — a session that can no longer pay for its bandwidth is terminated rather than quietly run on.

The Web Data endpoints add the escalation the diagram draws. In `auto` mode a page is fetched through the datacenter exit first and retried through a residential exit only when the navigation is classified as a bot wall, so residential bytes are spent on the handful of pages that actually need them instead of on the whole crawl.

Multilogin and Wayfern, capability by capability

Wayfern’s column is what this codebase does today. Multilogin’s column is what their own published documentation says; where we could not verify something, the cell says so instead of guessing.

Porting a Multilogin automation script

The shape of the change is: delete the launch step. Multilogin’s automation path starts a profile through the launcher endpoint and then attaches a remote WebDriver — and only a remote one. Wayfern has no launch call at all. Opening the CDP socket creates the session, closing it ends the session and stops the meter, and the same URL carries the exit you want.

What does not port is the profile. There is no Wayfern object that remembers a fingerprint, a cookie jar and a proxy between runs, so anything you were relying on a profile to hold has to be read out over CDP and re-applied on the next connection — or left on Multilogin, which is a perfectly reasonable answer for the accounts that genuinely need to age.

import { chromium } from "playwright";

// Multilogin: start the profile through the launcher endpoint, then attach a
// REMOTE WebDriver (a local one breaks automation).
//
// Wayfern: there is no launch call. Opening this socket IS the session, and
// closing it is what ends it and stops the meter.
const browser = await chromium.connectOverCDP(
  "wss://browser.wayfern.com/ws?token=" + process.env.WAYFERN_LINK_TOKEN +
    "&country=US&region=CA&session=run42",
);

// Omit country= and the session leaves through datacenter egress, which is
// free. Supplying it provisions a residential exit for this connection only,
// metered per byte for as long as the socket stays open.
const page = await browser.contexts()[0].newPage();
await page.goto("https://example.com");
console.log(await page.title());

// Nothing here outlives the socket. Read out any cookies or storage state you
// need to reuse before you close it.
await browser.close();

Profile slots versus a credit balance

Not what each one costs — what each one counts.

Multilogin counts profiles. Every tier is a number of browser profiles with seats and a monthly proxy-traffic allowance attached: a free plan with 5 cloud profiles and no card, three Pro tiers, and a Business slider from 300 to 10,000 profiles with unlimited seats. Pricing is published openly and a yearly toggle advertises 35% off. If you know how many identities you need to keep alive, you can price the year exactly.

Wayfern counts seconds and bytes. A plan is a flat monthly fee that grants credits and a concurrency cap — Developer at $19/mo grants 1,520 credits and 20 concurrent open pages, Business at $99/mo grants 9,000 credits and 100 concurrent open pages, Scale at $499/mo grants 46,000 credits and 400 concurrent open pages — and everything draws on that one balance. An open page costs 8 credits an hour (about $0.10) with a 60-second minimum bill, residential egress costs 320 credits per GB (about $4) metered per byte as it is used, datacenter egress is free, and the Web Data endpoints price per page. Paying yearly takes 20% off, and credit packs are one-time and non-expiring, so unspent balance rolls forward.

The two models fail in opposite directions, which is the useful thing to know before you pick one. On a profile meter, an identity you open twice a month costs the same as one you drive all day, so idle identities are the expensive case. On a credit meter there is no per-identity cost at all, so ten thousand short sessions are cheap — and one browser you leave open for a week is not.

Before you switch