Two stealth browser engines. One container.

Chroma and Junglefox stealth browsers on any Docker environment. No GPU. No display server. Your existing Playwright, Puppeteer, or Selenium code connects without changes.

Installation
# 1. Run Kameleo
$ docker run -p 5050:5050 --shm-size=2g -e EMAIL="<EMAIL>" -e PASSWORD="<PASSWORD>" -v kameleo-data:/data kameleo/kameleo-app:latest
# 2. Install Kameleo SDK
$ npm i @kameleo/local-api-client playwright
Example Code
import { KameleoLocalApiClient } from "@kameleo/local-api-client";
import playwright from "playwright";

// Create a Kameleo profile
const client = new KameleoLocalApiClient({ basePath: "http://localhost:5050" });
const fps = await client.fingerprint.searchFingerprints("desktop", "linux", "chrome");
const profile = await client.profile.createProfile({ fingerprintId: fps[0].id, name: "playwright demo" });

// Connect Playwright (auto-starts the profile)
const wsEndpoint = `ws://localhost:5050/playwright/${profile.id}`;
const browser = await playwright.chromium.connectOverCDP(wsEndpoint, { timeout: 90_000 });

// Use Playwright as usual
const context = browser.contexts()[0];
const page = await context.newPage();
await page.goto("https://wikipedia.org");
Installation
# 1. Run Kameleo
$ docker run -p 5050:5050 --shm-size=2g -e EMAIL="<EMAIL>" -e PASSWORD="<PASSWORD>" -v kameleo-data:/data kameleo/kameleo-app:latest
# 2. Install Kameleo SDK
$ pip install kameleo-local-api-client playwright
Example Code
from kameleo.local_api_client import KameleoLocalApiClient
from kameleo.local_api_client.models import CreateProfileRequest
from playwright.sync_api import sync_playwright

# Create a Kameleo profile
client = KameleoLocalApiClient(endpoint='http://localhost:5050')
fps = client.fingerprint.search_fingerprints(device_type='desktop', platform='linux', browser_product='chrome')
profile = client.profile.create_profile(CreateProfileRequest(
    fingerprint_id=fps[0].id,
    name='playwright demo'
))

# Connect Playwright (auto-starts the profile)
ws_endpoint = f'ws://localhost:5050/playwright/{profile.id}'
with sync_playwright() as playwright:
    browser = playwright.chromium.connect_over_cdp(endpoint_url=ws_endpoint, timeout=90_000)

    # Use Playwright as usual
    context = browser.contexts[0]
    page = context.new_page()
    page.goto('https://wikipedia.org')
Installation
# 1. Run Kameleo
$ docker run -p 5050:5050 --shm-size=2g -e EMAIL="<EMAIL>" -e PASSWORD="<PASSWORD>" -v kameleo-data:/data kameleo/kameleo-app:latest
# 2. Install Kameleo SDK
$ dotnet add package Kameleo.LocalApiClient
# 3. Install Playwright
$ dotnet add package Microsoft.Playwright
Example Code
using Kameleo.LocalApiClient;
using Kameleo.LocalApiClient.Model;
using Microsoft.Playwright;

// Create a Kameleo profile
var client = new KameleoLocalApiClient(new Uri("http://localhost:5050"));
var fps = await client.Fingerprint.SearchFingerprintsAsync("desktop", "linux", "chrome");
var profile = await client.Profile.CreateProfileAsync(new CreateProfileRequest(fps[0].Id) { Name = "playwright demo" });

// Connect Playwright (auto-starts the profile)
var wsEndpoint = $"ws://localhost:5050/playwright/{profile.Id}";
var playwright = await Playwright.CreateAsync();
var browser = await playwright.Chromium.ConnectOverCDPAsync(wsEndpoint, new BrowserTypeConnectOverCDPOptions { Timeout = 90_000 });

// Use Playwright as usual
var context = browser.Contexts[0];
var page = await context.NewPageAsync();
await page.GotoAsync("https://wikipedia.org");

Get running in 3 steps

Create your account, spin up a container, and connect your automation script. That's all it takes to start running browser instances at scale.

Create a Kameleo account

Start the container

Automate with Playwright

Read the Docs

Your automation stack deserves a real anti-detect browser. In a container.

Most anti-detect tools ship as desktop apps for manual use. Running them in production means X11-over-SSH tunnels, Windows VMs bolted onto Linux infrastructure, or DIY stealth wrappers that break every time Chrome updates.

Kameleo Docker runs on Linux and Windows servers. It brings the full fingerprint masking stack — real device profiles, C++ engine-level patches, automatic geo-location matching — into a container you can drop into any server, CI pipeline, or Kubernetes cluster.

Unlimited, real browser fingerprints

Profiles sourced from millions of real devices, not static templates. Every session gets a unique, convincing fingerprint that reflects how real hardware actually looks to anti-bot systems.

Fast release cycles for browser updates

Chroma kernels ship within 5 days of every Chrome stable release. Junglefox follows every 2 months. Your scrapers keep running when browsers update — no manual patching required.

Continuously auto-tested stealth mode

Every release is validated against real anti-bot systems and fingerprint detectors before it ships. You get a browser that's confirmed undetected, not one you have to test yourself.

Linux and Windows containers

One image, two platforms. Docker pulls the right variant automatically: Linux (Ubuntu 22.04) or Windows (Server Core 2022). Same Local API, same fingerprint database, same two browser engines on both.

Drop into your existing stack

Works with Playwright, Puppeteer, and Selenium out of the box. Point your existing automation at the container's WebSocket endpoint. No framework rewrite, no new SDK to learn.

Your data stays on your servers

All scraping runs on your own infrastructure. No traffic routed through vendor APIs, no per-request pricing. Cost is fixed by concurrent browsers, predictable at any scale.

Questions

Everything you need to know about running Kameleo in Docker

Does pricing change for Docker?

No. Docker is included in every plan. Same concurrent browser limits, same RPM limits, no additional cost.

Can I run multiple containers?

Yes. Give each container its own named volume to avoid conflicts when working with profiles simultaneously. Sharing a single volume across containers can cause issues. Mount the data directory on every container so kernels persist across recreations.

How does the Linux container differ from the Windows one?

Same Local API, same fingerprint database, same two browser engines. The difference is the host OS: Linux (Ubuntu 22.04, amd64) vs Windows (Server Core 2022). Automation code works identically on both.

How do I scale?

Use Kubernetes or Docker Swarm to orchestrate thousands of instances. Kameleo integrates with standard container orchestration platforms without special configuration.

Need more help?

Check our documentation or reach out