Camoufox Tutorial: Scrape Without Getting Detected

By Rajesh Kannan, Co-Founder & CTO, Gramosoft · Last updated: November 5, 2026 · Install audit from our own lab on November 5, 2026 (Python 3.13, camoufox 0.5.9, Playwright 1.62)

Camoufox shows up in almost every 2026 thread about scrapers that get flagged. It's a Firefox build for automation, driven through the Playwright API, that sets fingerprint values inside the browser engine instead of patching them in JavaScript. This tutorial covers what it is, how to install it and run a first scrape, what our install audit found, where it falls short, and when GcrawlAI is the simpler route.

Camoufox at a glance

A real browser without running one: GcrawlAI

Camoufox gives you a browser you install, pin, update and scale yourself, along with the proxies it needs. That's the right trade for some teams. If what you want is the rendered page, GcrawlAI runs a real browser on its side and returns the HTML or Markdown, with nothing to download or keep in step with releases.

The homepage puts it in one line: JavaScript rendering, anti-bot stealth and proxies come with every request, with no credit system. For a page Camoufox would render, that means the same result arrives from one API call, and the browser binary, its version pins and its memory use never touch your servers.

Here's the same practice page our Camoufox example uses, fetched through GcrawlAI and kept only if the books are in it:

# pip install gcrawl-sdk parsel
"""The same page through GcrawlAI: a real browser on GcrawlAI's side, so there is no browser binary
to fetch, pin or update on your machine. Keep the page only if the books are in it."""
import os

from gcrawl_sdk import GcrawlClient, ScrapeOptions
from parsel import Selector

gc = GcrawlClient(api_key=os.getenv("GCRAWL_API_KEY", "gc-YOUR_API_KEY"))

page = gc.scrape(url="https://books.toscrape.com/",
                 options=ScrapeOptions(html_enabled=True, markdown_enabled=True, proxy_geo="US"), wait=True)
books = Selector(page.html or "").css("article.product_pod")
print(f"{len(books)} books" if books else "page came back without books: check before storing")

• Rendering and access: a real browser through residential IPs in the country you choose, with retries and stealth escalation inside the request.
• Output you can check: HTML, Markdown or JSON, plus extractors that return structured fields for common page types.
• Scrape, crawl, screenshots and Search API: scrape single pages, crawl whole sites, capture screenshots, or use the Search API.
• For developers and AI agents: a Python SDK, an MCP server for Claude, Cursor and other agents, the Playground to test a page before you write code, and the docs.

The MIT-licensed core also runs on your own servers: clone it from GitHub and the setup script in the code download starts the API with Redis and a Celery worker.

Pricing is a free plan of 50 requests a month with no card, paid plans from $0.67 to $1.45 per 1,000 requests, and a self-hosted core that costs nothing. Failed requests are never charged. The full plan table is in the cost section.

Where it falls short: you don't get Camoufox's level of control over the browser profile, and no service reaches every page, GcrawlAI included. Test your own targets on the free plan. It won't solve CAPTCHAs meant for humans or log in for you, and it doesn't make collecting a site's data acceptable when that site's terms say no.

"Camoufox is a well-built browser. The question we ask teams is whether they want to own a browser fleet or just the data. Most of them only wanted the data."

Rajesh Kannan, Co-Founder & CTO at Gramosoft

What Camoufox is and how it works

Camoufox is a fork of Firefox built for automation. Instead of loading a stock browser and patching JavaScript properties after the page starts, it changes values such as navigator properties, screen size, fonts and WebGL details inside the browser's own code. Pages read those values the same way they read any real Firefox install.

Bright Data's guide describes it as changing browser behaviour at the engine level rather than relying on JavaScript tricks. Roundproxies adds that it generates fingerprints with BrowserForge, a library that follows the real-world spread of device characteristics, and that it strips Mozilla's telemetry and bundled services.

• Playwright API: Camoufox() returns a Playwright browser, so new_page(), goto() and locators work as usual. ZenRows notes that porting a Playwright script mostly means changing imports and setup.
• One identity per session: each launch gets a complete, internally consistent profile rather than a mix of randomised values.
• Proxy-matched location: the geoip option reads the proxy's exit IP and sets timezone, language and geolocation to match it.
• Other languages: python -m camoufox server starts a Playwright server, and ByteTunnels shows Node.js connecting to it over WebSocket.

The trade-off is the engine. Camoufox is Firefox all the way down, so it can't present itself as Chrome. That's by design: a browser claiming to be Chrome while running Firefox's engine would be the kind of mismatch detection systems look for.

When Camoufox is the right tool

Camoufox fits a narrow set of jobs well. It suits teams that already write Playwright, need a real browser for JavaScript-heavy public pages, want to control the browser profile themselves, and are ready to run browsers, proxies and version pins. It's a poor fit when you only need a page's data occasionally.

How to install Camoufox

Installation has two parts, and the second one surprises people. pip installs the Python package and Playwright, but not the browser. The browser is a separate download that python -m camoufox fetch pulls from GitHub, and the first launch tries the same download if you skip that step.

• Use a virtual environment: python -m venv camoufox-env, then activate it. The stable camoufox package and the alpha cloverlabs-camoufox package share module names and conflict if installed together, as Roundproxies warns.
• Install the package: pip install "camoufox[geoip]". The geoip extra adds the data that matches timezone and language to a proxy's location.
• Download the browser: python -m camoufox fetch. python -m camoufox version shows the package and browser you have, and python -m camoufox path shows where it's stored.
• On Linux servers: Roundproxies lists libgtk-3-0, libasound2 and libdbus-glib-1-2 as commonly required on Ubuntu and Debian.

In Docker or CI, run the fetch while building the image, not when the container starts. That keeps runs from depending on GitHub being reachable, and it fixes the browser version for every worker built from that image.

Your first Camoufox scrape

A first scrape looks just like Playwright. The script below opens Books to Scrape, a public site built for scraping practice, reads each book's title and price, and stops if the page came back without them. Swap in your own URL and selectors once it runs.

# pip install "camoufox[geoip]"  then  python -m camoufox fetch   (downloads the browser once)
"""A first Camoufox scrape: open a public practice site in Camoufox's Firefox build through the
Playwright API, read the books on the page, and stop if the page came back without them."""
from camoufox.sync_api import Camoufox

with Camoufox(headless=True) as browser:
    page = browser.new_page()
    page.goto("https://books.toscrape.com/", wait_until="domcontentloaded")
    rows = [{"title": book.locator("h3 a").get_attribute("title"),
             "price": book.locator(".price_color").inner_text()}
            for book in page.locator("article.product_pod").all()]

print(f"{len(rows)} books, first: {rows[0]}" if rows else "no books on the page: check it before storing")

• Headless: headless=True runs without a window. On Linux, Camoufox also offers headless="virtual", which runs it with a virtual display.
• Async: from camoufox.async_api import AsyncCamoufox gives the same API with async with and await.
• Check the content: a page that loads isn't the same as a page with data. Count the items you need before you store anything.

Leave the fingerprint settings at their defaults. Camoufox raises a LeakWarning when you pass settings that can make the profile inconsistent, and a profile that contradicts itself is easier to spot than the default one.

Using Camoufox with a proxy

Camoufox takes the same proxy setting as Playwright: a server address plus an optional username and password. Add geoip=True and it reads the proxy's exit IP and sets the browser's timezone, language and location to match, so a German exit doesn't arrive with a New York clock.

Bright Data recommends session-based rotation, one IP for a short run of pages, over a new IP per request, and warns that rotating on every request creates unnatural traffic. That matches what we've seen: keep one IP, one cookie jar and one profile together for a session.

• Proxy type: residential or ISP proxies for pages that refuse datacenter ranges; our guide to residential vs datacenter proxies covers the trade-offs.
• WebRTC and DNS: a browser can still show a site another address through WebRTC; read WebRTC and DNS leaks and test your setup.
• Pace: a consistent profile at an inhuman request rate is still an inhuman request rate.

What pip install camoufox gave us

We installed camoufox[geoip] into a fresh Python 3.13 environment on November 5, 2026 and audited what arrived. GitHub was blocked in our sandbox, which turned out to be useful: it showed exactly what the package contains and what it still has to download. The audit script is in the code download.

Two findings matter for production. First, the Playwright rule means upgrading Playwright alone can break a working setup if the browser build is older, so pin both together. Second, the preset count differs from figures in some write-ups: one cites 312 presets, while the 0.5.9 package ships 285. Check numbers against the version you install.

"The browser not being in the pip package is the detail that breaks deployments. The scraper works on a laptop, then the first container start in a locked-down network fails on a download nobody knew it needed."

Rajesh Kannan, Co-Founder & CTO at Gramosoft

Limitations to plan around

Camoufox solves one problem, a browser profile that holds together, and leaves the rest with you. Before building on it, weigh the project's own status, the Firefox-only engine and the cost of running real browsers. Competitors that sell managed alternatives publish their own numbers here, so treat those as their measurements, not ours.

• Project status: Roundproxies notes the project warns it may not suit stable production use, that code has moved between repositories, and that some fingerprinting components are kept closed source. Pin a version and test every upgrade.
• Resources: Bright Data and Roundproxies both put memory at about 200 MB per browser instance, and Bright Data estimates about 30 concurrent browsers on an 8 GB server.
• Long runs: Bright Data reports cookies expiring every 30 to 60 minutes and success falling from about 92% in hour one to about 10% by hour three without intervention.
• Sessions: ZenRows points out that session cookies are often tied to one IP and user agent, so rotating either can reset the session.
• Firefox only: if a target behaves differently for Firefox, Camoufox can't change that.

We don't cover clicking through CAPTCHA or Turnstile checks, harvesting challenge cookies to reuse later, or tuning fingerprints and mouse movement to defeat a site's bot checks. Those steps exist to get around a control the site chose to turn on, and a challenge in particular is the site asking for a human.

What rendered pages cost

Camoufox itself is free, but browsers, proxies and upkeep aren't, so compare it with managed APIs on the cost of a page you can use. For 100,000 successful protected pages a month, credit-based APIs cost $249 to $399 at list price and GcrawlAI costs $101. For plain pages, they're cheaper.

List-price arithmetic, not a benchmark. Credit costs and billing rules come from ScraperAPI's credit docs, ZenRows' pricing docs and ScrapingBee's FAQ, checked November 1, 2026. The honest read: for plain HTML, ZenRows, ScraperAPI and ScrapingBee cost less than GcrawlAI, and a self-run Camoufox setup costs servers and proxies rather than credits. Count cost per page with your fields in it.

GcrawlAI plans (GcrawlAI pricing, checked October 28, 2026):

Every plan, Free included, has scrape, crawl, the Search API, JavaScript rendering, residential IP rotation and stealth escalation in each request, and each feature counts as one request. Failed requests are never charged. Annual billing charges 10 months for 12, unused requests on paid plans roll over once, and Indian customers are billed in INR with a GST invoice.

Which route fits your project

Start with the simplest tool that returns the data, and add a browser only where pages need one. Camoufox earns its place when you want to own the browser; a managed API wins when you only want the page. The table shows where GcrawlAI fits in each case.

When your own Python is enough

Many pages that look like they need a browser don't. Check View Source and the browser's network tab first: if the data is in the HTML or a JSON endpoint, Python's requests or httpx gets it faster and cheaper than Camoufox or any browser. Save browsers for pages that only build their content in JavaScript.

When you do need rendering and don't want to run browsers, move those pages to GcrawlAI and keep your field checks. Its free Cloud plan's 50 requests a month are enough to test your real targets, the Playground shows the result without code, and the MIT core self-hosts for free. For the build-or-buy trade-off, read web scraping with Python vs a scraping API.

Using Camoufox responsibly

A browser that presents a consistent profile doesn't change what you're allowed to collect. Read the site's terms and robots.txt, prefer an official API or data licence, stay on public pages, keep request rates low, and don't collect personal data you have no basis to hold. When a site shows a CAPTCHA, stop and ask for access.

Leave logins, checkouts and account pages alone unless they're your own accounts and the terms allow automation. For the rules a site publishes, read how to check if a website allows scraping, and for the legal background, what web scraping is and where it's legal. Get advice for your own case.

Related guides

• 10 Best Headless Browsers for Scraping in 2026: Playwright, Camoufox, Cloud Browsers and More
• Scrapling Tutorial: Adaptive Web Scraping in Python
• WebRTC and DNS Leaks: Why Your Proxy Still Exposes Your Scraper
• HTTP/2 Fingerprinting: Why Your Scraper Still Gets Detected
• How Websites Detect Scrapers: 13 Signals Anti-Bot Systems Check
• How to Scrape Dynamic JavaScript Websites with Python (2026 Guide)
• Residential vs Datacenter Proxies, and How IP Rotation Works (2026 Guide)
• Web Scraping with Python vs a Scraping API: When to Stop Writing Your Own Scraper