// Alternatives
Multilogin sells identities you keep. Wayfern sells browser time you drive from code. Which one you want follows almost entirely from that.
Wayfern in one look
// The short answer
This is the part most "alternatives" pages skip. Multilogin is a profile manager, and for a large amount of real work that is exactly the correct shape — Wayfern would be a downgrade.
Stay on Multilogin if an identity has to outlive the run. Its whole product is the durable profile: local or cloud storage with a converter between the two, cookie import and export, pre-made cookies, and a CookieRobot that browses to build history — the tooling that account-aging actually needs. It also gives a person real controls, with more than a dozen documented fingerprint vectors each carrying explicit modes — Masked / Custom / Real, plus Noise on canvas, WebGL and AudioContext, and Disabled on WebRTC and canvas — rather than one anti-detect toggle. Residential, mobile and static ISP proxies are built in, so there is no second vendor to sign up with, and there is a free-forever tier — five cloud profiles, no credit card — which is more than Wayfern offers anyone.
Move to Wayfern when the browser is a dependency of a program rather than a workspace for a person. There is no profile to name, open or age, and nothing to install: you connect a CDP client to a WebSocket and are handed a browser in a hosted container. That trade buys concurrency measured in hundreds of simultaneous pages, per-endpoint rate limits instead of one workspace-wide RPM budget, exit-IP geo selection as query parameters on the connect URL, and a Web Data API — scrape, crawl, map, extract, screenshot, brand, styleguide, fonts — that returns parsed results instead of a browser you then have to drive yourself.
// Architecture
A Wayfern identity lives exactly as long as you hold the socket: you connect, you get a browser in a hosted container, and when the last connection on it closes the container is torn down.
Multilogin inverts that. The profile is the durable object and the browser run is the disposable one — you launch profile 47, it comes back with the cookies, local storage and fingerprint it had last week, and closing it saves that state rather than discarding it. That is why it can support the workflows it does, and why it charges by how many identities you keep.
Wayfern has no such object anywhere in its product. The gateway proxies raw Chrome DevTools Protocol from your client into a browser container; a container is only ever shared by connections carrying the same link token and the same exit, never across links, and it is torn down when the last of those connections closes. State lives only while a connection holds the container, and there is nowhere to save it, name it, export it or deliberately re-open it. If your workflow depends on that, this is a real loss and not a framing difference.
Wayfern has no customer-facing persistent profiles at any plan tier, and no upgrade adds them. Read the capability table below as describing what a customer can actually buy.
// Capabilities
Competitor cells are drawn from Multilogin’s own documentation and pricing page. Where the published material does not settle a question, the cell says so rather than guessing.
| Capability | Wayfern | Multilogin |
|---|---|---|
| Where the browser runs | Only in Wayfern’s hosted containers (headed Chromium on a virtual display), reached over a wss:// CDP endpoint. There is no desktop client in the product. | Multilogin X ships a desktop app and a web interface; the legacy Multilogin 6 was desktop-only and no longer takes new subscriptions. |
| What you install and on what | Nothing. Any machine that can open a WebSocket and speak CDP — no OS floor, no RAM floor, no GUI. | Windows 10+, macOS 14+ or Ubuntu 22+, 64-bit only, minimum 4 GB RAM and 1 GB free disk, GUI required. Apple silicon is supported; the Windows build is not ARM-compatible. |
| Durable named profiles | None. Wayfern has no customer-facing persistent profiles: nothing to name, export or re-open, and container state is gone once the last connection closes. | The core of the product: profiles with local storage or cloud storage for multi-device access, plus a converter to move a profile between the two. |
| Per-profile fingerprint controls | Not a customer-facing knob. The browser exposes Wayfern.getFingerprint / refreshFingerprint / setFingerprint over CDP, but they require a licence token the manager holds server-side, and the fingerprint API is service-account-only. | Thirteen documented vectors configured per profile — WebRTC, timezone, geolocation, languages, screen, fonts, media devices, navigator, WebGL/WebGPU metadata, WebGL graphics, canvas, AudioContext, port-scan protection — each with explicit modes; the product page advertises 55+ settings. |
| How automation attaches | Any CDP client, straight at the gateway: playwright chromium.connectOverCDP(), Puppeteer connect(), or raw CDP frames. The link token in the query string is the entire credential. | Selenium, Puppeteer and Playwright, plus Python scripts, a CLI and Postman endpoints — but only over a remote WebDriver connection to the launcher; a local WebDriver breaks automation. |
| Headless launching | Not a setting. The browser runs in a hosted container (headed Chromium on a virtual display), so there is nothing to install or display locally and no headless switch to manage. | Opt-in per launch: headless_mode=true on the launcher endpoint, --profile-id <id>:true via the CLI, or "is_headless": true in the Postman body. |
| API rate limits | Per-endpoint throttles rather than one shared budget: 60/min scrape, 30/min screenshot, brand, styleguide, fonts and map, 20/min extract, 10/min crawl starts, 240/min crawl polling. | 50 requests per minute on Pro 10 and 100 RPM on Pro 50, Pro 100 and Business — shared across every team member in the workspace, not per seat. |
| Exit-IP geo control | country, region, city, isp and a sticky session id as query parameters on the connect URL, against a catalog you can browse from the dashboard. Web Data calls take proxy=auto|datacenter|residential, where auto uses a datacenter exit and retries residential only when the site blocks it. | Built-in Multilogin proxy with residential, mobile and static ISP options, favourite locations, a proxy template manager and a traffic saver; the product page advertises 150+ countries and 1,400+ cities. |
| Free tier | None. Opening a browser requires an active subscription or a positive credit-pack balance; without either, the gateway refuses the connection. | Free forever with no credit card: 5 cloud profiles (browser and mobile combined, including 1 mobile), plus one-time bonuses of 200 MB proxy traffic and 30 mobile minutes. |
| Structured-data endpoints | Eight: scrape, crawl, map, extract, screenshot, brand profile, styleguide and fonts, plus web search — all billed from the same credit balance as sessions. | (not published) |
| Concurrent browsers | 20 on Developer, 100 on Business, 400 on Scale, enforced live — a session is terminated if the account can no longer pay for it. | (not published) |
// Architecture
Wayfern routes datacenter egress for free and only escalates to a residential exit when you ask for one or when a page is classified as blocked, metering the bytes as they move.
Multilogin bundles proxy bandwidth into the plan: 1 GB a month on Pro 10, 3 GB on Pro 50, 5 GB on Pro 100 and 10 GB on Business, with a traffic saver to stretch it. That is the right model for account work, where the traffic is a person clicking through a handful of sites and the allowance is effectively invisible.
Wayfern meters instead of allocating, because a scraping run’s bandwidth is not predictable enough to bundle. Datacenter egress costs nothing and is not counted. A residential exit is billed per byte at 320 credits per GB: a sidecar in the container counts real rx+tx, the manager samples it every five seconds, debits the elapsed bytes, and terminates the session when the account can no longer pay. A session that cannot be metered is refused outright rather than allowed to stream unbilled.
The practical consequence is that a heavy month costs more on Wayfern than a plan allowance would, and a light month costs nothing at all. Neither model is more honest than the other; they are sized for different traffic shapes.
// Pricing model
The two price lists do not convert into one another, so comparing headline numbers is meaningless. Compare the units.
Multilogin prices the identity. Pro tiers are a profile count with a seat count and a bandwidth allowance attached — 10 profiles / 1 seat, 50 profiles / 2 seats, 100 profiles / 5 seats — and Business is a slider from 300 to 10,000 profiles with unlimited seats. On monthly billing the Pro tiers run $11, $29 and $40 a month and Business runs $89 a month at 300 profiles to $900 at 10,000; annual billing advertises 35% off, with the Pro tiers at $85, $230 and $320 a year and the Business slider’s own figures running $685 to $6,885 a year. What you never pay for is usage: a profile you open every day and a profile you open once cost the same.
Wayfern has no profile line item at all. A plan buys a monthly credit grant, a concurrency ceiling and seats — Developer at $19/mo grants 1,520 credits, 20 concurrent pages and 1 seat; Business at $99/mo grants 9,000 credits, 100 concurrent pages and 10 seats; Scale at $499/mo grants 46,000 credits, 400 concurrent pages and 50 seats. Everything then burns from that one balance: 8 credits per open-page hour, prorated per second with a 60-second floor on each page, 320 credits per GB of residential egress, and a scrape at 1 credit per page. Credit packs are one-time and roll over; plan grants do not.
So the question that decides it is not "which is cheaper" but "what does my cost scale with". If it scales with how many accounts you hold, Multilogin’s unit matches your bill and Wayfern’s does not. If it scales with how many pages you open, the reverse is true — and a Multilogin plan large enough to hold the identities is beside the point, because the bandwidth allowance runs out first.
// Migration
On Multilogin the script talks to the launcher, not to the browser: you start a profile through the launcher endpoint and attach a remote driver to what it returns. The documentation is explicit that this must be a remote WebDriver — a local one breaks automation — so the profile id and the launcher are load-bearing parts of every script.
On Wayfern there is no launcher and no profile id. You point a CDP client at the gateway and the link token in the query string is the whole credential; exit geo is set on the same URL. Link tokens are named, revocable, can carry an expiry, and each one has its own concurrency cap between 1 and 100, so a runaway job is bounded by the credential rather than by the plan.
The part that does not port is state. There is no equivalent of re-opening profile 47 tomorrow with its cookies intact, so anything that depended on that has to be rebuilt around storage you own — inject cookies at the start of a run and read them back before you disconnect, or keep the workload stateless.
multilogin launcher → wayfern gateway
// Multilogin: start the profile through the launcher, then attach a REMOTE
// driver to what it hands back. A local WebDriver will break automation.
//
// GET …/start?automation_type=puppeteer&headless_mode=true
// Wayfern: no launcher, no profile id. Connect straight to the gateway.
import { chromium } from 'playwright';
const url = new URL('/ws', process.env.WAYFERN_GATEWAY); // wss://…
url.searchParams.set('token', process.env.WAYFERN_LINK_TOKEN);
// Optional: pick the residential exit. Omit these and you egress datacenter,
// which is free and unmetered.
url.searchParams.set('country', 'de');
url.searchParams.set('city', 'berlin');
url.searchParams.set('session', 'run-42'); // sticky exit for this run
const browser = await chromium.connectOverCDP(url.toString());
const context = browser.contexts()[0];
// State you care about is yours to carry — nothing is saved for you.
await context.addCookies(JSON.parse(await fs.readFile('session.json', 'utf8')));
const page = await context.newPage();
await page.goto('https://example.com');
await fs.writeFile('session.json', JSON.stringify(await context.cookies()));
await browser.close(); // closes the session; billing stops// FAQ
No, and treating it as one will go badly. Multilogin manages persistent identities for a person; Wayfern rents browser time to a program. If your work is "log into forty accounts and keep them warm", Wayfern has no feature that does that and you should stay where you are.
No. Wayfern has no customer-facing persistent profiles. Each connection is proxied into a hosted container that is only shared with connections from the same link token and the same exit, and the container is torn down when the last of them closes. Anything you want to survive has to be exported by your own code before you disconnect and injected again next time.
No. Multilogin documents more than a dozen fingerprint vectors per profile with explicit Masked, Custom, Real, Noise and Disabled modes, and that granularity has no equivalent on Wayfern. Wayfern’s browser does implement fingerprint refresh over CDP, but the commands require a licence token the manager keeps server-side and never returns, and the fingerprint API itself is limited to service accounts. Assume you cannot hand-tune identity on Wayfern.
Differently enough that it can decide the choice. Multilogin publishes 50 requests per minute on Pro 10 and 100 RPM on Pro 50, Pro 100 and Business, shared across every member of the workspace — so a second engineer halves your headroom. Wayfern throttles per endpoint instead: 60/min for scrape, 30/min for screenshot and the site reports, 20/min for extract, 10/min for starting a crawl and 240/min for polling one, on top of a plan concurrency cap of 20, 100 or 400 simultaneously open pages.
No. Multilogin has a free-forever plan with five cloud profiles and no credit card. Wayfern has no free tier for browser sessions: the gateway checks for an active subscription or a positive credit-pack balance before it will open a container, and refuses the connection otherwise.
For residential egress, yes — exits are selected by country, region, city and ISP on the connect URL, with a sticky session id, and billed per byte rather than bought as an allowance. Multilogin also bundles proxies, and additionally offers mobile and static ISP exits, which Wayfern’s published surface does not; if you need those specifically, its built-in proxy is the stronger option.
// Keep reading
// Next step
Browser sessions, the Web Data API, search and captcha solving all draw on one credit balance. Plans start at $19 a month for 1,520 credits; there is no free tier.