Stealth browser for AI agents: fetch pages behind Cloudflare/DataDome/CAPTCHA, extract clean data.
io.github.tiliondev/fortress (MCP Server)
This MCP server provides a stealth browser engine for AI agents to fetch web pages that may be protected by Cloudflare, DataDome, or CAPTCHA. It extracts “clean data” from fetched pages, using automated headless browser tooling and page rendering.
🛠️ Key Features
Stealth browser for AI agents
Fetches pages behind Cloudflare/DataDome/CAPTCHA
Extracts clean data
Based on a Chromium engine
Related tooling/ecosystem referenced: Playwright, Puppeteer, Selenium, headless-chrome, headless-browser, crawler/web-crawling, web-scraping
🚀 Use Cases
Web scraping and data scraping in bot-protected contexts
Fortress is a Chromium fork that stops scrapers and browser agents from getting blocked. Bot detectors flag automation by reading the browser fingerprint. Fortress corrects that fingerprint inside Chromium's C++, so the browser reads as an ordinary Chrome install. Point your existing Playwright or Puppeteer at it over CDP; nothing else in your code changes.
Headless, on datacenter IPs, with no proxies, Fortress loaded 86.4% of 92 protected sites. The next best stack (Camoufox) loaded 74.5%.
A site scans the browser fingerprint. Stock Chrome fails CreepJS, BrowserScan, rebrowser and WebGL checks and is blocked. Fortress passes all four and the page loads.
A site reads the fingerprint. Stock Chrome driven by a script fails CreepJS, BrowserScan, rebrowser and the WebGL check and is blocked; Fortress passes all four.
Akamai, before and after, on aa.com from the same residential IP: a stock browser gets Access Denied, Fortress loads the page and Akamai issues its _abck sensor cookie. Same result on lowes.com, macys.com and kohls.com.
pip install tilion-fortress # or: npm install tilion-fortress
docker run --rm -p 9222:9222 tilion/fortress:latest # any OS, raw CDP on :9222
python
from tilion_fortress import Fortress
from playwright.sync_api import sync_playwright
with Fortress() as f: # launches the engine on a CDP endpointwith sync_playwright() as p:
browser = p.chromium.connect_over_cdp(f.cdp_url)
page = browser.new_page()
page.goto("https://bot.sannysoft.com")
The pip and npm SDKs download a prebuilt, SHA-256-verified binary (Linux x64, Windows x64). Portable tarballs, a .deb and the Windows .zip are on Releases.
Free for developers
v3 is free for developers, with no machine, session or concurrency caps. Activate once:
bash
tilion activate # sign in with GitHub, Google or email; key saved to ~/.tilion/license.jwt
The key is checked offline and Fortress never reports usage. Without activation it still runs, on the public first-generation engine. For CI, Docker and agents, set TILION_LICENSE_KEY=<key> or run tilion activate --token <key>; one key covers a fleet. Production keys for larger organizations are at fortress.tilion.com/pricing.
The tilion CLI
Command
What it does
tilion activate
Unlock v3 with a one-click device flow (browser sign-in)
tilion activate --headless
Same flow, prints the URL and code (SSH or remote hosts)
tilion activate --token <jwt>
Save a key with no browser (CI, agents)
tilion license status [--json]
Show the saved key's tier and expiry (--json for scripts)
tilion license refresh
Re-issue the key before it expires
tilion license logout
Remove the saved key and drop back to v1
tilion get [platform]
Download the build for this host. tilion get list shows all: linux-x64, arm64, armhf, x86, win-x64, mac-arm64, mac-x64
tilion mcp
Run the Fortress MCP server, stealth browsing as agent tools
tilion[--port N]
Launch the engine and print the CDP endpoint
Platforms
Platform
Package
Widevine
Status
Linux x64
portable tarball · Docker · pip / npm
shipping
Windows x64
portable .zip + tillion.cmd launcher
shipping
Linux arm64
portable tarball (Graviton, dense cloud fleets)
no
shipping
Linux x86 · armhf
portable tarball (32-bit x86 / ARM)
no
shipping
macOS (arm64 / x64)
.app, built from source
build from source
The arm64, x86 and armhf builds ship without the bundled Widevine CDM.
Set it up with an AI assistant
Every session a distinct machine
Twelve identical browser windows, tagged same machine times twelve, turn one by one into twelve different machines, each with its own screen and clock.
Each launch mints a fresh, internally coherent machine: GPU, screen, cores, timezone, language and fonts all agree. The persona reaches the renderer over IPC, so nothing shows on the command line and every BrowserContext can hold its own identity. Across 40 back-to-back launches of the same binary:
Across 40 launches
Distinct
Canvas fingerprint
40 / 40
Audio fingerprint
40 / 40
GPU (WebGL renderer)
25
Screen resolution
14
Timezone (geo-coherent with language)
23
Platform mix
31 Windows · 9 macOS
Reproduce with tools/gauntlet.py --runs 40. A 64-clone fleet resumed from one snapshot comes up 48/48 distinct, because on_restore re-keys the whole persona with no relaunch.
The Fortress MCP
A Model Context Protocol server that gives Claude, Codex, Cursor, Windsurf, Cline or any MCP client a stealth browser as 29 tools, local and free. When a plain fetch is blocked, the agent calls a tool and gets the page.
bash
pip install "tilion[mcp]"# or zero-install: npx -y tilion-mcp
claude mcp add fortress -- tilion-mcp # Claude Code
For Claude Desktop, Cursor (~/.cursor/mcp.json), Cline and Windsurf, add the same block to the client's MCP config:
get_stealth_cdp_endpoint: a CDP url for Playwright / Puppeteer / browser-use
The full tool reference, benchmarks and agent skill are in mcp/.
Works with your stack
A Playwright script where one line changes from p.chromium.launch() to p.chromium.connect_over_cdp on localhost:9222. The rest of the script stays the same.
With Fortress running (Docker or the tilion command), one line changes: launch() becomes connect_over_cdp("http://localhost:9222").
In Fortress the getter for navigator.vendoris the C++ getter. It reports [native code] because it is native code, the same in every frame and worker. Fortress applies the Camoufox idea to V8 and Blink, so the fingerprint matches a Chrome user agent by construction.
Runtime.enable leaks via sourceURL + init-script footprints, however clean the binary is
The control / CDP-client layer: hold back Runtime.enable, use Runtime.addBinding + isolated worlds
no leak (verified on rebrowser)
C: fingerprint surface
canvas, WebGL, WebGPU, audio, fonts, navigator, across main frame, iframes, workers
The engine (C++), because JS overrides self-reveal
this is Fortress
D: network / IP egress
datacenter ASN, IP reputation, geo-vs-persona mismatch
Your proxies (residential / mobile), or the Tilion hosted version
bring your own with the self-hosted engine; available on the Tilion hosted version, waitlist at tilion.com
Fortress is the Layer C engine, built to be driven so A and B hold too, and to stay geo-coherent (timezone, locale, WebRTC) once you bring a Layer D IP.
Fortress builds on prior art: fingerprint-chromium, ChromiumFish and CloakBrowser came first, and Camoufox, Multilogin, GoLogin and Dolphin also patch engine C++. Fortress's edge is the combination: the broadest native surface set on a Chromium base, fleet dynamism with on_restore, and parameter-level coherence. Where it is behind: IP egress (bring your own) and behavioral humanization beyond mouse motion.
Run on 2026-09-28 from US-East cloud machines, headless, on datacenter IPs with no proxies. Every tool loaded every target twice, each time on a fresh machine destroyed afterwards (1,584 machines). A run counts only if the real page loaded with no challenge or deny page. Method and target list: docs/BENCHMARK.md.
Stack
Served
n
95% range
Fortress
86.4%
159/184
81 to 91
Camoufox
74.5%
137/184
68 to 80
puppeteer-extra + stealth
72.3%
133/184
65 to 78
Brave
36.4%
67/184
30 to 44
nodriver
35.9%
66/184
29 to 43
stock Chrome
34.2%
63/184
28 to 41
patchright
34.2%
63/184
28 to 41
undetected-chromedriver
33.7%
62/184
27 to 41
95% Wilson intervals; Fortress's does not overlap the next stack's. Fortress got 2/2 on ten sites where neither Camoufox nor puppeteer-stealth got more than 1/2, and there is no site where it got 0/2 while either of them got 2/2. A repeat run the same day scored 85.3%.
Live detectors
Headless, from a datacenter IP, on the v3 binary. Reproduce with tools/gauntlet.py --bundle ./fortress-v153; dated re-runs are in docs/GAUNTLET_RESULTS.md.
Suite
Stock Chromium
Fortress v3
CreepJS
flagged headless
0% headless · 0% stealth, worker signals coherent
bot.sannysoft.com
red rows
0 failed · every intoli + PHANTOM_/HEADCHR_ check green · navigator.webdriver undefined
browserscan.net
bot detected
“Normal: No bots detected, could be a human” · WebDriver / Selenium / PhantomJS / Headless / CDP / DevTool all Normal
BrowserLeaks · WebGL
SwiftShader leak
Unmasked ANGLE (Intel HD Graphics, Direct3D11) with fully coherent D3D11 parameters
WebGPU(secure context)
software-backend tell
navigator.gpu coherent with the persona GPU: adapter identity, limits, subgroup sizes (verified)
AmIUnique · pixelscan · iphey
automation flags
consistent, no automation flags
rebrowser bot-detector
Runtime.enable LEAK
no leak · webdriver=false · clean init-scripts (raw CDP)
Output: out/Fortress/chrome. The fork is 81 single-surface patches, and the gauntlet gates every release. The first-generation patch series is public and rebuilds with the same script.
Still blocked on Cloudflare, DataDome or Kasada. Usually the IP: datacenter ranges are flagged before any page script runs. Retry through a residential or mobile proxy; if it clears, the fingerprint was fine. Tilion Cloud runs Fortress on residential egress (waitlist at tilion.com).
The fingerprint looks off on a Linux host. The default persona is Windows, but TLS and some OS signals follow the host. Match the persona to your egress OS with --uxr-*, or run the native Windows build.
macOS. Run the Docker image or build the .app from source.
A detector flags something the gauntlet passes. Confirm you are on the current rebase, then email team@tilion.dev with the test page.
FAQ
Does Fortress work with Selenium? Drive it over CDP. chromedriver adds the driver artifacts Fortress is built to avoid.
How is it different from puppeteer-stealth, undetected-chromedriver, nodriver and patchright? Those patch the JavaScript or CDP layer, which toString and realm re-acquisition reveal, and headless they send HeadlessChrome in the user agent. In the benchmark they loaded 34 to 36% (puppeteer-stealth 72.3%) against Fortress's 86.4%.
How is it different from Camoufox? Same engine-level idea. Camoufox forks Firefox; Fortress forks Chromium/V8, the majority engine, and adds WebGPU coherence and on_restore fleet re-identity. Benchmark: 86.4% vs 74.5%.
Is it an alternative to Multilogin, GoLogin, Kameleo, AdsPower or Dolphin? Those are closed-source builds sold as persistent profiles with bundled proxies. Fortress is an engine you run yourself, with a fresh identity per launch, published first-generation patches and no telemetry.
Does it run headless? Yes. The benchmark is headless, and headless and headed launches present the same fingerprint.
Do I still need proxies? For sites that block datacenter ranges, yes. Fortress keeps timezone, locale and WebRTC coherent with whatever exit you use.
Is this legal? Fortress is for legitimate automation, testing and scraping of public data. Respect each site's terms and your local law.
Will it pass everything forever? No. Detection moves, so Fortress rebases on Chromium monthly and publishes a dated, reproducible gauntlet.
Roadmap
First-party residential and mobile egress, wired to the existing geo-coherence
Keystroke and scroll variance (mouse motion has shipped)
TLS ClientHello (JA3/JA4) in the persona surface set
Linux arm64 / x86 / armhf tarballs (rolling out) and a macOS .app
Code-signed Windows .exe and macOS .app
Shipped in v3: the IPC persona with per-context isolation, on_restore, parameter-level WebGL and WebGPU, recorded-human mouse motion, the Widevine CDM, the native Windows build, the MCP server and the 92-site benchmark.
Repo layout
code
patches/ the first-generation C++ patch series (Fortress Source Available License 1.1)
build/ args.gn, build.sh, apply-patches.sh, rebase-monthly.sh, windows/, macos/
packaging/ tilion launcher, fonts.conf, Dockerfile, .deb + bundle builders
fonts/ 222 metric-compatible OS-named font files (154 distinct families, incl. color emoji)
sdk/ python + node (tilion-fortress) prebuilt-binary SDKs
mcp/ the Fortress MCP server (29 tools) and the agent skill
tools/ gauntlet.py, the CreepJS / Sannysoft / BrowserScan CI gate
docs/ UXR_CONFIG (the --uxr-* reference), GAUNTLET_RESULTS, BENCHMARK
Contributing
Fortress does not accept outside pull requests; see CONTRIBUTING.md. Found a detection vector or a leak? Email team@tilion.dev with a reproducible test page.
License
Fortress Source Available License 1.1. Free to read, modify, rebuild and redistribute, and to use for development, testing and evaluation at any size. Production use is free for individuals and for organizations under US$500,000 in cumulative funding and US$300,000 or less in ARR; other organizations need one flat subscription (fortress.tilion.com/pricing, LICENSE, SUBSCRIPTION-TERMS.md). Earlier BSD-licensed releases keep their BSD permissions (LICENSE-BSD-LEGACY). Chromium and the bundled fonts keep their own licenses (NOTICE).
Install
Configuration
Environment variables
TILION_MCP_PREWARM
Boot the browser at startup so the first tool call is instant (default 1).
TILION_MCP_HEADLESS
Set 0 to show a visible browser window (default 1).
TILION_ALLOW_PRIVATE_EGRESS
Set 1 to allow tools to reach localhost / private IPs (SSRF guard off).
TILION_BASE_URL
Run browsers on a hosted Tilion server instead of locally.
TILION_API_KEYsecret
Bearer key for the hosted Tilion server (cloud mode only).