Skip to content

Kornelijus/camoufox

BranchesTags
 
 

Repository files navigation

Camoufox

A stealthy, minimalistic, custom build of Firefox for web scraping 🦊

Camoufox is an open source anti-detect browser for robust fingerprint injection & anti-bot evasion.

daijro%2Fcamoufox | Trendshift

Important

About This Fork

The original maintainer @daijro is recovering from a medical emergency (hospitalized since March 2025).

When the original maintainer returns, this work will be contributed back upstream. In the meantime, this fork provides newer Firefox builds.

❤️ Wishing @daijro a full recovery.

Note

The documentation for upstream is available at camoufox.com.

Camoufox is the most modern, effective & future-proof open source solution for avoiding bot detection and intelligent fingerprint rotation. It outperforms most commercial anti-bot browsers.

Features

  • Invisible to all anti-bot systems 🎭
    • Camoufox performs better than most commercial anti-bot browsers.
  • Fingerprint injection & rotation (without JS injection!)
    • All navigator properties (device, OS, hardware, browser, etc.) ✅
    • Screen size, resolution, window, & viewport properties ✅
    • Geolocation, timezone, & locale spoofing ✅
    • Font spoofing & anti-fingerprinting ✅
    • WebGL parameters, supported extensions, context attributes, & shader precision formats ✅
    • WebRTC IP spoofing at the protocol level ✅
    • Media devices, voices, speech playback rate, etc. ✅
    • And much, much more!
  • Quality of life features
    • Human-like mouse movement 🖱️
    • Blocks & circumvents ads 🛡️
    • No CSS animations 💨
  • Debloated & optimized for memory efficiency ⚡
  • PyPi package 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 fingerprint properties, pass a JSON containing properties to spoof to the Python interface:

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

Config data not set by the user will be automatically populated using BrowserForge fingerprints, which mimic the statistical distribution of device characteristics in real-world traffic.

Legacy documentation

The following properties can be spoofed:

Navigator

Navigator properties can be fully spoofed to other Firefox fingerprints, and it is completely safe! However, there are some issues when spoofing Chrome (leaks noted).

Property Notes
navigator.userAgent ✅
navigator.doNotTrack ✅
navigator.appCodeName ✅
navigator.appName ✅
navigator.appVersion ✅
navigator.oscpu ✅
navigator.language ✅
navigator.languages ✅
navigator.platform ✅
navigator.hardwareConcurrency ✅
navigator.product ✅
navigator.productSub ✅
navigator.maxTouchPoints ✅
navigator.cookieEnabled ✅
navigator.globalPrivacyControl ✅
navigator.appVersion ✅
navigator.buildID ✅
navigator.doNotTrack ✅

Camoufox will automatically add the following default fonts associated your spoofed User-Agent OS (the value passed in navigator.userAgent).

Notes:

  • navigator.webdriver is set to false at all times.
  • navigator.language & navigator.languages will fall back to the locale:language/locale:region values if not set.
  • When spoofing Chrome fingerprints, the following may leak:
    • navigator.userAgentData missing.
    • navigator.deviceMemory missing.
  • Changing the presented Firefox version can be detected by some testing websites, but typically will not flag production WAFs.
Cursor movement

Human-like Cursor movement

Camoufox has built-in support for human-like cursor movement. The natural motion algorithm was originally from rifosnake's HumanCursor, but has been rewritten in C++ and modified for more distance-aware trajectories.

Demo

humanize-demo.mp4

Properties

Property Supported Description
humanize ✅ Enable/disable human-like cursor movement. Defaults to False.
humanize:maxTime ✅ Maximum time in seconds for the cursor movement. Defaults to 1.5.
showcursor ✅ Toggles the cursor highlighter. Defaults to True.

Notes:

  • The cursor highlighter is not ran in the page context. It will not be visible to the page. You don't have to worry about it leaking.
Fonts

Adding Fonts

Fonts can be passed to be used in Camoufox through the fonts config property.

By default, Camoufox is bundled with the default Windows 11 22H2 fonts, macOS Sonma fonts, and Linux fonts used in the TOR bundle.

Camoufox will automatically add the default fonts associated your spoofed User-Agent OS (the value passed in navigator.userAgent):

  • Mac OS fonts (from macOS Sonma):
  • Windows fonts (from Windows 11 22H2):
  • Linux fonts (from TOR Browser):

Other fonts can be added by copying them into the fonts/ directory in Camoufox, or by installing them on your system.

Note: It is highly recommended that you randomly pass custom fonts to the fonts config property to avoid font fingerprinting!

Font Metrics

Camoufox has a built in mechanism to prevent fingerprinting by font metrics & unicode glyphs:

This works by shifting the spacing of each letter by a random value between 0-0.1px.

Screen
Property Status
screen.availHeight ✅
screen.availWidth ✅
screen.availTop ✅
screen.availLeft ✅
screen.height ✅
screen.width ✅
screen.colorDepth ✅
screen.pixelDepth ✅
screen.pageXOffset ✅
screen.pageYOffset ✅

Notes:

  • screen.colorDepth and screen.pixelDepth are synonymous.
Window
Property Status Notes
window.scrollMinX ✅
window.scrollMinY ✅
window.scrollMaxX ✅
window.scrollMaxY ✅
window.outerHeight ✅ Sets the window height.
window.outerWidth ✅ Sets the window width.
window.innerHeight ✅ Sets the inner viewport height.
window.innerWidth ✅ Sets the inner viewport width.
window.screenX ✅
window.screenY ✅
window.history.length ✅
window.devicePixelRatio ✅ Works, but not recommended.

Notes:

  • Setting the outer window viewport will cause some cosmetic defects to the Camoufox window if the user attempts to manually resize it. Under no circumstances will Camoufox allow the outer window viewport to be resized.
Document

Spoofing document.body has been implemented, but it is more advicable to set window.innerWidth and window.innerHeight instead.

Property Status
document.body.clientWidth ✅
document.body.clientHeight ✅
document.body.clientTop ✅
document.body.clientLeft ✅
HTTP Headers

Camoufox can override the following network headers:

Property Status
headers.User-Agent ✅
headers.Accept-Language ✅
headers.Accept-Encoding ✅

Notes:

  • If headers.User-Agent is not set, it will fall back to navigator.userAgent.
Geolocation & Intl
Property Status Description Required Keys
geolocation:latitude ✅ Latitude to use. geolocation:longitude
geolocation:longitude ✅ Longitude to use. geolocation:latitude
geolocation:accuracy ✅ Accuracy in meters. This will be calculated automatically using the decminal percision of geolocation:latitude & geolocation:longitude if not set.
timezone ✅ Set a custom TZ timezone (e.g. "America/Chicago"). This will also change Date() to return the local time.
locale:language ✅ Spoof the Intl API, headers, and system language (e.g. "en") locale:region
locale:region ✅ Spoof the Intl API, headers, and system region (e.g. "US"). locale:language
locale:script ✅ Set a custom script (e.g. "Latn"). Will be set automatically if not specified.

The Required Keys are keys that must also be set for the property to work.

Notes:

  • Location permission prompts will be accepted automatically if geolocation:latitude and geolocation:longitude are set.
  • timezone must be set to a valid TZ identifier. See here for a list of valid timezones.
  • locale:language & locale:region must be set to valid locale values. See here for a list of valid locale-region values.
WebRTC IP

Camoufox implements WebRTC IP spoofing at the protocol level by modifying ICE candidates and SDP before they're sent.

Property Status Description
webrtc:ipv4 ✅ IPv4 address to use
webrtc:ipv6 ✅ IPv6 address to use

Notes:

  • To completely disable WebRTC, set the media.peerconnection.enabled preference to false.
WebGL

WebGL in Camoufox

WebGL is disabled in Camoufox by default. To enable it, set the webgl.disabled Firefox preference to false.

WebGL being disabled typically doesn't trigger detection by WAFs, so you generally don't need to be concerned about it. Only use WebGL when it's absolutely necessary for your specific use case.

Because I don't have a dataset of WebGL fingerprints to rotate against, WebGL fingerprint rotation is not implemented in the Camoufox Python library. If you need to spoof WebGL, you can do so manually with the following properties.

Demo site

This repository includes a demo site (see here) that prints your browser's WebGL parameters. You can use this site to generate WebGL fingerprints for Camoufox from other devices.

Properties

Camoufox supports spoofing WebGL parameters, supported extensions, context attributes, and shader precision formats.

Note: Do NOT randomly assign values to these properties. WAFs hash your WebGL fingerprint and compare it against a dataset. Randomly assigning values will lead to detection as an unknown device.

Property Description Example
webGl:renderer Spoofs the name of the unmasked WebGL renderer. "NVIDIA GeForce GTX 980, or similar"
webGl:vendor Spoofs the name of the unmasked WebGL vendor. "NVIDIA Corporation"
webGl:supportedExtensions An array of supported WebGL extensions (full list). ["ANGLE_instanced_arrays", "EXT_color_buffer_float", "EXT_disjoint_timer_query", ...]
webGl2:supportedExtensions The same as webGl:supportedExtensions, but for WebGL2. ["ANGLE_instanced_arrays", "EXT_color_buffer_float", "EXT_disjoint_timer_query", ...]
webGl:contextAttributes A dictionary of WebGL context attributes. {"alpha": true, "antialias": true, "depth": true, ...}
webGl2:contextAttributes The same as webGl:contextAttributes, but for WebGL2. {"alpha": true, "antialias": true, "depth": true, ...}
webGl:parameters A dictionary of WebGL parameters. Keys must be GL enums, and values are the values to spoof them as. {"2849": 1, "2884": false, "2928": [0, 1], ...}
webGl2:parameters The same as webGl:parameters, but for WebGL2. {"2849": 1, "2884": false, "2928": [0, 1], ...}
webGl:parameters:blockIfNotDefined If set to true, only the parameters in webGl:parameters will be allowed. Can be dangerous if not used correctly. true/false
webGl2:parameters:blockIfNotDefined If set to true, only the parameters in webGl2:parameters will be allowed. Can be dangerous if not used correctly. true/false
webGl:shaderPrecisionFormats A dictionary of WebGL shader precision formats. Keys are formatted as "<shaderType>,<precisionType>". {"35633,36336": {"rangeMin": 127, "rangeMax": 127, "precision": 23}, ...}
webGl2:shaderPrecisionFormats The same as webGL:shaderPrecisionFormats, but for WebGL2. {"35633,36336": {"rangeMin": 127, "rangeMax": 127, "precision": 23}, ...}
webGl:shaderPrecisionFormats:blockIfNotDefined If set to true, only the shader percisions in webGl:shaderPrecisionFormats will be allowed. true/false
webGl2:shaderPrecisionFormats:blockIfNotDefined If set to true, only the shader percisions in webGl2:shaderPrecisionFormats will be allowed. true/false
AudioContext

Camoufox can spoof the AudioContext sample rate, output latency, and max channel count.

Property Status Description
AudioContext:sampleRate ✅ Spoofs the AudioContext sample rate.
AudioContext:outputLatency ✅ Spoofs the AudioContext output latency.
AudioContext:maxChannelCount ✅ Spoofs the AudioContext max channel count.

Here is a testing site: https://audiofingerprint.openwpm.com/

Addons

In the Camoufox Python library, addons can be loaded with the addons parameter:

from camoufox.sync_api import Camoufox

with Camoufox(addons=['/path/to/addon', '/path/to/addon2']) as browser:
    page = browser.new_page()

Camoufox will automatically download and use the latest uBlock Origin with custom privacy/adblock filters, and B.P.C. by default to help with ad circumvention.

You can also exclude default addons with the exclude_addons parameter:

from camoufox.sync_api import Camoufox
from camoufox import DefaultAddons

with Camoufox(exclude_addons=[DefaultAddons.UBO, DefaultAddons.BPC]) as browser:
    page = browser.new_page()
Loading addons with the legacy launcher...

Addons can be loaded with the --addons flag.

Example:

./launcher --addons '["/path/to/addon", "/path/to/addon2"]'

Camoufox will automatically download and use the latest uBlock Origin with custom privacy/adblock filters, and B.P.C. by default to help with scraping.

You can also exclude default addons with the --exclude-addons flag:

./launcher --exclude-addons '["uBO", "BPC"]'
Miscellaneous (battery status, etc)
Property Status Description
pdfViewer ✅ Sets navigator.pdfViewerEnabled. Please keep this on though, many websites will flag a lack of pdfViewer as a headless browser.
battery:charging ✅ Spoofs the battery charging status.
battery:chargingTime ✅ Spoofs the battery charging time.
battery:dischargingTime ✅ Spoofs the battery discharging time.
battery:level ✅ Spoofs the battery level.
WebSocket Port Remapping

Camoufox automatically remaps WebSocket connection attempts to localhost fingerprinting ports, preventing timing-based port scanning attacks (like Kasada uses) that detect automation environments. Each monitored port is remapped to a unique target port to prevent timing correlation attacks.

Property Status Description
websocket:remapping:enabled ✅ Enable/disable port remapping. Defaults to true.
websocket:remapping:basePort ✅ Base port for auto-assignment in default mode. Defaults to 1080.
websocket:remapping:manualPortMappings ✅ Array of "source:target" mappings. Replaces defaults if provided.

Two Operating Modes:

  1. Default Mode (no manual mappings configured):

    • Uses hardcoded fingerprinting port list (see below)
    • Each port auto-assigned unique sequential target starting at basePort (default: 1080)
    • Example: 63333→1080, 5900→1081, 5901→1082, etc.

  2. Manual Mode (manualPortMappings provided):

    • User specifies explicit "source:target" mappings
    • Each source port must have unique target to prevent timing correlation
    • Replaces default list entirely
    • Example config:
    {
  "websocket:remapping:manualPortMappings": [
    "9222:1080",
    "4444:1081",
    "5900:1082"
  ]
}

Default monitored ports (used in default mode):

  • Remote desktop: VNC (5900-5903, 5931, 5938-5939, 5944, 5950, 6039-6040), RDP (3389)
  • Automation: Selenium/WebDriver (4444, 4445, 9515), Chrome DevTools (9222, 9223)
  • Development: 3000, 8080, 8081, 35729
  • Docker: 2375, 2376, 2377
  • Proxies: 1080, 3128, 8888, 9050
  • Android debugging: 5037
  • Other: 63333, 5279, 7070, 2112

Notes:

  • Only affects WebSocket connections to localhost (127.0.0.1, localhost, ::1)
  • Connection attempts still occur (maintains timing), but redirected to different closed ports
  • Each source port maps to unique target to prevent fingerprinting via timing correlation
  • Test with: python3 browser-tests/test-websocket-port-remapping.py

Patches

What changes were made?

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
  • 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
  • Battery API 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

Anti font fingerprinting

  • Automatically uses the correct system fonts for your User Agent
  • Bundled with Windows, Mac, and Linux system fonts
  • Prevents font metrics fingerprinting by randomly offsetting letter spacing

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
  • Removed all CSS animations
  • Minimalistic theming
  • etc.

Addons

  • Firefox addons can be loaded with the --addons flag
  • 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

Stealth Performance

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

Tests

Camoufox performs well against every major WAF I've tested. (Original test sites from Botright)

Test Status
CreepJS ✔️ 71.5%. Successfully spoofs all OS predictions.
Rebrowser Bot Detector ✔️ All tests pass.
BrowserScan ✔️ 100%. Spoofs all geolocation & locale proxy detection.
reCaptcha Score ✔️
‣ nopecha.com ✔️
‣ recaptcha-demo.appspot.com ✔️ 0.9
‣ berstend.github.io ✔️ 0.9
DataDome ✔️
‣ DataDome bot bounty ✔️ All test sites pass.
‣ hermes.com ✔️
Imperva ✔️
‣ ticketmaster.es ✔️
Cloudflare ✔️
‣ Turnstile ✔️
‣ Interstitial ✔️
WebRTC IP Spoofing ✔️
‣ Browserleaks WebRTC ✔️ Spoofs public IP correctly.
‣ CreepJS WebRTC ✔️ Spoofs Host & STUN IP correctly.
‣ BrowserScan WebRTC ✔️ Spoofs Host & STUN IP correctly.
Font Fingerprinting ✔️
‣ Browserleaks Fonts ✔️ Rotates all metrics.
‣ CreepJS TextMetrics ✔️ Rotates all metrics.
Incolumitas ✔️ 0.8-1.0
SannySoft ✔️
Fingerprint.com ✔️
IpHey ✔️
Bet365 ✔️

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

Playwright Usage

See here for documentation on Camoufox's Python interface.

Note

The content below is intended for those interested in building & debugging Camoufox. For Playwright usage instructions, see here.

Build System

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 & B.P.C.]
        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
Loading

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

Tarball Workflow (Original)

This workflow downloads Firefox as a tarball and extracts it:

make dir        # Download & extract Firefox, apply patches
make bootstrap  # Install dependencies (one-time)

Git Workflow (Recommended for Development)

This workflow clones the Firefox git repository, preserving full commit history for debugging:

make git-fetch      # Clone Firefox source from Mozilla
make git-dir        # Apply patches and setup
make git-bootstrap  # Install dependencies (one-time)

Benefits of git workflow:

  • Full Firefox git history for git log, git blame, git diff
  • Works with make retag-baseline (requires commit history)
  • Better for tracking upstream Firefox changes
  • Faster than tarball download (uses blobless clone)

Building

Both workflows use the same build command:

uv run scripts/multibuild.py --target linux windows macos --arch x86_64 arm64 i686
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:
$ uv run scripts/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 .
  1. 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.

Development Tools

This repo comes with a developer UI under scripts/developer.py:

make edits

Patches can be edited, created, removed, and managed through here.

How to make a patch

  1. In the developer UI, click Reset workspace.
  2. Make changes in the camoufox-*/ folder as needed. You can test your changes with make build and make run.
  3. After you're done making changes, click Write workspace to patch and save the patch file.

How to work on an existing patch

  1. In the developer UI, click Edit a patch.
  2. Select the patch you'd like to edit. Your workspace will be reset to the state of the selected patch.
  3. After you're done making changes, hit Write workspace to patch and overwrite the existing patch file.

Testing with the Python library (local development)

After building Camoufox locally, you can test your changes with the Camoufox Python library without packaging:

make build              # Build your changes
make setup-local-dev   # One-time setup (creates symlinks)

The setup-local-dev target creates symlinks so the Python library uses your local build instead of a downloaded release:

  • Symlinks bundled fonts and fontconfigs into the build directory
  • Creates version.json with current version info
  • Links ~/.cache/camoufox to your build directory

After setup, you can iterate quickly:

<edit Firefox source>
make build             # Rebuild
# Python library now uses your fresh build automatically

Note: Symlinks persist across rebuilds, so you only need to run make setup-local-dev once per build directory.

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["Open the developer UI(5), apply config.patch, 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["Open the developer UI, apply the playwright bootstrap patch, 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
Loading

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 edits Opens the developer UI. Allows the user to apply/undo patches, and see which patches are currently applied.
(6) make edit-cfg Edit camoufox.cfg in the default system editor.

Thanks

Scrapfly.io

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.

About

🦊 Anti-detect browser

Resources

Readme

License

MPL-2.0 license
Activity

Stars

16 stars

Watchers

5 watching

Forks

3 forks
Report repository

Releases

32 tags

Packages

No packages published

Languages

  • C++ 67.6%
  • JavaScript 19.0%
  • Python 9.8%
  • Makefile 1.0%
  • HTML 1.0%
  • CSS 0.9%
  • Other 0.7%