Camofox Browser
A self-hosted anti-detection browser API for agent-driven browsing with isolated sessions and ref-based page control.
Per-dimension scores and reasoning
Evidence: API key used for cookie import, but other endpoints not authenticated; cookie import disabled by default, requires explicit key; data flow transparency good with logging and telemetry; sensitive data anonymized; dependency audit in CI; external effects include auto-created GitHub Issues, but can be disabled; no rollback; source attribution has author and repo info. Deductions: least privilege insufficient (API key only protects some endpoints), user confirmation missing (telemetry on by default), rollback missing, source attribution based on self-report.
Evidence: README consistent with package.json, features align with code structure; dependency versions pinned (camoufox-js 0.11.5), but availability not guaranteed; failure messages structured (e.g., navigation_race). Deductions: dependency availability unverified, failure messages not comprehensive.
Evidence: Clearly targets AI agents, multiple deployment options (Docker, Fly.io, Railway); capability boundaries clear (feature list); trigger precision high (explicit API endpoints); environment fit good (multiple platforms). Deductions: no major flaws, but lacks detailed scenario examples.
Evidence: Information architecture clear (README TOC); install notes detailed (npm, Docker, source); naming stable (version numbers); examples and FAQ present (usage examples); known limitations minimal; MIT license clear; version number exists but no changelog; maintenance responsibility has author info but not explicit. Deductions: known limitations insufficient, no changelog, maintenance responsibility unclear.
Evidence: Output usability high (API and plugin); marginal value high (solves anti-detection); cost-benefit reasonable (lightweight). Deductions: no major flaws, but no performance benchmarks.
Evidence: Some claims traceable (e.g., telemetry endpoint verifiable); cross-source corroboration limited (self-report only); fact-inference separation unclear. Deductions: lack of independent verification, claims mostly self-reported.
- API key only protects cookie import endpoint; other endpoints may be unauthenticated, posing unauthorized access risk.
- Telemetry is on by default, auto-creating GitHub Issues, may leak anonymized site info; verify privacy policy.
- Depends on camoufox-js and playwright-core; monitor their security updates.
What does this agent do, and when should you use it?
Camofox Browser is a self-hosted Node.js browser server built around the Camoufox Firefox engine and exposed through a REST API. Instead of returning raw page HTML, it produces accessibility snapshots with stable element references such as e1 and e2 for subsequent interaction. Each user is assigned an isolated BrowserContext, while sessionKey values organize tab groups and persisted storage can restore cookies and localStorage after restarts. The server launches the browser lazily, shuts it down after idle time, and documents npm, source, Docker, Railway, and Fly.io deployment paths. Optional capabilities include proxy-backed GeoIP settings, Netscape cookie import, VNC login, Playwright traces, YouTube transcript extraction, and anonymized crash and hang telemetry.
A client creates a page with POST /tabs, supplying userId, sessionKey, and url; the service starts Camoufox and opens the page in that user's BrowserContext. GET /tabs/:id/snapshot returns an accessibility snapshot with element refs and can add a base64 PNG through includeScreenshot=true; POST /tabs/:id/click, /type, /press, /scroll, and /navigate perform page actions, with navigate supporting macros such as @google_search and @reddit_search. GET /tabs/:id/links, /images, /downloads, and /screenshot return page links, image metadata, captured downloads, and screenshots; POST /tabs/:tabId/extract accepts a JSON Schema that maps properties to snapshot refs with x-ref. POST /sessions/:userId/cookies injects Playwright cookie objects, GET /sessions/:userId/storage_state exports storage state, and trace:true on the first tab of a session enables Playwright trace archives. POST /youtube/transcript uses yt-dlp when available and otherwise falls back to a browser-based interception method.
- A developer building a web-research assistant that needs to create pages over HTTP, inspect accessibility snapshots, and act on e1-style references.
- A team operating browser jobs for multiple users that needs cookies, localStorage, and tabs isolated by userId and restorable after browser restarts.
- A scraping workflow that must route browser traffic through a residential or backconnect proxy and align browser locale, timezone, and geolocation with the proxy exit IP.
- An operator who needs to reuse an authenticated website session by importing a Netscape-format cookie file or completing a visual login through the VNC plugin.
- An engineering team diagnosing flaky browser sessions that needs per-session Playwright traces containing screenshots, DOM snapshots, network activity, and console output.
- A workflow extracting captions from YouTube URLs that can install yt-dlp for the documented faster transcript path.
What are this agent's strengths and limitations?
- It uses Camoufox as its underlying engine; the project describes its fingerprint changes as Firefox C++-level implementation changes rather than JavaScript shims or stealth wrappers.
- Accessibility snapshots and stable element refs provide an API-oriented interaction loop, with pagination and optional snapshot screenshots.
- BrowserContext isolation is paired with cookie import, persisted storage state, session-level tracing, and sessionKey-based tab grouping.
- The repository documents several delivery paths: npm, source checkout, Docker, Railway, Fly.io, and a Windows PowerShell build script.
- Proxy configuration can use Camoufox GeoIP to align locale, timezone, and geolocation with the proxy exit location.
- Initial installation downloads roughly 300MB of Camoufox; an external executable must come from a Camoufox bundle containing properties.json, version.json, and fontconfig resources.
- Cookie import is disabled until CAMOFOX_API_KEY is set, and deployments exposed beyond localhost need CAMOFOX_ACCESS_KEY for route protection.
- The faster YouTube transcript route depends on a separate yt-dlp installation; the documented browser fallback is slower and less reliable.
- Sessions and tabs have documented default limits and expiry behavior, including MAX_SESSIONS of 50, MAX_TABS_PER_SESSION of 10, and a 30-minute session inactivity timeout.
- Anonymized crash and hang telemetry is enabled by default, so adopters that do not want it must set CAMOFOX_CRASH_REPORT_ENABLED=false.
How do you install or deploy this agent?
Run from source:
git clone https://github.com/jo-inc/camofox-browser && cd camofox-browser
npm install
npm startThe server defaults to http://localhost:9377, and the first run downloads roughly 300MB of Camoufox. Alternatively run:
npx @askjo/camofox-browserFor Docker, use the included build flow:
make upCookie import requires a key before startup:
export CAMOFOX_API_KEY="your-generated-key"
npm startFor the faster local YouTube transcript path, install:
pip install yt-dlpHow do you use this agent?
Create a first tab:
curl -X POST http://localhost:9377/tabs \
-H 'Content-Type: application/json' \
-d '{"userId":"agent1","sessionKey":"task1","url":"https://example.com"}'Use the returned TAB_ID to retrieve a snapshot:
curl "http://localhost:9377/tabs/TAB_ID/snapshot?userId=agent1"Click a reference returned in that snapshot:
curl -X POST http://localhost:9377/tabs/TAB_ID/click \
-H 'Content-Type: application/json' \
-d '{"userId":"agent1","ref":"e1"}'For deployments beyond loopback, set CAMOFOX_ACCESS_KEY and send Authorization: Bearer <key> with protected requests.
How does this agent compare with similar options?
The project positions itself as a browser-service alternative to typical Playwright or Puppeteer use: it says standard Playwright or headless Chrome can be fingerprinted, while this service uses the Camoufox Firefox engine and exposes automation through REST endpoints, accessibility snapshots, and element refs. It is not a conventional in-process Playwright replacement; clients integrate through its HTTP API.