Install, authenticate, and drive it.
Capium Browser is our proprietary stealth Chrome, licensed per session and installed with a single command. Drop in your license key and drive it locally with the Playwright API you already know.
Drive it like Playwright
Navigate, click, type, wait for selectors and network. The stock Playwright API works unchanged.
Real stealth Chrome
A genuine, always-latest Chrome core hardened against bot detection, not a headless stub or patched wrapper.
Screenshots & PDFs
Capture full-page screenshots or render any page to PDF, exactly as you would with a local browser.
Concurrent sessions
Run several browsers at once. Each live browser counts as one session against your plan's cap.
1. Getting started
Install the toolkit for your language. There is nothing to self-host and nothing to patch. The stealth binary is fetched on first run and kept current automatically.
# Python
pip install capiumbrowser
python -m playwright install-deps # Chromium's OS libraries (once)
# JavaScript / TypeScript
npm install capiumbrowserDrop in your license key and drive your first page. Turn on humanize=True for human-like input and timing.
from capiumbrowser import launch_context
# Your license key is on the dashboard: Dashboard -> Capium Browser.
# Export it once: export CAPIUM_LICENSE_KEY="CAPIUM-XXXX-XXXX-XXXX-XXXX"
# launch_context returns (browser, context, page); the always-latest
# stealth binary is downloaded on first run.
browser, ctx, page = launch_context(
seed=200123, # one seed = one coherent device
humanize=True, # human-like input + timing
url="https://example.com",
)
print(page.title())
browser.close()2. Authentication
Your license key lives on the dashboard under Capium Browser. Reveal, copy, or reissue it there. Keep it secret and load it from the environment rather than hard-coding it.
# Keep the key out of source. Export it in your shell or CI:
# export CAPIUM_LICENSE_KEY="CAPIUM-XXXX-XXXX-XXXX-XXXX"
# The SDK reads it from the environment (or ~/.capium/license)
# automatically — nothing to pass in code.
from capiumbrowser import launch_context
browser, ctx, page = launch_context(seed=200123)- Reissue the key from the dashboard if it is ever exposed. The old key stops working immediately.
- One live license per account. Higher tiers raise how many sessions run at once.
- The key authorizes the binary; no separate login or cookie is required.
3. Driving with Playwright (Python)
Everything you know from Playwright works: locators, waits, network interception, and more. Capium just swaps in a hardened, real Chrome core.
from capiumbrowser import launch_context
browser, ctx, page = launch_context(seed=200123, humanize=True)
page.goto("https://example.com/login")
page.fill("#email", "[email protected]")
page.fill("#password", "hunter2")
page.click("button[type=submit]")
page.wait_for_url("**/dashboard")
# The Playwright API you already know: locators, waits, network, etc.
print(page.locator("h1").inner_text())
browser.close()4. Async API
The async API mirrors the sync one: launch_context_async returns the same (browser, context, page) trio with awaitable Playwright methods.
import asyncio
from capiumbrowser import launch_context_async
async def main():
browser, ctx, page = await launch_context_async(
seed=200123, humanize=True, url="https://example.com",
)
print(await page.title())
await browser.close()
asyncio.run(main())5. Humanize mode
Passing humanize=True at launch adds human-like input and timing: natural mouse motion, realistic typing cadence, and small variable pauses, plus page.human_type and page.human_scroll helpers. Leave it on for interactive flows; turn it off for pure fetch-and-parse where speed matters.
browser, ctx, page = launch_context(seed=200123, humanize=True)
page.human_type("#email", "[email protected]") # natural typing cadence
page.human_scroll(1200) # smooth, variable scrolling6. Sessions & concurrency
Each live browser is one session. Your plan's session cap is how many you can run at the same time. Close a browser when you are done to free the session.
import concurrent.futures
from capiumbrowser import launch_context
def fetch(url, seed):
browser, ctx, page = launch_context(seed=seed, url=url)
title = page.title()
browser.close()
return title
# Each live browser counts as one session against your plan's cap.
urls = ["https://a.example", "https://b.example", "https://c.example"]
seeds = range(200001, 200001 + len(urls)) # one coherent device per worker
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as pool:
print(list(pool.map(fetch, urls, seeds)))7. Recipes: screenshots & PDFs
page.goto("https://example.com")
# Full-page screenshot
page.screenshot(path="shot.png", full_page=True)
# Render the page to a PDF
page.pdf(path="page.pdf", format="A4")8. Platforms & CI
Native binaries ship for Linux, Windows, and macOS, with identical behavior on your laptop, a CI runner, and your fleet. In CI, set the license key as a secret environment variable:
# GitHub Actions / GitLab CI
env:
CAPIUM_LICENSE_KEY: ${{ secrets.CAPIUM_LICENSE_KEY }}9. Troubleshooting
Confirm the key matches the dashboard and that your license (or trial) is still active. Reissue the key if needed.
You have as many live browsers as your plan allows. Close finished browsers, or upgrade for a higher session cap.
The binary is fetched on first run; allow outbound HTTPS. In locked-down CI, cache the toolkit between runs.
10. FAQ
Where is my license key?›
On the dashboard under Capium Browser. Reveal it, copy it, or reissue it there. Keep it secret; treat it like a password.
Do I need to download anything manually?›
No. The toolkit fetches the latest hardened binary for your OS on first run and keeps it current automatically.
Which languages and drivers are supported?›
Python is canonical, driven with the stock Playwright API you already use. A JavaScript/TypeScript package installs as capiumbrowser on npm.
What counts as a session?›
One live browser instance. Your plan's session cap is the number you can run concurrently, not a monthly total.
Does the free trial expire?›
Yes. The trial gives you one browser session for 30 days, then it ends. Upgrade any time for more sessions and support.
Ready to start?
Grab your license key and drive your first stealth session in minutes.