Lightpanda loaded 50 pages through 25 parallel workers in 195 MB of memory, while headless Chrome needed 2,477 MB for the same job. That 12.7x memory gap is close to the 16x the project advertises. The speed gap is smaller than the 9x in the README: we measured 3.5x to 4.4x at 25 workers, and with a single worker Lightpanda was slower than Chrome with images switched off. Both results have one cause. Lightpanda runs JavaScript and builds a DOM, but it skips CSS layout, painting and image decoding.
Coverage of this headless browser so far repeats the vendor numbers without re-running them, so we measured instead. This guide installs the Linux binary and the Docker image, drives the CDP server from Puppeteer and from Playwright connectOverCDP, tests the built-in MCP server, and ends with the errors we hit. The results come from Lightpanda 1.0.2 (benchmarked October 2026 on Ubuntu 26.04) and Chrome 156 on one 4 vCPU, 8 GB VM.
Lightpanda vs headless Chrome: the measured numbers
Each cell in the table is the median of three runs. Every run starts a fresh browser, loads the same 50 URLs split across 1, 10 or 25 workers, counts the scraped items on every page and records peak memory for the whole browser process tree. All 27 runs returned 50 of 50 pages and 900 of 900 items, so every row compares complete work rather than a browser that gave up early.
| Workers | Lightpanda time | Chrome time | Chrome, images off | Lightpanda peak PSS | Chrome peak PSS | Chrome, images off PSS |
|---|---|---|---|---|---|---|
| 1 | 31.6 s | 36.7 s | 21.0 s | 60 MB | 611 MB | 614 MB |
| 10 | 5.4 s | 12.0 s | 8.4 s | 118 MB | 1,358 MB | 1,303 MB |
| 25 | 4.5 s | 19.6 s | 15.6 s | 195 MB | 2,477 MB | 2,424 MB |
Memory is the clear result. Lightpanda used 10.2x less at one worker and 12.7x less at 25, and the ratio held whether or not Chrome loaded images. Time depends on concurrency. With one worker the test is bound by network round trips, so Chrome with images off finished 50 pages in 21.0 s against 31.6 s for Lightpanda. At 10 workers Lightpanda pulled ahead by 1.6x to 2.2x. At 25 workers Chrome got slower than it had been at 10, because 68 to 87 Chrome processes were fighting over 4 vCPUs, while the single Lightpanda process finished in 4.5 s.
Idle cost and start time point the same way. We took each three times, with the browser listening on its CDP port and no client attached:
| Measurement | Lightpanda | Headless Chrome |
|---|---|---|
| Idle PSS, CDP server up | 17 MB | 382 to 388 MB |
| Launch to open CDP port | 27 to 48 ms | 169 to 266 ms |
| Processes at 25 workers | 1 | 77 to 87 (68 to 87 with images off) |
| Summed RSS at 25 workers | 197 MB | 9,859 MB |
Summed RSS is why the main table reports PSS. Chrome reached 9.9 GB of RSS on a VM with 8 GB of RAM, which cannot be real usage, because every renderer counts the same shared libraries again. PSS (proportional set size) splits each shared page across the processes that map it, so it is the honest figure for a multi-process browser. Quoting RSS would have made Chrome look 50x heavier, and we did not want to publish a number that flattering to Lightpanda.
How the numbers were taken:
- Machine: Proxmox VM on an Intel Core i7-6700 host, 4 vCPU, 8 GB RAM, Ubuntu 26.04, Node.js 22 with puppeteer-core 25.16.
- Page set: 40 catalogue pages of books.toscrape.com (static HTML plus jQuery) and 10 pages of quotes.toscrape.com/js, where the quotes only exist after the page script runs. Both are public sandboxes built to be scraped.
- Client: one Puppeteer script for both browsers. Each worker opens its own CDP connection and browser context, calls
page.goto()withwaitUntil: 'load'and counts.product_podand.quoteelements. - Chrome flags:
--headless=new --remote-debugging-port=9223 --no-first-run --no-default-browser-checkwith a fresh--user-data-dirper run. The images-off column adds--blink-settings=imagesEnabled=false, because Lightpanda skips images by default and Chrome does not. - Memory: a sampler reads
/proc/<pid>/smaps_rollupfor the browser and every descendant every 100 ms and keeps the peak sum.
Pages came over the internet, so absolute times move with the network. The spread inside each cell was small (Lightpanda at 25 workers ran 4.48 to 5.26 s, Chrome 17.1 to 21.9 s), which is why we trust the ratios more than the seconds. Step 8 has every script, so the run can be repeated on your own page set, and that is the test that matters for your workload.

One extra pair of runs at 25 workers, taken for the screenshot after the three-run matrix, lands close to it. Memory sits inside the PSS ranges at 204 MB and 2,483 MB, the 4.09 s was the fastest Lightpanda pass we recorded, and Chrome peaked at 89 processes, two more than in any matrix run. Lightpanda is not the only CDP engine that works without a Chrome process behind it: Cloudflare’s Kitesurf engine is written in Rust, runs on the Workers runtime and takes Puppeteer connections the same way, although that test timed it against agent-browser and Playwright MCP rather than this matrix.
What Lightpanda leaves out
Lightpanda is written from scratch in Zig, with a JavaScript engine, a DOM and a CDP server, and no rendering pipeline behind them. On books.toscrape.com, fetch --json shows the trade in one line: 20 images and 3 stylesheets skipped, 0 JavaScript errors. Page scripts ran, so a JavaScript-built page such as quotes.toscrape.com/js comes back populated, but nothing was laid out or painted.
Scraping, crawling, link checking and an AI agent that reads pages as text all fit that design. Anything that needs pixels or geometry does not, which rules out visual tests, real screenshots, PDF reports and scripts that click by coordinates. Licensing is AGPL-3.0, so it matters if you plan to modify Lightpanda and offer it as a network service.
Step 1: Install the Lightpanda binary on Linux
Each release on the Lightpanda GitHub releases page carries one executable per platform: lightpanda-x86_64-linux and lightpanda-aarch64-linux, plus two macOS builds and .deb packages. The README points at the rolling nightly tag. Pin a numbered release instead, because a nightly can change behaviour between two runs of the same scraper or benchmark.
LP_VERSION=1.0.2 # pin: benchmarked release; newer tags at https://github.com/lightpanda-io/browser/releases
curl -L -o lightpanda "https://github.com/lightpanda-io/browser/releases/download/${LP_VERSION}/lightpanda-x86_64-linux"
sudo install -m 0755 lightpanda /usr/local/bin/lightpanda
On an ARM server, swap x86_64 for aarch64 in the file name. Confirm the file type and the version next:
file /usr/local/bin/lightpanda
lightpanda version
A 73 MB ELF binary linked against glibc comes back, and the loader path in the output is why it does not start on Alpine (the error is in the last section):
/usr/local/bin/lightpanda: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, stripped
1.0.2
Lightpanda sends usage telemetry by default. Every command in this guide ran with it switched off, and adding the same export to ~/.bashrc keeps it off for new shells.
export LIGHTPANDA_DISABLE_TELEMETRY=true
A first fetch under GNU time gives a baseline for one page. Install jq and time now as well, because later steps parse JSON output and /usr/bin/time is not in a minimal Ubuntu image:
sudo apt install -y jq time
/usr/bin/time -v lightpanda fetch --dump html https://books.toscrape.com/ 2>&1 >/dev/null | grep -E 'Elapsed|Maximum resident'
On the test box this run peaked at 49,548 KB of RSS and took 1.65 s including the network round trips.

In an earlier pair of captures, where Lightpanda measured 49,312 KB and 1.36 s, google-chrome --headless=new --dump-dom on the same URL peaked at 246,644 KB and took 3.27 s. GNU time reports the largest single process, so the Chrome figure understates its total. No Windows build exists among the release assets, so on Windows the route is the Linux binary inside WSL2.
Step 2: Fetch pages from the command line
The fetch subcommand loads one or more URLs, runs their JavaScript and dumps the result, which covers most one-off scraping without any Node.js. Markdown is the most useful form for feeding a language model, because navigation and text survive while the markup does not.
lightpanda fetch --dump markdown https://quotes.toscrape.com/js/ | head -12
Quotes on this page are written into the DOM by an inline script. They are present in the dump, so the JavaScript ran:
# [Quotes to Scrape](https://quotes.toscrape.com/)
[Login](https://quotes.toscrape.com/login)
βThe world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.βby Albert Einstein
Tags: change
deep\-thoughts
thinking
world
βIt is our choices, Harry, that show what we truly are, far more than our abilities.βby J.K. Rowling
Tags: abilities
choices
Markdown is one of seven documented dump formats in this release, and two of them are not what their names suggest:
- html and markdown: the DOM after scripts ran, serialized or converted. These are the formats to scrape from.
- semantic_tree and semantic_tree_text: a semantic tree of the page as JSON, or pruned to plain text compact enough to hand to an agent.
- structured_data: JSON-LD, OpenGraph, Twitter card, meta and link tags as JSON.
- png and pdf: text-only renderings, covered in the limits section. Neither is a picture of the page.
For scripts, --json wraps the result with the HTTP status, response headers and a page_status object:
lightpanda fetch --json https://books.toscrape.com/ | jq '{http_status, error, bot_challenge, page_status}'
Read the skipped counters before trusting a scrape. Here 20 product images and 3 stylesheets were never requested, which is fine for text and wrong for anything that depends on CSS. The output below is cut after the skipped block:
{
"http_status": 200,
"error": null,
"bot_challenge": null,
"page_status": {
"js_errors": 0,
"skipped": {
"iframe": 0,
"worker": 0,
"image": 20,
"stylesheet": 3
},
Passing several URLs to one fetch requires --json, and one failed URL does not stop the rest. Use --load-resources to bring back iframes, workers, stylesheets or images when a page needs them, knowing that every resource type you add gives back part of the memory saving measured above.
Step 3: Run Lightpanda in Docker
Docker Hub carries the official lightpanda/browser image, with numbered tags next to latest and nightly. Its default command runs lightpanda serve --host 0.0.0.0 --port 9222 under tini, so the container is a CDP server and nothing else. On a fresh Ubuntu host, Docker from the archive is enough; log out and back in after the group change so it takes effect:
sudo apt install -y docker.io
sudo usermod -aG docker $USER
Then start the container with the port published on loopback only:
docker run -d --name lightpanda -e LIGHTPANDA_DISABLE_TELEMETRY=true -p 127.0.0.1:9222:9222 lightpanda/browser:1.0.2
Keep the 127.0.0.1: prefix. CDP has no authentication, so anyone who reaches port 9222 can drive the browser, read its cookies and make requests from inside your network. Check the container and the image size:
docker ps --format "table {{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}"
docker images lightpanda/browser --format "{{.Repository}}:{{.Tag}} {{.Size}}"
Port 9222 is bound to loopback, and the unpacked image takes 224 MB on disk.
NAMES IMAGE STATUS PORTS
lightpanda lightpanda/browser:1.0.2 Up 3 seconds 127.0.0.1:9222->9222/tcp
lightpanda/browser:1.0.2 224MB
After the Playwright script from Step 6 had run against the container and disconnected, docker stats reported 6.449 MiB of memory for it. Clients reach the container on the same ws://127.0.0.1:9222 endpoint as the binary, so every client step below works against either one. Stop it with docker rm -f lightpanda before starting the binary on the same port, or the second server fails to bind.
Step 4: Start the CDP server
Puppeteer and Playwright talk to Lightpanda over the Chrome DevTools Protocol, the same way they attach to a running Chrome. With the binary, serve starts that server. Raise the connection cap if you will run more than 16 clients at once, for reasons Step 5 explains.
lightpanda serve --host 127.0.0.1 --port 9222 --cdp-max-connections 32 &
CDP clients read a version endpoint before they open the WebSocket. Query it by hand:
curl -s http://127.0.0.1:9222/json/version
Look at webSocketDebuggerUrl. It is a bare ws://127.0.0.1:9222/, without the /devtools/browser/<id> path Chrome uses, and clients take it as it is:
{"Browser": "Lightpanda/1.0", "Protocol-Version": "1.3", "User-Agent": "Lightpanda/1.0", "Lightpanda-Version": "1.0.2", "webSocketDebuggerUrl": "ws://127.0.0.1:9222/"}
Mind the User-Agent before pointing Lightpanda at third-party sites. It announces itself as Lightpanda/1.0, so a site that filters on user agent sees that string. A /metrics endpoint in Prometheus format also answers on port 9222 unless you start the server with --disable-metrics.
Step 5: Drive Lightpanda from Puppeteer
Use puppeteer-core, not puppeteer, because the full package downloads a Chrome build you do not need here. Node.js 22 from the Ubuntu 26.04 archive is enough, and playwright-core goes in at the same time for Step 6.
sudo apt install -y nodejs npm jq
mkdir -p ~/bench && cd ~/bench
npm init -y && npm pkg set type=module
npm install puppeteer-core playwright-core
List what landed in the project:
npm ls --depth=0
Both client libraries in the test project resolved to these versions:
[email protected] /home/klinsmann/bench
βββ [email protected]
βββ [email protected]
Create the Puppeteer script in the project folder.
vim ~/bench/puppeteer-demo.mjs
Paste the following. It connects to the running server, opens a context and a page, and extracts quotes from the JavaScript-rendered page:
import puppeteer from 'puppeteer-core';
const browser = await puppeteer.connect({ browserWSEndpoint: 'ws://127.0.0.1:9222' });
const context = await browser.createBrowserContext();
const page = await context.newPage();
await page.goto('https://quotes.toscrape.com/js/', { waitUntil: 'load' });
const quotes = await page.$$eval('.quote', els =>
els.map(q => ({
author: q.querySelector('.author').textContent,
text: q.querySelector('.text').textContent.slice(0, 50),
}))
);
console.log(await page.title(), '|', quotes.length, 'quotes');
console.log(quotes.slice(0, 3));
await page.close();
await context.close();
await browser.disconnect();
Run it against the server from Step 4.
node puppeteer-demo.mjs
All ten quotes on the page were found, the same count Chrome returns:
Quotes to Scrape | 10 quotes
[
{
author: 'Albert Einstein',
text: 'βThe world as we have created it is a process of o'
},
{
author: 'J.K. Rowling',
text: 'βIt is our choices, Harry, that show what we truly'
},
{
author: 'Albert Einstein',
text: 'βThere are only two ways to live your life. One is'
}
]
Calling browser.disconnect() instead of browser.close() keeps the server running for the next client. One rule shapes every concurrent design on Lightpanda: one browser context per CDP connection. A second createBrowserContext() on the same connection fails, so parallel work means parallel connections, each counted against --cdp-max-connections (16 by default). The benchmark script follows that pattern for both browsers, so neither gets an advantage from connection reuse.
Step 6: Connect Playwright with connectOverCDP
The code example in the Lightpanda README uses Puppeteer only, but Playwright attaches the same way through chromium.connectOverCDP(), and the Lightpanda docs list it. Create the script.
vim ~/bench/playwright-demo.mjs
Locators replace the raw $$eval in this version, because locators are the part of Playwright most likely to call a CDP method Lightpanda has not implemented:
import { chromium } from 'playwright-core';
const browser = await chromium.connectOverCDP('ws://127.0.0.1:9222');
const context = await browser.newContext();
const page = await context.newPage();
await page.goto('https://books.toscrape.com/');
const books = await page.locator('article.product_pod h3 a').evaluateAll(links =>
links.slice(0, 5).map(a => a.getAttribute('title'))
);
const prices = await page.locator('.price_color').allTextContents();
console.log(await page.title());
console.log(books);
console.log('prices on page:', prices.length, 'first:', prices[0]);
await context.close();
await browser.close();
Run it with node playwright-demo.mjs. The title, five book titles and all 20 prices came back on the first try.

Locators, evaluation in the page, text extraction and a new context all worked over CDP. Screenshot, PDF and layout-based actions are a different matter, for the reasons in the limits section. If most of your Playwright code generates PDFs, the Playwright HTML to PDF guide still needs a real Chromium behind it.
Step 7: Give an AI agent Lightpanda over MCP
Low idle cost is what makes Lightpanda attractive as a headless browser for AI agents, and the binary has an MCP server built in. Running lightpanda mcp speaks JSON-RPC over stdio, or over HTTP with --port. Before wiring it into a client, confirm the handshake and list the tools with three raw messages:
(printf "%s\n" \
'{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"bench","version":"1"}}}' \
'{"jsonrpc":"2.0","method":"notifications/initialized"}' \
'{"jsonrpc":"2.0","id":2,"method":"tools/list"}'; sleep 2) \
| lightpanda mcp | jq -c 'select(.id==2) | [.result.tools[].name]'
Thirty-two tools came back, from navigation and extraction to form filling and session control.
["goto","search","markdown","html","screenshot","links","evaluate","extract","tree","nodeDetails","interactiveElements","structuredData","detectForms","click","fill","scroll","waitForSelector","waitForScript","waitForState","hover","press","selectOption","setChecked","findElement","consoleLogs","getUrl","getCookies","getEnv","save","session_new","session_list","session_close"]
A goto call to books.toscrape.com answered Navigated. HTTP 200 OK., and a following links call returned the anchors as JSON with their text and href. Any MCP client that launches stdio servers can use /usr/local/bin/lightpanda as the command with mcp as its only argument. Give the full path, because clients do not always inherit the PATH of your shell. Setting up the client side for Claude Code is covered in our guide to connecting MCP servers. An agent that needs a real Chrome for performance traces, console errors and failed requests is better served by Chrome DevTools MCP, and our headless setup guide weighs that browser MCP choice against Playwright MCP and agent-browser.
Step 8: Reproduce the benchmark
Four files make the benchmark, and all of them are shown exactly as they ran. Chrome comes from the Google .deb; the Chrome on Ubuntu guide covers the repository setup, and the short form is two commands.
curl -sSLo /tmp/chrome.deb https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo apt install -y /tmp/chrome.deb
Generate the 50-URL page set next. Keeping it in a file means both browsers read the identical list in the identical order.
cd ~/bench
for i in $(seq 1 40); do echo "https://books.toscrape.com/catalogue/page-$i.html"; done > urls.txt
for i in $(seq 1 10); do echo "https://quotes.toscrape.com/js/page/$i/"; done >> urls.txt
Now open the client file.
vim ~/bench/bench.mjs
Each worker opens its own connection and context, then pulls URLs from a shared queue until it is empty. Our first draft wrote items += await page.evaluate(...), which reads items before the await and silently lost counts under concurrency. That version reported 290 items at 25 workers where 900 existed, so the separate found variable below is deliberate:
import puppeteer from 'puppeteer-core';
import { readFileSync } from 'node:fs';
const [target, n] = [process.argv[2], Number(process.argv[3] || 1)];
const urls = readFileSync(new URL('./urls.txt', import.meta.url), 'utf8').trim().split('\n');
const opts = target.startsWith('ws') ? { browserWSEndpoint: target } : { browserURL: target };
let next = 0, ok = 0, fail = 0, items = 0;
const errors = {};
async function worker() {
const browser = await puppeteer.connect(opts);
const context = await browser.createBrowserContext();
const page = await context.newPage();
while (next < urls.length) {
const url = urls[next++];
try {
await page.goto(url, { waitUntil: 'load', timeout: 30000 });
const found = await page.evaluate(() => document.querySelectorAll('.product_pod, .quote').length);
items += found;
ok++;
} catch (e) {
fail++;
errors[e.message.split('\n')[0]] = (errors[e.message.split('\n')[0]] || 0) + 1;
}
}
await page.close();
await context.close();
await browser.disconnect();
}
const t0 = performance.now();
await Promise.all(Array.from({ length: n }, worker));
const wall = ((performance.now() - t0) / 1000).toFixed(2);
console.log(JSON.stringify({ workers: n, pages: urls.length, ok, fail, items, wall_s: Number(wall), errors }));
A memory sampler walks the process tree under the browser PID and keeps the highest RSS and PSS totals it sees. Create it.
vim ~/bench/sampler.py
Paste the sampler. It stops on SIGTERM and prints the peaks as JSON, which the runner then folds into its own output line:
import os, sys, time, signal, json
root = int(sys.argv[1])
peak = {"rss_mb": 0, "pss_mb": 0, "procs": 0}
stop = False
signal.signal(signal.SIGTERM, lambda *a: globals().__setitem__("stop", True))
def tree(root):
kids = {}
for p in os.listdir("/proc"):
if p.isdigit():
try:
ppid = int(open(f"/proc/{p}/stat").read().rsplit(")", 1)[1].split()[1])
kids.setdefault(ppid, []).append(int(p))
except OSError:
pass
out, todo = [], [root]
while todo:
p = todo.pop()
out.append(p)
todo.extend(kids.get(p, []))
return out
while not stop:
rss = pss = 0
procs = tree(root)
for p in procs:
try:
for line in open(f"/proc/{p}/smaps_rollup"):
if line.startswith("Rss:"):
rss += int(line.split()[1])
elif line.startswith("Pss:"):
pss += int(line.split()[1])
except OSError:
pass
peak["rss_mb"] = max(peak["rss_mb"], rss // 1024)
peak["pss_mb"] = max(peak["pss_mb"], pss // 1024)
peak["procs"] = max(peak["procs"], len(procs))
time.sleep(0.1)
print(json.dumps(peak))
A runner script starts one fresh browser, waits for its port, samples it through one benchmark pass and shuts it down. Open it.
vim ~/bench/run.sh
Paste the runner. Its first argument picks the browser (lightpanda, chrome or chrome-noimg) and the second sets the worker count:
#!/bin/bash
# usage: run.sh lightpanda|chrome WORKERS
B=$1; N=$2; cd ~/bench
if [ "$B" = lightpanda ]; then
LIGHTPANDA_DISABLE_TELEMETRY=true lightpanda serve --host 127.0.0.1 --port 9222 --cdp-max-connections 32 --log-level err >/tmp/lp.log 2>&1 &
EP=ws://127.0.0.1:9222; PORT=9222
else
PROFILE=$(mktemp -d)
EXTRA=""; [ "$B" = chrome-noimg ] && EXTRA="--blink-settings=imagesEnabled=false"
google-chrome --headless=new $EXTRA --remote-debugging-port=9223 --user-data-dir="$PROFILE" --no-first-run --no-default-browser-check about:blank >/tmp/chrome.log 2>&1 &
EP=http://127.0.0.1:9223; PORT=9223
fi
BPID=$!
until ss -ltn | grep -q ":$PORT "; do sleep 0.1; done
python3 sampler.py $BPID >/tmp/peak.json &
SPID=$!
RES=$(node bench.mjs $EP $N)
kill $SPID; wait $SPID 2>/dev/null
kill $BPID; wait $BPID 2>/dev/null
sleep 1; [ -n "$PROFILE" ] && rm -rf "$PROFILE" 2>/dev/null
echo "{\"browser\":\"$B\",\"run\":$RES,\"peak\":$(cat /tmp/peak.json)}"
Stop any Lightpanda server or container still holding port 9222, because the runner starts its own. Then make the runner executable and try one pass.
chmod +x run.sh
./run.sh lightpanda 25
Check ok and items first. A run with fewer than 50 pages or 900 items measured less work, so its time and memory do not belong in a comparison:
{"browser":"lightpanda","run":{"workers":25,"pages":50,"ok":50,"fail":0,"items":900,"wall_s":4.09,"errors":{}},"peak":{"rss_mb": 207, "pss_mb": 204, "procs": 1}}
For the full matrix, a small loop covers repetitions, worker counts and browsers. Create it.
vim ~/bench/matrix.sh
Paste the loop. A 3-second pause between runs keeps one browser exit from overlapping the next start:
#!/bin/bash
for rep in 1 2 3; do for n in 1 10 25; do for b in lightpanda chrome chrome-noimg; do
echo "{\"rep\":$rep,\"r\":$(./run.sh $b $n)}"; sleep 3
done; done; done
Run it in the background, since 27 runs took about 10 minutes on the test box, then take the median of each cell from results.jsonl.
chmod +x matrix.sh
nohup ./matrix.sh > results.jsonl 2>matrix.err &
Swap urls.txt for your own targets before drawing conclusions about your workload. A page set heavy on images, iframes or bot protection will move both the ratios and the error count, so a sandbox result is a floor for planning, not a promise.
Where Lightpanda breaks
Every entry here was reproduced on the test box with short Puppeteer probes against the same server. Most follow from the missing rendering engine, and two are protocol limits that shape how you write concurrent code.
Error: “Cannot have more than one browser context at a time”
A second browser.createBrowserContext() on one Puppeteer connection fails with this message:
Protocol error (Target.createBrowserContext): Cannot have more than one browser context at a time
Chrome code that opens one connection and many incognito contexts has to be restructured into one puppeteer.connect() per worker, as bench.mjs does. A connection costs little on Lightpanda, so the change is cheap, but it runs straight into the next limit.
Error: “Unexpected server response: 503” on the 17th connection
With the default server settings, opening 17 connections at once connected 16 and refused the rest:
asked 17, connected 16
ERROR Unexpected server response: 503
Start the server with --cdp-max-connections above your worker count. With 32, all 25 benchmark workers connected. In Docker, the flag goes on a full serve command after the image name, which replaces the default command of the image.
docker run -d --name lightpanda -e LIGHTPANDA_DISABLE_TELEMETRY=true -p 127.0.0.1:9222:9222 lightpanda/browser:1.0.2 /bin/lightpanda serve --host 0.0.0.0 --port 9222 --cdp-max-connections 32
All 25 test connections to that container succeeded. Inside the container --host 0.0.0.0 is required so the Docker port mapping can reach the server, while the host side stays on loopback.
Lightpanda screenshots and PDFs are text-only renders
Puppeteer page.screenshot() and page.pdf() both return without an error, and that is the trap. The PNG is 800 x 600 and the PDF has 5 pages, but neither is a rendering of the page. On the right below is what Lightpanda produced for books.toscrape.com, next to a Chrome capture of the same URL:

No stylesheet, no images, only the text in document order. On the CLI, fetch --dump png behaves the same and wrote a 1920 x 4818 image of text. For real captures and print output keep Chrome, using the headless Chrome PDF flags or page.pdf() in Puppeteer against a real Chromium.
Layout values are placeholders
Code that reads geometry gets numbers, not errors. On books.toscrape.com the h1 reported this from getBoundingClientRect() and getComputedStyle():
layout -> {"width":1920,"height":5,"offsetWidth":1920,"color":"rgb(0, 0, 0)","display":"block"}
viewport -> {"innerWidth":800,"innerHeight":600,"ua":"Lightpanda/1.0"}
Headless Chrome measured the same h1 at 453 x 40 px in rgb(51, 51, 51), the grey from the site stylesheet. A heading 1920 px wide and 5 px tall inside an 800 px viewport is not a real box, and the black is only the default because the stylesheet was never applied. Anything that decides visibility, scroll position or click targets from layout will make wrong decisions without raising an exception. Selectors and DOM state are reliable; pixels and sizes are not.
Bot-protected sites return a status, not a challenge flag
We fetched three bot-protected sites with fetch --json and compared them with --dump-dom from headless Chrome. Neither browser came out ahead:
| Site | Lightpanda | Headless Chrome |
|---|---|---|
| g2.com | HTTP 403, empty content, bot_challenge null | Page titled “g2.com” |
| zillow.com | HTTP 200, full navigation in Markdown | “Access to this page has been denied” |
| nowsecure.nl | HTTP 200, page text | Page titled “nowsecure.nl” |
Design for the g2.com row. The request was blocked, yet bot_challenge and error both stayed null, so a script that only checks those fields records an empty page as a success. Check http_status and the content length too, or add --fail-on-http-error so fetch exits with code 22. Three sites prove nothing general about evasion, and we would not pick either browser on that basis.
Error: “exec /lightpanda: no such file or directory” on Alpine
Lightpanda for Linux needs the glibc loader at /lib64/ld-linux-x86-64.so.2. Mounted into an alpine:3.22 container it fails before main runs:
docker run --rm -v /usr/local/bin/lightpanda:/lightpanda:ro alpine:3.22 /lightpanda version
Despite the wording, the binary exists. What is missing is the loader it names:
exec /lightpanda: no such file or directory
Build on a glibc base such as Debian slim or Ubuntu, or start from the official lightpanda/browser image. Windows has the same answer for a different reason: there is no Windows asset in the release, so WSL2 with the Linux binary is the supported route.
When to run Lightpanda and when to keep Chrome
Concurrency decides first, then whether the job needs pixels. At one worker Lightpanda saved about 550 MB but was slower than Chrome with images off; at 25 workers it saved 2.3 GB and finished 3.5x to 4.4x sooner. Our verdict by workload:
- Parallel scraping and crawling: Lightpanda. Ten or more workers on a small VM is where the 12x memory gap turns into fewer machines.
- AI agents reading pages: Lightpanda over MCP or CDP. At 17 MB idle an agent can keep one browser per session.
- Single serial jobs: either. Chrome with images off was faster in our run, and Lightpanda used a tenth of the memory.
- Screenshots, PDFs, visual tests: Chrome. Lightpanda output is text drawn on a canvas, not the page.
- Layout-driven automation or sites that fingerprint browsers: Chrome, after testing your own target list.
A mixed setup is often the practical answer: Lightpanda for the bulk crawl, Chrome for the few pages that need a render. Archivers such as ArchiveBox and video renderers such as HyperFrames belong on the Chrome side, because their output is the rendered page. Re-run Step 8 after each Lightpanda release, since the project has shipped roughly every one to three weeks and Web API coverage changes with it.