# CloakBrowser

> Stealth Chromium that drops into Playwright and Puppeteer code unchanged

- Category: Agents & Automation / Computer & Browser Use
- Language: Python
- Licence: MIT
- Repository: https://github.com/CloakHQ/CloakBrowser
- Website: https://cloakbrowser.dev
- Canonical page: https://ai-tldr.dev/tools/cloakbrowser/

## In short

CloakBrowser is a Chromium build whose fingerprints are modified at the C++ source level rather than patched at runtime. It sits in the Computer & Browser Use category of the Agents & Automation tools and is open-source, written in Python and licensed MIT. To get started: try it without installing.

## Overview

CloakBrowser is a Chromium build whose fingerprints are modified at the C++ source level rather than patched at runtime. The project's argument is that JS injection and launch-flag tricks are themselves detectable, so it ships 87 source-level patches covering canvas, WebGL, audio, fonts, GPU, screen, WebRTC, network timing, automation signals and CDP input behaviour — and antibot systems score the result as an ordinary browser.

It is designed as a drop-in replacement: the Python and JavaScript packages expose the same API surface as Playwright (and Puppeteer via a separate entry point), so switching an existing automation script means changing the import and nothing else. A `humanize=True` flag adds human-like mouse curves, keyboard timing and scroll patterns for behavioural detection, and `geoip=True` matches timezone and locale to a proxy's IP.

The core is MIT-licensed and the stealth Chromium binary (~200MB) is downloaded and cached on first run; a Pro tier gates a separate binary with stronger scores. The project publishes its results against 30+ detection sites, including Cloudflare Turnstile, FingerprintJS and BrowserScan. Use it on targets you are authorized to automate — the same tool that makes an agent's browsing session work is subject to each site's terms.

## What it does

- 87 source-level C++ patches across canvas, WebGL, audio, fonts, GPU, screen, WebRTC, network timing and automation signals
- Drop-in Playwright and Puppeteer replacement — same API, just change the import
- `humanize=True` for human-like mouse curves, keyboard timing and scroll patterns
- `geoip=True` matches timezone and locale to the proxy IP; proxy and headed/headless are launch options
- Clients for Python (pip), JavaScript/Node (npm) and .NET (NuGet), plus a Docker image
- Binary auto-downloads and caches on first run — no manual Chromium management

## Getting started

There is a zero-install smoke test via Docker; after that, install the client for your language and swap the import in existing automation code.

1. Try it without installing

   The Docker image ships a built-in self test.

```bash
docker run --rm cloakhq/cloakbrowser cloaktest
```

2. Install the client

   The stealth Chromium binary (~200MB) downloads automatically on first run and is cached locally.

```bash
pip install cloakbrowser

# JavaScript, with Playwright
npm install cloakbrowser playwright-core

# or with Puppeteer
npm install cloakbrowser puppeteer-core
```

3. Launch a page in Python

   The API mirrors Playwright's, so existing scripts port over unchanged.

```python
from cloakbrowser import launch

browser = launch()
page = browser.new_page()
page.goto("https://example.com")
browser.close()
```

4. Or in JavaScript

   Use `cloakbrowser/puppeteer` instead of `cloakbrowser` for the Puppeteer surface.

```js
import { launch } from 'cloakbrowser';

const browser = await launch();
const page = await browser.newPage();
await page.goto('https://example.com');
await browser.close();
```

5. Harden the session for protected sites

   The README's recommended combination for anti-bot targets: a residential proxy, geoip matching, headed mode and humanized input.

```python
browser = launch(
    proxy="http://user:pass@residential-proxy:port",
    geoip=True,
    headless=False,
    humanize=True,
)
```

## When to use it

- Give a browser agent a session that does not get blocked before it reaches the page it needs
- Port an existing Playwright or Puppeteer scraper onto a less detectable browser without rewriting it
- Run authorized QA and monitoring against your own properties behind bot-protection layers
- Scale headless collection across many sessions with per-session proxy, locale and fingerprint control