Deploy and manage headful browsers in docker.

https://docs.blitzbrowser.com

Managing browsers can be a recipe for memory leaks, zombie processes and devops issues. BlitzBrowser handles all the hard work of deploying and scaling the browsers, so you can focus on your code.

Connect to headful browsers from Puppeteer, Playwright and any CDP frameworks. Persist your user data with S3 and connect to HTTP proxies.

• Features
• Quick Start
• Configuration
• Changlog
• F.A.Q.
• Support

• Live View - Watch and interact directly with any browser currently running.
• Persistent Sessions - Persist your browser user data.
• Proxy Support - Connect your browsers to any HTTP proxies.
• Security - Control who can access the browsers.
• Chrome DevTools Protocol - No proprietary SDK. Connect directly from Puppeteer, Playwright or any CDP supported framework.
• Google Chrome Versions - Run any google chrome version from 116 to the latest one.
• Parallelism - Spin up and run multiple browsers concurrently.
• Headful - Run the browsers with a GUI to render exactly as a user would see.
• Queueing - CDP connections are automatically queued while the browsers are starting.
• No DevOps - Run your browsers without worrying about the infrastructure, zombie processes or a custom script. The container manages everything for you.

Start in seconds with docker and then connect your code.

docker run -p=9999:9999 --shm-size=2g ghcr.io/blitzbrowser/blitzbrowser:latest

services:
  blitzbrowser:
    image: ghcr.io/blitzbrowser/blitzbrowser:latest
    ports:
      - "9999:9999"
    shm_size: "2gb"
    restart: always

services:
  blitzbrowser:
    image: ghcr.io/blitzbrowser/blitzbrowser:latest
    ports:
      - "9999:9999"
    environment:
      S3_ENDPOINT: http://s3:9000
      S3_ACCESS_KEY_ID: rustfsadmin
      S3_SECRET_ACCESS_KEY: rustfsadmin
      S3_USER_DATA_BUCKET: user-data
    shm_size: "2gb"
    restart: always
  s3:
    image: rustfs/rustfs
    ports:
      - "9000:9000"
      - "9001:9001"
    environment:
      RUSTFS_VOLUMES: /data
      RUSTFS_ADDRESS: :9000
      RUSTFS_ACCESS_KEY: rustfsadmin
      RUSTFS_SECRET_KEY: rustfsadmin
      RUSTFS_CONSOLE_ENABLE: true
    restart: always
    volumes:
      - s3_data:/data
  # RustFS volume permissions fixer service
  volume-permission-helper:
    image: alpine
    volumes:
      - s3_data:/data
    command: >
      sh -c "
        chown -R 10001:10001 /data &&
        echo 'Volume Permissions fixed' &&
        exit 0
      "
    restart: "no"
volumes:
  s3_data:

import puppeteer from 'puppeteer';

const browser = await puppeteer.connect({
    browserWSEndpoint: `ws://localhost:9999`
});

const context = await browser.createBrowserContext();
const page = await context.newPage();

// ...

await browser.close();

import { chromium } from 'playwright';

const browser = await chromium.connectOverCDP(`ws://localhost:9999`);

const context = await browser.newContext();
const page = await context.newPage();

// ...

await browser.close();

The developer documentation is available at https://docs.blitzbrowser.com.

• Getting Started
• Persist the user data with S3
• Run any Google Chrome version
• Configure your browser

March 3, 2026

• Dashboard doesn't require HTTPS to authenticate if environment variable HTTPS_DISABLED=true is configured.

February 28, 2026

• Support running any Google Chrome version since 116.

February 15, 2026

• Browser user data can now be stored on local disk or with an S3 provider. All details here.

February 14, 2026

• BlitzBrowser and the dashboard now support authentication.

February 1, 2026

• Added Live View and the dashboard.

January 15, 2026

• Released the open source version of BlitzBrowser.com(Cloud version, now closed).

Puppeteer and Playwright are libraries that give you control of a browser. With them you can:

• Take a screenshot of a web page.
• Automate tasks on websites like clicking, scrolling and typing.
• Extract data from a website.

They do not handle the infrastructure or cleanup. If you run them directly in your application code, you are responsible for:

• Killing zombie processes that don't always close properly.
• Managing multiple browsers concurrently.
• Handling dependencies to run Google Chrome.
• Persisting browser user data.
• Authenticate and route traffic to HTTP proxies.
• Secure the access to the browser.

BlitzBrowser is a browser-as-a-service software. Your code stays focused on your project needs and the heavy lifting of managing the browsers happens inside the BlitzBrowser container.

Yes. BlitzBrowser isn't a library like Puppeteer and Playwright. BlitzBrowser is deployed as a docker container to run your browsers. To control a browser, you still need Puppeteer and Playwright. You will only need 1 line of code changed to use BlitzBrowser instead of running the browsers yourself.

import puppeteer from 'puppeteer';

// Change the launch() method to connect({ ... })

// const browser = await puppeteer.launch();

const browser = await puppeteer.connect({ browserWSEndpoint: `ws://localhost:9999` });

const context = await browser.createBrowserContext();
const page = await context.newPage();

// ...

await browser.close();

import { chromium } from 'playwright';

// Change the launch() method to connect({ ... })

// const browser = await chromium.launch();

const browser = await chromium.connectOverCDP(`ws://localhost:9999`);

const context = await browser.newContext();
const page = await context.newPage();

// ...

await browser.close();

No. BlitzBrowser is language and framework agnostic. It works with any framework using the Chrome DevTools Protocol (CDP). If your browser automation tool/framework can connect to a browser through CDP, you can use BlitzBrowser.

import asyncio
import os

from playwright.async_api import async_playwright

async def main():
    playwright = await async_playwright().start()

    browser = await playwright.chromium.connect_over_cdp("ws://localhost:9999")
    context = await browser.new_context()
    page = await context.new_page()

    # ...

    await browser.close()
    await playwright.stop()

if __name__ == "__main__":
    asyncio.run(main())

package com.example.demo;

import com.microsoft.playwright.Browser;
import com.microsoft.playwright.BrowserContext;
import com.microsoft.playwright.Page;
import com.microsoft.playwright.Playwright;

public class PlaywrightJavaExample {

    public static void main(String[] args) {
        try (Playwright playwright = Playwright.create();
             Browser browser = playwright.chromium().connectOverCDP("ws://localhost:9999")
        ) {
            BrowserContext context = browser.newContext();
            Page page = context.newPage();

            // ...
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

Yes. BlitzBrowser runs the browsers in headful mode within a virtual display. The browsers appear more like a real user to websites compared to headless mode, which carries signals that anti bot services, like Cloudflare or Akamai, can detect.

It doesn't mean BlitzBrowser will bypass all the anti bot mechanisms. You still need to implement different strategies like residential IPs, captcha solving and human-like behaviour.

To get support, you can contact us on Discord or at [email protected].