Free tools Windows power users keep installed
One-click scans. No signup required.
To read page performance with Puppeteer, collect three different kinds of evidence separately: browser counters from page.metrics(), document-navigation milestones from the Performance API, and user-facing Core Web Vitals such as LCP, CLS, and INP. They are not interchangeable measures of “page speed.” A load event or a low JavaScript heap reading cannot, on its own, show whether the main content appeared quickly or whether the page stayed responsive.
Collect Puppeteer metrics and navigation timings
Navigate under an explicitly chosen wait condition, then read Puppeteer’s metrics and the browser’s navigation timing entry. This example reports the HTTP status when a response exists, a snapshot of Puppeteer counters, and selected navigation milestones:
As an Amazon Associate I earn from qualifying purchases.
const response = await page.goto(url, { waitUntil: 'load' });
const pptrMetrics = await page.metrics();
const browserTimings = await page.evaluate(() => {
const nav = performance.getEntriesByType('navigation')[0];
return nav ? {
startTime: nav.startTime,
domInteractive: nav.domInteractive,
domContentLoadedEventEnd: nav.domContentLoadedEventEnd,
domComplete: nav.domComplete,
loadEventEnd: nav.loadEventEnd,
} : null;
});
console.log({ status: response?.status(), pptrMetrics, browserTimings });page.evaluate() runs the supplied function in the page context and awaits a returned promise. The function above reads the first navigation entry; if there is no entry, it returns null. See the Puppeteer page.evaluate() reference.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →This is an API usage pattern, not a benchmark or a claim about a particular site’s results. Consult the Puppeteer Page class reference and Metrics interface for the version you run; the API pages surfaced as version 25.12.0 when reviewed, and API versions can change.
#1 Best Overall
Choose what navigation completion means
waitUntil: 'load' waits for the document’s load lifecycle event. A network-idle condition uses a network-idle interval, but neither condition proves that an application is visually complete or that interactions have finished. Choose the condition that matches the question being tested, and record it with the result. For example, a page that renders its main content after the load event needs a separate, application-relevant readiness condition if that content is the target of the measurement.
Understand Puppeteer’s counters
page.metrics() reports browser-side counters such as document and frame counts, JavaScript event-listener count, and total and used JavaScript heap size. These describe aspects of the page’s runtime and memory at the time you collect them. They are not elapsed navigation milestones or direct measurements of what a user saw.
Read the units and clock correctly
Puppeteer documents its timestamps as monotonic seconds from an arbitrary point in the past, not wall-clock dates. Do not compare them directly with Unix timestamps unless you have a defined conversion. The Metrics interface lists JavaScript heap sizes in bytes; check the field and unit before comparing values. A value without its unit, collection point, and run conditions is easy to misread.
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 →Rank #2
Interpret Navigation Timing as phases, not user experience
The browser’s navigation entry describes milestones in a document navigation. The selected values in the example are offsets associated with that navigation entry; they help explain when phases completed, but do not measure every aspect of perceived responsiveness or visual stability. See MDN’s Navigation timing guide.
startTimeis the beginning of the navigation timing entry.domInteractivemarks the point at which DOM construction has finished and interaction with the DOM from JavaScript is possible.domContentLoadedEventStartanddomContentLoadedEventEndbracket the DOMContentLoaded event handling. The example returns the end milestone; add the start field if you need the interval.domCompletemarks completion of the document and its subresources.loadEventStartandloadEventEndbracket the load event handler. The example returns the end milestone; include the start field if you need to inspect the handler interval.
DOMContentLoaded and load can help locate a slow navigation phase, but neither establishes that the most important content rendered quickly, the layout remained stable, or the page responded promptly to user input.
Keep browser counters, navigation timings, and Web Vitals distinct
| Measurement layer | What it answers | Where and when evidence comes from |
|---|---|---|
Puppeteer page.metrics() |
What browser counters and JavaScript memory values were reported at collection time? | A controlled Puppeteer browser run, collected at the point your script calls the method. |
| Navigation Timing | How did the document navigation progress through its browser-reported milestones? | A navigation entry in the page context, read after the selected wait condition or other defined point. |
| Core Web Vitals: LCP, CLS, and INP | How did loading, visual stability, and interaction responsiveness affect users? | Instrumented visits and field data, or an appropriately designed lab scenario; these are not supplied by page.metrics(). |
Google’s Web Vitals guidance identifies LCP, CLS, and INP as the stable Core Web Vitals. Use instrumentation designed for those experience metrics when you need them. The guidance recommends aggregating data and checking thresholds for at least 75% of page visits; the reviewed page does not state a year for that guidance. It also notes that JavaScript API measurements may differ from CrUX, Google’s anonymized real-user measurement data, and points to the web-vitals library as a production-ready wrapper designed to match Google tools.
Controlled Puppeteer runs are useful for repeatable diagnosis, while field data represents real visits and a wider range of user conditions. Use them as complementary evidence, not as substitutes. A lab result can help reproduce a regression; representative field data helps establish whether users experience it.
Make Puppeteer runs comparable
Performance numbers are only meaningfully comparable when the test setup and page scenario are controlled and recorded. Puppeteer exposes controls for viewport and device emulation, CPU and network conditions, cache, and service-worker behavior. Set viewport or device conditions before navigation when appropriate: changing them later can resize or reload the page.
- Record the URL, browser build, Puppeteer version, and date of the run.
- Set and record the viewport or device emulation before navigation.
- Record whether the run used a warm or cold cache, and how service workers were handled.
- Record network and CPU throttling conditions, plus the navigation wait condition.
- State whether the scenario includes an interaction and when metrics are collected relative to it.
- Repeat runs under the same conditions before treating small differences as meaningful; do not combine unlike setups into one comparison.
Chrome DevTools supports network and CPU throttling, but its documentation cautions that CPU throttling is relative to the host computer and does not truly simulate mobile CPU architecture. Report it as a test condition, not a perfect stand-in for a real phone. See the Chrome DevTools Performance features reference.
Rank #4
Diagnose common interpretation and collection problems
The reported time seems like a date or is on the wrong scale
Puppeteer timestamps are monotonic seconds from an arbitrary starting point, not Unix time. Keep them as elapsed-time values and compare values collected on a compatible basis; do not label them as clock time.
Heap values do not match another tool’s display
The Metrics interface gives heap sizes in bytes. Confirm the field and unit, and make sure both readings were collected at comparable points in the same kind of run before drawing a conclusion.
The script reports load completion, but the page still looks unfinished
The load event is a lifecycle milestone, not proof that an application’s important content has rendered or that all visual changes have stopped. Choose a readiness condition tied to the content under test, and use visual or Web Vitals instrumentation for user-facing questions.
Best Value
- Used Book in Good Condition
There is no navigation timing entry
The example returns null if performance.getEntriesByType('navigation')[0] is absent. Check that evaluation ran in the expected page context after navigation and that the page has a navigation entry; retain the null case rather than treating it as a numeric measurement.
Two runs disagree despite using the same URL
Compare the browser and Puppeteer versions, viewport, cache and service-worker state, network and CPU settings, wait condition, and interaction scenario. A URL alone does not define a reproducible performance test.
Or skip the browser setup
If you need a screenshot rather than browser performance counters or timing instrumentation, ScreenshotNeo provides a website screenshot API and MCP server. A single request can return an image or PDF, but a screenshot does not replace page.metrics(), Navigation Timing, or Web Vitals data.
See the ScreenshotNeo documentation for request options. Example cURL request:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpBefore capture, ScreenshotNeo can accept cookie or consent banners and remove more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, with response headers indicating the page verdict and billing status. Its MCP server includes take_screenshot, get_page_info, and capture_pdf for AI agents. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 shots.
Sign up for ScreenshotNeo’s free plan to try 1,000 screenshots a month with no card.
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.
