AIO Copilot

Page Speed Analyzer

This tool does not time a page load. It reads a page's HTML for eight things that commonly slow pages down, from blocking scripts to images without lazy loading. To time the page, use PageSpeed Insights.

How to use the HTML speed check

From page source to a real measurement, in four steps.

  1. Copy the page source

    Open the page, right-click and choose View Page Source, then copy all of it. This is the HTML the server sent, before any script runs.

  2. Paste it and run the check

    The tool counts the scripts, stylesheets and images in the markup and weighs the HTML and inline code in bytes. Nothing is uploaded and no page is fetched.

  3. Read the eight results

    Each check is marked pass, warning or fail against this tool's own thresholds. The score is the share of checks passed, with a warning counting as half.

  4. Measure the real load

    Run the same URL through PageSpeed Insights for a Lighthouse lab test and field data from real Chrome visitors, then compare after your fixes.

How do I test my page load speed?

Run the URL through PageSpeed Insights, Google's free tool. It loads the page with Lighthouse in a simulated environment and shows field data from real Chrome users over the previous 28 days, according to Google's PageSpeed Insights documentation. The analyzer on this page does neither. It reads the HTML you paste and flags the markup that tends to make pages slow, so it is a way to find likely causes, while PageSpeed Insights measures the result.

What does PageSpeed Insights measure?

Two different things, which can disagree. Lab data comes from a single Lighthouse run in a controlled setting, which Google describes as useful for debugging. Field data comes from the Chrome User Experience Report, anonymized timings from real visitors. A page passes Google's Core Web Vitals assessment only if the 75th percentile of all three Core Web Vitals is in the good band: Largest Contentful Paint (LCP) within 2.5 seconds, Interaction to Next Paint (INP) of 200 milliseconds or less, and Cumulative Layout Shift (CLS) of 0.1 or less.

The 0 to 100 performance score at the top of the report is Lighthouse's lab score, where 90 or more is good and below 50 is poor. The field numbers are what visitors actually got, and they are the same data behind the Core Web Vitals report in Search Console. To see which band each of your field numbers falls in, enter them into the Core Web Vitals calculator.

What does this HTML check catch?

Eight patterns in the markup, each scored against this tool's own thresholds. They are rules of thumb, not Google limits:

  • HTML size: pass at 100 KB or less, fail above 300 KB. For scale, the median home page HTML was 18 KB on both mobile and desktop in the HTTP Archive's 2024 Web Almanac (October 2024 crawl). The hard ceiling is far higher: Googlebot crawls the first 2 MB of an HTML file, measured uncompressed, and indexes only what it fetched.
  • Script tags: up to 5 pass and more than 15 fail, counting inline and external scripts together.
  • Linked stylesheets: up to 3 pass and more than 8 fail.
  • Images: up to 10 img tags pass and more than 30 fail. This is a count only; the tool never downloads an image, so it cannot see file sizes.
  • Inline CSS: up to 14 KB passes. The figure comes from web.dev's advice to keep above-the-fold content under 14 KB compressed, roughly what most servers can send in the first round trip of a new connection. The tool counts uncompressed bytes, so it is stricter than that advice.
  • Inline JavaScript: up to 10 KB passes and more than 50 KB fails.
  • Blocking scripts: external scripts in the head with no async, defer or type="module". One or two is a warning; three or more fail.
  • Lazy loading: images without loading="lazy". Up to two count only as a warning, because the main image near the top of the page should load straight away.

The score is the share of checks passed, with a warning counting as half.

What can't the HTML check see?

Anything that happens while the page loads. It records no timings at all: no server response time, no LCP, no INP, no layout shift. It does not open linked CSS or JavaScript files, so a 2 MB script bundle counts as one script tag. It reads the HTML the server sent, so content a framework injects after load is invisible to it. It also flags only scripts as blocking, while Lighthouse also counts stylesheets that lack a media attribute matching the device. Those gaps are why the measurement has to come from PageSpeed Insights or Search Console.

Which fixes make the most difference?

The ones that get the largest element on screen sooner. web.dev splits LCP into four parts: time to first byte, resource load delay, resource load duration and element render delay. Its advice for the HTML is to make the LCP image discoverable in the page source rather than loading it from a script or stylesheet, to set fetchpriority="high" on it, and never to lazy-load it. Lazy-load the images further down instead: web.dev's lazy loading guide says to use loading="lazy" only for images outside the initial viewport and to give every img tag width and height attributes, so the page does not shift as they arrive. The image SEO checker lists the images missing them.

For scripts, the attribute decides when they run. MDN documents that a deferred script runs after the document has been parsed, in the order the scripts appear, before the DOMContentLoaded event; an async script runs as soon as it downloads, in no guaranteed order; and module scripts are deferred by default. Use defer for your own code and async for independent tags such as analytics. For CSS, Lighthouse's advice is to inline the styles needed for first paint in a style block in the head and load the rest asynchronously.

How much does page speed affect Google rankings?

Some, mostly at the slow end. Google made site speed a ranking signal in April 2010 and said at the time that fewer than 1% of search queries were affected. The 2018 Speed Update extended it to mobile searches, and Google said it would only affect pages that deliver the slowest experience, adding that a slow page may still rank highly if it has great, relevant content.

Google's current page experience documentation says Core Web Vitals are used by its ranking systems, that Search always seeks to show the most relevant content even if the page experience is sub-par, and that chasing a perfect score just for SEO reasons may not be the best use of your time. The sensible order is to fix pages in the poor band first, especially templates shared by many pages, and then put the effort into content. Our technical SEO audit checklist puts speed after crawling, indexing and mobile parity, in the order problems block rankings.

Page speed questions.

Load times, scores, scripts and images.

Is this a page speed test?

No. It reads a page's HTML and flags markup that tends to slow loading, such as blocking scripts in the head, heavy inline code and images without lazy loading, but it never loads the page or times anything. To measure load speed, run the URL through Google's PageSpeed Insights, which combines a Lighthouse lab test with field data from real Chrome users over the previous 28 days.

What is a good page load time?

Google's closest yardstick is Largest Contentful Paint: 2.5 seconds or less is good, up to 4 seconds needs improvement and anything slower is poor, judged at the 75th percentile of visits. PageSpeed Insights also rates First Contentful Paint as good up to 1.8 seconds and time to first byte as good up to 0.8 seconds. Google says there is no single page experience signal, so no one load time number decides rankings.

Why does my PageSpeed Insights score disagree with my Core Web Vitals result?

They come from different data. The 0 to 100 performance score is Lighthouse's result from one simulated load, where 90 or more is good and below 50 is poor. The Core Web Vitals assessment uses field data from real Chrome users over 28 days and passes only if the 75th percentile of LCP, INP and CLS are all good. A page can score well in the lab and still fail in the field, or the other way round.

What is the difference between async and defer?

Both let the browser keep parsing the HTML while the script downloads. A deferred script runs after the document has been parsed, in the order it appears and before the DOMContentLoaded event; an async script runs as soon as it arrives, in no guaranteed order. Module scripts are deferred by default. Use defer for code that needs the page or other scripts, and async for independent tags such as analytics.

Should I lazy-load every image?

No. Google's web.dev guidance says not to lazy-load images that are likely to be in the viewport when the page loads, especially the Largest Contentful Paint image, because that delays the most important visual. Use loading="lazy" for images further down the page, and give every image width and height attributes so the layout does not shift as they arrive.

Does Google stop reading a very large HTML page?

Yes, at 2 MB. Google's Googlebot documentation says that when crawling for Search it fetches the first 2 MB of a supported file type, measured on the uncompressed data, and passes only that part on for indexing. Linked CSS and JavaScript files are fetched separately, each under the same limit. The median home page HTML was 18 KB in the HTTP Archive's 2024 Web Almanac, so few pages come close.

Speed is one row of a technical audit.

This tool reads one page's HTML. Our technical SEO audit checklist puts speed alongside crawling, indexing, mobile and structured data, ordered by what blocks ranking first, with a free test for each check.

Read the checklist

What to do next.