Stealth browser · always latest

The stealth browser you drive with the API you already know.

Capium is a hardened, always-latest Chromium you control with the Playwright interface. Human-like input, one license key, runs locally on Linux, Windows and macOS.

No card required · Free tier runs a live session

Why Capium

Built to look human, everywhere

A single, coherent stealth build, not a pile of patches. It stays current so you don't have to chase releases.

Hardened stealth engine

A real Chromium build with a coherent, native fingerprint. No patched flags that give the game away.

Always the latest binary

One license key, forever current. We ship the newest hardened build the moment it's ready.

Runs everywhere

Linux, Windows and macOS. Local execution means your traffic, your IPs, your control.

The API you know

Drive it with the Playwright interface you already use, through the Python SDK. No forked driver.

Who it's for

Built for teams that automate the web

Wherever you need a real, coherent browser instead of an obvious bot, Capium fits into the tools you already use.

QA & test automation

Run end-to-end tests against your own apps in a real, coherent browser instead of an obvious automation signature.

Web scraping at scale

Collect publicly available data you're permitted to access, with a device that stays consistent across sessions.

Ad & brand verification

Check how your ads and listings render for real users in different regions, with geo you control.

Price & market monitoring

Track prices, availability and competitors over time from a stable, repeatable browsing identity.

For authorized automation and testing only. See our Acceptable Use Policy.

How it works

Three lines from install to running

If you've used Playwright, you already know Capium. Install, add your key, drive.

01

Install

pip install capium. No system Chrome required, the stealth binary downloads on first launch.

02

Add your key

Paste your license key. It unlocks the always-latest stealth binary and runs entirely on your machine.

03

Drive it

Use the Playwright API you already know. Turn on humanize for human-like input and timing.

install.sh
# Install the SDK + the Playwright driver
pip install capium
python -m playwright install-deps
drive.py
from capium import launch_context

# Your license key (from CAPIUM_LICENSE_KEY or ~/.capium/license) unlocks
# the always-latest stealth binary. It runs locally on Linux, Windows or macOS.
# launch_context returns (browser, context, page).
browser, ctx, page = launch_context(
    seed=200123,            # a coherent, repeatable device
    humanize=True,          # human-like input + timing
    url="https://example.com",
)
print(page.title())
browser.close()
What Capium rewrites

Every fingerprint surface, one coherent story

These are rewritten in the browser's own source, not shimmed in JavaScript a detector can catch re-defining. One seed keeps them all consistent.

User-Agent & UA-CH

Full User-Agent string plus the modern Client Hints: platform, platform version, brand list and versions, all coherent.

WebGL & GPU

GPU vendor and renderer strings reported by WebGL, matched to the persona instead of the host card.

Canvas

Deterministic per-seed noise on toDataURL, getImageData and measureText so canvas hashes are stable per device and unique across devices.

Audio

Per-seed noise on the AudioContext stack so the audio fingerprint tracks the seed, not the host.

Screen & display

screen.width / height, devicePixelRatio and the storage-quota estimate, all seed-driven.

Hardware

navigator.hardwareConcurrency (CPU cores) reported as the persona, not the real machine.

Fonts

Windows font metrics for a Windows persona so default-text measurement matches real Windows.

Voices

Windows SAPI voice list (speechSynthesis) presented for a Windows persona.

Timezone & geolocation

In-browser IANA timezone and the Geolocation API coordinates, aligned to your proxy exit.

WebRTC

The IP WebRTC reports is pinned to your proxy exit, so it never leaks your real address.

navigator.webdriver

Reported false at the source, not shimmed in JS that detectors can catch re-defining.

DevTools / Runtime.enable

The CDP Runtime.enable console-reporting tell is suppressed in-source, so automation reads as a benign DevTools-open session.

Pointer & hover

Presents a desktop mouse (fine pointer + hover), not a touch device, matching a real desktop.

Client rects

Optional per-seed noise on getClientRects / getBoundingClientRect for layout-based fingerprints.

Why not just Playwright

Rewritten at the source, not shimmed in JavaScript

Patched drivers and injected stealth scripts leave tells a detector can catch. Capium changes the surfaces inside Chromium, so there is nothing to catch.

Approach
Vanilla / patched driver
Capium
Where the fingerprint changes
Shimmed in JavaScript at runtime
Rewritten in the browser's own source
Detection surface
Re-defined properties are catchable
Nothing is re-defined to catch
Coherence across surfaces
Hand-wired, easy to contradict
One seed derives the whole device
Staying current
You chase every Chrome release
Always the latest hardened binary
The driver
A patched Playwright fork to maintain
Stock Playwright, no fork
Geo / WebRTC alignment
Manual, per-surface
geoip pins IP, timezone and location
1 key
Unlocks every platform
Always
Latest hardened binary
3 OSes
Linux · Windows · macOS
Local
Your machine, your IPs
Pricing

Session-based, not per-gigabyte

Pick a concurrency tier. Every plan ships the same always-latest binary. Billing is handled securely on capzy.ai.

Trial

Free

$0forever
1 concurrent session
  • Always the latest stealth binary
  • Undetected across major bot-defense stacks
  • Runs on Linux, Windows and macOS
  • Python SDK (Playwright API)
  • Playwright-compatible API
  • Human-like input & timing
  • Community support
Start free

Solo

$19/mo$29
Launch price
5 concurrent sessions
  • Always the latest stealth binary
  • Undetected across major bot-defense stacks
  • Runs on Linux, Windows and macOS
  • Python SDK (Playwright API)
  • Playwright-compatible API
  • Human-like input & timing
  • Hands-on support
Subscribe
Most Popular

Team

$49/mo$79
Launch price
20 concurrent sessions
  • Always the latest stealth binary
  • Undetected across major bot-defense stacks
  • Runs on Linux, Windows and macOS
  • Python SDK (Playwright API)
  • Playwright-compatible API
  • Human-like input & timing
  • Hands-on support
Subscribe

Business

$199/mo$249
Launch price
200 concurrent sessions
  • Always the latest stealth binary
  • Undetected across major bot-defense stacks
  • Runs on Linux, Windows and macOS
  • Python SDK (Playwright API)
  • Playwright-compatible API
  • Human-like input & timing
  • Priority support
Subscribe

Scale

$499/mo$699
Launch price
2,000 concurrent sessions
  • Always the latest stealth binary
  • Undetected across major bot-defense stacks
  • Runs on Linux, Windows and macOS
  • Python SDK (Playwright API)
  • Playwright-compatible API
  • Human-like input & timing
  • Priority support
Subscribe

For authorized automation and testing only.

FAQ

Questions, answered

The things people ask before they start. Anything else, reach us on the contact page.

Is Capium legal to use?

Capium is a professional tool for authorized automation and testing. It is your responsibility to use it lawfully and only against systems and data you own or are permitted to access. See our Acceptable Use Policy.

How is it billed?

By concurrent session, not per gigabyte. You pick a plan whose concurrency fits your workload; every plan ships the same always-latest binary. Billing is handled securely on capzy.ai and you can cancel anytime.

Do I have to manage proxies?

No. Capium runs locally and uses whatever network egress you configure. Point a session at any proxy you control, and turn on geoip to align timezone, geolocation and the WebRTC IP to that exit automatically.

Do I need a patched Playwright or a special driver?

No. Capium is driven by stock Playwright, so there is no forked driver to maintain. The stealth lives in the binary, which is rewritten at the source rather than shimmed in JavaScript.

Which platforms does it run on?

Linux, Windows and macOS, including headless Linux servers. One license key unlocks the always-latest hardened build on every platform.

Will it get past a specific protection?

Results depend on the target, your egress reputation, and how you drive the session. Capium gives you a coherent, always-current device and human-like input; it does not promise to defeat any specific system. Try the free tier on your own workload.

Run your first stealth session in minutes

Create a free account on Capzy, grab your license key, and drive Capium with the API you already know.