Enterprise Docker Image

The Enterprise Docker Image provides enhanced features and capabilities for production deployments. This image is available through our private registry and requires a valid license key to operate.

Prerequisites

Before getting started, you'll need:

1. Registry Access: Credentials for our private Docker registry
2. License Key: A valid enterprise license key provided by Browserless
3. Docker or Docker Compose: Installed on your target system

Registry Access Setup

1. Docker Registry Login

First, authenticate with our private registry using the credentials provided by our team:

docker login registry.browserless.io

When prompted, enter your provided username and password.

2. Pull the Enterprise Image

Once authenticated, pull the latest enterprise image:

docker pull registry.browserless.io/browserless/browserless/enterprise:latest

The image supports multiple platforms (ARM64 and AMD64) and will automatically pull the correct version for your architecture.

Configuration

License Key Setup

The enterprise image requires a license key to operate. Configure this using the KEY environment variable:

Important

Use the KEY environment variable for your license, not TOKEN. The TOKEN variable is used for API authentication, while KEY is used for license validation.

Basic Docker Run

Here's a minimal example to run the enterprise image:

docker run \
  -e KEY=your-license-key-here \
  -p 3000:3000 \
  registry.browserless.io/browserless/browserless/enterprise:latest

Docker Compose Configuration

For production deployments, we recommend using Docker Compose. Here's a complete example:

Basic Setup

---
services:
  browserless:
    image: registry.browserless.io/browserless/browserless/enterprise:latest
    container_name: browserless-enterprise
    environment:
      - KEY=your-license-key-here
    ports:
      - "3000:3000"
    restart: unless-stopped

Advanced Setup

---
services:
  browserless:
    image: registry.browserless.io/browserless/browserless/enterprise:latest
    container_name: browserless-enterprise
    environment:
      - KEY=your-license-key-here
      - CONCURRENT=20
      - DOWNLOAD_DIR=/downloads
      - DATA_DIR=/user_data
      - TOKEN=optional-api-token-for-external-access
      - ALLOW_GET=true
      - ENABLE_CORS=true
      - TZ=America/New_York
      - MAX_PAYLOAD_SIZE=30MB
      - KEEP_ALIVE=true
    ports:
      - "3000:3000"
    volumes:
      - ./downloads:/downloads
      - ./user_data:/user_data
      - ./fonts:/usr/share/fonts/custom
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/pressure"]
      interval: 30s
      timeout: 10s
      retries: 3

Environment Variables

The enterprise image supports all standard Browserless environment variables plus enterprise-specific options:

Variable	Description	Default	Required
KEY	Enterprise license key	-	✅
TOKEN	API authentication token (optional for local networks)	-	❌
CONCURRENT	Maximum concurrent browser sessions	10	❌
DOWNLOAD_DIR	Directory for file downloads	/tmp	❌
DATA_DIR	User data directory for browser profiles	/tmp	❌
ALLOW_GET	Allow GET requests for simple operations	false	❌
ENABLE_CORS	Enable CORS headers	false	❌
TZ	Timezone setting	UTC	❌

For a complete list of configuration options, see our Docker Configuration guide.

Connecting to the Enterprise Image

Local Network Access

For applications running on the same network as your Browserless container, you can connect without an API token:

Puppeteer

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

const browser = await puppeteer.connect({
  browserWSEndpoint: 'ws://localhost:3000/chromium'
});

const page = await browser.newPage();
await page.goto('https://example.com');
const screenshot = await page.screenshot();
await browser.close();

Playwright

const { chromium } = require('playwright');

const browser = await chromium.connectOverCDP('ws://localhost:3000/chromium');
const context = await browser.newContext();
const page = await context.newPage();

await page.goto('https://example.com');
const screenshot = await page.screenshot();
await browser.close();

External Access with Token

For external access or additional security, configure a TOKEN and include it in your connection string:

Puppeteer with Token

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

const browser = await puppeteer.connect({
  browserWSEndpoint: 'ws://your-server:3000/chromium?token=your-api-token'
});

Playwright with Token

const { chromium } = require('playwright');

const browser = await chromium.connectOverCDP('ws://your-server:3000/chromium?token=your-api-token');

Verification

After starting your container, verify it's running correctly:

1. Health Check: Visit http://localhost:3000/pressure to check system status
2. API Documentation: Visit http://localhost:3000/docs to view available endpoints
3. WebSocket Test: Use the connection examples above to test browser automation

Troubleshooting

Common Issues

License Key Errors

• Ensure you're using the KEY environment variable, not TOKEN
• Verify your license key is valid and hasn't expired
• Check that the key is properly formatted without extra spaces or characters

Registry Access Issues

• Confirm you're logged into registry.browserless.io
• Verify your registry credentials are still valid
• Try pulling the image again if authentication fails

Connection Problems

• For local networks, ensure no TOKEN is required in your connection string
• For external access, verify the TOKEN environment variable matches your connection string
• Check that the container port (3000) is properly exposed and accessible

Getting Help

If you encounter issues with the enterprise image:

1. Check the container logs: docker logs your-container-name
2. Verify your license key status through your account dashboard
3. Contact our enterprise support team with your container configuration

Next Steps

• Configure advanced Docker settings
• Set up webhooks for monitoring
• Extend the image with custom functionality
• Explore enterprise utility functions