Best Page Speed Test Tools 2027: 7 Picks and 20 Test Runs

The best page speed test tools for 2027, free and paid, plus what 10 PageSpeed Insights runs on one page showed: scores of 91 to 99, LCP failing 8 of 10 times.

· BugViso Team

13 min read

The best page speed test tools for 2027 are PageSpeed Insights for a free lab-plus-field check, Chrome DevTools for finding the cause, the Chrome UX Report for real-user data, GTmetrix for tests from many locations, DebugBear for monitoring, and BugViso for testing every page of a site in one run. Each answers a different question.

The bigger lesson came from testing one tool against itself. We ran PageSpeed Insights 10 times on the same unchanged page: the score ranged from 91 to 99, and its lab LCP passed Google's 2.5-second "good" line in only 2 of the 10 runs.

By the end you will know which tool to use for each speed question, why one test is never enough, and how to run repeat tests for free with the script below.

Data used: PageSpeed Insights API v5, mobile strategy, performance category only, run on 2026-11-16 against two pages of bugviso.com (the homepage and one blog post), 10 runs each with a unique query string per run to avoid cached results, 5 seconds apart. A first set of 5 back-to-back runs per page without the query string is reported separately. Neither page had Chrome UX Report field data. Tool facts come from each vendor's own page, fetched the same day. We make BugViso, one of the tools listed.

Best Page Speed Test Tools at a Glance

Use a lab tool to debug, a field data source to judge, and a site-wide tool to find which pages need work. Mixing these up is the most common reason speed work doesn't move rankings or conversions.

ToolBest forData typePrice
PageSpeed InsightsA quick check of one URLLab (Lighthouse) + field (CrUX)Free
Chrome DevTools (Lighthouse and Performance panel)Finding the exact cause of a slow pageLab, on your own machineFree
Chrome UX Report (CrUX)Real-user Core Web Vitals over 28 daysFieldFree
GTmetrixTesting from different locationsLab (Lighthouse in real Chrome)Free tier, paid plans
DebugBearOngoing monitoring of key pagesLab + CrUX + real-user monitoringPaid, free trial
BugVisoSpeed plus SEO and accessibility on every crawled pageLab, with CrUX field data when Google has itFirst report free, then $1.49 per report

That is six rows for seven picks because DevTools holds two tools in one: the Lighthouse panel and the Performance panel.

What 20 PageSpeed Insights Runs on One Page Showed

Lab scores move between runs even when nothing on the page changes, so a single test can't tell you whether a page is fast. Our 10 fresh runs on each page:

Measure (10 mobile runs each)HomepageBlog post
Performance score91 to 99 (median 94.5)90 to 99 (median 98.5)
Lab LCP2.25 s to 3.37 s (median 2.94 s)0.93 s to 0.97 s (median 0.95 s)
Runs with LCP ≤ 2.5 s2 of 1010 of 10
Total Blocking Time0 to 69 ms (median 22 ms)118 to 366 ms (median 148 ms)
CLS0.003 every run0.000 every run
Field data (CrUX)None for this URLNone for this URL

The two pages moved in different ways. On the homepage, LCP swung by more than a second and fell into two clusters, one around 2.3–2.6 s and one around 3.3 s. Five of the ten runs landed in the slower cluster. On the blog post, LCP was rock steady but Total Blocking Time varied threefold, and the two runs with the most blocking time scored 90 and 93 while the rest scored 97–99.

Google explains why in its own PageSpeed Insights documentation: network conditions, server load and the test machine all add variability between runs.

Repeat runs can return a cached result

Five back-to-back PageSpeed Insights runs on the same URL returned identical numbers, down to the millisecond, before we added a unique query string. The homepage scored 98 with a 2.25 s LCP all five times; the fresh runs afterwards ranged from 91 to 99. If you are measuring variance yourself, change the URL slightly for every run, as the script below does.

The 7 Best Page Speed Test Tools, One by One

PageSpeed Insights: best free first check

PageSpeed Insights runs Lighthouse in Google's data centre and, when the page has enough traffic, adds 28 days of real-user Core Web Vitals from the Chrome UX Report. It is free and needs no setup at pagespeed.web.dev. Read the field data first when it exists: that is what users experienced. Use the lab section for diagnostics.

Its limit is one URL at a time, and, as the table shows, one run is not a verdict.

Lighthouse in Chrome DevTools: best for debugging locally

Lighthouse is the open-source engine behind PageSpeed Insights, and it runs inside Chrome DevTools on your own machine. Running it locally lets you test pages behind a login or on a staging server. Google's Lighthouse overview explains the categories it scores.

Chrome DevTools Performance panel: best for finding the cause

The Performance panel records exactly what the browser did while loading the page: every script, layout and paint on a timeline. When Lighthouse says Total Blocking Time is high, this is where you find which script caused it. Start with Google's Performance panel docs.

Chrome UX Report: best for real-user data

The Chrome UX Report (CrUX) is Google's public dataset of real Chrome users' experience, and it is the field data behind the Core Web Vitals assessment. Google's CrUX documentation covers the API and dashboards. Small sites often have no CrUX data at all, as both of our test pages showed, and then lab data is all you have.

GTmetrix: best for testing from many locations

GTmetrix tests pages in real Chrome with Lighthouse and Core Web Vitals, and its site lists 28 test locations. That makes it useful when your users are far from your server or CDN edge. It has a free tier and paid plans.

DebugBear: best for continuous monitoring

DebugBear combines scheduled synthetic tests, Google CrUX data and its own real-user monitoring for the pages you care about most. Monitoring catches the regression a one-off test misses, such as a new tag that slows every page after a release. It is paid, with a free trial.

BugViso: best for testing a whole site at once

BugViso measures speed on every crawled page in a real browser, next to SEO, accessibility and security checks, so you can see which pages are slow, not just whether the homepage is. It reports LCP, CLS, INP (best effort), FCP and TTFB, uses CrUX p75 field data when Google has it and lab data otherwise, and labels every number with its source. Where others go further: it is an audit, not a monitor, so it checks a site when you run or schedule a scan rather than continuously.

How to Choose the Right Speed Test Tool

Pick the tool by the question you are asking. Four questions cover almost every case.

  1. "Is this page fast for real users?" Check field data: PageSpeed Insights or CrUX. Judge it against Google's thresholds at the 75th percentile: LCP within 2.5 s, INP of 200 ms or less, and CLS of 0.1 or less, as set out on web.dev's Core Web Vitals page.
  2. "Why is this page slow?" Use Lighthouse and the Performance panel in DevTools.
  3. "Which of my pages are slow?" Use a site-wide crawler such as BugViso.
  4. "Did a release make us slower?" Use monitoring, such as DebugBear, or scheduled audits.

For a plain explanation of what each metric means, see our guide to Core Web Vitals explained simply.

Run It Yourself: Test a Page 10 Times With PageSpeed Insights

This script runs PageSpeed Insights several times on one URL, adds a unique query string to skip cached results, and prints each run plus the spread. It needs only Python's standard library. Without an API key you will hit the keyless quota quickly; a free Google API key in PSI_KEY fixes that.

python
#!/usr/bin/env python3
"""Run PageSpeed Insights N times on one URL and show how much the lab numbers move.

Usage: python3 psi_runs.py <url> [runs=5] [strategy=mobile]
Optional: set PSI_KEY to a free Google API key to avoid the keyless quota.
"""
import json, os, statistics, sys, time, urllib.parse, urllib.request

url = sys.argv[1]
runs = int(sys.argv[2]) if len(sys.argv) > 2 else 5
strategy = sys.argv[3] if len(sys.argv) > 3 else "mobile"


def api_for(i):
    # PSI caches repeat tests of one URL for a while; a unique query string forces a fresh run.
    target = url + ("&" if "?" in url else "?") + f"psi_run={int(time.time())}{i}"
    q = {"url": target, "strategy": strategy, "category": "performance"}
    if os.environ.get("PSI_KEY"):
        q["key"] = os.environ["PSI_KEY"]
    return "https://www.googleapis.com/pagespeedonline/v5/runPagespeed?" + urllib.parse.urlencode(q)


rows = []
for i in range(runs):
    for attempt in range(3):  # PSI sometimes times out; retry before giving up
        try:
            with urllib.request.urlopen(api_for(i), timeout=180) as r:
                d = json.load(r)
            break
        except (TimeoutError, OSError) as e:
            print(f"run {i + 1}: retry after {type(e).__name__}")
            time.sleep(10)
    else:
        continue
    a = d["lighthouseResult"]["audits"]
    row = {
        "score": round(d["lighthouseResult"]["categories"]["performance"]["score"] * 100),
        "lcp_s": a["largest-contentful-paint"]["numericValue"] / 1000,
        "tbt_ms": a["total-blocking-time"]["numericValue"],
        "cls": a["cumulative-layout-shift"]["numericValue"],
    }
    rows.append(row)
    print(f"run {i + 1}: score {row['score']:>3}  LCP {row['lcp_s']:.2f} s  "
          f"TBT {row['tbt_ms']:.0f} ms  CLS {row['cls']:.3f}")
    time.sleep(5)

if not rows:
    sys.exit("No successful runs: set PSI_KEY to a free Google API key, or try again later.")
field = d.get("loadingExperience", {}).get("metrics")
print("field data (CrUX):", "yes" if field else "none for this URL")
for k in ("score", "lcp_s", "tbt_ms"):
    v = [r[k] for r in rows]
    print(f"{k}: min {min(v):.2f}  max {max(v):.2f}  spread {max(v) - min(v):.2f}  "
          f"median {statistics.median(v):.2f}")

The first five lines of our homepage run, unedited:

text
run 1: score  91  LCP 3.37 s  TBT 69 ms  CLS 0.003
run 2: score  99  LCP 2.25 s  TBT 5 ms  CLS 0.003
run 3: score  92  LCP 3.33 s  TBT 56 ms  CLS 0.003
run 4: score  92  LCP 3.33 s  TBT 59 ms  CLS 0.003
run 5: score  97  LCP 2.55 s  TBT 24 ms  CLS 0.003

Use the median, not the best run, when you report a lab number. If the spread is wide, look in the Performance panel for what changes between runs: usually a late image, a third-party script or the server's response time.

How BugViso Tests Speed Across Every Page

BugViso's performance engine loads each crawled page in a real Chromium browser and records Core Web Vitals with Google's web-vitals library, so slow templates show up as a pattern, not a single bad URL. It also re-loads pages on throttled Slow 3G and Fast 3G connections, measures long tasks and Total Blocking Time, and reports unused JavaScript and CSS bytes from coverage data.

For images, it simulates WebP and AVIF compression and shows the bytes each image would save. Every vital is labelled as CrUX field data or lab data, so you never mistake a lab estimate for what users saw. Findings land in a ranked fix list with AI-written code fixes, in the dashboard and the PDF. The Core Web Vitals and speed feature page lists every check.

5 Speed Testing Mistakes That Waste Time

Most speed work goes wrong at the measuring stage, before any code changes. These five are the usual culprits.

  • Trusting one run. Our homepage scored 91 and 99 on two runs minutes apart. Run several tests and use the median.
  • Chasing the score instead of the metric. Users feel LCP, INP and CLS, not the 0–100 number. A page can score 95 and still have a slow LCP on real phones.
  • Testing only the homepage. Product pages, blog templates and checkout often have different problems. A site-wide test finds them.
  • Reading lab data as field data. Lab tests use one simulated device and network. Field data reflects your real visitors, when you have enough of them.
  • Optimising for desktop. Google's thresholds apply per device type, and mobile is usually the harder one to pass.

The guide on why a high PageSpeed score can still feel slow goes deeper into the score-versus-experience gap.

Frequently Asked Questions

What is the best free page speed test tool?

PageSpeed Insights is the best free starting point because it combines a Lighthouse lab test with real-user Chrome UX Report data when your page has enough traffic. For debugging, Lighthouse and the Performance panel in Chrome DevTools are free and show exactly what slowed the page down.

Why does my PageSpeed Insights score change every time?

Lab tests run on shared machines over real networks, so server response time, network conditions and third-party scripts vary from run to run. In our test, one unchanged page scored between 91 and 99 across 10 runs. Run several tests and use the median.

Is GTmetrix better than PageSpeed Insights?

They answer different questions. PageSpeed Insights adds Google's real-user field data when it exists; GTmetrix lets you choose the test location, which matters when users are far from your server. Many teams use PageSpeed Insights for the verdict and GTmetrix or DevTools for investigation.

What is a good page speed score?

Focus on the metrics rather than the score. Google treats a page as good when, at the 75th percentile of real visits, LCP is within 2.5 seconds, INP is 200 milliseconds or less, and CLS is 0.1 or less. A lab score of 90 or more is a helpful sign, not the target.

How do I test the speed of my whole website?

Single-URL tools test one page at a time. To test a whole site, use a crawler that measures each page, such as BugViso, or run the script in this post over a list of URLs from your sitemap. Group results by template to find the patterns.

The Speed Test Habit That Saves the Most Time

Never act on a single run: test each important page several times, judge it on the median and on field data, and look for slow templates across the whole site rather than one URL. When you want that site-wide view in one report, run a BugViso audit and sort pages by LCP.

Written by

· BugViso Team

Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.

Found this useful? Share it.

Summarise with AI

Open this guide in your assistant.

Follow BugViso

New guides and audit data as we publish them.

AI visibility tracker

Is your brand in AI answers?

See how often AI assistants mention you, cite your site and rank you against your competitors.

  • ChatGPT
  • Gemini
  • Perplexity
  • Claude
  • AI Overviews
See how it works

See where your site stands

Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.