Start with a measured baseline. Run your workload with Puppeteer’s bundled Chrome for Testing and headless: true, then repeat it with headless: 'shell'. Keep the browser binary, pages, cache state, wait strategy, concurrency, and machine limits identical. Compare throughput, latency, memory, and output correctness—not speed alone. Puppeteer describes chrome-headless-shell as potentially more performant when you do not need the complete Chrome feature set, but it publishes no universal speedup.
What the two headless modes actually do
In current Puppeteer, headless: true is the default. It launches Chrome’s new headless mode, which follows the regular Chrome code path. Setting headless: 'shell' launches the separate chrome-headless-shell program, the successor to the old headless implementation.
| Setting | Browser path | When to use it | Important qualification |
|---|---|---|---|
headless: true |
New headless Chrome | Default choice when you need broad Chrome behavior and compatibility | Usually the safest correctness baseline |
headless: 'shell' |
Separate chrome-headless-shell binary |
Automation that does not require the complete Chrome feature set | Puppeteer says it is currently more performant for suitable tasks, but gives no percentage and it does not match regular Chrome completely |
headless: false |
Headful Chrome | Visual debugging or workflows that require a visible browser | Not a headless performance optimization |
Puppeteer v20 and later downloads Chrome for Testing for Chrome automation. The supported-browser mapping changes over time; the documentation retrieved for this article lists Puppeteer 25.12.0 with Chrome for Testing 154.0.8037.57. Treat that mapping as version-specific rather than permanent.
Establish a reproducible baseline
Before changing options, record the variables that can change a result:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
#1 Best Overall
- Intel Celeron N4120: 4 Cores & Threads, 1.1GHz Base Clock, Up to 2.6GHz Boost Clock, 4MB Cache, Intel UHD Graphics 600. The perfect combination of performance, power consumption, and value helps your device handle multitasking smoothly and reliably with four processing cores to divide up the work.
- 14" HD Display: 14.0-inch diagonal, HD (1366 x 768), micro-edge, anti-glare. See your digital world in a whole new way. Enjoy movies and photos with the great image quality and high-definition detail of 1 million pixels.
- Memory & Storage: 4 GB LPDDR4x & 64 GB eMMC Storage. Adequate high-bandwidth RAM to smoothly run multiple applications and browser tabs all at once. An embedded multimedia card provides reliable flash-based storage.
- Ports:2 x USB 3.0 Type-A，1 x USB 3.0 Type-C，1 x HDMI，1 x Headphone Jack
- Chrome OS: Chromebook is a computer for the way the modern world works, with thousands of apps. Enjoy the seamless simplicity that comes with Google Chrome and Android apps, all integrated into one laptop. It’s fast, simple, and secure.
- Puppeteer and Node.js versions.
- The downloaded Chrome for Testing version.
- Operating system, CPU, RAM, container limits, and whether a shared host is busy.
- The exact URL set, authentication state, viewport, device scale factor, and output operation.
- Navigation and wait conditions, such as
networkidle0, a selector, or a fixed delay. - Concurrency, browser reuse policy, and whether each test starts a fresh browser.
- Cache behavior and whether the pages are cold or warm.
- Metrics: total jobs per minute, navigation latency, p50/p95 latency, peak and average memory, error rate, and a correctness check on the result.
Use the browser Puppeteer downloads by default for the first comparison. Puppeteer’s compatibility guidance does not guarantee behavior with arbitrary Chrome versions, so changing the binary at the same time as the headless mode makes the test inconclusive.
Benchmark both modes with the same workload
The following script measures a small URL set. It intentionally keeps the workload and cache policy constant. Replace the URLs with representative pages from your application and run enough iterations to observe stable results.
const puppeteer = require('puppeteer');
const urls = [
'https://example.com/',
'https://example.org/'
];
async function run(headlessMode) {
const browser = await puppeteer.launch({
headless: headlessMode,
// Keep Puppeteer's defaults unless a tested requirement says otherwise.
timeout: 30000
});
const started = process.hrtime.bigint();
const results = [];
try {
for (const url of urls) {
const page = await browser.newPage();
await page.setCacheEnabled(true);
const pageStart = process.hrtime.bigint();
let ok = false;
try {
await page.goto(url, { waitUntil: 'load', timeout: 30000 });
await page.screenshot({ type: 'png' });
ok = true;
} finally {
results.push({
url,
ok,
ms: Number(process.hrtime.bigint() - pageStart) / 1e6
});
await page.close();
}
}
} finally {
await browser.close();
}
return {
headlessMode,
totalMs: Number(process.hrtime.bigint() - started) / 1e6,
results
};
}
(async () => {
for (const mode of [true, 'shell']) {
console.log(JSON.stringify(await run(mode), null, 2));
}
})();Run each mode several times, discard only runs you exclude in advance (for example, a known network outage), and report the exclusion rule. A lower mean time is not a win if the shell misses a required API, renders differently, or raises the failure rate. Include cold-cache and warm-cache results when production experiences both.
Control caching deliberately
Puppeteer enables page caching by default and exposes page.setCacheEnabled(). A warm cache can make a run look dramatically faster while hiding the cost of a first visit. Decide which behavior represents production, then apply it identically to every mode.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Warm-cache comparison
Leave caching enabled and reuse the same browser and page lifecycle for both modes. This models repeated visits where resources are likely available locally.
Rank #2
- Storage: 16GB Flash Memory
- OS: Chrome OS
- Screen Size: 11.6"
Cold-cache comparison
Call await page.setCacheEnabled(false) before navigation, or isolate runs so that each mode starts with equivalent storage and network conditions. Disabling cache changes the workload; it does not make the browser intrinsically faster.
Launch arguments: change one thing at a time
The launch API accepts args, but Puppeteer cautions that its default arguments should generally be retained. Start with no extra flags. Add one documented, necessary argument, rerun the correctness checks, and keep it only if it improves the metric you actually care about without introducing failures.
ignoreDefaultArgs deserves particular caution: removing defaults can prevent Chrome from starting, alter sandboxing, or change automation behavior. It is not a general performance switch. If a container requires a launch adjustment, document the security and operational reason separately from the benchmark result.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Options that are not speed controls
slowMointentionally slows Puppeteer operations for debugging.dumpioforwards browser-process logs to Node output; use it to diagnose startup or page failures, not to optimize throughput.timeoutcontrols how long Puppeteer waits before failing. Increasing it can reduce false timeout errors on slow pages, but it does not accelerate page execution.devtools: trueforces headful mode and therefore changes the comparison.
Choose the right mode for your workload
Use ordinary new headless Chrome when compatibility is the priority
Choose headless: true when your automation depends on the complete Chrome feature set, when output must match headful Chrome closely, or when you use APIs that the shell does not implement identically. It is the appropriate baseline for screenshots, PDFs, interaction-heavy flows, and pages whose correctness you have not yet characterized.
Try the shell for narrowly defined automation
Test headless: 'shell' when the job is a straightforward automation task and does not need all of Chrome. Puppeteer’s documentation says the shell is currently more performant in that situation, but the statement is conditional and qualitative. The shell may behave differently, so verify navigation, JavaScript APIs, fonts, media, downloads, screenshots, PDFs, authentication, and any site-specific checks your job relies on.
Rank #3
- Intel Processor Up to 2.80GHz, 4GB DDR4, 128GB Storage
- 15" FHD IPS Display, Intel UHD Graphics
- 1x USB Type C, 1 x USB Type A, 1x Headphone/Microphone Combo Jack, HDMI
- Super Fast WiFi and Bluetooth, Integrated Webcam
- Chrome OS, AC Charger Included, Pastel Blue
Do not claim a winner without measuring
There is no official percentage or benchmark table that applies to every page. Network latency, JavaScript execution, image decoding, rendering, concurrency, cache state, and container limits can dominate the result. A mode that wins on a static page may lose on a client-rendered application.
Improve throughput without sacrificing correctness
Reuse browsers carefully
Launching a browser for every URL adds startup cost. Reusing one browser and creating or recycling pages can increase throughput, but cap concurrency to the CPU and memory available. Measure browser-level memory and per-page failures; unlimited parallel pages often turn a faster single job into a slower, unstable queue.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Make waits match the product requirement
waitUntil: 'load', network-idle waits, selector waits, and fixed delays measure different outcomes. A shorter wait can look faster while capturing incomplete content. Define a readiness condition that represents the artifact you deliver, then use that same condition in both headless modes.
Keep outputs comparable
Use the same viewport, device scale factor, fonts, locale, timezone, permissions, cookies, and screenshot or PDF options. Compare pixels or extracted assertions where visual fidelity matters, and record functional failures separately from timing.
Troubleshooting common failures
Chrome fails to launch
Check the Puppeteer and Node versions, available executable dependencies, sandbox permissions, and container limits. Remove newly added arguments and retry with the downloaded Chrome for Testing binary. If the default mode starts but the shell does not, treat that as a compatibility result rather than repeatedly adding undocumented flags.
Rank #4
- THE BETTER WAY TO LAPTOP – Imagine a Chromebook that’s as flexible as your day: thin and lightweight with built-in Google apps and stress-free security.
- TAKE HITS KEEP MOVING – Sleek, light, and built to last- the Chromebook 2-in-1 is just 0.69” thick and 3.3lbs. Enjoy long-lasting battery life, fast charging, and military-grade durability for nonstop productivity wherever life takes you.
- PERFORMANCE THAT MATCHES YOUR HUSTLE – Fuel your ideas with an Intel Core processor and 128GB storage. Boot up in under 10 seconds to start the day powerfully efficient.
- FLEX YOUR CREATIVITY ANYWHERE, ANYTIME – Create, work, or unwind your way with a versatile 2-in-1 design. Flip easily between laptop, tent, and tablet modes with a responsive touchscreen built for flexibility.
- BRILLIANT VIEWS AND IMMERSIVE AUDIO – See, hear, and create with awesome clarity. The WUXGA display brings rich detail to your work and play, while audio tuned by Waves MaxxAudio provides immersive, balanced sound.
The shell is faster but output is wrong
Identify the first failing feature: missing browser API, different rendering, unsupported media behavior, authentication state, or an altered wait condition. Use headless: true for that workflow unless you can redesign the task without the required feature.
Runs time out
Confirm that the URL is reachable from the test machine and that the readiness condition is attainable. Log the URL and navigation error, then distinguish a slow page from an unreachable page. Raising the 30,000 ms default timeout may prevent premature failure, but it does not improve performance.
Results vary widely
Stabilize concurrency, CPU allocation, network location, cache state, and page data. Run both modes in alternating order to reduce time-of-day and host drift. Record p95 latency and error rate instead of relying on one unusually fast run.
Memory grows during a batch
Check whether pages are closed, whether listeners and references are retained, and whether concurrency is too high. Compare one browser with multiple pages against several smaller browser processes. A lower latency number is not useful if the process is eventually killed by its memory limit.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
If your goal is a clean website screenshot rather than controlling Puppeteer itself, ScreenshotNeo provides a single HTTP call. It accepts consent banners as a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each cleanup step can be disabled. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers identify the page verdict and whether the shot was billed. Its MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsSee the complete parameter reference in the ScreenshotNeo documentation. This cURL request returns a WebP image:
Best Value
- Storage: 16 GB Flash Memory
- OS: Chrome OS
- Screen Size: 11.6"
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpThe same request in Python:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)And in Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);ScreenshotNeo includes full-page capture with lazy images loaded, CSS-selector element capture, dark mode, 12 device presets plus custom viewports, retina scale, PDF controls, custom CSS and JavaScript, pre-capture clicks, hidden selectors, selector/delay/network-idle waits, request and resource blocking, custom headers/cookies/user agents and Authorization, timezone and geolocation, transparent backgrounds, resizing, selectable cache TTLs, signed image links, asynchronous jobs with signed webhooks, bulk capture for up to 100 URLs per call, a usage API, an OpenAPI specification, and compatibility with parameter names used by other screenshot APIs.
The Free plan includes 1,000 screenshots each month with no card. Paid plans start at $5 for 3,000 shots; every feature is included on every plan. Create a free ScreenshotNeo account to get started.
Cost and reliability considerations
For self-hosted Puppeteer, account for browser startup, CPU, memory, container density, network egress, and engineering time spent on upgrades and failed pages. Keep Puppeteer’s downloaded browser aligned with the package version and recheck the supported-browser mapping when upgrading.
Free tools Windows power users keep installed
One-click scans. No signup required.
For either headless mode, define what constitutes a successful job. Record status, elapsed time, output size, and a correctness assertion. Retries should be bounded and should distinguish transient network failures from deterministic rendering or compatibility failures. A benchmark that omits failed jobs can make an unreliable configuration appear fast.
A practical decision checklist
- Pin and record Puppeteer, Chrome for Testing, Node.js, and host versions.
- Run a representative workload with
headless: trueand default launch arguments. - Repeat with
headless: 'shell'while holding cache, waits, concurrency, and outputs constant. - Measure throughput, latency distribution, memory, error rate, and correctness.
- Test cold and warm cache behavior when both occur in production.
- Change only one launch argument at a time, retaining Puppeteer defaults unless a requirement justifies a change.
- Choose the shell only when its measured benefit outweighs any missing feature or fidelity difference.
- Re-run the comparison after Puppeteer or Chrome upgrades.
Frequently Asked Questions
What does Puppeteer use if I omit the headless option?
It defaults to headless: true, which launches new headless Chrome.
Is headless: 'shell' guaranteed to be faster?
No. Puppeteer describes it as currently more performant for automation that does not need the complete Chrome feature set, without publishing a universal percentage.
Should I disable the cache when benchmarking?
Only if a cold-cache workload matches your production case. Otherwise leave caching enabled and keep the setting identical for both modes.
What Puppeteer version and browser mapping should I use?
Use the Chrome for Testing binary Puppeteer downloads by default, then check the supported-browser mapping for the exact Puppeteer version you adopt; mappings change over time.
Quick 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.
