Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Measure a defined workload in a defined environment, not “the browser” in the abstract. A useful headless benchmark records the browser build and headless mode, operating system or container, CPU and memory, viewport, cache and storage state, network and CPU conditions, URL, authentication, interactions and waits. Run the same workload repeatedly, save raw metrics and traces, and report variation. A single Lighthouse score from one run is not a universal prediction of every visitor’s experience.
What a headless-browser measurement actually tells you
Headless mode removes the visible window; it does not remove the variables that determine performance. Your result describes a particular browser version, host, page state and workload. It is excellent for controlled comparisons and regression detection when those inputs stay fixed. It is not, by itself, a field measurement of every device, network or browser engine.
Current Chrome documentation says unified Headless and headful modes share Chrome browser code. Since Chrome 132.0.6793.0, the former implementation is also available as the separate chrome-headless-shell binary. Puppeteer exposes headless: true for current Headless, headless: 'shell' for Headless Shell and headless: false for headful mode. Record the mode explicitly and do not silently combine results from these modes.
Start with the question, then choose the instrument
| Question | Best starting point | What to retain |
|---|---|---|
| How fast does a navigation load? | Lighthouse navigation audit | Report artifact, Lighthouse version and raw metric values |
| Why is a page or interaction slow? | Chrome Performance trace | Trace file and the matching workload description |
| How long does an application phase take? | User Timing marks and measures | Named intervals in the trace or report |
| Does animation remain smooth? | Performance trace and Performance monitor | FPS, CPU, main-thread, layout and style activity |
Lighthouse compresses several metrics into a score, and its scoring weights and distributions change over time. Always keep the raw values and tool version alongside the score. A trace is chronological evidence: inspect CPU and main-thread tracks for script, rendering and other work; use FPS when animation is part of the workload. DevTools Performance monitor can show CPU, heap, DOM nodes, event listeners, frames, layout and style recalculations while you interact with the page.
Free tools Windows power users keep installed
One-click scans. No signup required.
#1 Best Overall
- Used Book in Good Condition
Build a benchmark manifest before running it
Write the conditions down in a machine-readable file or CI log. The complete manifest below is a reproducibility recommendation assembled from the configuration factors that affect Lighthouse, DevTools and Puppeteer results.
- Browser name, exact version and mode (
true,'shell'or headful). - Operating-system or container-image identifier, CPU allocation, memory limit and relevant launch flags.
- Viewport dimensions, device scale factor and whether the capture is full-page.
- URL, authentication state, test data, feature flags and fixed interaction sequence.
- Cold (first visit) or warm (repeat visit) definition. For cold runs clear cookies, local storage, indexedDB and cache; for warm runs preserve them consistently.
- Network route and conditions, CPU throttling method, timezone and geolocation where they affect the page.
- Extensions, antivirus, A/B-test assignment and traffic-routing assumptions. These can alter Lighthouse results.
- Wait rules: navigation completion, selector visibility, network idle, explicit delays and any screenshot timing.
Keep a copy of the manifest with every report and trace. If a result changes, you can determine whether the page changed or the laboratory did.
Automate a repeatable navigation with Puppeteer
The following Node.js example launches current Chrome Headless, applies a fixed viewport, records a trace, adds User Timing marks and saves a screenshot. Pin Puppeteer and the browser revision in your project or container so upgrades are intentional.
import puppeteer from 'puppeteer';
const browser = await puppeteer.launch({
headless: true,
args: ['--no-sandbox'] // use only when your container policy requires it
});
const page = await browser.newPage();
await page.setViewport({ width: 1365, height: 768, deviceScaleFactor: 1 });
await page.tracing.start({
path: 'trace.json',
screenshots: true,
categories: ['devtools.timeline', 'disabled-by-default-devtools.timeline']
});
await page.evaluateOnNewDocument(() => {
performance.mark('benchmark-start');
});
await page.goto('https://example.com/app', { waitUntil: 'domcontentloaded', timeout: 90000 });
await page.waitForSelector('#app-ready', { visible: true, timeout: 30000 });
await page.evaluate(() => {
performance.mark('app-ready');
performance.measure('navigation-to-app-ready', 'benchmark-start', 'app-ready');
});
await page.screenshot({ path: 'after-ready.webp', fullPage: true, type: 'webp' });
await page.tracing.stop();
console.log(await page.evaluate(() => performance.getEntriesByType('measure')));
await browser.close();Replace the URL, selector and application milestone with values in your test. Use a separate run for a warm-cache question rather than mixing cold and warm navigations in one distribution. For complex workflows, use Puppeteer clicks, form input and waits exactly as a real test would, then mark each user-visible phase.
Rank #2
Use throttling deliberately
Simulated throttling
Lighthouse can simulate network and CPU conditions and extrapolate a result. This is efficient for automated page-load audits, but the number is an estimate under the model you selected.
Applied DevTools throttling
DevTools can actually throttle CPU and network. It takes longer, but the page experiences the constrained conditions during execution. State which method you used; do not call either method a physical mobile-device test. Neither substitutes for testing other browser engines, hardware architectures or field data.
Capture the metrics that answer your question
Navigation and page-load audits
Run Lighthouse with a pinned version and retain its complete JSON or HTML artifact. Report the individual metric values and the score separately. The score is a convenience summary, not a stable physical quantity; scoring changes and environmental factors such as routing, extensions, antivirus and experiments can move it.
Runtime diagnosis
Open the saved trace in Chrome DevTools. Start with the CPU and main-thread tracks: long script tasks, style and layout work, painting and garbage collection often explain a slow interaction. Check network activity and screenshots for ordering. If the workload animates, inspect frames and FPS. Use Performance monitor during the interaction to correlate CPU, heap, DOM, listeners, layout and style recalculation changes.
Recommended Free Tools
Rank #3
Application milestones with User Timing
When “load” does not describe the user-visible outcome, add performance.mark() at the start and end of the phase and performance.measure() between them. Lighthouse and Chrome trace data can expose these intervals. Name marks around events such as route-ready, search-results-rendered or checkout-confirmed; avoid unnamed timers that cannot be interpreted later.
Server contribution
The Server-Timing response header can report a server-side duration to the browser. Treat older server-rendering examples as API illustrations for that header, not as current benchmark guidance or a general expected timing.
Make runs comparable and statistically honest
- Establish a baseline with the manifest, report and trace saved as artifacts.
- Run repeated samples under unchanged conditions. There is no universal repetition count; continue until the distribution is stable enough for your decision.
- Report a central value (such as median) and spread (such as percentile range or standard deviation), plus every important outlier and its cause.
- Change one factor—code, asset, browser flag or server response—then repeat the same workload.
- Compare raw metrics first, then use the trace to explain the mechanism behind a difference.
Do not cherry-pick the fastest run. A cold-cache median and a warm-cache median answer different questions. Keep authentication, data volume, consent state, ad blocking, viewport and waits identical when comparing implementations.
Common failures and fixes
| Symptom | Likely cause | Fix |
|---|---|---|
| Different scores on identical commits | Browser or Lighthouse update, CPU contention, routing, A/B test, extension or antivirus | Pin versions and container resources; record routing and experiments; repeat runs and inspect spread. |
| “Element not found” timeout | Selector appears after an API response, in an iframe or only after interaction | Wait for the correct frame or network state, use a stable selector and mark the actual readiness condition. |
| Trace is empty or too short | Tracing stopped before work occurred or the page crashed | Start tracing before navigation, stop after the final interaction, and save console and page-error logs. |
| Cold and warm results are mixed | Storage and cache were not reset consistently | Use separate jobs with explicit clearing or preservation and label them. |
| Headless differs unexpectedly from CI | Different mode, binary, flags, fonts, OS or resource limits | Log the executable path, version, mode, launch flags, image digest, CPU and memory; compare manifests. |
| “Fast” result is not representative | Simulated throttling or a single synthetic host was treated as a user measurement | Describe the result as applying to the tested conditions and supplement it with field or cross-browser evidence when needed. |
Performance, reliability and cost considerations
Tracing, screenshots and repeated runs consume CPU, memory and storage. Use a fixed worker count in CI, avoid running unrelated jobs on the same host, and archive only the artifacts needed for diagnosis. Browser startup can dominate very short tests; reuse a browser within a controlled job, but create a fresh context when isolation is required. Longer waits improve determinism only when they represent a real readiness condition; arbitrary delays can hide regressions.
Headless measurements are strongest for relative decisions inside one controlled setup. For a release gate, define a metric threshold and an acceptable spread, not just a score threshold. Re-run suspicious failures before blocking a build, and retain the failing trace so the change is diagnosable.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
If your task is obtaining a clean, repeatable website image rather than diagnosing browser internals, ScreenshotNeo provides a hosted screenshot API and MCP server. A single request can return PNG, JPEG, WebP or PDF. Before capture it accepts the cookie or consent banner like a visitor and removes more than 60 known consent platforms, newsletter popups and chat widgets; each 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 billing status.
Use the ScreenshotNeo API documentation for the complete option list. This cURL request captures Stripe as WebP:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpPython:
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)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}`);For AI-driven workflows, its MCP server exposes take_screenshot, get_page_info and capture_pdf to Claude, Cursor and other MCP clients. Features include full-page lazy-image loading, CSS-element capture, dark mode, 12 device presets or any viewport, retina scale, PDF paper and page controls, HTML/CSS rendering, custom JavaScript and CSS, clicks, selector waits, network-idle waits, request and resource blocking, headers, cookies, user-agent and Authorization, timezone and geolocation, transparency, resizing, configurable-TTL caching, signed image links, asynchronous signed webhooks, 100-URL bulk calls, a usage API and an OpenAPI specification. Existing parameter names used by other screenshot APIs also work.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated 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 matchThe Free plan includes 1,000 shots per month with no card. Paid plans start at $5 for 3,000 shots; yearly billing gives two months free, and every feature is included on every plan. Create a free ScreenshotNeo account to try it.
Best Value
FAQ
Should I benchmark Chrome Headless Shell and current Headless together?
No. They are distinct modes and should have separate baselines and reports.
Can a Lighthouse score serve as a service-level objective?
Only with a pinned Lighthouse version, defined environment, raw-metric thresholds and an explicitly monitored run distribution.
When should I add field data?
Add it when the decision concerns real users across devices, networks, locations or browser engines; a headless lab result cannot establish those conditions.
Frequently Asked Questions
How many repetitions are enough?
There is no universal count. Run enough samples to characterize noise for your own page, host and decision, then publish the central value and spread.
Is headless always faster than headful?
Not as a general claim. Compare the exact browser mode, version, host resources and workload you care about.
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.
