🛰️ KC Browser

The anti-detect browser that looks 100% real — because the disguise lives inside the engine, not bolted on top.

English · 简体中文

---

KC Browser is a precompiled, Chromium-based anti-detect / fingerprint browser for web scraping, ad verification, multi-accounting, and any automation that has to survive bot detection.

Give it one seed and it produces a complete, self-consistent browser identity — UA, Client Hints, WebGL, Canvas, Audio, fonts, hardware, locale, timezone — all masked inside the browser engine, before a single line of JavaScript runs. No injected script to unwrap, no navigator.webdriver, no CDP banner. To a detector, it's just a real person on a real browser.

🎯 See it pass — and verify it yourself

Every check below is public. Take any anti-detect browser, run it through demo.fingerprint.com, and compare:

Check on demo.fingerprint.com	Typical anti-detect browser	KC Browser
Browser	⚠️ Chromium-Based Browser	✅ Google Chrome / Microsoft Edge
Incognito Mode	⚠️ Detected	✅ Not detected
Bot (in a VM / headless)	🔴 Detected as bot	✅ Not detected
Browser Tampering	🔴 Flagged	✅ Clean
Virtual Machine	🔴 Flagged	✅ Not flagged

Real screenshots — one seed, no manual tuning:

BrowserScan — clean, even in incognito	CreepJS — consistent, no lies
Fingerprint.com — bot not detected	reCAPTCHA v3 — score 0.9

Results come from one seed on one network path at one moment. Different seeds, exit IPs, or detector updates will vary — see Status.

✨ Highlights

• 🧬 Engine-level, not a script — everything is masked inside Chromium itself. There's no wrapper to toString(), no hook to trip over, nothing a page can inspect.
• 🎲 One seed → one identity — a single 64-bit seed deterministically builds an entire profile, and every dimension agrees with the rest: screen ↔ GPU ↔ core count ↔ platform ↔ version.
• 👥 Sampled from real users — ~130 real consumer GPUs, real screen resolutions, real brand/version combos — weighted by market share, so you always land inside a real population, never an impossible combo.
• 🌍 Locale that matches your IP — timezone drives language/languages across 95+ regions, so region never contradicts your exit node.
• 🎚️ Tunable entropy — Canvas / WebGL / Audio / Font noise dials from off to high, independently per surface.
• 🪟🍎🐧 Any OS on any host — present as Windows, macOS, or Linux regardless of what you actually run on.
• 🕵️ Truly private — incognito reads as ordinary browsing; detectors can't tell them apart.
• 🔀 Rotate without restarting — every browser context automatically derives its own independent identity from the base seed.

👤 Who it's for

• 🕸️ Scrapers & crawlers hitting sites behind Cloudflare, Akamai, DataDome, PerimeterX.
• 🎭 Multi-accounting — each profile is a distinct, believable person that stays consistent across runs.
• 📊 Ad verification & QA — see the web exactly as a real user in another region would.
• 🔬 Fingerprinting researchers who want a reproducible, engine-level baseline.

⬇️ Download

Prebuilt binaries — download, unzip, run. No build step.

Version	Windows	Linux x64
150.0.7871.47	installer · portable zip	tar.xz

Portable Windows build: unzip and run chrome.exe. Newer builds land on the releases page.

🚀 Quick start

Give it a seed, get a coherent identity. Add a timezone and locale follows the exit IP automatically:

chrome.exe --fp-seed=2 --fp-timezone=Asia/Singapore --no-sandbox

chrome.exe --fp-seed=2                                     # seed only, identity auto-derived
chrome.exe --fp-seed=2 --fp-platform=macos                 # present as macOS
chrome.exe --fp-seed=2 --fp-platform=windows --fp-brand=edge

Flag	What it controls
--fp-seed	Base seed. Same seed → same identity, every time.
--fp-platform	Presented OS: windows / macos / linux.
--fp-timezone	IANA timezone; drives locale/language to match.

Dozens more flags cover Client Hints, per-surface noise, hardware, and per-context identity — run --help for the full list.

🔌 Drop it into your automation stack

KC Browser is Chromium, so it plugs into the tools you already use. You don't download a browser through Playwright or Puppeteer — install just the client library and point it at KC Browser via executablePath. Nothing else in your code changes.

Python + Playwright

pip install playwright   # client library only — skip `playwright install`

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        executable_path="/path/to/kc-browser",  # Linux
        headless=False,
        args=["--fp-seed=2", "--fp-timezone=Asia/Singapore", "--no-sandbox"],
    )
    page = browser.new_page()
    page.goto("https://demo.fingerprint.com/playground")
    browser.close()

Node + Puppeteer

npm install puppeteer-core   # `-core` = no bundled Chromium download

const puppeteer = require("puppeteer-core");

const browser = await puppeteer.launch({
  executablePath: "C:\\path\\to\\kc-browser\\chrome.exe",  // Windows
  headless: false,
  args: ["--fp-seed=2", "--fp-timezone=Asia/Singapore", "--no-sandbox"],
});
const page = await browser.newPage();
await page.goto("https://demo.fingerprint.com/playground");
await browser.close();

Every browser.new_context() (or Puppeteer createBrowserContext()) is a separate off-the-record profile that automatically gets its own independent identity — rotate identities without ever restarting the browser.

🧠 How one seed becomes an identity

seed  ->  platform family  ->  seeded pools per dimension  ->  explicit overrides
                                                    ^
                              locale / language derived from --fp-timezone

• --fp-seed alone picks a fully self-consistent default profile — screen, GPU, core count, brand, and version all agree.
• --fp-timezone drives language/languages so locale always matches the timezone (and your exit IP).
• --fp-platform switches the presented OS while keeping every other dimension consistent with it.
• Any other --fp-* flag overrides just that dimension; everything else stays derived and self-consistent.

⚔️ Why engine-level wins

	Script / CDP stealth	KC Browser
What a detector sees	A patched browser — the patch is the tell	A browser that's real all the way down
Leftover traces	Wrappers, banners, timing quirks	None to leave behind
Cross-surface consistency	Patch one, forget another	Every surface derives from one seed
Your code changes	Preload scripts, CDP calls, per-page hooks	Just point executablePath at the binary

❓ FAQ

Is it truly undetectable? No tool is, and anyone claiming otherwise is selling something. KC Browser closes the vectors that catch most stealth setups (see the table above) and keeps every dimension internally consistent — but a determined, first-party detector on a hostile network can still find edges. Treat results as strong, not absolute.

How is this different from puppeteer-stealth / playwright-stealth? Those patch the browser from JavaScript after launch, which leaves detectable seams. KC Browser masks everything inside the engine before any page script runs — there's nothing at the JS layer to catch.

Does it need a GPU? No. It runs headless or headed, on servers without a GPU.

📈 Star history

If KC Browser saves you a fight with a bot wall, a ⭐ helps others find it.

🚧 Status

Under active development, built for browser-fingerprinting research and controlled compatibility testing. It doesn't guarantee passing every detector on every network. Found a vector it misses? Open an issue.