Open-Source Multi-Account Browsers: What You Get, and What You Give Up
Picture a platform engineer with forty automated profiles on an open-source stack: pinned versions, a patch file carried across three jobs. Chromium ships a stable release on a Tuesday. By Thursday sessions are failing, and the GitHub issue that explains why has fourteen people in it saying "same here" and nobody with merge rights.
It gets fixed in about nine hours. Then it happens again six weeks later.
None of that argues against open source. The tools do what they say. What it shows is the shape of the bill: free at the licence, invoiced in maintenance, due date set by someone else's release calendar. If you're weighing an open-source multi-account browser setup against a paid engine, that's the trade you're pricing. Not features. Cadence.
Three different things wear the same label
"Open-source multi-account browser" covers tools that barely belong in the same paragraph. Sorting them is most of the work.
Automation libraries. Playwright, Puppeteer, Selenium and the wrappers around them. They drive a stock browser through a protocol. Not browsers, not identity tools: they run one session, and what that session looks like is whatever the browser underneath is.
Privacy-focused browsers. Tor Browser, LibreWolf and Brave's per-site randomisation want every user identical to everyone else or randomised per site, not distinct per profile. Excellent for privacy, the wrong tool for ten separate accounts: a uniform fingerprint is shared and a reshuffling one is unstable, and account systems expect a browser that stays the same between visits.
Configurable forks. Camoufox is the serious one: Firefox, with identity parameters set in the browser's own C++ and exposed to Playwright. No injection layer, because there's nothing to inject over.
If the ground-up definitions are new, what a multi-account browser actually is covers the category. This post assumes you're deciding what to run.
What open-source multi-account browsers genuinely get you
Real advantages, stated plainly, because the vendor-written version of this skips them.
Zero licence cost. Chromium is BSD-licensed, Firefox is MPL, the tooling on top mostly permissive. Ten profiles or a thousand, the bill doesn't move.
You can read the code. No closed product matches this. When something behaves oddly you open the diff and know what was and wasn't set, instead of filing a ticket.
It runs on Linux. Matters more than anything else here. Headless on a cheap VPS, in Docker, in CI on every pull request. That's where test farms and scraping fleets of public data live, and the free tooling goes there natively.
It's native to your language. Python, Node, Go, C#: import a library and you're driving a browser. And nobody can reprice you or move a feature behind a tier.
Any team with a platform engineer and a Linux habit should take that list seriously before spending a cent. Against that team, on that stack, the free route often wins the comparison, and it should.
The three bills that arrive later
1. The upgrade treadmill never stops
Chromium ships fast, and every stable release can move a behaviour your configuration depends on. A maintained project catches up in days; an unmaintained one never does, and you won't know which you picked until the week it matters. Pin versions and you're running a browser that's visibly behind. Don't pin, and you're one pip install from a broken fleet.
2. Everything around the engine, you build
Profile storage. Per-profile proxy binding. Per-profile DNS. WebRTC handling. Timezone and language matched to the exit IP. Cookie state that survives a restart. Health checks. Sharing with a teammate without couriering a folder. None of it ships with an automation library, and each piece is a week, then forever.
3. Verification is on you, and so is the clock
There's no regression suite for your profile settings. You find out a change broke something when sessions start failing, the most expensive possible alert, and you infer the cause late from a wave of failed runs.
And nine hours on a Thursday, twice a quarter, plus the profile layer, has a rate. Do that multiplication before calling anything free.
| Automation libraries | Privacy browsers | Camoufox (fork) | Commercial engine | |
|---|---|---|---|---|
| Drives a browser from code | Yes | No | Yes | Yes |
| Identity set in the engine (not injected) | No | No | Yes | Yes |
| Distinct, consistent identity per profile | No | No | Partly | Yes |
| Profile store + state management | Build it | Build it | Build it | Included |
| Per-profile proxy + DNS | Build it | Build it | Build it | Included |
| Runs headless on Linux | Yes | Yes | Yes | No |
| Licence cost | $0 | $0 | $0 | Subscription |
Read the Linux row before the price row. It settles more of these arguments than the price does.
The consistency problem, concretely
Four failure modes that trip real setups. It's the fourth bill, and the biggest.
Canvas noise against a real GPU string. Randomise the canvas but leave WEBGL_debug_renderer_info reporting the actual card, and you've built a machine whose rendering changes while its hardware doesn't. The two values disagree with each other, which makes a profile less stable, not more.
Fonts handled in one place out of three. Most JavaScript approaches override the measurement trick and stop. The Font Access API and @font-face local() are still there. Consistent font sets cover all three together, an engine-level job, not a shim.
Headless defaults nobody checked. A headless session has no real window, so screen and viewport geometry follow headless defaults. Profiles meant to show a laptop-sized viewport report numbers that read as a server, and nobody notices because the script only sees the DOM. True of any API-started browser, ours included: send {"headless": false} when a session must have a real window.
TLS, which happens before any of your JavaScript runs. Your handshake has a stable shape per build, offered in the first packet, outside anything a page script can set. ClickzProtect, our sibling product on the site-owner side, has the difference between browser and TLS fingerprinting written up. They are independent identifiers: getting one consistent buys nothing on the other.
For the full inventory of what sites read, the signals glossary is the reference, and cookieless tracking from the analytics side is worth an hour, written by people whose job is recognising returning visitors without cookies.
Deciding, in order
- Count the accounts you're allowed to hold per platform. One? Stop here. An automation library if you're automating, nothing if you're not. Don't buy identity tooling for a problem you don't have.
- Name where it has to run. If the answer is "a Linux box in CI", the free stack is your stack. That decision is already made, and no Windows/macOS app changes it.
- Price your own hours, and check who maintains the thing. Weeks of platform work plus a recurring patch tax, against a subscription. Look at the last commit date and whether one person holds the keys.
- Re-test after every browser release. Check timezone, language, proxy location and rendering against what you configured. That delta is the maintenance cost, measured rather than guessed.
- Sort the proxy first, always. A proxy address with a poor reputation shapes every layer above it, free or paid.
Things people learn at month three
Four things worth knowing before you need them, whichever route you take.
Don't create a fresh context to get a clean page. new_context() in Playwright builds an incognito context outside the profile, so the profile's cookies and settings aren't applied. Use the existing context and its first page. And browser.close() only disconnects your client; the profile keeps running until something stops it.
Selenium needs ChromeDriver matched to the browser core's major, or Selenium Manager fetches a driver for the machine's own Chrome and the attach fails.
Automation clients should respect the terms of the sites they touch, and your own rate limits. Read a site's terms before automating anything on it.
And resist changing a profile's identity settings once an account is using it: a stable identity is the goal. The automation and API glossary covers the vocabulary; the concurrency and rate-limit notes matter past a handful of profiles.
Where a commercial engine actually differs
Not "it's better", but specifically what's in the box that an open-source multi-account browser setup leaves you to assemble.
JustBrowser is a custom Chromium engine with the identity settings written in C++ and compiled into the core, patched with every upstream release. Real C++ engine patches at the canvas / WebGL / audio / font / screen layer, across 40+ identity parameters. Font sets are gated to the profile's platform at engine level across all three enumeration paths.
Around it: per-profile proxy routing (HTTP, HTTPS, SOCKS5) with a tester reporting exit IP, ISP name, city, timezone, latency and blocklist reputation. Per-profile DNS-over-HTTPS pointed at Cloudflare, Google, Quad9 or your own resolver. WebRTC protection, so a profile's WebRTC does not expose the real IP. Profile health scoring. Owner, admin, member and viewer roles. Encrypted export using AES-256-GCM. For automation, a local REST API on 127.0.0.1:36542, Bearer-authenticated from the app's AI page, with CDP for Playwright, Puppeteer and Selenium. It is local only, and the reference at justbrowser.app/docs is generated from the app's real route registrations, so it can't drift.
The limits, stated rather than buried. Windows x64 and macOS on Apple Silicon only. No Linux build, so the VPS pattern the free tooling is good at isn't available here. No mobile app, though mobile profiles present Chrome on Android's client hints, memory range and touch screen. One plan at $9.99/month or $99.99/year with unlimited profiles, unlimited cloud sync and free team seats; the only free option is a 7-day trial that wants a card. A free seat runs profiles the owner shares with it and nothing else: no cloud sync of its own, no API, no AI tab.
Stop paying and your profiles stay on your machine and keep launching. You can keep up to five local profiles; cloud sync, team sharing and the API pause until you resubscribe.
Frequently Asked Questions
Is there a genuinely good open-source multi-account browser?
Camoufox is the honest answer for engine-level identity settings: a Firefox fork with its identity parameters set in the browser's own C++ rather than injected as JavaScript, and driveable from Playwright. Architecturally it's the right idea. What it doesn't ship is the product layer: no profile store, no per-profile proxy or DNS plumbing, no cloud sync, no team sharing, no health scoring. You get the hard part free and build the rest, which is where the weeks go.
Can't I just use an open-source automation library instead of paying for a multi-account browser?
For a single account, or automating one workflow of your own, often yes, and you should rather than buying what you don't need. Where it stops is keeping several accounts separate. An automation library drives one browser; it doesn't give profile two its own cookies, storage, canvas, GPU string, font set, screen geometry and timezone, separate from profile one. Ten sessions are ten sessions on one machine's identity, not ten separate, consistent profiles for the accounts you legitimately hold.
Is open source more transparent?
Yes, and that is real value no closed product matches. You can read the patch and know precisely what it does. The cost is that you also own every change: when upstream Chromium or Firefox changes a behaviour your configuration depends on, you find out, and you fix it, on someone else's release calendar.
What actually runs on a Linux server, and what doesn't?
This is where the free route wins outright and we won't pretend otherwise. Automation libraries and Camoufox all run headless on a Linux box or in CI, which is why scraping fleets and test farms live there. JustBrowser doesn't: Windows x64 and macOS on Apple Silicon only, no Linux build, so a VPS deployment isn't a path. Worth separating two things: there's no Linux build, but a Linux identity is generatable, and an x86_64 Linux profile runs fine from a Mac or Windows host. The OS you present isn't the OS you run on.
Try JustBrowser
Multi-account browser on a custom Chromium engine, always current with upstream — not extension-based. Real C++ engine patches at the canvas / WebGL / audio / font / screen layer, so 40+ identity parameters are consistent rather than faked. Local REST API + CDP for Playwright, Puppeteer, Selenium. Windows x64 and macOS (Apple Silicon). One plan: $9.99/month or $99.99/year — unlimited profiles, free team seats, 7-day free trial, card required.
Get started → · How it differs from Multilogin / GoLogin / AdsPower
Ready to manage multiple accounts?
Seven days free, then $9.99/month — one plan, everything included.