PageSpeed Insights and Search Console
Read PageSpeed Insights' field section and lab section correctly, see why they disagree with real numbers, and use Search Console's report to find and fix groups of slow pages.
- 01Read both sections of PageSpeed InsightsTell the field section's p75s, bands and assessment apart from the lab section's one Lighthouse load.
- 02Explain why they disagreeSay why one pretend phone and weeks of real visits give different numbers, and which ones decide what to fix.
- 03Use Search Console's reportFind the group of pages behind an issue, compare its p75 with one page's, and follow a fix through validation.
Field data and lab data on one screen
Ravi runs Leaf and Kettle, the tea shop. An agency has just rebuilt his site. It has four pages: a home page with a photo slider, a Shop page, a Mint tea page and an Our story page. The agency sends a happy note: "The Mint tea page scores 93 in Lighthouse!" Green, the top band.
But Ravi's customers tell another story. The page jumps while it loads. A tap on the cookie banner feels slow. So who is right: the 93, or the customers?
Google has a page that answers both at once. It's called PageSpeed Insights, or PSI, at pagespeed.web.dev. You type an address and press Analyze. A few seconds later, it shows two kinds of numbers on one screen:
- Field data: what real visitors got. It comes from CrUX, Chrome's report of real visits, which The Chrome User Experience Report explained.
- Lab data: one test load, run by Lighthouse on Google's computers. How Lighthouse works covered it.
Chrome's guide to the page names the two sections. The field section is called "Discover what your real users are experiencing". The lab section is called "Diagnose performance issues". Here they are for the Mint tea page, on phones:
The top says the page failed. The bottom gives it 93. Both are right. They answer different questions, the way a restaurant guide does:
A restaurant guide shows two things about each place. At the top, what hundreds of guests said this month. Below, a report from one inspector who came once, on a quiet Tuesday. Only the guests can tell you whether dinner felt slow. Only the inspector can tell you why: the oven is too small.
- In real life: What hundreds of guests said this month
- In PageSpeed Insights: The field section: real visits over 28 days
- In real life: "Would you come back?" Yes or no
- In PageSpeed Insights: The Core Web Vitals assessment: passed or failed
- In real life: One inspector's visit on a quiet Tuesday
- In PageSpeed Insights: The lab section: one Lighthouse load
- In real life: The inspector's notes: the oven is too small
- In PageSpeed Insights: Lighthouse's audits: the causes it found
PSI also has an API: a web address a program can call. It sends back the same report as JSON. The field data sits in a part called loadingExperience, and the lab data in lighthouseResult. Here are both LCP numbers for the Mint tea page:
// Two parts of one PageSpeed Insights answer: the Mint tea page, on phonesconst psi = { loadingExperience: { metrics: { LARGEST_CONTENTFUL_PAINT_MS: { percentile: 632 } } }, lighthouseResult: { audits: { "largest-contentful-paint": { displayValue: "1.5 s" } } },}; const field = psi.loadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS;const lab = psi.lighthouseResult.audits["largest-contentful-paint"];console.log(`Real visitors, p75 LCP: ${field.percentile} ms`);console.log(`One lab load, LCP: ${lab.displayValue}`); - Line 1 is a comment. LCP, Largest Contentful Paint, is when the biggest image or text appears.
- Lines 2 to 5 are a small part of the answer, with the course's numbers in it.
- Line 7 reads the field LCP. Its
percentileis the p75: three in four visits got that or better. - Line 8 reads the lab LCP, as the report shows it.
- It prints
Real visitors, p75 LCP: 632 msandOne lab load, LCP: 1.5 s.
The two numbers are far apart, for the same page. The rest of this lesson reads each section, and then explains the gap.
How the course recorded it
- The field numbers come from the course's RUM pipeline, from Project: build a RUM dashboard. RUM, real user monitoring, means each page sends home its own numbers.
- It made 480 visits to the site in Chrome 157: four weeks' worth, at 120 a week. Each visitor's phone or computer, and network, were drawn as in Reading performance data.
- The lesson lays those numbers out the way PSI lays out CrUX's. On phones, that's 336 visits.
- The lab numbers come from Lighthouse 13.6.0 in the same Chrome, with its default mobile settings, the ones PSI uses. It ran five times on each page, taking turns, on the same site the visitors used.
PageSpeed Insights puts two answers on one screen. The top is field data: the p75 of real visits, and a pass or a fail. The bottom is lab data: one Lighthouse load on a pretend phone, with a score and clues. Read the top to learn whether visitors are happy. Read the bottom to find out why not.
To call the API from your own program, get an API key first. Its Get Started page shows how, and you add the key to each request as key=. That page also says Google plans to stop sending CrUX's data through this API. It points to the CrUX API instead.
Reading the field section
The field section reads CrUX for the address you typed. It covers the last 28 days of visits, and it's updated every day. It shows five metrics. Three are the Core Web Vitals:
- LCP: when the biggest image or text appears. Good is 2,500 ms or less.
- INP, Interaction to Next Paint: how long the page takes to answer a tap, click or key. Good is 200 ms or less.
- CLS, Cumulative Layout Shift: how much the page jumps. Good is 0.1 or less.
The other two, FCP and TTFB, are listed below them as "other notable metrics". They help you find causes. They don't count toward passing.
Passed or failed
At the top sits one word: passed or failed. That's the Core Web Vitals assessment. PSI's docs give the rule. A page or a site passes "if the 75th percentiles of all three metrics are Good." If there isn't enough INP data, LCP and CLS decide alone.
In the API, each metric has a category. It's FAST for good, AVERAGE for needs improvement and SLOW for poor. Here is the rule, run on the Mint tea page:
// The Mint tea page's field data, on phones: each metric's p75const metrics = { LARGEST_CONTENTFUL_PAINT_MS: { percentile: 632, category: "FAST" }, INTERACTION_TO_NEXT_PAINT: { percentile: 232, category: "AVERAGE" }, CUMULATIVE_LAYOUT_SHIFT_SCORE: { percentile: 17, category: "AVERAGE" },}; const notGood = Object.keys(metrics).filter((key) => metrics[key].category !== "FAST");console.log(notGood.length === 0 ? "Passed" : `Failed: ${notGood.join(", ")}`); - Lines 3 to 5 hold the page's three metrics, with each p75 and its category.
- Line 5 is CLS. Its percentile is 17, but the CLS is 0.17. The API sends CLS times 100, as a whole number. Google's own Site Kit plugin divides it by 100 again.
- Line 8 keeps the metrics whose category isn't FAST.
- Line 9 prints
Failed: INTERACTION_TO_NEXT_PAINT, CUMULATIVE_LAYOUT_SHIFT_SCORE.
One metric that isn't good is enough to fail, and this page has two. The score of 93 plays no part. Why it matters: the assessment comes from real visits, and so do the Core Web Vitals that Google Search uses.
Three bands and a line
A p75 is one number. To see the whole spread, PSI also splits the visits into three bands: good, needs improvement and poor. The CrUX guide says to click Expand view to see them.
A pizza shop sorts last month's deliveries into three bands: on time, a bit late and very late. Its chart shows how many fell in each. Then it lines every delivery up, quickest first, and walks three quarters of the way along. The delivery it stops at is its headline number.
- In real life: On time, a bit late, very late
- In PageSpeed Insights: Good, needs improvement, poor
- In real life: How many deliveries fell in each band
- In PageSpeed Insights: Each band's
proportion - In real life: The delivery three quarters of the way along
- In PageSpeed Insights: The p75, the
percentile - In real life: The band that delivery falls in
- In PageSpeed Insights: The metric's
category
In the API, the bands are in distributions. Each one has a min, a max and a proportion: its share of the visits. Here is the home page's LCP on phones:
// The home page's LCP on phones: the share of visits in each bandconst lcp = { percentile: 4588, distributions: [ { min: 0, max: 2500, proportion: 0 }, { min: 2500, max: 4000, proportion: 0.5195 }, { min: 4000, proportion: 0.4805 }, ],};const bands = ["good", "needs improvement", "poor"];lcp.distributions.forEach((bucket, i) => console.log(`${bands[i]}: ${Math.round(bucket.proportion * 100)}%`)); - Line 3 is the p75: 4,588 ms.
- Lines 5 to 7 are the three bands. The last one has no max: it's everything over 4,000 ms.
- Line 11 prints each band's share as a percentage.
- It prints
good: 0%,needs improvement: 52%andpoor: 48%.
Not one phone visit to the home page got a good LCP. Now find the p75. Walk three quarters of the way along: the first two bands only reach 52%, so the 75% point falls in the poor band. That's why the p75 is over 4,000 ms. Here are all three metrics, with that point marked:
Why it matters: the bands tell you how many visitors had a bad time. Almost half of the home page's phone visits were poor.
This URL or the whole origin
PSI shows numbers for the page, and for its origin: the whole site, like https://leafandkettle.example. A button switches between them. In the API, the page is loadingExperience and the site is originLoadingExperience:
// LCP on phones: the home page, and the whole siteconst pageData = { id: "https://leafandkettle.example/", lcp: { percentile: 4588, category: "SLOW" } };const siteData = { id: "https://leafandkettle.example", lcp: { percentile: 3888, category: "AVERAGE" } }; for (const data of [pageData, siteData]) { console.log(`${data.id}: ${data.lcp.percentile} ms, ${data.lcp.category}`);} - Line 2 is the home page's LCP on phones. Line 3 is the whole site's, with every page's visits added up.
- Line 6 prints each one's address, p75 and category.
- It prints
https://leafandkettle.example/: 4588 ms, SLOWandhttps://leafandkettle.example: 3888 ms, AVERAGE.
The site's number is better than the home page's, because the other pages load faster. Some pages have too few visits for numbers of their own. Then, in PSI's words, it will "fall back to origin-level granularity". The API marks that with origin_fallback: true. Why it matters: check which one you're reading before you blame a page.
PSI reports each address twice, for mobile and for desktop. In the API, a setting called strategy picks one. Its default is desktop, so ask for strategy=mobile to get phones.
Here is the course's whole answer for the Mint tea page. Change any value, and the reader says what each field means:
id"https://leafandkettle.example/mint-tea.html"- The page that was tested, after any redirects.
loadingExperience{...}- Field data: real Chrome users' visits to the page, over the last 28 days.
loadingExperience.id"https://leafandkettle.example/mint-tea.html"- The page or origin these numbers are for.
loadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS{...}- LCP, one of the three Core Web Vitals, for this page.
loadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS.percentile632- The p75: 3 in 4 visits got 632 ms or better. Rating: good.
loadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS.distributions[0]{"min":0,"max":2500,"proportion":0.9888}- 99% of visits were in the good band: 0 ms to 2,500 ms.
loadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS.distributions[1]{"min":2500,"max":4000,"proportion":0.0112}- 1% of visits were in the needs improvement band: 2,500 ms to 4,000 ms.
loadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS.distributions[2]{"min":4000,"proportion":0}- 0% of visits were in the poor band: over 4,000 ms.
loadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS.category"FAST"- FAST means good.
loadingExperience.metrics.INTERACTION_TO_NEXT_PAINT{...}- INP, one of the three Core Web Vitals, for this page.
loadingExperience.metrics.INTERACTION_TO_NEXT_PAINT.percentile232- The p75: 3 in 4 visits got 232 ms or better. Rating: needs improvement.
loadingExperience.metrics.INTERACTION_TO_NEXT_PAINT.distributions[0]{"min":0,"max":200,"proportion":0.7191}- 72% of visits were in the good band: 0 ms to 200 ms.
loadingExperience.metrics.INTERACTION_TO_NEXT_PAINT.distributions[1]{"min":200,"max":500,"proportion":0.2809}- 28% of visits were in the needs improvement band: 200 ms to 500 ms.
loadingExperience.metrics.INTERACTION_TO_NEXT_PAINT.distributions[2]{"min":500,"proportion":0}- 0% of visits were in the poor band: over 500 ms.
loadingExperience.metrics.INTERACTION_TO_NEXT_PAINT.category"AVERAGE"- AVERAGE means needs improvement.
loadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE{...}- CLS, one of the three Core Web Vitals, for this page.
loadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE.percentile17- The p75: 3 in 4 visits got 0.17 or better. Rating: needs improvement. The API sends CLS times 100.
loadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE.distributions[0]{"min":0,"max":10,"proportion":0}- 0% of visits were in the good band: 0.00 to 0.10.
loadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE.distributions[1]{"min":10,"max":25,"proportion":1}- 100% of visits were in the needs improvement band: 0.10 to 0.25.
loadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE.distributions[2]{"min":25,"proportion":0}- 0% of visits were in the poor band: over 0.25.
loadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE.category"AVERAGE"- AVERAGE means needs improvement.
loadingExperience.initial_url"https://leafandkettle.example/mint-tea.html"- The address that was asked about. It can differ from id after a redirect.
originLoadingExperience{...}- Field data for the whole origin: the visits to every page of the site, added up.
originLoadingExperience.id"https://leafandkettle.example"- The page or origin these numbers are for.
originLoadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS{...}- LCP, one of the three Core Web Vitals, for the whole site.
originLoadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS.percentile3888- The p75: 3 in 4 visits got 3,888 ms or better. Rating: needs improvement.
originLoadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS.distributions[0]{"min":0,"max":2500,"proportion":0.5387}- 54% of visits were in the good band: 0 ms to 2,500 ms.
originLoadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS.distributions[1]{"min":2500,"max":4000,"proportion":0.2411}- 24% of visits were in the needs improvement band: 2,500 ms to 4,000 ms.
originLoadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS.distributions[2]{"min":4000,"proportion":0.2202}- 22% of visits were in the poor band: over 4,000 ms.
originLoadingExperience.metrics.LARGEST_CONTENTFUL_PAINT_MS.category"AVERAGE"- AVERAGE means needs improvement.
originLoadingExperience.metrics.INTERACTION_TO_NEXT_PAINT{...}- INP, one of the three Core Web Vitals, for the whole site.
originLoadingExperience.metrics.INTERACTION_TO_NEXT_PAINT.percentile232- The p75: 3 in 4 visits got 232 ms or better. Rating: needs improvement.
originLoadingExperience.metrics.INTERACTION_TO_NEXT_PAINT.distributions[0]{"min":0,"max":200,"proportion":0.7381}- 74% of visits were in the good band: 0 ms to 200 ms.
originLoadingExperience.metrics.INTERACTION_TO_NEXT_PAINT.distributions[1]{"min":200,"max":500,"proportion":0.2619}- 26% of visits were in the needs improvement band: 200 ms to 500 ms.
originLoadingExperience.metrics.INTERACTION_TO_NEXT_PAINT.distributions[2]{"min":500,"proportion":0}- 0% of visits were in the poor band: over 500 ms.
originLoadingExperience.metrics.INTERACTION_TO_NEXT_PAINT.category"AVERAGE"- AVERAGE means needs improvement.
originLoadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE{...}- CLS, one of the three Core Web Vitals, for the whole site.
originLoadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE.percentile17- The p75: 3 in 4 visits got 0.17 or better. Rating: needs improvement. The API sends CLS times 100.
originLoadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE.distributions[0]{"min":0,"max":10,"proportion":0.7351}- 74% of visits were in the good band: 0.00 to 0.10.
originLoadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE.distributions[1]{"min":10,"max":25,"proportion":0.2649}- 26% of visits were in the needs improvement band: 0.10 to 0.25.
originLoadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE.distributions[2]{"min":25,"proportion":0}- 0% of visits were in the poor band: over 0.25.
originLoadingExperience.metrics.CUMULATIVE_LAYOUT_SHIFT_SCORE.category"AVERAGE"- AVERAGE means needs improvement.
lighthouseResult{...}- Lab data: one Lighthouse load of the page, on a pretend phone.
lighthouseResult.lighthouseVersion"13.6.0"- The Lighthouse version that ran the test.
lighthouseResult.configSettings.formFactor"mobile"- A mobile test: a phone's screen, Slow 4G, and a CPU 4 times slower.
lighthouseResult.categories.performance.score0.93- The Performance score: 93 out of 100. 90 or more is good. It comes from one load.
lighthouseResult.audits["largest-contentful-paint"].numericValue1513.5- Lab LCP: 1,514 ms, from one simulated load. It's one load, not a p75.
lighthouseResult.audits["total-blocking-time"].numericValue0- Total Blocking Time: 0 ms. The lab load has no taps, so it has no INP. TBT stands in for it.
lighthouseResult.audits["cumulative-layout-shift"].numericValue0.171- Lab CLS: 0.171, from the shifts in this one load. Here it isn't times 100.
The whole site: Core Web Vitals assessment: Failed. Not good: LCP, INP, CLS.
Reading the lab section
The lab section is one load of the page by Lighthouse. PSI's docs say it simulates "a mid-tier device" on a mobile network, and runs "in a Google datacenter". Lighthouse's own docs say its default method "matches the setup of PageSpeed Insights". Lighthouse 13.6.0's settings make the pretend phone:
- A phone's screen: 412 by 823 pixels, like a Moto G Power.
- Slow 4G: a 150 ms round trip, and 1.6 megabits a second down.
- A slower CPU: 4 times slower than the computer running the test.
- Simulated: Lighthouse loads the page at full speed, then works out how slow it would be. It's the Lantern model from Throttling and simulation.
It's like testing a car on rollers in a garage: the same road, at the same speed, every time. The course ran it five times on the home page:
// 5 Lighthouse runs of the home page, one after anotherconst lcp = [4155.7, 4157.6, 4007.3, 4183.5, 4006.7];const scores = [86, 86, 87, 86, 87]; console.log(`LCP from ${Math.min(...lcp)} to ${Math.max(...lcp)} ms`);console.log(`Score from ${Math.min(...scores)} to ${Math.max(...scores)}`); - Line 2 holds each run's LCP, in ms. Line 3 holds each run's Performance score.
- Lines 5 and 6 print the lowest and the highest.
- It prints
LCP from 4006.7 to 4183.5 msandScore from 86 to 87.
The runs barely moved. The Mint tea page got 93 every time, and the Shop page 100. Simulated runs on one computer stay steady. PSI's run, from another computer and another place, can still differ, as Throttling and simulation showed.
Two things are missing from the lab, by design. The first is INP. A Lighthouse load has no taps, so it can't time one. It shows Total Blocking Time, or TBT, instead: how long the main thread was too busy to answer, during the load. On the Mint tea page, TBT was 0 to 42 ms.
The second is a verdict. The 0 to 100 score sums up one load. It isn't a Core Web Vital, and PSI's docs warn that "having good lab data does not necessarily mean real-user experiences will also be good."
Why the two sections disagree
PSI's docs answer this question directly. Field data comes from "users in the real-world on a variety of devices and network conditions." Lab data is "a simulated load of a page on a single device and fixed set of network conditions." So the values may differ.
A tailor fits a coat on a dummy. The dummy is one size and never moves, so every fitting is the same. Then real customers try it on. Some are bigger, some smaller. They sit, reach and bend. A coat can fit the dummy perfectly and still feel tight to one customer in four.
- In real life: The dummy: one size, one pose
- In PageSpeed Insights: The lab: one pretend phone, one network
- In real life: Customers of every size, sitting and stretching
- In PageSpeed Insights: The field: many phones and networks, tapping and scrolling
- In real life: "Fits the dummy perfectly"
- In PageSpeed Insights: A Lighthouse score of 93
- In real life: "Tight for one customer in four"
- In PageSpeed Insights: A p75 that isn't good
Here is LCP on phones for all four pages, the lab's middle run next to the field's p75:
// LCP on phones, page by page: the lab's middle run and the field's p75const pages = [ { name: "Home", lab: 4156, field: 4588 }, { name: "Shop", lab: 1515, field: 716 }, { name: "Mint tea", lab: 1514, field: 632 }, { name: "Our story", lab: 1959, field: 1164 },]; for (const { name, lab, field } of pages) { console.log(`${name}: lab ${lab} ms, field ${field} ms, ${lab > field ? "lab slower" : "lab faster"}`);} - Lines 3 to 6 hold each page's lab LCP and field p75, rounded to whole ms. The lab one is the run Lighthouse's own median rule picks.
- Line 10 prints both, and which one is slower.
- It prints
Home: lab 4156 ms, field 4588 ms, lab fasterandShop: lab 1515 ms, field 716 ms, lab slower. - Then
Mint tea: lab 1514 ms, field 632 ms, lab slowerandOur story: lab 1959 ms, field 1164 ms, lab slower.
Each gap has a reason you can name.
- The pretend phone is slow. On the Mint tea page, 86 of the 89 real phone visits beat the lab's 1.5 s. Slow 4G and a 4 times slower CPU were slower than most of Ravi's visitors.
- The lab is one load among many. On the home page, 93 of 154 phone visits beat the lab, and the other 61 were slower. The lab's load sits inside the spread of real visits, not at its p75.
- The lab never taps. Every field visitor tapped Accept on the cookie banner, so the field has an INP. The lab has none, and its TBT looked fine.
- Sometimes they agree. The Mint tea page's CLS was 0.171 in every lab run, and 0.17 at the field's p75. A second after the page loads, the reviews box arrives and pushes the photo down. It happens the same way on every visit, and Lighthouse waits long enough to see it.
web.dev lists more reasons. Real visitors may have files in their cache. They may scroll, which can move content. In the field, LCP stops counting at the first tap or scroll.
So which section wins? web.dev is clear: when you have both, "field data is what you should use to prioritize your efforts." Use the field to choose what to fix, and the lab to find out why.
Search Console's Core Web Vitals report
PSI answers for one address at a time. Ravi's site will grow to hundreds of pages. Which ones are slow? Google's Search Console, its tool for site owners, has a Core Web Vitals report for that. Search and Core Web Vitals showed how Google Search uses it. Here, you'll read it closely.
To open it, add your site to Search Console as a property and prove you own it. Search Console's help page lists the ways. For a whole domain, you add a record to the domain's DNS.
The report's numbers come from CrUX too. Its help page explains how it's laid out:
- There's one report for mobile and one for desktop.
- Pages are sorted into three statuses: Poor, Need improvement and Good.
- A table lists each issue: a metric with a status, like LCP that needs improvement. Each row shows how many URLs have it, and its validation state.
- A URL with two issues appears in two rows. The chart above counts it once, for its slowest issue.
- Only pages Google has indexed can appear.
The report is built to show the site as a whole, not one page. For one page, the help page sends you to PSI. Why it matters: Search Console tells you where to look, and PSI then tells you about one page.
URL groups and validating a fix
Search Console doesn't rate pages one by one. It puts them into URL groups: "pages that have a similar user experience." Search Console makes the groups for you.
A builder puts up a whole street of houses from one plan. If the roofs leak, they leak on every house, for the same reason. So the inspector writes one report for the street, and names a few houses as examples. One owner may have fixed their own roof. The street's report still says "leaks".
- In real life: A street of houses from one plan
- In Search Console: A URL group: pages from one template
- In real life: The report on the whole street
- In Search Console: The group's status and p75
- In real life: A few houses named as examples
- In Search Console: The example URLs
- In real life: One house with a new roof
- In Search Console: An outlier URL in the group
How groups form
The help page says the pages in a group are assumed to have "a common framework". So a bad number most likely has one cause for the whole group. The status, and the numbers, apply to the whole group.
A group needs enough data to be shown. When it doesn't have enough, Search Console makes an origin group instead. It holds every URL on the origin: the scheme, the host and the port.
Example URLs
Click an issue in the table, and you get its details page. It lists example URLs. Each one stands for a whole group. Click one to see other URLs in its group, with the group's p75. They're listed by impressions: how often they appeared in Google's results. The top ones count the most toward the group's status.
The group's p75 and one URL's p75
A group's p75 adds up visits to every URL in it. In the help page's words, "75% of visits to all URLs in the group experienced the group status shown." Say Ravi's four pages form one origin group. Here is CLS on phones:
// Phone visits with a good CLS, page by page, in the site's one groupconst pages = [ { url: "/", visits: 154, good: 154 }, { url: "/shop.html", visits: 52, good: 52 }, { url: "/mint-tea.html", visits: 89, good: 0 }, { url: "/story.html", visits: 41, good: 41 },]; const visits = pages.reduce((sum, page) => sum + page.visits, 0);const good = pages.reduce((sum, page) => sum + page.good, 0);console.log(`${good} of ${visits} visits good: ${((good / visits) * 100).toFixed(1)}%`); - Lines 3 to 6 hold each page's phone visits, and how many had a good CLS.
- Line 5 is the Mint tea page. None of its 89 visits had a good CLS.
- Lines 9 and 10 add up the visits and the good ones.
- Line 11 prints
247 of 336 visits good: 73.5%.
That's fewer than 3 in 4, so the group's p75 isn't good. It comes out at 0.17: needs improvement. Three of the four pages had a CLS of 0.00, yet all four sit in a group with a CLS issue:
Now Ravi checks the home page in PSI. Its CLS is good. It doesn't match Search Console, and both are right. The help page says a URL's numbers in PSI can differ from its group's, "because an individual URL might be an outlier in its group." There's one more difference. Search Console keeps a URL's parameters, like ?ref=email. PSI removes them. Why it matters: to fix a group, look for the page that drags it down. Here, that's the Mint tea page.
Validating a fix
Ravi fixes the Mint tea page's jump. How does he tell Search Console? Google's steps are short. Fix the issue. Test it with an outside tool, such as PSI. Then click Start Tracking on the issue's details page.
A new worker starts a four-week trial. Nobody judges them on the first morning. The manager watches the whole four weeks. One serious mistake, and the trial ends early. Four clean weeks, and they're hired.
- In real life: The first day of the trial
- In Search Console: Clicking Start Tracking
- In real life: Four weeks of watching
- In Search Console: 28 days of CrUX data
- In real life: One serious mistake ends it
- In Search Console: One URL with the issue fails it
- In real life: Hired at the end
- In Search Console: Passed
Start Tracking begins "a 28-day monitoring session". If the issue isn't found on any URL in those 28 days, it's fixed. One URL with the issue is enough to fail it. The click doesn't make Google crawl or measure anything again. In the help page's words, it "just (re)starts the clock".
The issue moves through states. Read this table from top to bottom:
| State | What it means |
|---|---|
| Not started | Some URLs with the issue have never been in a validation. |
| Started | You began a validation, and no remaining URL with the issue has been found yet. |
| Looking good | Every URL with the issue checked so far is fixed. |
| Passed | Every URL passed. You must have clicked to start the validation. |
| N/A | Google found the issue fixed on every URL, but you never started a validation. |
| Failed | One or more URLs still have the issue after you started a validation. |
Step through one validation, from the issue to the end:
- Before the fixNot started
- Day 0Not started
- Day 0Started
- During the 28 daysLooking good
- Day 28Passed
- Or, during the 28 daysFailed
- Issue validation status
- Not started
- URL validation status
- No URL status yet
The report lists an issue: CLS needs improvement on mobile, for the site's group. None of its URLs has been in a validation.
Why it matters: a fix takes weeks to confirm, because every CrUX number covers 28 days. Your own RUM shows it sooner.
Which section answers this?
Each card is a question about Ravi's site. Sort it by the place that answers it:
- Does the Mint tea page pass the Core Web Vitals assessment?
- What share of real phone visits had a poor LCP?
- How long do real visitors wait after a tap?
- Which element was the LCP element in one load, and what held it up?
- How long was the main thread blocked while the page loaded?
- What Performance score does one test give the page?
- Which groups of pages on the site have poor LCP on mobile?
- Did a fix hold on every affected page for 28 days?
Sort each question by the place that answers it.
Common mix-ups
- "A green Lighthouse score means the page passes." No. The Mint tea page scored 93 and failed the Core Web Vitals assessment.
- "When the two sections disagree, one is wrong." No. One is a single load on a pretend phone. The other is many real visits.
- "The field LCP is an average." No. It's the p75: three in four visits got that or better.
- "PSI's field numbers are always the page's own." No. With too few visits, PSI shows the origin's instead.
- "A CLS percentile of 17 means a CLS of 17." No. The API sends CLS times 100. It means 0.17.
- "Search Console shows each page's own numbers." No. It shows the group's, and one page can be an outlier.
- "Start Tracking makes Google measure the page again." No. It starts a 28-day watch of CrUX data.
Practice exercises
Answer first, then use the hints.
Ravi makes taps faster on the Mint tea page. INP's p75 drops to 180 ms. What does the last line print now?
// The Mint tea page after a fix that makes taps faster
const metrics = {
LARGEST_CONTENTFUL_PAINT_MS: { percentile: 632, category: "FAST" },
INTERACTION_TO_NEXT_PAINT: { percentile: 180, category: "FAST" },
CUMULATIVE_LAYOUT_SHIFT_SCORE: { percentile: 17, category: "AVERAGE" },
};
const notGood = Object.keys(metrics).filter((key) => metrics[key].category !== "FAST");
console.log(notGood.length === 0 ? "Passed" : `Failed: ${notGood.join(", ")}`);
Failed: CUMULATIVE_LAYOUT_SHIFT_SCORE. INP is good now, but CLS still needs improvement, and one is enough to fail.
What if 44 of the Mint tea page's 89 visits had a good CLS? What does the group example print?
// The group again, if 44 of the Mint tea page's visits had a good CLS
const pages = [
{ url: "/", visits: 154, good: 154 },
{ url: "/shop.html", visits: 52, good: 52 },
{ url: "/mint-tea.html", visits: 89, good: 44 },
{ url: "/story.html", visits: 41, good: 41 },
];
const visits = pages.reduce((sum, page) => sum + page.visits, 0);
const good = pages.reduce((sum, page) => sum + page.good, 0);
console.log(`${good} of ${visits} visits good: ${((good / visits) * 100).toFixed(1)}%`);
291 of 336 visits good: 86.6%. That's more than 3 in 4, so the group's CLS p75 would be good.
In the reader, what share of the whole site's phone visits had a poor LCP, in percent?
22%. Over a fifth of all the site's phone visits had a poor LCP, mostly on the home page.
Right after Start Tracking, what's the status of each URL in the validation?
Pending: Google is waiting for enough data to tell whether the URL still has the issue.
Open the course's copy of the Mint tea page and run Lighthouse on it from DevTools. Which element is its LCP element?
The Mint tea photo, img.photo. The course's own run named body > main.product > img.photo.
CrUX's tools page says how many pages per group Search Console shows at most. How many?
20. Search Console presents at most a sample of 20 pages per group for you to look at.
Check your understanding
For each question, ask which section it's about, and whose visits went into the number.
Question 1 of 7What does this assessment example print?
Read the code, then predict// The Mint tea page's field data, on phones: each metric's p75 const metrics = { LARGEST_CONTENTFUL_PAINT_MS: { percentile: 632, category: "FAST" }, INTERACTION_TO_NEXT_PAINT: { percentile: 232, category: "AVERAGE" }, CUMULATIVE_LAYOUT_SHIFT_SCORE: { percentile: 17, category: "AVERAGE" }, }; const notGood = Object.keys(metrics).filter((key) => metrics[key].category !== "FAST"); console.log(notGood.length === 0 ? "Passed" : `Failed: ${notGood.join(", ")}`);Choose an answer to see the explanation.
Question 2 of 7The Mint tea page scored 93 in the lab, yet its field data failed the Core Web Vitals assessment. How can both be true?
Choose an answer to see the explanation.
Question 3 of 7A PageSpeed Insights answer has CUMULATIVE_LAYOUT_SHIFT_SCORE with a percentile of 17. What CLS is that?
Choose an answer to see the explanation.
Question 4 of 7Why does the lab section show Total Blocking Time and no INP?
Choose an answer to see the explanation.
Question 5 of 7PageSpeed Insights shows the home page's CLS as good. Search Console lists the home page under a CLS issue. Why?
Choose an answer to see the explanation.
Question 6 of 7What does clicking Start Tracking in the Core Web Vitals report do?
Choose an answer to see the explanation.
Question 7 of 7A page's lab data and field data disagree. Which should decide what you fix first?
Choose an answer to see the explanation.
Key takeaways
- PSI's top section is field data from CrUX: p75s over 28 days, three bands, and a pass or a fail.
- A page passes when the p75 of LCP, INP and CLS are all good. The lab score plays no part.
- The lab section is one Lighthouse load on a pretend phone: Slow 4G and a 4 times slower CPU. It has no INP.
- They disagree because one load isn't many visitors. Use the field to choose, and the lab to find causes.
- Search Console rates URL groups, not pages. A page can be an outlier in its group.
- Start Tracking begins a 28-day watch. One URL with the issue fails it.
Remember the one-liner.
The field says whether visitors are happy, the lab says why, and Search Console says which group of pages to fix.
Sources
The facts on this page come from these docs and source code:
- About PageSpeed Insights, Google for Developers.
- How to view Chrome UX Report data on PageSpeed Insights, Chrome for Developers.
- Method: pagespeedapi.runpagespeed, PageSpeed Insights API reference.
- Get Started with the PageSpeed Insights API, Google for Developers.
- reportMetrics.ts: reading PageSpeed Insights' field data, Site Kit by Google, source code.
- Network Throttling and CPU Throttling (throttling.md), Lighthouse 13.6.0.
- constants.js: Lighthouse's default settings, Lighthouse 13.6.0, source code.
- Why lab and field data can be different (and what to do about it), web.dev.
- Core Web Vitals report, Search Console Help.
- Add a website or platform property to Search Console, Search Console Help.
- CrUX tools: Search Console, Chrome UX Report docs.
Coming next: The CrUX API, history, and BigQuery. You'll ask CrUX for numbers from your own code, follow a site over many weeks, and query the monthly tables.