What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
A self-hosted browser automation API runs browser processes inside infrastructure your team controls. Your application sends REST requests or connects over a browser protocol such as CDP, while the service launches and manages Chromium, Chrome, Firefox, WebKit, or Edge. This model can keep page traffic and captured data inside a VPC or private network, but you become responsible for authentication, patching, capacity, observability, and licensing.
Browserless is a documented example: its open-source Docker image exposes Puppeteer and Playwright over WebSocket and includes REST APIs for screenshots, PDFs, content, and scraping. The exact API and feature set depend on the deployment and license you choose; do not assume every self-hosted browser server behaves the same way.
What “self-hosted browser automation API” means
In this pattern, your worker or application does not launch a browser on every request. Instead, it calls a browser service running on your own VM, Kubernetes cluster, bare-metal host, or private network. The service allocates a browser session, applies the requested URL and options, then returns JSON, rendered HTML, an image, a PDF, or a protocol connection.
REST versus browser protocols
- REST: convenient for fixed tasks such as screenshots, PDFs, HTML rendering, and structured extraction. Responses may be JSON or binary files.
- WebSocket/CDP: your Puppeteer or Playwright code controls a remote browser directly. This is appropriate for multi-step flows, authentication, waits, downloads, and custom JavaScript.
Browserless documents REST endpoints plus WebSocket access for CDP, Playwright, and Puppeteer. Its open-source image is distributed through GitHub Container Registry and includes browser images for Chromium, Chrome, Firefox, WebKit, Edge, and a multi-browser image. The documentation lists linux/amd64 and linux/arm64 support; Chrome and Edge are amd64-only, while the ARM multi-browser image includes Chromium, Firefox, and WebKit.
#1 Best Overall
When running browsers yourself is worthwhile
Strong reasons
- Page requests, cookies, screenshots, PDFs, and extracted content must stay within an approved VPC, on-premises network, or isolated environment.
- You need private routing, custom egress controls, internal hostnames, or network policies that a shared service cannot provide.
- Your workload is steady enough to justify operating a pool of browser capacity.
- You need protocol-level control and can maintain compatible browser and client versions.
Reasons to use a managed service instead
- Your traffic is highly variable and you do not want to size queues and autoscaling.
- You need managed residential proxies or cloud-only extraction features.
- Your team cannot provide browser security patching, on-call response, logging, and credential management.
Self-hosting changes who operates the infrastructure; it does not remove browser complexity.
Deploying Browserless with Docker
Browserless’ documented open-source deployment starts a container, publishes its service port, sets a token, and connects a matching client. A minimal pattern is:
docker run -d --name browserless
-p 3000:3000
-e TOKEN=replace-with-a-long-random-secret
-e CONCURRENT=5
ghcr.io/browserless/chromiumUse the image and browser type that match your client. Browserless’ guidance emphasizes that the Docker image, browser, and endpoint must agree when Playwright connects. For Enterprise deployments, the documented default host is http://localhost:3000; configure the token with the TOKEN environment variable.
Connect with Playwright over CDP
import { chromium } from 'playwright';
const browser = await chromium.connectOverCDP(
'ws://localhost:3000?token=replace-with-a-long-random-secret'
);
const context = await browser.newContext();
const page = await context.newPage();
await page.goto('https://example.com', { waitUntil: 'networkidle' });
console.log(await page.title());
await page.screenshot({ path: 'example.png', fullPage: true });
await browser.close();Use the WebSocket URL and query format documented for your Browserless edition. A client-library version mismatch can produce protocol errors even when the container is healthy.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Use REST for a simple screenshot
curl -X POST 'http://localhost:3000/screenshot?token=replace-with-a-long-random-secret'
-H 'Content-Type: application/json'
--data '{"url":"https://example.com","options":{"fullPage":true}}'
-o example.pngEndpoint paths and request schemas differ by Browserless API version, so consult the API reference for the exact REST operation you deploy. The reference describes binary and JSON responses as well as direct protocol connections.
Security: never leave the endpoint open
Browserless explicitly warns: “If you don’t set TOKEN, Browserless does not generate one for you.” Without a token, all endpoints remain unauthenticated, including /function, which executes Puppeteer code supplied in a request. An exposed endpoint can therefore become an arbitrary browsing and code-execution service.
Minimum controls
- Set a long random
TOKENand store it in a secret manager, not source control. - Place the service on a private network. Require an authenticated reverse proxy or private link for callers.
- Allow-list outbound destinations where feasible; restrict access to cloud metadata, internal admin panels, and other sensitive networks.
- Disable unused endpoints and features. Browserless’ self-hosting guidance recommends a reverse proxy and protecting tokens and keys.
- Run the container with a non-privileged configuration, apply image updates, and monitor browser crashes and unusual request volume.
- Sanitize uploaded scripts, headers, cookies, and URLs. Treat all request data as untrusted.
API and feature boundaries
Self-hosted does not mean feature parity with a vendor cloud. Browserless identifies these advanced REST endpoints as cloud-only: /unblock, /smart-scrape, /search, /map, /crawl, and /agent/run. For self-hosted extraction, it identifies /scrape for structured data and /content for rendered HTML.
Self-hosted customers bring their own proxy. Managed residential proxies are described as available in cloud and private options, not as part of the self-hosted Docker image. Check the current endpoint list, license, and browser support before committing an application design.
Licensing and deployment choices
| Deployment | Who operates infrastructure | Important implication |
|---|---|---|
| Shared cloud | Vendor | Least operational work; traffic leaves your infrastructure. |
| Private deployment | Browserless on dedicated VMs | Dedicated environment with vendor operations. |
| Self-hosted Docker | Your team | You control location and networking, and own operations. |
Browserless says its open-source image is SSPL-1.0 and free for open-source projects, prototyping, and evaluation. It says closed-source commercial products or closed-source CI require a commercial license. Commercial licensing and Enterprise are not interchangeable: the product information describes additional use rights, support, source access, and an admin UI under commercial licensing, while Enterprise adds features such as BrowserQL, stealth, and session recording. Read the license that applies to your deployment and obtain legal advice for commercial distribution.
Capacity, queues, and reliability
Each browser consumes CPU and memory according to page complexity, JavaScript, media, screenshots, downloads, and parallel tabs. Set an explicit concurrency limit, queue excess work, and enforce navigation and total-job timeouts. Track queue depth, active sessions, launch failures, browser crashes, response latency, and outbound errors.
Browserless’ undated product sizing guidance is illustrative, not an independent benchmark:
| Concurrent sessions | Vendor guidance |
|---|---|
| 5–10 | 2 CPU · 4 GB RAM |
| 10–20 | 4 CPU · 8 GB RAM |
| 20–50 | 8+ CPU · 16+ GB RAM |
Measure your own pages before setting production limits. Use multiple containers behind a load balancer for failure isolation and horizontal scaling. Keep workloads idempotent so a timed-out job can be retried safely. Cache deterministic results where policy permits, and close contexts after every task to prevent memory growth.
Operational checklist
- Health check the service and verify that a browser can actually launch, not merely that port 3000 is open.
- Set separate limits for request rate, concurrent sessions, queue length, and job duration.
- Capture structured logs with request ID, target host, duration, outcome, and resource usage; redact cookies and authorization headers.
- Roll browser-image updates through staging, then drain and replace containers.
- Test CAPTCHA, bot-check, login, download, PDF, and large-page failure paths explicitly.
Common failures and fixes
401 or unauthenticated requests
Cause: missing or incorrect token, or a proxy that strips the authorization/query parameter. Fix the secret injection, verify the endpoint’s expected token format, and test from inside the private network.
WebSocket connection refused
Cause: wrong port, container not ready, firewall policy, or an HTTP/HTTPS mismatch. Confirm published ports, container logs, readiness checks, and the correct ws:// or wss:// scheme.
Protocol or browser mismatch
Cause: connecting Playwright to an image or endpoint intended for another browser/protocol. Select the matching Browserless image and client API, then pin compatible versions.
Timeouts and blank pages
Cause: slow third-party assets, blocked network access, JavaScript errors, or insufficient capacity. Add a bounded wait strategy, inspect browser console and network logs, raise resources only after measuring, and retry transient failures with a limit.
Recommended Free Tools
Out-of-memory crashes
Cause: too much concurrency, unclosed contexts, large PDFs, or media-heavy pages. Lower concurrency, close contexts, cap job size, and scale out rather than allowing the host to swap.
Alternative: skip the browser setup with ScreenshotNeo
If you need a screenshot API rather than an infrastructure project, ScreenshotNeo is the first alternative to try: it removes cookie banners, newsletter popups, and chat widgets before capture, bills only clean shots, and has a $5 paid plan for 3,000 shots.
One GET request is enough:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for all options. The service supports PNG, JPEG, WebP, and PDF; full-page and element captures; device and retina settings; dark mode; custom CSS and JavaScript; waits; request blocking; headers, cookies, user agents, timezone and geolocation; caching; signed links; asynchronous webhooks; bulk capture; and an MCP server with take_screenshot, get_page_info, and capture_pdf tools for AI agents.
Bot checks, CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers identify the page verdict and billing status. The Free plan includes 1,000 shots per month without a card; paid plans start at $5 for 3,000. Create a free ScreenshotNeo account.
Frequently Asked Questions
Can I self-host Browserless?
Yes. Browserless documents an open-source Docker image for customer-managed infrastructure, alongside private and shared cloud deployments. Confirm the license and feature set for your intended use.
Does self-hosted Browserless include managed proxies?
No. Browserless says self-hosted customers bring their own proxy; managed proxy options are described for cloud or private deployments.
What should I monitor first?
Start with active sessions, queue depth, job duration, browser crashes, timeout rate, memory, CPU, and outbound network failures.
The Bottom Line
Run a self-hosted browser API when data locality and network control outweigh the operational cost. Secure the endpoint before connecting clients, verify licensing and endpoint availability, and size capacity with your own workload rather than vendor guidance alone.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsQuick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
