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 →Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
For a fair Puppeteer performance comparison, first measure your workload with its bundled Chrome for Testing in the default new headless mode, then run the same workload with headless: 'shell'. Puppeteer describes chrome-headless-shell as potentially more performant for automation that does not need the complete Chrome feature set, but publishes no universal speedup. Keep the browser version, pages, cache behavior, waits, and concurrency consistent; compare correctness, latency, throughput, and memory before choosing.
What Puppeteer’s headless options actually select
In current Puppeteer, headless: true is the default and launches new headless Chrome. Setting headless: 'shell' selects the old headless mode, which runs as a separate chrome-headless-shell program. They are not simply two names for the same browser executable.
Puppeteer documentation says the shell does not match regular Chrome behavior completely, but is currently more performant for automation tasks that do not need the complete Chrome feature set. Treat that as a conditional reason to test it, not a promise of a particular percentage or a result for every page. If your task depends on behavior that differs between shell and regular Chrome, compatibility and output correctness matter more than a faster run.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Establish a trustworthy baseline
Use the Chrome for Testing binary Puppeteer downloads by default as your starting point. Puppeteer says it works best with that version and does not guarantee behavior with other browser versions. Since Puppeteer v20, it uses Chrome for Testing for Chrome automation; current documentation describes headful and new headless modes as sharing the same code path, while the old headless shell is separate.
#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.
The official supported-browser page identified Puppeteer v25.12.0 with Chrome for Testing 154.0.8037.57 and Firefox 156.0.1 when retrieved. These mappings change; check the page for the version you actually install rather than assuming this mapping remains current. The launch API reference retrieved was also v25.12.0.
Record the conditions that affect results
- Puppeteer and browser versions, operating system, and available CPU and memory limits.
- The actual URLs or representative page set, including whether pages are static, script-heavy, or load substantial assets.
- Navigation and wait strategy: for example, which navigation event or selector signals that capture work can begin.
- Concurrency and whether runs are cold-started or reuse a browser process.
- Cache state and whether you are optimizing a first visit or repeat visits.
- The metric you care about: throughput, end-to-end latency, peak memory, or a balance of these, plus checks that results remain correct.
Use a repeatable sample
Run enough repetitions to see ordinary variation rather than relying on one unusually quick or slow run. Apply the same pages in the same order and at the same concurrency for both modes. Record failures as well as successful timings: a configuration that finishes quickly only because pages did not load is not a performance win.
Measure the complete operation your application needs, including navigation, waits, and screenshot or other work. If startup time is important in production, include browser launch; if a long-lived browser is reused, measure that separate pattern too. Do not compare a cold launch in one mode with a warm browser in the other.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Rank #2
- Storage: 16GB Flash Memory
- OS: Chrome OS
- Screen Size: 11.6"
Compare the two modes with a controlled test
This minimal Node.js script runs the same URL list in either mode, measures elapsed time per page, and reports failures instead of silently counting them as fast captures. It is a starting point: adapt the wait condition and correctness checks to your real job. Install Puppeteer in the project with npm install puppeteer; its default installation uses the browser build it supports.
const puppeteer = require('puppeteer');
const { performance } = require('node:perf_hooks');
const urls = [
'https://example.com/',
'https://example.org/',
];
async function main() {
const mode = process.env.HEADLESS_MODE || 'true';
const headless = mode === 'shell' ? 'shell' : true;
const browser = await puppeteer.launch({ headless });
const results = [];
try {
for (const url of urls) {
const page = await browser.newPage();
const started = performance.now();
try {
const response = await page.goto(url, {
waitUntil: 'domcontentloaded',
timeout: 30000,
});
const elapsedMs = Math.round(performance.now() - started);
results.push({
url,
status: response ? response.status() : null,
elapsedMs,
ok: Boolean(response && response.ok()),
});
} catch (error) {
results.push({ url, elapsedMs: Math.round(performance.now() - started), error: error.message });
} finally {
await page.close();
}
}
} finally {
await browser.close();
}
console.log(JSON.stringify({ mode, results }, null, 2));
}
main().catch(error => {
console.error(error);
process.exitCode = 1;
});Run both configurations under the same conditions:
node benchmark.js
HEADLESS_MODE=shell node benchmark.jsIn production, add your own assertion that the expected page content or screenshot is present. domcontentloaded is only an example wait condition; it does not guarantee that a site’s client-side rendering, lazy images, or other asynchronous work is finished. Pick a wait condition that represents your actual completion criteria and use it unchanged for both runs.
Read the results as a trade-off
- Compare successful runs on latency and throughput, not just the best single observation.
- Track memory under your intended concurrency. A faster single page may not be the best choice if the mode uses more resources when many pages run together.
- Compare response status, extracted values, or image output against the expected result. Investigate any mode-specific failures before making a performance decision.
- Re-run on the machine or container limits you will deploy. A local developer machine result does not establish production behavior under different CPU or memory constraints.
Options that matter—and options that do not make it faster by definition
Keep cache behavior consistent
Puppeteer enables page caching by default. You can toggle it with page.setCacheEnabled(). Leave it at the same setting in both comparisons. A cache-enabled repeat visit and a cache-disabled first visit measure different workloads; choose the one that reflects your users or job queue.
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
// Use the same setting in both benchmark runs.
await page.setCacheEnabled(true); // or false, if that matches your target workloadChange launch arguments cautiously
The launch API accepts additional browser args, but Puppeteer cautions that default arguments should generally be retained. Do not paste a list of purported “speed flags” into production as a universal fix. Change one argument at a time, record the exact configuration, and verify that the browser starts and still produces correct output. Use ignoreDefaultArgs carefully: changing Puppeteer’s defaults can alter behavior as well as performance.
Keep diagnostic settings in their lane
slowMo deliberately slows Puppeteer operations and is documented as a debugging aid, not an optimization. dumpio forwards browser process output to Node.js, which can help diagnose startup or browser errors; it is not a speed control. The launch API’s default timeout is 30,000 ms. Raising a timeout may allow a slow operation more time to finish, but does not make it execute faster. Setting devtools forces headful mode, so it changes the comparison rather than tuning headless performance.
Choose the mode that fits the job
| Choice | What it means | When to test it | Trade-off to verify |
|---|---|---|---|
headless: true |
Default new headless Chrome. | Use as the baseline for ordinary Chrome automation and when matching regular Chrome behavior matters. | Measure it against your workload; no universal performance figure is published. |
headless: 'shell' |
Runs the separate chrome-headless-shell old-headless program. |
Test for automation that does not require the full Chrome feature set. | Behavior does not completely match regular Chrome; validate features and results before adopting it. |
There is no documentation-based winner for every workload. The useful decision is the mode that meets your correctness requirements and performs best on your own representative pages, machine, and concurrency.
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.
Troubleshoot misleading results and failures
The shell mode is not faster
That does not contradict Puppeteer’s guidance: its performance description is conditional and qualitative, not a measured promise. Check that both runs use the same browser/Puppeteer setup, cache state, page set, waits, and concurrency. If the difference is within run-to-run variation, treat the result as inconclusive and collect more consistent repetitions.
A page times out or appears incomplete
Check whether the wait event is appropriate for the page and whether client-side content appears after navigation completes. Use a selector or application-specific readiness check when necessary. Keep that condition the same between modes; otherwise, a shorter wait can look like a speed improvement while capturing incomplete content.
The browser fails to launch after changing arguments
Remove the last argument you added and retry with Puppeteer’s defaults. Confirm that you have not discarded defaults via ignoreDefaultArgs. Then add only the required argument back and check startup and output before measuring again.
Best Value
- Storage: 16 GB Flash Memory
- OS: Chrome OS
- Screen Size: 11.6"
Timings change sharply between runs
Look for differences in cache state, browser reuse, page order, concurrency, available machine resources, and external page load behavior. Record whether the run used a warm or cold browser and whether it reused cached resources. Avoid comparing observations taken under different conditions.
Logs are needed to understand a browser problem
Use the launch option dumpio: true to forward browser process logs to Node.js output. Treat this as diagnosis: inspect the error, then repeat the performance measurement with the intended production configuration.
Or skip the browser setup
If your goal is simply to get a website screenshot rather than tune a Puppeteer worker, ScreenshotNeo is a website screenshot API and MCP server for developers. Its API takes a URL in one GET request and returns an image or PDF. The following cURL call saves a WebP screenshot; create an API key and see the ScreenshotNeo API documentation for options.
PC 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 & 11Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchcurl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpScreenshotNeo accepts cookie or consent banners as a visitor and removes 60+ known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers identify the page verdict and billing status. Its MCP server provides screenshot and PDF tools for AI agents, including Claude, Cursor, and other MCP clients. The free plan includes 1,000 shots a month with no card; paid plans start at $5 for 3,000 shots. Sign up free for 1,000 screenshots a month, with no card required.
Frequently Asked Questions
Does Puppeteer still support Firefox?
The supported-browser page retrieved for Puppeteer v25.12.0 listed Firefox 156.0.1, alongside Chrome for Testing. Check the supported-browser mapping for the Puppeteer version you install.
Can I use an arbitrary installed Chrome version for this comparison?
Puppeteer says it works best with the Chrome for Testing version it downloads by default and makes no guarantee for other versions. Using another binary can be useful for a specific compatibility requirement, but it changes the basis of the comparison.
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.
