Cloak Browser Complete Guide: Build an Anti-Detection Browser Environment from Scratch

Created

Ever searched for something on an e-commerce site, only to see related ads on social media moments later? Or logged into two accounts on the same machine, only to have one of them blocked immediately? These scenarios are all linked to browser fingerprinting — your browser quietly reveals device model, operating system, screen resolution, installed fonts, and more. Websites use these traits to “recognize” you.

Cloak Browser is a free anti-detection browser based on a deep-customized Chromium. It modifies 58 browser fingerprint features at the C++ source code level (Canvas, WebGL, Audio, Fonts, GPU, Screen, WebRTC, etc.), making every browsing session appear as a brand-new device. Its core encapsulation code (Python/JS wrapper) is licensed under the MIT open-source license, while the browser binary is free to use (see BINARY-LICENSE.md for details).

📊 Cloak Browser Core Data at a Glance

Data Point Value
Current Version v0.3.30 (based on Chromium 146)
License MIT (wrapper code) + BINARY-LICENSE.md (binary free for personal/commercial use, no redistribution)
C++ Fingerprint Patches 58 patches (Canvas, WebGL, Audio, Fonts, GPU, Screen, WebRTC, etc.)
Binary Size ~ 200 MB (first-time download, SHA-256 verified)
Memory Usage ~ 190 MB idle, ~ 280 MB with 3 tabs
Supported Platforms Windows / macOS / Linux (x86_64 + ARM64)
Python Package cloakbrowser (installable via pip)
Docker Images cloakhq/cloakbrowser-manager, cloakhq/cloakbrowser
vs. Commercial Tools 100% free vs Multilogin ($29+/mo), GoLogin ($24+/mo), AdsPower ($5.4+/mo)

In the past, achieving this level of privacy protection meant paying a premium for commercial tools like Multilogin (starting at $29/month), GoLogin, or AdsPower — or building a custom technical solution. Cloak Browser changes the game — it’s completely free (no subscription, no usage limits), its core code is open source, and you can deploy it on your own machine.

This guide will walk you through installing and using Cloak Browser step by step. Whether you’re a non-technical user or a developer, there’s a plan here for you.

Prerequisites

Before you start, make sure your environment is ready:

  • A computer: Windows / macOS / Linux — at least 8 GB of RAM recommended
  • Internet connection: First launch requires downloading ~200 MB of the custom browser core (binary download verifies SHA-256 checksum)
  • Basic terminal skills: Knowing how to open a command line is enough
  • Optional: Docker environment — needed if you choose the “casual user” approach

💡 Don’t worry — I’ll also walk you through installing Docker. Don’t let the word “command line” scare you.

Overview: Which Path Should You Choose?

Cloak Browser offers two main usage methods. Here’s a quick comparison:

Method Best For Difficulty Highlight
Docker + CloakBrowser Manager Casual users, business professionals ⭐⭐ Visual interface — manage multiple browsers like a web app
Python / Node.js API Developers, automation engineers ⭐⭐⭐ Launch with a few lines of code, supports automation scripts and data collection

🎯 Casual users → jump to [Option 1]; developers → see [Option 2].

The beauty of this approach — you don’t need to touch any code. Open a web page to create and manage multiple “stealth” browser environments. Each profile has its own independent fingerprint, proxy, cookies, and session data.

The Manager is also an open-source project (MIT licensed) — source code at CloakBrowser-Manager.

Step 1: Install Docker

Think of Docker as a “software container” that lets Cloak Browser run stably on any computer.

Windows users:

  1. Go to the Docker Desktop website and download the installer
  2. Double-click to install, click “Next” all the way through
  3. Restart your computer after installation, open Docker Desktop — you’ll see the whale icon when it’s ready

macOS users:

  1. Download Docker Desktop for Mac from the official site (x86_64 for Intel, ARM64 for Apple Silicon)
  2. Drag the installer into the “Applications” folder
  3. Open Docker and wait for the whale icon to appear in the menu bar

Linux users (Ubuntu example):

1
2
3
4
5
6
sudo apt update
sudo apt install docker.io docker-compose-v2
sudo systemctl enable --now docker
# Add your user to the docker group to avoid typing sudo each time
sudo usermod -aG docker $USER
# Log out and back in for the change to take effect

⚠️ Stuck? After installing Docker, run docker --version in the terminal. If you see a version number, everything is working.

Step 2: Launch CloakBrowser Manager

Open a terminal (Windows users can use PowerShell or CMD) and run:

1
docker run -p 8080:8080 -v cloakprofiles:/data cloakhq/cloakbrowser-manager

Keep this terminal window open — the service needs it to keep running. Here’s what this command does:

  • -p 8080:8080 — Maps port 8080 on your machine to the container so you can access it via browser
  • -v cloakprofiles:/data — Stores your browser profiles in a Docker volume called cloakprofiles; data persists even if the container is removed
  • cloakhq/cloakbrowser-manager — The image to run

You’ll know it’s working when you see output like this:

1
CloakBrowser Manager is running on http://0.0.0.0:8080

Step 3: Create Your First Browser Profile in the Web UI

  1. Open Chrome or any browser and go to http://localhost:8080
  2. You’ll see a clean management interface. Click “Create Profile”
  3. Give your profile a name, e.g., “Work Account 1” or “Shopping Alt”
  4. Configure some parameters (all editable later):
    • Proxy: Fill in if you have one; leave blank otherwise
    • Timezone/Language: Choose “Auto-detect” or specify manually
  5. Click Save — your profile is ready

Running Manager on Linux? Make sure font packages are installed, or the anti-detection system will flag font mismatches:

1
sudo apt install -y fonts-noto-color-emoji fonts-freefont-ttf fonts-unifont fonts-ipafont-gothic fonts-noto-cjk

Step 4: Launch a Browser Instance

  1. In the profile list, find the profile you just created and click “Launch”
  2. The system will automatically start an independent browser window in the background (displayed via noVNC in your web browser)
  3. Wait about ten seconds — you’ll see a fully functional browser interface right in your web page!

🎬 Pro tip: You can run multiple profiles simultaneously, each with its own fingerprint, cookies, and session data. Switching between them in the Manager UI is as easy as changing channels.

Step 5: Verify the Effect — Is It Really “Stealth”?

Open the newly launched browser and visit these detection sites:

  1. BrowserScan — Check your browser fingerprint score
  2. FingerprintJS — See what features are being collected
  3. IP Info Site — Confirm IP address and timezone

If you’re using default settings without a proxy, you’ll notice that while your IP address stays the same, Canvas fingerprints, WebGL renderer, font lists, and other features are different from your real browser — this is Cloak Browser applying its “makeup” at the engine level.

If you want to keep the Manager service running long-term, adding authentication is a good idea — otherwise anyone on your local network can access it.

1
2
3
4
5
# First stop the running container (Ctrl+C)
# Then restart with AUTH_TOKEN
docker run -p 8080:8080 -v cloakprofiles:/data \
  -e AUTH_TOKEN=your_password \
  cloakhq/cloakbrowser-manager

Next time you visit http://localhost:8080, you’ll see a login page (enter the password you set). API calls require the Authorization: Bearer <token> header.

Note: The password is transmitted in plain text over HTTP. If you plan to expose Manager to the internet, add an HTTPS reverse proxy (e.g., Caddy, Nginx, Traefik) in front of it.

Option 2: Python API for Developers & Power Users

If you write code or want to automate tasks with scripts, the Python approach is more convenient.

Step 1: Install the Python Package

1
2
3
pip install cloakbrowser
# Want automatic timezone/locale detection? Add the geoip extra
pip install cloakbrowser[geoip]

🐍 It’s recommended to install in a virtual environment to avoid conflicts with system Python packages.

On first launch, the ~200 MB customized Chromium binary will be automatically downloaded and cached locally (SHA-256 verified) — no manual setup required.

CLI Tool: After installation, you can also manage the binary via the command line:

1
2
3
4
python -m cloakbrowser install       # Download the binary
python -m cloakbrowser info          # View version, path, platform
python -m cloakbrowser update        # Check and update to latest version
python -m cloakbrowser clear-cache   # Clear cached binary

Step 2: Launch a Browser in 5 Lines of Code

1
2
3
4
5
6
7
8
from cloakbrowser import launch

browser = launch(headless=False, humanize=True)
page = browser.new_page()
page.goto("https://browserscan.net")
# You'll see a browser window open automatically, just like a real person is using it
input("Press Enter to exit...")
browser.close()

Parameter Reference:

Parameter Purpose Recommended Value
headless=False Show the browser window for visual feedback Use False for debugging, True for production scripts
humanize=True Simulate human behavior (Bezier curve mouse paths, keystroke timing, natural scrolling) Strongly recommended for anti-detection
proxy="http://user:pass@ip:port" Specify a proxy Use when you need to change IP

Step 3: Persistent Context Usage

Want to save login state and cookies so they’re available next time? Use launch_persistent_context:

1
2
3
4
5
6
7
8
9
from cloakbrowser import launch_persistent_context

# Specify a folder to store the profile
ctx = launch_persistent_context("./my-account-profile")
page = ctx.new_page()
page.goto("https://example.com/login")
# ... perform login ...
# After closing, login info is saved in ./my-account-profile
ctx.close()

The next time you launch with the same folder, the site will treat you as a “returning user.” You can also load Chrome extensions:

1
2
3
4
ctx = launch_persistent_context(
    "./my-account-profile",
    extension_paths=["./my-extension"],
)

Step 4: One-Line Migration for Playwright Projects

If you’re already using Playwright for automation scripts, switching to Cloak Browser only requires changing one line:

1
2
3
4
5
6
7
8
9
10
11
12
# Before: Using Playwright
# from playwright.sync_api import sync_playwright
# pw = sync_playwright().start()
# browser = pw.chromium.launch()

# After: Using Cloak Browser
from cloakbrowser import launch

# The rest of your code stays exactly the same!
browser = launch()
page = browser.new_page()
page.goto("https://example.com")

That’s right — in your existing Playwright scripts, you only need to change the import statement and the launch method. All other APIs (new_page, goto, click, fill, etc.) work identically!

Advanced: Environment Variable Configuration

The following environment variables let you customize runtime behavior:

Environment Variable Default Description
CLOAKBROWSER_BINARY_PATH — Skip download and use a local Chromium binary
CLOAKBROWSER_CACHE_DIR ~/.cloakbrowser Binary cache directory
CLOAKBROWSER_AUTO_UPDATE true Set to false to disable background update checks
CLOAKBROWSER_SKIP_CHECKSUM false Set to true to skip SHA-256 verification
CLOAKBROWSER_GEOIP_TIMEOUT_SECONDS 5 GeoIP resolution timeout (seconds)

Frequently Asked Questions (FAQ)

❓ What’s the difference between Cloak Browser and regular “incognito/private mode”?

They are completely different things. A normal browser’s incognito mode simply doesn’t save history locally, but websites still collect fingerprints the same way. Cloak Browser modifies the browser’s underlying fingerprint generation logic at the C++ source code level, making websites think you’re using an entirely different device.

❓ Will the browser be slow?

The first launch requires downloading 200 MB of the customized Chromium binary. After that, startup speed is comparable to regular Chrome. Memory usage is about 100-200 MB more than Chrome (190 MB idle, ~280 MB with 3 tabs), which is hardly noticeable on modern computers.

❓ Docker says the port is already in use — what do I do?

This means another program on your machine is using port 8080. Try a different port:

1
docker run -p 9090:8080 -v cloakprofiles:/data cloakhq/cloakbrowser-manager

Then visit http://localhost:9090 instead.

❓ macOS says “developer cannot be verified”?

This is macOS Gatekeeper’s security mechanism blocking the binary. Run this command to lift the restriction:

1
xattr -cr ~/.cloakbrowser/chromium-*/Chromium.app

❓ A website says I’m using an automation tool?

Combine these parameters for the best results:

1
2
3
4
5
6
browser = launch(
    proxy="http://your-proxy",   # Use a residential proxy
    geoip=True,                  # Auto-match timezone/locale
    headless=False,              # Show the window
    humanize=True                # Simulate human behavior
)

Most blocks aren’t caused by fingerprint detection, but by a missing residential proxy, timezone mismatch (geoip=True), or headless mode (headless=False) — missing any one of these three can trigger detection.

❓ Can I log into the same account on multiple sites at the same time?

Technically yes, but it’s recommended to use a separate profile for each site/account, especially when managing multiple accounts. One profile = one account, to avoid fingerprint cross-contamination that could lead to platform linking.

❓ Is this project open source? What’s the license?

Code License: The Cloak Browser wrapper code (Python/JS packages) is licensed under the MIT License — see LICENSE.
Binary License: The compiled Chromium binary is free for personal and commercial use, but cannot be redistributed, resold, or modified. Full terms at BINARY-LICENSE.md.
Manager UI (GUI source code) is also MIT licensed.

Summary

Cloak Browser’s value can be summed up in one sentence: Free + C++ source-level fingerprint modification + Self-hosted. These three attributes together are virtually unique in today’s anti-detection browser market.

Casual users → Use Docker + CloakBrowser Manager to manage multiple independent browser environments through a web interface — as simple as using any web app.

Developers → Use the Python or Node.js API to launch a “fully armed” stealth browser in just a few lines of code, and seamlessly migrate existing Playwright projects. You can also manage binaries via the CLI tool (python -m cloakbrowser install/info/update) and customize runtime behavior through environment variables (CLOAKBROWSER_BINARY_PATH, etc.).

Quick-Reference Resources:

  • Quick Docker test (no installation needed): docker run --rm cloakhq/cloakbrowser cloaktest
  • CLI binary management: python -m cloakbrowser install
  • Environment variable for custom path: export CLOAKBROWSER_BINARY_PATH=/path/to/chrome

One final reminder: Technology is a neutral tool. Using Cloak Browser to protect your privacy is perfectly fine — just don’t use it for anything illegal. Here’s to a freer, safer browsing experience 🎉

This guide is based on Cloak Browser v0.3.30 / Chromium 146 (verified May 2026). Features may change in future versions. Check the GitHub repository for the latest updates.

📝 Citation Declaration: The information in this article was verified on May 23, 2026. All data is sourced from the following official references: