[opensourcedex]

camofox-browser is a free, open source data extraction & web scraping project written in JavaScript and released under MIT. It has 11,073 GitHub stars, 1,095 forks and 66 open issues, and was last pushed 23 hours ago. On this registry it ranks #20 of 45 tracked projects in Data Extraction & Web Scraping, with 5 head-to-head comparisons available. It gained 25 stars over the last 3 tracked days.

What is camofox-browser?

What it is

camofox-browser is an anti-detection browser server for AI agents, built in JavaScript and distributed under the MIT license. It wraps Camoufox, a Firefox fork that performs fingerprint spoofing at the C++ implementation level, and exposes that engine through a REST API designed for programmatic agents rather than human users. The project lives in the Node.js ecosystem and is published by the team behind jo, a personal AI agent. It is positioned as a drop-in replacement for Puppeteer and Playwright when those tools are blocked.

The concrete problem it solves is detection. Playwright gets blocked, headless Chrome gets fingerprinted, and stealth plugins themselves become a fingerprint. Camoufox patches values such as navigator.hardwareConcurrency, WebGL renderers, AudioContext, screen geometry, and WebRTC before JavaScript ever observes them, so no shims or wrappers are needed. On top of that engine, camofox-browser returns accessibility snapshots instead of raw HTML, which the README states are roughly 90 percent smaller, and assigns stable element references such as e1, e2, and e3 so agents can click and type reliably.

Key capabilities

  • C++ level anti-detection that bypasses Google, Cloudflare, and most bot detection.
  • Stable element references for reliable clicking and typing across snapshots.
  • Token-efficient accessibility snapshots, reported as about 90 percent smaller than raw HTML.
  • Lazy browser launch with idle shutdown, keeping memory near 40MB when idle.
  • Session isolation with separate cookies and storage per user, plus Netscape-format cookie import for authenticated browsing.
  • Proxy and GeoIP routing through residential proxies with automatic locale and timezone adjustment.
  • Search macros including @google_search, @youtube_search, @amazon_search, and @reddit_subreddit, alongside ten more.
  • Structured extraction via POST /tabs/:tabId/extract with a JSON Schema mapping properties to snapshot refs through x-ref.

Who uses it and how

  • AI agent developers who need a browsing backend that survives anti-bot defenses on real sites.
  • Teams running agents on constrained hardware, since the README targets Raspberry Pi, a $5 VPS, or shared infrastructure.
  • Operators who need authenticated sessions, using VNC interactive login through noVNC and exported storage state for later agent reuse.
  • Workflows requiring captured artifacts, including download capture, DOM image extraction, base64 snapshot screenshots, and YouTube transcript retrieval through yt-dlp.
  • Production deployments needing observability, using JSON structured logging with request IDs and opt-in per-session Playwright trace capture.

Getting started

Clone the repository, run npm install, then npm start, which serves the API at http://localhost:9377 with OpenAPI docs at /openapi.json and /docs. Deployment options include Docker, Fly.io, and Railway, and an OpenClaw plugin is available via openclaw plugins install @askjo/camofox-browser.

When to use it — and when not to

The project is a reasonable fit when Puppeteer or Playwright automation is being blocked and a self-hosted REST service is acceptable. A self-hoster must operate the Node.js service and its browser process, though no database or external service is required beyond the optional yt-dlp dependency for the fast transcript path. Two caveats are evident: anonymized crash and hang telemetry is enabled by default and must be disabled with `CAMOFOX_CRASH

project readme (upstream, from github) — read inline

camofox-browser

Anti-detection browser server for AI agents, powered by Camoufox

License: MIT GitHub stars npm version GitHub last commit

Standing on the mighty shoulders of Camoufox - a Firefox fork with fingerprint spoofing at the C++ level.


Built by the team behind jo, a personal AI agent that runs half on your Mac, half on a dedicated cloud machine just for you -- with zero maintenance needed. Available on macOS, Telegram, WhatsApp, and email. Try the beta free ->

Pradeep Elankumaran (@pradeep24) — co-founder and technical CEO at Jo.



git clone https://github.com/jo-inc/camofox-browser && cd camofox-browser
npm install && npm start
# -> http://localhost:9377

Why

AI agents need to browse the real web. Playwright gets blocked. Headless Chrome gets fingerprinted. Stealth plugins become the fingerprint.

Camoufox patches Firefox at the C++ implementation level - navigator.hardwareConcurrency, WebGL renderers, AudioContext, screen geometry, WebRTC - all spoofed before JavaScript ever sees them. No shims, no wrappers, no tells.

This project wraps that engine in a REST API built for agents: accessibility snapshots instead of bloated HTML, stable element refs for clicking, and search macros for common sites.

Features

  • C++ Anti-Detection - bypasses Google, Cloudflare, and most bot detection
  • Element Refs - stable e1, e2, e3 identifiers for reliable interaction
  • Token-Efficient - accessibility snapshots are ~90% smaller than raw HTML
  • Runs on Anything - lazy browser launch + idle shutdown keeps memory at ~40MB when idle. Designed to share a box with the rest of your stack -- Raspberry Pi, $5 VPS, shared infra.
  • Session Isolation - separate cookies/storage per user
  • Cookie Import - inject Netscape-format cookie files for authenticated browsing
  • File Upload - attach files from a configured upload directory without a native OS dialog
  • Proxy + GeoIP - route traffic through residential proxies with automatic locale/timezone
  • Structured Logging - JSON log lines with request IDs for production observability
  • YouTube Transcripts - extract captions from any YouTube video via yt-dlp, no API key needed
  • Search Macros - @google_search, @youtube_search, @amazon_search, @reddit_subreddit, and 10 more
  • Snapshot Screenshots - include a base64 PNG screenshot alongside the accessibility snapshot
  • Large Page Handling - automatic snapshot truncation with offset-based pagination
  • Download Capture - capture browser downloads and fetch them via API (optional inline base64)
  • DOM Image Extraction - list `` src/alt and optionally return inline data URLs
  • Deploy Anywhere - Docker, Fly.io, Railway
  • VNC Interactive Login - log into sites visually via noVNC, export storage state for agent reuse
  • OpenAPI Docs - auto-generated spec at /openapi.json and interactive docs at /docs
  • Structured Extract - POST /tabs/:tabId/extract with a JSON Schema that maps properties to snapshot refs via x-ref
  • Session Tracing - opt-in per-session Playwright trace capture (screenshots + DOM snapshots + network) with API endpoints to list, fetch, and delete trace zips
  • Telemetry - automatic anonymized crash/hang telemetry via GitHub Issues. Identifies which sites cause failures and common failure patterns. Private domains are HMAC-hashed, paths/params stripped, tokens/IPs redacted. Opt-out with CAMOFOX_CRASH_REPORT_ENABLED=false.

Optional Dependencies

Dependency Purpose Install
yt-dlp YouTube transcript extraction (fast path) pip install yt-dlp or brew install yt-dlp

The Docker image includes yt-dlp. For local dev, install it for the /youtube/transcript endpoint. Without it, the endpoint falls back to a slower browser-based method.

Quick Start

OpenClaw Plugin

openclaw plugins install @askjo/camofox-browser

Tools: camofox_create_tab | camofox_snapshot | camofox_click | camofox_type | camofox_navigate | camofox_scroll | camofox_screenshot | camofox_close_tab | camofox_list_tabs | camofox_import_cookies

Standalone

Run from npm:

npx @askjo/camofox-browser

Or from source:

git clone https://github.com/jo-inc/camofox-browser
cd camofox-browser
npm install
npm start  # downloads Camoufox on first run (~300MB)

Default port is 9377. See Environment Variables for all options.

Note: the postinstall script unsets PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD for itself before fetching the Camoufox binary. Without that override, an exported PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 (common when Playwright is configured to use system Chrome) would silently skip the binary download and crash the server at runtime.

External Camoufox executable: set CAMOUFOX_EXECUTABLE=/path/to/camoufox-bin before npm install and when starting the server to skip the bundled download and launch that executable. Compatibility aliases are CAMOUFOX_EXECUTABLE_PATH and CAMOFOX_EXECUTABLE_PATH. This is useful for NixOS paths such as /nix/store/.../camoufox-bin; the executable must come from a Camoufox bundle that includes properties.json, version.json, and fontconfig/.

Air-gapped or custom binary management: prefer CAMOUFOX_EXECUTABLE when you already have a Camoufox bundle. Otherwise disable the auto-fetch with npm install --ignore-scripts (skips lifecycle scripts for every dependency -- bluntest option) or, more surgically, npm install --omit=optional plus a manual npx camoufox-js fetch step against your mirror. Note that PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 npm install no longer skips the Camoufox download (the postinstall sanitizes the env locally); use --ignore-scripts or CAMOUFOX_EXECUTABLE for that.

Docker

The included Makefile auto-detects your CPU architecture and pre-downloads Camoufox + yt-dlp binaries outside the Docker build, so rebuilds are fast (~30s vs ~3min).

# Build and start (auto-detects arch: aarch64 on M1/M2, x86_64 on Intel)
make up

# Stop and remove the container
make down

# Force a clean rebuild (e.g. after upgrading VERSION/RELEASE)
make reset

# Just download binaries (without building)
make fetch

# Override arch or version explicitly
make up ARCH=x86_64
make up VERSION=135.0.1 RELEASE=beta.24
Windows

On Windows, make is not available. Use the included build.ps1 PowerShell script instead:

# Build and start
.\build.ps1 up

# Stop and remove the container
.\build.ps1 down

# Build image only
.\build.ps1 build

# Force a clean rebuild
.\build.ps1 reset

# Download binaries only (without building)
.\build.ps1 fetch

# Override architecture
.\build.ps1 up -Arch x86_64
.\build.ps1 up -Arch aarch64

Note: PowerShell 7+ (pwsh) is recommended but powershell.exe (Windows PowerShell 5.1) also works. The script requires Docker Desktop for Windows with the WSL2 backend.

Line endings: This project includes a .gitattributes file that forces Unix (LF) line endings for .sh files. If you've already cloned the repo and get sh: not found or set: Illegal option - errors during docker build, run:

Get-ChildItem -Recurse *.sh | ForEach-Object { (Get-Content $_) -join "`n" + "`n" | Set-Content $_ -NoNewline }

This converts shell scripts to LF line endings. Future clones will handle this automatically thanks to .gitattributes.

WARNING: Do not run docker build directly. The Dockerfile uses bind mounts to pull pre-downloaded binaries from `

readme truncated — read the full docs on github

Frequently asked questions

Is camofox-browser free to use?

camofox-browser is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does camofox-browser do?

Stealth headless browser for AI agents — bypass Cloudflare, bot detection, and anti-scraping. Drop-in Puppeteer/Playwright replacement.

What is camofox-browser written in?

camofox-browser is primarily written in JavaScript. Its source is publicly available at https://github.com/jo-inc/camofox-browser, and it has 11,073 GitHub stars.