Camoufox

Camoufox is an open source anti-detect browser built for webscraping & AI agents. 🦊

⚠️ This project is under development. It may not be suitable for stable production use. ⚠️

---

Note

All of the latest documentation is available at camoufox.com.

---

Sponsors

View/Collapse All

Premium

	NodeMaven: The most efficient proxy provider for Web Scrapping and Automation with the Highest Quality IP on the market. Why NodeMaven? • 99.9% uptime • ZIP Targeting • IP filtering: all proxies have fraud score <97% • No KYC required • Unique free tools: Proxy Bandwidth Checker, Meta Tag Checker, IP Lookup and others! Special codes for Camoufox users: • CAMOUFOX35 - 35% off to Mobile and Residential Proxies • CAMOUFOX40 - 40% off to ISP (Static) Proxies
	Need proxies for Camoufox? Use Node Proxy — a provider of datacenter, residential and mobile proxies offering high speed, security and near-100% uptime. Fully tested and supported in Camoufox. What sets them apart from other providers • 90+ IP score • HTTP + SOCKS5 — multiprotocol support • Discounts for retail customers • Full B2B support • Ethically sourced IP addresses • Special terms for Enterprise clients Want to support Camoufox? Just use my promo code CAMOUFOX — it gets you a 30% discount and supports the developer at the same time. Get started at node-proxy.com →
	Byteful is a UK-based web data infrastructure platform that provides ethically sourced residential, mobile, static residential (ISP) and datacenter proxies alongside API-first tools for web scraping, data collection, and AI-driven automation. Processing tens of billions of requests per month for thousands of customers, Byteful powers browser-based AI agents, automation systems, and data workflows. It is a member of the Internet Watch Foundation and the Ethical Web Data Collection Initiative. Get 10% off Byteful Residential Bandwidth with the code: CAMOUFOX10
	Layer3 Intel | See your proxies the way anti-bots see them Camoufox hides your browser. Your proxy IP is the part it can't hide. Layer3 Intel is the residential proxy detection engine used to catch proxy traffic — check whether the IPs your provider sells you are clean, or already known and flagged. • 🔍 Live threat score for any IP • 🗂️ Proxy pool membership - identify IP resellers • 📡 70M+ residential, mobile & ISP proxy IPs tracked across 200+ providers • ⚡ <40ms API responses — vet IPs inline before your scraper uses them Check your IPs: https://layer3intel.com

Tools & Services

	Scrapfly is an enterprise-grade solution providing Web Scraping API that aims to simplify the scraping process by managing everything: real browser rendering, rotating proxies, and fingerprints (TLS, HTTP, browser) to bypass all major anti-bots. Scrapfly also unlocks the observability by providing an analytical dashboard and measuring the success rate/block rate in detail.
	Clover Labs is a Toronto based venture studio building AI agents for growth and distribution.
	SerpApi, a web search API to scrape Google and other search engines with a simple API.
	Web data that survives the anti-bots. Crawlbase gives developers and AI teams reliable data at scale: a 99% success-rate Crawler, Crawling API, Smart AI Proxies, and Web MCP Server that get through, so your scrapers and agents don't break. You build, we handle the infrastructure. Get 15% off your first 3 months with code CAMOUFOX → crawlbase.com
	Scrappey is a Web Scraping API that only charges successful scrapes with pay as you go - no subscriptions. Scrape complex sites. Residential proxies included, no hidden proxy fees, or expiring balances. One API for direct HTTP, full-browser rendering, JavaScript-heavy pages, screenshots, sessions, 30+ browser actions and 200+ concurrent sessions at a time - trusted by 1000+ developers and AI agents. Get 10% off with code CAMOUFOX.
	Cloro is a SERP and AI search API. Get structured results from Google, ChatGPT, Perplexity, Gemini, Copilot and Grok.

Proxy Providers

Camoufox is intended to be used with rotating proxies (preferably residential IPs). Check out these providers:

	🚀 Camoufox × ProxyEmpire Running Camoufox? Your proxy layer decides whether you scale — or get blocked. ProxyEmpire delivers: • 🌍 30M+ Residential IPs (170+ countries) • 📱 4G/5G Mobile Proxies • 🔄 Rotating & Sticky Sessions • ⚡ Unlimited Concurrent Sessions • 🎯 Precise geo-targeting • HTTP, HTTPS & SOCKS5 Support Built for scraping, automation, and high-stealth workflows. 🔥 Exclusive Offer - Use code Camoufox30 Get 30% recurring discount (not just first month). Upgrade your proxies. Reduce bans. Scale properly
	RapidProxy - Power Your Data with Premium Proxies. 🎁 Try proxies for free + Use code RAPID10 for 10% OFF Why Choose RapidProxy? • 🌍 90M+ IPs in 200+ countries & regions • ♾️ No expiration on traffic — use anytime, no pressure • 🔥 Unlimited concurrency for maximum performance • 💰 Starting from just $0.65/GB — built for scale • 📍 City-level targeting for precise geo access • 🔄 Flexible session control tailored to your needs Don’t miss out — start your free trial today and experience fast, stable, and scalable proxy performance with RapidProxy.
	Swiftproxy - High-Performance Residential Proxies for Scalable Data Collection Built for developers who need reliable, anti-detection proxy infrastructure. Swiftproxy delivers stable connections, high success rates, and flexible control for large-scale scraping and automation. • 🌍 195+ locations with ethically sourced residential IPs • 🔄 Rotating & sticky sessions with precise geo-targeting • ⚡ Optimized for anti-ban & high success rate • 🔌 HTTP / HTTPS / SOCKS5 support • 🧪 Free 500MB trial for testing • 💸 Special discount code for Camoufox users: PROXY90 - 10% Best for: Web scraping, automation, multi-accounting, and large-scale data extraction
	MangoProxy is a Residential, ISP, Mobile and Datacenter proxy service designed for professional tasks where stability, speed, and anonymity matter. Use code DAIJRO for 8% OFF ISP Static Proxies
	Proxidize | Mobile and Residential Proxies for Camoufox Running Camoufox at scale? Your browser setup is only half the stack. Your proxy layer matters too. Proxidize provides mobile and residential proxies built for scraping, browser automation, SEO monitoring, AI agents, and data collection workflows. Why Proxidize? • Real 4G and 5G mobile proxies • Residential proxies in 195+ countries • Rotating and sticky sessions • City-level and carrier targeting • Unlimited concurrency • HTTP(S), SOCKS5, and UDP over SOCKS support • No hardware or DIY setup required Built for teams that need reliable proxy infrastructure without managing devices, servers, or proxy rotation themselves. Special offer for Camoufox users: Use code CAMOUFOX20 for 20% off. Start now: https://proxidize.com
	NiuProxy | Rotating Residential Proxies from $0.35/GB NiuProxy provides residential, ISP, mobile, and datacenter proxies for scraping, browser automation, SEO, AI agents, and data collection. Why NiuProxy? • Residential proxies from $0.35/GB • ISP proxies from $3/IP • Mobile proxies from $1.5/GB • Datacenter proxies from $0.5/GB • HTTP(S) & SOCKS5 support • Flexible geo targeting and sessions • Alipay, USDT, cards, Google Pay & Apple Pay Special offer for Camoufox users: Use code PAY2 for 10% off your recharge. Start now: https://niuproxy.com
	🔍 Camoufox × Thordata Real Residential IPs for Smarter AI Agents & Automation With 100M+ residential IPs, Thordata helps your scraper access the web through real user IPs across 195+ countries. Target specific locations with precision — including city, ISP, and ASN-level targeting — so your Camoufox automation runs with a more authentic network identity. • 🔄 Rotating & Sticky Sessions (up to 90 minutes) • ⚡ 99.99% uptime with unlimited concurrent sessions • 🌍 Global residential coverage for AI agents, scraping, and automation workflows 🎁 Exclusive for Camoufox users: Get free trial traffic after signup + use code Camoufox for 10% OFF. Start your free trial with Thordata
	Webshare gives you instant access to a proxy pool of 80M+ ethically-sourced IPs across 195+ countries, with rotating residential, static ISP, and datacenter options plus a full API. It includes a 100+ Gbps backbone, country/city/state/ZIP/ASN-level targeting, and requires no credit card to start. 🏷️ Get 20% OFF your first purchase with promo code CAMOUFOX20
	Roam — Residential & static residential proxies, pay-as-you-go per GB. Use code CAMOUFOX15 for 15% extra credit on your first top-up.

---

Introduction

Camoufox is a Firefox fork engineered for web scraping and AI agents. It is headless, undetectable, and optimized to run at scale. Every run gets a fresh identity drawn from the real-world distribution of devices, so it blends into normal traffic instead of standing out.

Highlights

• Built for AI agents 🤖
  • Minimal, debloated Firefox - fast to launch, cheap to run
  • Drop-in Playwright compatibility from Python and JavaScript/TypeScript
  • Invisible to anti-bot systems so you can run your agent cluster locally or in the cloud without being flagged

• Undetectable by design 🎭
  • Page automation hidden from JavaScript inspection. See the stealth page for more details.

• Fingerprint injection & rotation (without JS injection!)
  • All navigator properties (device, OS, hardware, browser, etc.) ✅
  • Screen size, resolution, window, & viewport properties ✅
  • Geolocation, timezone, locale, & Intl spoofing ✅
  • WebRTC IP spoofing at the protocol level ✅
  • Voices, speech playback rate, etc. ✅
  • And much, much more!

• Anti Graphical fingerprinting
  • WebGL parameters, supported extensions, context attributes, & shader precision formats ✅
  • Font spoofing & anti-fingerprinting ✅

• Optimized for automation
  • Human-like mouse movement 🖱️
  • Blocks & circumvents ads 🛡️
  • Optional instant animations (instantAnimations), so Playwright never waits on one 💨

• Debloated & optimized for memory efficiency ⚡
• PyPI and npm packages for updates & auto fingerprint injection 📦
• Stays up to date with the latest Firefox version 🕓

---

Fingerprint Injection

In Camoufox, data is intercepted at the C++ implementation level, making the changes undetectable through JavaScript inspection.

To spoof individual fingerprint properties, pass a JSON containing properties to spoof to the Python or TypeScript interface:

>>> with Camoufox(config={"property": "value"}) as browser:

Config data not set by the user is populated from fpgen, a model of the statistical distribution of device characteristics in real-world traffic. The assembled identity is then checked for coherence, so parts that are each plausible cannot combine into a machine that does not exist.

[See implemented properties]

---

Usage

Camoufox is compatible with your existing Playwright code. You only have to change your browser initialization.

Python, sync API

from camoufox.sync_api import Camoufox

with Camoufox() as browser:
    page = browser.new_page()
    page.goto("https://example.com")

Python, async API

from camoufox.async_api import AsyncCamoufox

async with AsyncCamoufox() as browser:
    page = await browser.new_page()
    await page.goto("https://example.com")

JavaScript / TypeScript

import { Camoufox } from "@camoufox/camoufox";

const browser = await Camoufox({ headless: true });
const page = await browser.newPage();
await page.goto("https://example.com");
await browser.close();

[Python installation & usage] · [TypeScript package]

---

Capabilities

Below is a list of patches and features implemented in Camoufox.

Fingerprint spoofing

• Navigator properties spoofing (device, browser, locale, etc.)
• Support for emulating screen size, resolution, etc.
• Spoof WebGL parameters, supported extensions, context attributes, and shader precision formats.
• Spoof inner and outer window viewport sizes
• Spoof AudioContext sample rate, output latency, and max channel count
• Spoof device voices & playback rates
• Spoof the amount of microphones, webcams, and speakers available.
• Network headers (Accept-Languages and User-Agent) are spoofed to match the navigator properties
• WebRTC IP spoofing at the protocol level
• Geolocation, timezone, and locale spoofing
• etc.

Stealth patches

• Avoids main world execution leaks. All page agent javascript is sandboxed
• Avoids frame execution context leaks
• Fixes navigator.webdriver detection
• Fixes Firefox headless detection via pointer type (#26)
• Removed potentially leaking anti-zoom/meta viewport handling patches
• Uses non-default screen & window sizes
• Re-enable fission content isolations
• Re-enable PDF.js
• Other leaking config properties changed
• Human-like cursor movement

Anti font fingerprinting

• Automatically uses the correct system fonts for your User Agent
• Bundled with Windows, Mac, and Linux system fonts
• No glyph-spacing noise: measured text widths are the ones the same font gives on a real machine

Playwright support

• Custom implementation of Playwright for the latest Firefox
• Various config patches to evade bot detection

Debloat/Optimizations

• Stripped out/disabled many, many Mozilla services. Runs faster than the original Mozilla Firefox, and uses less memory (200mb)
• Patches from LibreWolf & Ghostery to help remove telemetry & bloat
• Debloat config from PeskyFox, LibreWolf, and others
• Speed & network optimizations from FastFox
• Animations run on stock timing; instantAnimations: True finishes them at once, at the cost of being detectable
• Minimalistic theming
• etc.

Addons

• Load Firefox addons without a debug server by passing a list of paths to the addons property
• Added uBlock Origin with custom privacy filters
• Addons are not allowed to open tabs
• Addons are automatically enabled in Private Browsing mode
• Addons are automatically pinned to the toolbar
• Fixes DNS leaks with uBO prefetching

Python & TypeScript Interfaces

• Automatically generates & injects unique device characteristics into Camoufox based on their real-world distribution
• WebGL fingerprint injection & rotation
• Uses the correct system fonts and subpixel antialiasing & hinting based on your target OS
• Avoid proxy detection by calculating your target geolocation, timezone, & locale from your proxy's target region
• Calculate and spoof the browser's language based on the distribution of language speakers in the proxy's target region
• Remote server hosting to use Camoufox with other languages that support Playwright
• Built-in virtual display buffer to run Camoufox headfully on a headless server
• Toggle image loading, WebRTC, and WebGL
• etc.

Note

Camoufox does not fully support injecting Chromium fingerprints. Some WAFs (such as Interstitial) test for Spidermonkey engine behavior, which is impossible to spoof.

---

Stealth Overview

How Camoufox hides its automation library

In Camoufox, all of Playwright's internal Page Agent's code is sandboxed and isolated. This makes it impossible for a page to detect the presence of Playwright through Javascript inspection.

Normally, Playwright injects some JavaScript into the page such as window.__playwright__binding__ and to perform actions like querying elements, evaluating javascript, or running init scripts, which can be detected by websites. In Camoufox, these actions are handled in an isolated scope outside of the page. In other words, websites can no longer "see" any JavaScript that Playwright would typically inject. This prevents traces of Playwright altogether.

However, even with hiding its automation library, Camoufox is not immune to inconsistencies in fingerprint rotation. This still requires maintenance to spot and fix.

Page Interactions

Anti-bot systems also run client-side scripts to monitor your behavior. For example, they look for patterns in mouse movements, clicks, scrolling, and the timing between actions.

Every dot above is a mousemove event the page received from six page.mouse.move() calls, replayed at the speed it arrived. Close dots mean the hand slowed down. scripts/cursor-demo.py regenerates the figure from a build.

Camoufox does not draw its cursor paths. With humanize=True it uses Cursory by Vinyzu, which holds 2357 mouse movements recorded from real people: it picks a recording whose direction, distance and wander suit the move being made, morphs it onto the requested start and end points, and replays it with that recording's own timing — pauses, overshoots and all.

That last part matters as much as the shape. Camoufox previously walked a Bézier curve through two random knots and emitted a point every 10ms. Both halves of that are tells: an analytic curve sampled at a fixed rate has velocity and jerk profiles that separate cleanly from a hand's, and the acceleration came entirely from one easing function, so every movement Camoufox ever made sped up and slowed down the same way. A replayed recording has neither property.

Camoufox ships cursory-js, a TypeScript port of Cursory, vendored into Juggler at additions/juggler/input/cursory/. It reproduces the Python original bit for bit, so a path can be reproduced against pip install cursory. Cursory is LGPLv3-or-later, not MPL-2.0 like the rest of the browser; its licence and full provenance are in additions/juggler/input/cursory/NOTICE.

However, this isn't perfect. It may still be detected with sophisticated enough analysis. (WIP for the future)

---

How Camoufox rotates identities

AI agents need to operate across many sessions without getting flagged or rate-limited. Rotating your IP address isn't enough — every browser session carries thousands of signals that create a unique fingerprint. A website can see your OS, GPU, screen resolution, fonts, timezone, and more. If those signals are inconsistent or unusual, you get blocked.

Market Share Distribution

Even if you are rotating your IP for each running bot instance, web access firewalls can still use machine learning to analyze incoming web traffic to detect if it's abnormal. If the Linux market share was 5%, then suddenly it's 20%, it's a red flag. They will unconditionally require all Linux users to complete a captcha.

Camoufox draws identities from fpgen, a Bayesian network trained on live traffic, so each device characteristic appears about as often as it does in the real world, and in the combinations real devices produce.

How can Camoufox be detected?

Camoufox can spoof fingerprints with a correct market share. However, fingerprints must also be internally consistent. A Windows user agent with an Apple M1 GPU, a MacOS user agent with a Windows DirectX renderer, and a mobile device with a desktop screen resolution are all impossible, and will be flagged for being suspicious.

Every drawn identity passes a coherence check (pythonlib/camoufox/coherence.py) that rejects impossible combinations before launch. But of the thousands of datapoints that must agree with each other, Camoufox doesn't always get every one right. Anti-bot providers test Camoufox over and over again to find even 1 unique inconsistency, then they immediately update their background scripts to test for it.

---

How does Camoufox compare to other solutions?

JavaScript-based solutions

In the past, developers tried injecting JavaScript to spoof these values, but it doesn't work reliably since JavaScript can't spoof everything. Incomplete coverage causes inconsistent fingerprints. For example, an anti-bot system will flag you if your network request's User Agent doesn't match your navigator's User Agent.

Additionally, all injected JavaScript is detectable in some way. Anti-bot systems can check if Object.getOwnPropertyDescriptor reveals an overwritten property, if a function's toString() no longer returns [native code] (revealing it was hijacked), or if data in the window context doesn't match the worker thread context. Workarounds only take you so far, but there will always be a way to detect JS injection if you search deep enough.

Camoufox's approach

Since Camoufox intercepts calls in the browser's C++ implementation level, all of the hijacked objects and properties appear native. There is no JavaScript hijacking to be detected.

Camoufox also generates consistent and believable fingerprints with fpgen and its coherence check. However, this can still be detected by complex fingerprint detection methods like mismatching data (as described earlier).

---

CDP-based libraries

CDP (Chrome DevTools Protocol) is an automation protocol built into Chromium and Firefox. However, CDP makes no effort to hide the fact that it's an automation protocol and exposes much of its functionality in the page scope. Some common methods are checking if navigator.webdriver is true, catching it reading the stack debugger, checking for variables that ChromeDriver injects into the document object for internal communication, and more.

Camoufox's approach

While Playwright uses CDP to control Chromium, it uses Juggler for Firefox. Juggler is a custom protocol developed before Firefox supported CDP (original repo). It is a distinct module within Firefox, and not part of its core browser. This makes it easier to edit and control what's revealed to the page.

Camoufox patches Juggler to give it its own isolated "copy" of the page to work with. Playwright can read and edit its own version of the page freely. Everything appears to work normally to it, but the real page is completely unaffected by these changes. The page also can't detect when things are being read (through tricks like hijacking getters) or listeners being added to watch elements.

Additionally, Juggler sends its inputs directly through the Firefox's original user input handlers, meaning they are handled the exact same way as if you were using the browser normally. Camoufox also patches Firefox's headless mode to appear the same as if it were running in a normal window. But as a fallback, the Python library can run Camoufox in a virtual display if headless mode ever leaks.

---

Build System

Warning

The content below is intended for those interested in building & debugging Camoufox. For usage instructions, see pythonlib or typescript.

Overview

Here is a diagram of the build system, and its associated make commands:

graph TD
    FFSRC[Firefox Source] -->|make fetch| REPO

    subgraph REPO[Camoufox Repository]
        PATCHES[Fingerprint masking patches]
        ADDONS[uBlock Origin]
        DEBLOAT[Debloat/optimizations]
        SYSTEM_FONTS[Win, Mac, Linux fonts]
        JUGGLER[Patched Juggler]
    end

    subgraph Local
    REPO -->|make dir| PATCH[Patched Source]
    PATCH -->|make build| BUILD[Built]
    BUILD -->|make package-linux| LINUX[Linux Portable]
    BUILD -->|make package-windows| WIN[Windows Portable]
    BUILD -->|make package-macos| MAC[macOS Portable]
    end

This was originally based on the LibreWolf build system.

Build CLI

Warning

Camoufox's build system is designed to be used in Linux. WSL will not work!

First, clone this repository with Git:

git clone --depth 1 https://github.com/daijro/camoufox
cd camoufox

Next, build the Camoufox source code with the following command:

make dir

Before bootstrapping, install the system build dependencies with the helper script. It detects your platform and installs everything the build needs (Python ≥ 3.11, Rust, aria2, p7zip, msitools, wget, sqlite, and the core build tools) using the appropriate package manager — Homebrew on macOS, or apt/dnf/pacman on Linux:

bash scripts/install-deps.sh

Note

The dependency installer has so far only been tested on macOS.

After that, you have to bootstrap your system to be able to build Camoufox. You only have to do this one time. It is done by running the following command:

make bootstrap

Finally you can build and package Camoufox the following command:

python3 multibuild.py --target linux windows macos --arch x86_64 arm64 i686

For new builds, i686 is supported only for Windows. Unsupported target/architecture combinations are skipped.

CLI Parameters

Options:
  -h, --help            show this help message and exit
  --target {linux,windows,macos} [{linux,windows,macos} ...]
                        Target platforms to build
  --arch {x86_64,arm64,i686} [{x86_64,arm64,i686} ...]
                        Target architectures to build for each platform
  --bootstrap           Bootstrap the build system
  --clean               Clean the build directory before starting

Example:
$ python3 multibuild.py --target linux windows macos --arch x86_64 arm64

Using Docker

Camoufox can be built through Docker on all platforms.

1. Create the Docker image containing Firefox's source code:

docker build -t camoufox-builder .

2. Build Camoufox patches to a target platform and architecture:

docker run -v "$(pwd)/dist:/app/dist" camoufox-builder --target <os> --arch <arch>

How can I use my local ~/.mozbuild directory?

If you want to use the host's .mozbuild directory, you can use the following command instead to run the docker:

docker run \
  -v "$HOME/.mozbuild":/root/.mozbuild:rw,z \
  -v "$(pwd)/dist:/app/dist" \
  camoufox-builder \
  --target <os> \
  --arch <arch>

Docker CLI Parameters

Options:
  -h, --help            show this help message and exit
  --target {linux,windows,macos} [{linux,windows,macos} ...]
                        Target platforms to build
  --arch {x86_64,arm64,i686} [{x86_64,arm64,i686} ...]
                        Target architectures to build for each platform
  --bootstrap           Bootstrap the build system
  --clean               Clean the build directory before starting

Example:
$ docker run -v "$(pwd)/dist:/app/dist" camoufox-builder --target windows macos linux --arch x86_64 arm64 i686

Build artifacts will now appear written under the dist/ folder.

---

Working on patches

make dir leaves camoufox-<version>-<release>/ as a git repository with every patch applied. A patch is a diff against a checkpoint in that repository:

# A new patch
make dir                 # apply every existing patch
make first-checkpoint    # mark the starting point
# ...edit files in camoufox-*/, test with `make build` and `make run`...
make diff > patches/my-change.patch

# An existing patch
make dir
make workspace ./patches/x.patch   # unapply x, checkpoint, reapply x
# ...edit...
make diff > patches/x.patch

make diff shows only tracked files, so git add -N <file> any new file first. make workspace needs every later patch to leave the hunks of x.patch alone. make patch and make unpatch apply or reverse one patch, and make revert resets the tree to unpatched Firefox.

Then run the suites that cover what you changed. CONTRIBUTING.md says which ones, and ci/README.md has the whole pipeline.

---

Leak Debugging

This is a flow chart demonstrating my process for determining leaks without deobfuscating WAF Javascript. The method incrementally reintroduces Camoufox's features into Firefox's source code until the testing site flags.

This process requires a Linux system and assumes you have Firefox build tools installed (see here).

See flow chart...

flowchart TD
    A[Start] --> B[Does website flag in the official Firefox?]
    B -->|Yes| C[Likely bad IP/rate-limiting. If the website fails on both headless and headful mode on the official Firefox distribution, the issue is not with the browser.]
    B -->|No| D["Run make ff-dbg(1) and build(2) a clean distribution of Firefox. Does the website flag in Firefox **headless** mode(4)?"]
    D -->|Yes| E["Does the website flag in headful mode(3) AND headless mode(4)?"]
    D -->|No| F["Apply config.patch(5), then rebuild(2). Does the website still flag(3)?"]
    E -->|No| G["Enable privacy.resistFingerprinting in the config(6). Does the website still flag(3)?"]
    E -->|Yes| C
    G -->|No| H["In the config(6), enable FPP and start omitting overrides until you find the one that fixed the leak."]
    G -->|Yes| I[If you get to this point, you may need to deobfuscate the Javascript behind the website to identify what it's testing.]
    F -->|Yes| K["Apply playwright/0-playwright.patch(5), then rebuild. Does it still flag?"]
    F -->|No| J["Omit options from camoufox.cfg(6) and rerun(3) until you find the one causing the leak."]
    K -->|No| M[Juggler needs to be debugged to locate the leak.]
    K -->|Yes| L[The issue has nothing to do with Playwright. Apply the rest of the Camoufox patches one by one until the one causing the leak is found.]
    M --> I

Cited Commands

#	Command	Description
(1)	make ff-dbg	Setup vanilla Firefox with minimal patches.
(2)	make build	Build the source code.
(3)	make run	Runs the built browser.
(4)	make run args="--headless https://test.com"	Run a URL in headless mode. All redirects will be printed to the console to determine if the test passed.
(5)	make patch ./patches/<name>.patch	Apply one patch. make unpatch reverses it.
(6)	make edit-cfg	Edit camoufox.cfg in the default system editor.

---

Licensing

• The browser (patches/, additions/, settings/, and the build system) is MPL-2.0, the licence of the Firefox source it modifies. The vendored Cursory trajectories are LGPLv3-or-later (additions/juggler/input/cursory/NOTICE).
• The launchers are MIT: the Python package (pythonlib/LICENSE) and the TypeScript package (typescript/LICENSE). The TypeScript package also contains ports of fpgen, CPython's random and NumPy's random generators; their notices are in typescript/THIRD_PARTY_NOTICES.md.

---

Thanks

Debloating & references:

• LibreWolf: Debloat patches & build system inspiration
• BetterFox: Speed and debloat preferences
• Ghostery: Debloat reference (disable onboarding)

Web scraping & testing:

• Vinyzu/cursory: The recorded human mouse trajectories behind humanize=True, vendored via cursory-js (LGPLv3-or-later — see additions/juggler/input/cursory/NOTICE)
• riflosnake/HumanCursor: The Bézier cursor algorithm Camoufox used before Cursory
• scrapfly/fingerprint-generator (fpgen): The device distribution identities are drawn from
• CreepJS, Browserleaks, BrowserScan - Valuable leak testing sites

UI theming:

• Jamir-boop/minimalisticfox: Inspired Camoufox's minimal css theming (link)