Stealth Chromium that passes every bot detection test.
| Not a patched config. Not a JS injection. A real Chromium binary with fingerprints modified at the C++ source level. Antibot systems score it as a normal browser — because it is a normal browser. |

Cloudflare Turnstile — 3 live tests passing (headed mode, macOS)
Drop-in Playwright/Puppeteer replacement for Python and JavaScript.
Same API, same code — just swap the import. 3 lines of code, 30 seconds to unblock.
- 87 source-level C++ patches — canvas, WebGL, audio, fonts, GPU, screen, WebRTC, network timing, automation signals, CDP input behavior
humanize=True— human-like mouse curves, keyboard timing, and scroll patterns. One flag, behavioral detection passes- Pro: 0.9 reCAPTCHA v3 score — human-level, server-verified
- Passes Cloudflare Turnstile, FingerprintJS, BrowserScan — tested against 50+ detection sites
- Auto-downloads the right binary — the latest build for your platform
pip install cloakbrowserornpm install cloakbrowser— binary auto-downloads, zero config- Latest binary, free to try — get a free key with your email (or just launch: the first run asks), point the newest build at your hardest target, scale to thousands of sessions on Pro
Try it now — no install needed. The first run asks for a key: get one free with your email, or paste yours:
docker run --rm -it cloakhq/cloakbrowser cloaktestPython:
from cloakbrowser import launch
browser = launch()
page = browser.new_page()
page.goto("https://example.com")
browser.close()JavaScript (Playwright):
import { launch } from 'cloakbrowser';
const browser = await launch();
const page = await browser.newPage();
await page.goto('https://example.com');
await browser.close();Also works with Puppeteer: import { launch } from 'cloakbrowser/puppeteer' (details)
For sites with anti-bot protection, add a residential proxy and these flags:
browser = launch(
proxy="http://user:pass@residential-proxy:port", # residential IP, not datacenter
geoip=True, # match timezone + locale to proxy IP
headless=False, # some sites detect headless even with C++ patches
humanize=True, # human-like mouse, keyboard, scroll
)const browser = await launch({
proxy: 'http://user:pass@residential-proxy:port',
geoip: true,
headless: false,
humanize: true,
});See Troubleshooting for site-specific issues (Kasada, Akamai, reCAPTCHA).
Install
Python:
pip install cloakbrowserJavaScript / Node.js:
# With Playwright
npm install cloakbrowser playwright-core
# With Puppeteer
npm install cloakbrowser puppeteer-core.NET / C#:
dotnet add package CloakBrowserCommunity-maintained .NET client built on Microsoft.Playwright. See
dotnet/README.mdfor the full API.
On first run, the stealth Chromium binary is automatically downloaded (~200MB, cached locally).
License key: every launch needs one, and a free key takes one email. The first launch in a terminal asks: get a free key (opens the signup page and continues once you confirm your email) or paste a key you have. In CI, Docker, or any run without a terminal, set CLOAKBROWSER_LICENSE_KEY (get one with cloakbrowser login or at cloakbrowser.dev/free).
Optional: Auto-detect timezone/locale from proxy IP:
pip install 'cloakbrowser[geoip]'Migrating from Playwright? One-line change:
- from playwright.sync_api import sync_playwright
- pw = sync_playwright().start()
- browser = pw.chromium.launch()
+ from cloakbrowser import launch
+ browser = launch()
page = browser.new_page()
page.goto("https://example.com")
# ... rest of your code works unchanged⭐ Star to show support — Watch releases to get notified when new builds drop.
Latest: v0.7.2 — 87 source-level stealth patches (Chromium 156.0.8078.47.1)
- CloakBrowser Pro Stable — Chromium
156.0.8078.47.1on Linux x64, Linux ARM64, Windows x64, and macOS (Apple Silicon and Intel). Set alicense_key(licenseKeyin JS) or theCLOAKBROWSER_LICENSE_KEYenv var and the wrapper fetches the latest Stable build for your platform automatically. See CloakBrowser Pro - .NET 8 / C# client — CloakBrowser now ships as a NuGet package (
CloakBrowser), mirroring the Python and JS wrappers. - Chromium 156 upgrade — rebased the full patch set onto Chromium 156 on every platform
- 87 fingerprint patches — rendering consistency improvements across Linux and Windows, corrected GPU/display/graphics parameters to match stock Chrome profiles
- Windows native GPU passthrough — real hardware values pass through directly instead of being spoofed, matching real browser behavior
- HTTP proxy inline credentials — new network-layer support for proxies with inline authentication
extension_paths— load Chrome extensions in all launch functions- Humanize actionability — auto-wait for visible, enabled, stable elements before humanized actions
- Per-call
human_config— override humanize settings on individual method calls - Composable JS helpers —
buildLaunchOptions()andhumanizeBrowser()for custom Playwright integrations - Native SOCKS5 proxy —
proxy="socks5://user:pass@host:port"works directly in all launch functions, Python + JS. QUIC/HTTP3 tunnels through SOCKS5 via UDP ASSOCIATE - Proxy signal removal — DNS/connect/SSL timing zeroed, proxy cache headers stripped, Proxy-Connection header leak removed
- WebRTC IP spoofing —
--fingerprint-webrtc-ip=autoresolves your proxy's exit IP and spoofs WebRTC ICE candidates. Auto-injected when usinggeoip=True(no extra network call) humanize=True— one flag makes all mouse, keyboard, and scroll interactions behave like a real user. Bézier curves, per-character typing, realistic scroll patterns- Stealthy with zero flags — binary auto-generates a random fingerprint seed at startup. No configuration required
- Timezone & locale from proxy IP —
launch(proxy="...", geoip=True)auto-detects timezone and locale - Persistent profiles —
launch_persistent_context()keeps cookies and localStorage across sessions
See the full CHANGELOG.md for details.
Why CloakBrowser?
- Config-level patches break —
playwright-stealth,undetected-chromedriver, andpuppeteer-extrainject JavaScript or tweak flags. Every Chrome update breaks them. Antibot systems detect the patches themselves. - CloakBrowser patches Chromium source code — fingerprints are modified at the C++ level, compiled into the binary. Detection sites see a real browser because it is a real browser.
- Source-level stealth — C++ patches handle fingerprints (GPU, screen, UA, hardware reporting) at the binary level. No JavaScript injection, no config-level hacks. Most stealth tools only patch at the surface.
- Same behavior everywhere — works identically local, in Docker, and on VPS. No environment-specific patches or config needed.
- Works with AI agents and automation frameworks — drop-in stealth for browser-use, Crawl4AI, Scrapling, Stagehand, LangChain, Selenium, and more. See integrations.
CloakBrowser doesn't solve CAPTCHAs — it prevents them from appearing. No CAPTCHA-solving services, no proxy rotation built in — bring your own proxies, use the Playwright API you already know.
CloakBrowser Pro
Anti-bot systems change every week and an older binary quietly degrades. The latest build is the one that keeps passing. Try it free, then upgrade when you're running for real.
- Free, latest build (Chromium 156) — the newest binary, the exact one that stays green against live detection. Free with your email, one concurrent session. Just launch (the first run asks), run
cloakbrowser login, or grab your key, then throw it at your hardest target. - Pro — when it's part of production scraping, QA, monitoring, or automation: scale to 5, 20, 200, 2,000, or more concurrent sessions, always first on the newest patches, with hands-on support. Linux, Windows, macOS. See plans and pricing →
cloakbrowser login # get a free key by email, or paste a key you have
# ...or set it directly (env var, license_key= param, or ~/.cloakbrowser/license.key):
export CLOAKBROWSER_LICENSE_KEY=cb_xxxxxxxxTry the latest free → cloakbrowser.dev/free · Scale up on Pro → cloakbrowser.dev
CloakBrowser Manager
The anti-detect browser, with a GUI. A self-hosted alternative to Multilogin, GoLogin, and AdsPower, running on this same engine, on your own machine, not someone else's cloud.
Every profile is a genuinely separate computer: its own fingerprint, GPU, screen, timezone, proxy, cookies, and history. Nothing bleeds between them. Close a profile, reopen it next month, and it's the same person, warmed up and ready.
- Unlimited profiles — the big brands charge per profile and push you up a tier when you hit the ceiling. Here profiles are unlimited and you pay only for how many run at the same time. A drawer full of dormant accounts costs nothing.
- Native desktop app — profiles open as normal windows on Windows and macOS. On a Linux server they run in Docker and stream to your browser.
- The real engine — most profile managers inject JavaScript into a stock browser. Every profile here runs the patched Chromium binary this repo ships.
- Automate what you can see — every running profile exposes a CDP endpoint. Drive it with Playwright or Puppeteer while you watch the exact same window live.
- One key, both products — your CloakBrowser key works in the Manager too. Free with your email for one profile at a time.
It's also the fastest way to try the browser without writing any code: download, create a profile, click Launch.
Get the Manager → · Manager repo — the GUI is open source (MIT)
Test Results
All tests verified against live detection services. Results below are for the latest Pro/current build unless noted. Last tested: Nov 2026 (Chromium 156).
| Detection Service | Stock Playwright | CloakBrowser | Notes |
|---|---|---|---|
| reCAPTCHA v3 | 0.1 (bot) | 0.9 (human) | Pro/current build; server-side verified |
| Cloudflare Turnstile (non-interactive) | FAIL | PASS | Auto-resolve |
| Cloudflare Turnstile (managed) | FAIL | PASS | Single click |
| ShieldSquare | BLOCKED | PASS | Production site |
| FingerprintJS bot detection | DETECTED | PASS | Pro/current build; demo.fingerprint.com |
| BrowserScan bot detection | DETECTED | NORMAL (4/4) | browserscan.net |
| bot.incolumitas.com | 13 fails | 1 fail | WEBDRIVER spec only |
| deviceandbrowserinfo.com | 6 true flags | 0 true flags | isBot: false |
navigator.webdriver |
true |
false |
Source-level patch |
navigator.plugins.length |
0 | 5 | Real plugin list |
window.chrome |
undefined |
object |
Present like real Chrome |
| UA string | HeadlessChrome |
Chrome/156.0.0.0 |
No headless leak |
| CDP detection | Detected | Not detected | isAutomatedWithCDP: false |
| TLS fingerprint | Mismatch | Identical to Chrome | ja3n/ja4/akamai match |
| Tested against 50+ detection sites |
Proof

Pro/latest build: reCAPTCHA v3 score 0.9 — server-side verified (human-level)

Cloudflare Turnstile non-interactive challenge — auto-resolved

BrowserScan bot detection — NORMAL (4/4 checks passed)

Pro/latest build: FingerprintJS web-scraping demo — data served, not blocked

deviceandbrowserinfo.com behavioral bot detection — "You are human!" with humanize=True (24/24 signals passed)
Comparison
| Feature | Playwright | playwright-stealth | undetected-chromedriver | CloakBrowser |
|---|---|---|---|---|
| reCAPTCHA v3 score (Pro/current) | 0.1 | 0.3-0.5 | 0.3-0.7 | 0.9 |
| Cloudflare Turnstile | Fail | Sometimes | Sometimes | Pass |
| Headless / Docker detection | Flagged | Flagged | Flagged | Passes |
| Patch level | None | JS injection | Config patches | C++ (Chromium) |
| Survives Chrome updates | N/A | Breaks often | Breaks often | Yes |
| Maintained | Yes | Stale | Stale | Active |
| Browser engine | Chromium | Chromium | Chrome | Chromium |
| Playwright API | Native | Native | No (Selenium) | Native |
How It Works
CloakBrowser is a thin wrapper (Python + JavaScript) around a custom-built Chromium binary:
- You install →
pip install cloakbrowserornpm install cloakbrowser - First launch → asks for a license key if you have none (free by email), then the latest build auto-downloads for your platform
- Every launch → Playwright or Puppeteer starts with our binary + stealth args
- You write code → standard Playwright/Puppeteer API, nothing new to learn
The binary includes 87 source-level patches covering canvas, WebGL, audio, fonts, GPU, screen properties, WebRTC, network timing, hardware reporting, automation signal removal, and CDP input behavior mimicking.
These are compiled into the Chromium binary — not injected via JavaScript, not set via flags.
Binary downloads are verified against a pinned Ed25519 signature on the published checksums before extraction, so the download is confirmed authentic (genuinely ours) and not just intact. A compromised mirror cannot serve a tampered or downgraded binary.
API
launch()
from cloakbrowser import launch
# Basic — headless, default stealth config
browser = launch()
# Headed mode (see the browser window)
browser = launch(headless=False)
# Pass a key explicitly (free via `cloakbrowser login`, or paid); otherwise the env var or saved key is used
browser = launch(license_key="cb_xxxxxxxx")
# With proxy (HTTP or SOCKS5)
browser = launch(proxy="http://user:pass@proxy:8080")
browser = launch(proxy="socks5://user:pass@proxy:1080")
# With proxy dict (bypass, separate auth fields)
browser = launch(proxy={"server": "http://proxy:8080", "bypass": ".google.com", "username": "user", "password": "pass"})
# With extra Chrome args
browser = launch(args=["--disable-gpu"])
# Auto-detect timezone/locale from proxy IP (requires: pip install cloakbrowser[geoip])
# Also auto-injects --fingerprint-webrtc-ip to prevent WebRTC IP leaks (no extra cost)
# Note: makes HTTP calls through your proxy to resolve exit IP (ipify.org, checkip.amazonaws.com)
browser = launch(proxy="http://proxy:8080", geoip=True)
# WebRTC IP spoofing only (no geoip dep needed — resolves exit IP via HTTP call through proxy)
browser = launch(proxy="http://proxy:8080", args=["--fingerprint-webrtc-ip=auto"])
# Explicit WebRTC IP (no network call)
browser = launch(proxy="http://proxy:8080", args=["--fingerprint-webrtc-ip=1.2.3.4"])
# Human-like mouse, keyboard, and scroll behavior
browser = launch(humanize=True)
# With slower, more deliberate movements
browser = launch(humanize=True, human_preset="careful")
# Without default stealth args (bring your own fingerprint flags)
browser = launch(stealth_args=False, args=["--fingerprint=12345"])Returns a standard Playwright Browser object. All Playwright methods work: new_page(), new_context(), close(), etc.
launch_async()
import asyncio
from cloakbrowser import launch_async
async def main():
browser = await launch_async()
page = await browser.new_page()
await page.goto("https://example.com")
print(await page.title())
await browser.close()
asyncio.run(main())launch_context()
Convenience function that creates browser + context in one call:
from cloakbrowser import launch_context
context = launch_context(
proxy="http://user:pass@residential-proxy:port",
geoip=True,
headless=False,
humanize=True,
)
page = context.new_page()
page.goto("https://protected-site.com")
context.close()Extra kwargs are forwarded to Playwright's browser.new_context() — use this for storage_state, permissions, extra_http_headers, etc. without needing a persistent profile folder:
from cloakbrowser import launch_context
# Restore a saved session (cookies, localStorage) from a JSON file
context = launch_context(storage_state="state.json")
page = context.new_page()
page.goto("https://example.com")
# Save state back for next run
context.storage_state(path="state.json")
context.close()launch_context_async()
Async counterpart to launch_context(). Same signature and kwargs forwarding:
import asyncio
from cloakbrowser import launch_context_async
async def main():
ctx = await launch_context_async(storage_state="state.json")
page = await ctx.new_page()
await page.goto("https://example.com")
await ctx.storage_state(path="state.json")
await ctx.close()
asyncio.run(main())launch_persistent_context()
Same as launch_context(), but with a persistent user profile. Cookies, localStorage, and cache persist across sessions.
A persistent profile keeps its fingerprint seed across launches (stored in .cloakbrowser-seed inside the profile; an explicit --fingerprint= in args overrides it, and a corrupt file is replaced with a warning). To rotate the identity, delete .cloakbrowser-seed and the next launch picks a new seed.
Use this when you need to:
- Stay logged in across runs (cookies/sessions survive restarts)
- Load Chrome extensions (extensions only work from a real user data dir)
- Build natural browsing history (cached fonts, service workers, IndexedDB accumulate over time, making the profile look more realistic)
from cloakbrowser import launch_persistent_context
# First run — creates the profile
ctx = launch_persistent_context("./my-profile", headless=False)
page = ctx.new_page()
page.goto("https://protected-site.com")
ctx.close() # profile saved
# Next run — cookies, localStorage restored automatically
ctx = launch_persistent_context("./my-profile", headless=False)
# Load Chrome extensions
ctx = launch_persistent_context(
"./my-profile",
headless=False,
extension_paths=["./my-extension"],
)Supports all the same options as launch_context(): proxy, user_agent, viewport, locale, timezone, color_scheme, geoip, extension_paths.
Async version: launch_persistent_context_async().
CLI
Pre-download the binary, diagnose your setup, or manage the cache from the command line:
python -m cloakbrowser login # Get a free key by email, or save a key you have
python -m cloakbrowser logout # Remove the saved key
python -m cloakbrowser install # Download binary with progress output
python -m cloakbrowser info # Diagnostics: binary that will launch, license tier, env checks
python -m cloakbrowser update # Check for and download newer binary
python -m cloakbrowser clear-cache # Remove cached binarieslogin with no argument shows the same menu as a first launch without a key: 1) get a free key (opens the signup page in your browser, then waits until you confirm your email) or 2) paste a key you have. login <key> saves a key directly. Keys are validated, then stored at ~/.cloakbrowser/license.key (readable by you only) so every launch picks them up.
info reports the binary that will actually launch given your license, runs a quick launch test (and flags missing system libraries on Linux), shows your license tier, and checks fonts, GeoIP, and optional dependencies. Add --quick to skip the launch test or --json for machine-readable output. Add --proxy <url> to resolve the exit IP, timezone, and locale a launch would apply through that proxy (the same geoip=True resolution; downloads the GeoIP DB if not cached) — useful for confirming a proxy hands you a timezone/locale that matches its exit IP.
CLOAKBROWSER_RELEASE_CHANNEL=preview also applies to install, info, and update. info shows the exact version that will launch and whether Preview resolved to Stable for the current platform.
The same commands are available via npx cloakbrowser <command> (JS) and the cloakbrowser CLI (.NET).
Utility Functions
from cloakbrowser import binary_info, clear_cache, ensure_binary
# Check binary installation status
print(binary_info())
# {'version': '156.0.8078.47.1', 'platform': 'linux-x64', 'installed': True, ...}
# ('version' is None until a build has been downloaded)
# Force re-download
clear_cache()
# Pre-download binary (e.g., during Docker build; needs CLOAKBROWSER_LICENSE_KEY set)
ensure_binary()JavaScript / Node.js API
CloakBrowser ships a TypeScript package with full type definitions. Choose Playwright or Puppeteer — same stealth binary underneath.
Playwright (default)
import { launch, launchContext, launchPersistentContext } from 'cloakbrowser';
// Recommended
const browser = await launch({
proxy: 'http://user:pass@residential-proxy:port',
geoip: true, // match timezone + locale to proxy IP
headless: false,
humanize: true,
});
// Pro — use the latest binary (or set CLOAKBROWSER_LICENSE_KEY env var)
const browser = await launch({
licenseKey: 'cb_xxxxxxxx',
proxy: 'http://user:pass@residential-proxy:port',
geoip: true,
headless: false,
humanize: true,
});
// Convenience: browser + context in one call
const context = await launchContext({
proxy: 'http://user:pass@residential-proxy:port',
geoip: true,
headless: false,
humanize: true,
});
const page = await context.newPage();
// Persistent profile — cookies/localStorage survive restarts
const ctx = await launchPersistentContext({
userDataDir: './chrome-profile',
proxy: 'http://user:pass@residential-proxy:port',
geoip: true,
headless: false,
humanize: true,
});Note: Each example above is standalone — not meant to run as one block.
All Python options work in JS: stealthArgs: false to disable defaults, geoip: true to auto-detect timezone/locale from proxy IP.
Puppeteer
Note: The Playwright wrapper is recommended for sites with reCAPTCHA Enterprise. Puppeteer's CDP protocol leaks automation signals that reCAPTCHA Enterprise can detect, causing intermittent 403 errors. This is a known Puppeteer limitation, not specific to CloakBrowser. Use Playwright for best results.
import { launch } from 'cloakbrowser/puppeteer';
const browser = await launch({
proxy: 'http://user:pass@residential-proxy:port',
geoip: true,
headless: false,
humanize: true,
});
const page = await browser.newPage();
await page.goto('https://example.com');
await browser.close();Utility Functions (JS)
import { ensureBinary, clearCache, binaryInfo } from 'cloakbrowser';
// Pre-download binary (e.g., during Docker build)
await ensureBinary();
// Check installation status
console.log(binaryInfo());
// Force re-download
clearCache();Human Behavior
Pass humanize=True to make all mouse, keyboard, scroll and element-read interactions indistinguishable from real users. All Playwright calls (page.click(), page.fill(), page.type(), page.mouse.*, page.keyboard.*, page.input_value(), page.text_content(), page.inner_text(), page.inner_html(), page.get_attribute(), Locator API) and Puppeteer calls (page.click(), page.type(), page.mouse.*, page.keyboard.*, ElementHandle API) are automatically replaced with human-like equivalents. No code changes needed.
browser = launch(humanize=True)
page = browser.new_page()
page.goto("https://example.com")
page.locator("#email").fill("[email protected]") # per-character timing, thinking pauses
page.locator("button[type=submit]").click() # Bézier curve, realistic aim point// Playwright
import { launch } from 'cloakbrowser';
const browser = await launch({ humanize: true });// Puppeteer
import { launch } from 'cloakbrowser/puppeteer';
const browser = await launch({ humanize: true });What changes:
| Interaction | Default | With humanize=True |
|---|---|---|
| Mouse movement | Instant teleport | Bézier curve with easing and slight overshoot |
| Clicks | Instant | Realistic aim point + hold duration |
| Keyboard | Instant fill | Per-character timing, thinking pauses, occasional typos with self-correction |
| Scroll | Jump | Accelerate → cruise → decelerate micro-steps |
fill() |
Instant value set | Clears existing content, types character by character |
Presets — default (normal speed) or careful (slower, more deliberate, idle micro-movements between actions):
browser = launch(humanize=True, human_preset="careful")const browser = await launch({ humanize: true, humanPreset: 'careful' });Custom config — override any parameter:
browser = launch(humanize=True, human_config={
"mistype_chance": 0.05, # 5% typo rate with self-correction
"typing_delay": 200, # slower typing (ms between keys)
"idle_between_actions": True, # micro-movements between clicks
"idle_between_duration": [0.3, 0.8], # idle duration range (seconds)
})const browser = await launch({
humanize: true,
humanConfig: {
mistype_chance: 0.05,
typing_delay: 200,
idle_between_actions: true,
idle_between_duration: [0.3, 0.8],
}
});Access the original un-patched Playwright page at page._original if you need raw speed for a specific call — this includes the reads (page._original.input_value(...), text_content, inner_text, inner_html, get_attribute), which are humanized by default.
For an arbitrary expression, page._stealth_world.evaluate("…") evaluates it in the isolated world the humanize engine uses.
Note (Playwright): Always use
page.click(selector),page.type(selector, text),page.hover(selector), orpage.locator(selector).*— these go through the full humanize pipeline. Avoidpage.query_selector()—ElementHandleobjects bypass all patches, so mouse movement teleports, keyboard events fire without timing, and scroll has no human curve.Note (Puppeteer): Both selector-based methods (
page.click(),page.type()) and ElementHandle methods (el.click(),el.type()) are fully humanized.page.$(),page.$$(), andpage.waitForSelector()return patched handles automatically.
Contributed by @evelaa123 — full Playwright and Puppeteer API coverage.
Configuration
| Env Variable | Default | Description |
|---|---|---|
CLOAKBROWSER_LICENSE_KEY |
— | Your license key (free or paid). Overrides ~/.cloakbrowser/license.key. Required wherever there is no terminal to ask (CI, Docker) |
CLOAKBROWSER_BINARY_PATH |
— | Skip download, use a local Chromium binary |
CLOAKBROWSER_CACHE_DIR |
~/.cloakbrowser |
Binary cache directory |
CLOAKBROWSER_AUTO_UPDATE |
true |
Set to false to keep the cached build and skip update checks |
CLOAKBROWSER_GEOIP_TIMEOUT_SECONDS |
5 |
Max seconds for GeoIP resolution before continuing without it |
CLOAKBROWSER_VERSION |
— | Pin to an exact Chromium version for rollback (e.g. 155.0.8059.39.1). Paid Pro key only |
CLOAKBROWSER_RELEASE_CHANNEL |
stable |
Set to preview to opt into the Preview binary channel |
Fingerprint Management
The binary is stealthy by default — no flags needed. It auto-generates a random fingerprint seed at startup and spoofs all detectable values (GPU, hardware specs, screen dimensions, canvas, WebGL, audio, fonts). Every launch produces a fresh, coherent identity.
How fingerprinting works:
| Scenario | What happens |
|---|---|
| No flags | Random seed auto-generated at startup. GPU, screen, hardware specs, and all noise patches are spoofed automatically. Fresh identity each launch. |
--fingerprint=seed |
Deterministic identity from the seed. Same seed = same fingerprint across launches. For a returning visitor, use a persistent profile instead (it keeps its own seed). |
--fingerprint=seed + explicit flags |
Explicit flags override individual auto-generated values. The seed fills in everything else. |
On Linux and Windows the wrapper presents as a Windows desktop (more common fingerprint, harder to cluster); on macOS it runs as a native Mac.
macOS persona (a second identity). Alongside the Windows persona, pass --fingerprint-platform=macos to present as a Mac — lined up with real Mac hardware across graphics, media, fonts, text, screen, and device features. Two things to set up: install the Mac fonts (the same way the Windows persona needs Windows fonts — see Font Setup on Linux; a persona without its fonts is a common cause of blocks), and for the most realistic result give it a large display — on a 4K screen it reports at the DPR most real Macs use. Having both the Windows and macOS personas gives you two strong identities to rotate between.
Tip: revisiting the same site? Use a persistent profile. A persistent profile saves its own seed on first launch and reuses it, so you come back as the same device with your cookies and storage intact. No seed flag needed. A fixed
--fingerprint=with plainlaunch()is the same device with an empty profile every time.ctx = launch_persistent_context("./my-profile")const ctx = await launchPersistentContext({ userDataDir: './my-profile' });
Default Fingerprint
Every launch() call sets these automatically. The wrapper applies platform-aware defaults — on Linux it spoofs as Windows for a more common fingerprint, on macOS it runs as a native Mac browser:
| Flag | Linux/Windows Default | macOS Default | Controls |
|---|---|---|---|
--fingerprint |
Random (10000–99999) | Random (10000–99999) | Master seed for canvas, WebGL, audio, fonts |
--fingerprint-platform |
windows |
macos |
navigator.platform, User-Agent OS, GPU pool selection |
The binary auto-generates everything else from the seed: GPU, hardware concurrency, device memory, and screen dimensions. Each seed produces a unique, consistent fingerprint: those values are drawn together as one coherent package. Keep the seed as the source of identity, since changing single values by hand can break that coherence.
Additional Flags
Supported by the binary but not set by default — pass via args to customize:
| Flag | Controls |
|---|---|
--fingerprint-gpu-vendor |
Switch the GPU family — NVIDIA or Intel. The binary reports the matching Chrome vendor value, Google Inc. (NVIDIA) or Google Inc. (Intel). Auto-generated from seed + platform when unset |
--fingerprint-hardware-concurrency |
navigator.hardwareConcurrency (seed-derived when unset) |
--fingerprint-device-memory |
navigator.deviceMemory in GB (seed-derived when unset) |
--fingerprint-screen-width |
Screen width (seed-derived when unset) |
--fingerprint-screen-height |
Screen height (seed-derived when unset) |
--fingerprint-platform-version |
Client Hints platform version |
--fingerprint-timezone |
Timezone (e.g. America/New_York) |
--fingerprint-locale |
Locale (e.g. en-US) |
--fingerprint-storage-quota |
Storage headroom in MB, reported on top of current usage — affects storage.estimate(), storageBuckets, and legacy webkit APIs. Default 10 GiB, like a regular Chrome profile |
--fingerprint-taskbar-height |
Override taskbar height (binary defaults: Win=48, Mac=95, Linux=0) |
--fingerprint-webrtc-ip |
WebRTC ICE candidate IP replacement. Use auto to resolve from proxy exit IP (makes an HTTP call through the proxy), or pass an explicit IP. Auto-injected when geoip=True |
--fingerprint-noise=false |
Disable noise injection (canvas, WebGL, audio) while keeping the deterministic fingerprint seed active |
--fingerprint=off |
Pass-through debug mode — turns spoofing off and presents the machine's real native fingerprint (keeps only the baseline any Chrome needs). The binary strips the injected seed and --fingerprint-platform, so there's no mixed OS profile. Most useful on a genuine Windows machine to check whether an issue is our spoofing or the environment. Accepts off/false/0/disable/disabled. For a pure pass-through don't combine it with geoip=True / explicit timezone / locale — those stay applied. |
--fingerprint-allow-3p-cookies |
Re-enable third-party cookies for embedded flows that need them (reCAPTCHA v3, SSO, some payment challenges). Off by default; turn on only where a login/payment/embedded challenge loads but never finishes. |
--fingerprint-sapi-voices=false |
Opt out of the Windows speech-voice tables when spoofing Windows. On by default (the voice set matches a real Chrome install); turn off only if a target reacts badly to the Windows voice list. |
--fingerprint-max-touch-points=<N> |
Report a touch screen with N touch points, like a Windows touch laptop. Default 0 (no touch). 156+ |
--fingerprint-search-engine=google|bing|duckduckgo|none |
Default search engine when you use the browser directly. Default google; you can also pass your own search URL. 155.0.8059.39.2+ on Linux, 156+ on all platforms |
--license-route=auto|direct|proxy |
How the Pro license and session calls leave the browser. auto (default): direct to cloakbrowser.dev first, and one retry through your --proxy-server if direct can't reach it. direct: never through the proxy. proxy: only through the proxy (needs --proxy-server). |
--license-through-proxy |
Older spelling of --license-route=proxy: route the Pro license/session calls through your --proxy-server instead of direct to cloakbrowser.dev. Still works; prefer --license-route=proxy. |
--fingerprint-transparent-proxy |
A stronger way of connecting through your --proxy-server, for sites and providers that block every proxy you try. Off by default; enable it alongside --proxy-server. |
--fingerprint-transparent-proxy-dns=<url>|local |
Linux and Windows. DNS for --fingerprint-transparent-proxy mode. By default sites are resolved with Cloudflare's DNS over HTTPS, sent through your proxy. Pass your own DNS over HTTPS address, or local to resolve on your own machine as before. |
--fingerprint-portable-cookies |
Encrypt cookies with a machine-independent key so a copied profile keeps its logins across machines. Turn it on from the first launch — it changes how cookies are written, so a cookie is only portable if this was set when it was saved. |
--enable-blink-features=FakeShadowRoot |
Access closed shadow DOM elements |
Note: All stealth tests were verified with the default fingerprint config above. Changing these flags may affect detection results — test your configuration before using in production.
Font Setup on Linux
On Linux, CloakBrowser spoofs the Windows platform by default. Two font layers matter, and most setups only do the first:
1. Baseline (minimal) — emoji + CJK canvas fonts. Aggressive anti-bot systems (Kasada, Akamai) render emoji on a hidden canvas and hash the pixel output. Minimal Linux environments (Docker, cloud VMs) lack these, producing hashes that don't match any real browser. This is the floor, not the finish line:
