Skip to content
Core Web Vitals & measurement

Live metrics in the browser: check LCP, INP, and CLS

Lighthouse shows one number, Search Console another: how to read Live Metrics in Chrome, add CrUX field data, and test five click paths through your shop.

20 min read Core Web VitalsPerformance-AnalyseDevToolsCrUX

In short and in plain language

Chrome has a tool for developers. It has a screen with three values. They show how fast a page loads, how fast it reacts to a click, and whether parts of the page jump.

The values are for your own computer. Many customers have slower phones. That is why you can slow down your computer on purpose in the tool.

You can also add values from real visitors. Then Chrome sends the addresses of the pages to Google. You should not do that with secret test pages.

Before big sale days, a short test is worth it. You click through the shop like a customer: home page, list, product, cart, and search.

We can do this test for you. After that, we tell you what is slow and what helps.

Lighthouse flags a red LCP value for the product page, Search Console shows green for the same page group, and your own monitoring lands somewhere in between. Shortly before Black Week, that is an uncomfortable position: for Black Friday and Cyber Monday 2025, the German retail association expected sales of 5.8 billion euros (HDE 2025), and a shop with a sluggish filter or a slow cart on those days notices it in its orders first. Checking whether the home page, the listing, and the product page respond fast enough does not require anyone to read a trace. The Performance panel in Chrome DevTools opens with a screen called Live Metrics, which shows LCP, INP, and CLS continuously as you click and navigate, and can place field data from real Chrome users right next to them. This article explains what the screen shows, how to read local values and field data, what is sent to Google when you turn on field data, how to set device, CPU, and network realistically, and how to use five click paths through your shop to find what still needs work before the sale starts.

Key takeaways

  • Since Chrome 129 (Chrome for Developers), the Performance panel in Chrome DevTools opens with the Live Metrics screen: LCP and CLS right away, INP after the first interaction, without any recording.
  • Field data from CrUX can be added and covers 28 days of real Chrome visits (Chrome for Developers). While DevTools is open, the URLs you visit are sent to Google to fetch it (Chrome DevTools, source code).
  • When local values and field data differ, device, network, or cache are often the reason. The screen recommends device, CPU, and network throttling based on field data; for fast machines, there is a 20x CPU slowdown (Chrome for Developers).
  • The interactions log lists every click, tap, and key press with target, duration, and phases, and a second log lists every layout shift with its score. That turns a poor INP into a specific filter or button.
  • Five click paths are enough for a pre-Black Week check: load the home page, set filters in the listing, choose a variant, add to cart, and type in search, each with a mobile profile and a throttled CPU.
  • The screen measures one device in Chrome, and CrUX covers only public pages with enough traffic. Because the field window spans 28 days (Chrome for Developers), a fix shipped shortly before the sale only partly shows up there.

Lab and field: two numbers, two sources

The reader question behind this article comes up in almost every project: Lighthouse shows one number, Search Console another. Both can be right; they simply measure in different places. Lighthouse loads a page once under fixed conditions on one machine, which makes it a lab test. Search Console and PageSpeed Insights show field data from the Chrome User Experience Report, or CrUX. That data comes from real visits, covers a window of 28 days (Chrome for Developers), and is assessed at the 75th percentile, separately for mobile and desktop (web.dev).

An example from the documentation shows how far apart the two can be. In the field, a page's LCP at the 75th percentile was 1.8 seconds (web.dev), while a lab run of the same page measured 3.0 seconds (web.dev). Neither value is wrong. The lab measures one visit on one device, on one network, from one location; the field measures many visits with caching, back navigation, and fast and slow devices. A lab test also generally does not capture real user behavior such as scrolling, selecting text, or tapping (web.dev).

In practice, that means a green Lighthouse score does not prove that customers experience a fast page, and a red field value does not yet reveal which click caused it. Websites in the CrUX dataset show how much room there is: 48 percent (Web Almanac 2025) of mobile websites pass all three Core Web Vitals, and on desktop the figure is 56 percent (Web Almanac 2025). How the Lighthouse report is structured is covered in Reading a Lighthouse report, and the grouping logic of Search Console in the article on the Core Web Vitals report.

Live Metrics closes the gap between those two worlds. It measures in the lab, on your own machine, but with real clicks you make yourself. And it puts the field data for the same page next to your values, so you can see right away whether your local impression matches what visitors experience.

What the Live Metrics screen shows

Opening the Performance panel in Chrome DevTools no longer drops you into an empty timeline. The reference puts it this way: when you first open the panel, you see the Live Metrics screen, which gives an instant performance summary of the current page using the three Core Web Vitals (Chrome for Developers). The screen was introduced with Chrome 129 (Chrome for Developers). LCP and CLS appear right away, and the INP value shows up as soon as you interact with the page (Chrome for Developers).

The values update as you click and move to other pages. That includes soft navigations in single-page applications, marked with a SOFT NAV badge (Chrome for Developers). The reference names the benefit directly: INP and CLS issues that only appear under certain circumstances become easier to spot, and once an issue repeats consistently, a recording is worth making to find the cause (Chrome for Developers). How soft navigations change field data is covered in the article on soft navigations in CrUX.

Measurement happens in the background. According to the announcement, DevTools does not even need to be open; the values are ready whenever you open the panel (Chrome for Developers). The three cards are color-coded with the same thresholds that apply to field data:

LCP: Largest Contentful Paint

The point at which the largest visible image or text block is rendered. A value of up to 2.5 seconds after the page starts loading counts as good (web.dev). The card names the element behind it.

INP: Interaction to Next Paint

The time from a click, a tap, or a key press to the next frame being presented. 200 milliseconds or less counts as good (web.dev). The value only appears after the first interaction.

CLS: Cumulative Layout Shift

The sum of unexpected layout shifts in the worst session window. A value of up to 0.1 counts as good (web.dev). The card names the cluster of shifts that determines the value.

Hovering over a value reveals more detail, such as the subparts of LCP and INP and, if field data is turned on, their distribution (Chrome for Developers). The same screen also shows the LCP element, which you can highlight on the page, details on the CLS cluster and the interaction type, and two logs for interactions and layout shifts (Chrome for Developers). For most questions a shop owner has, this one screen is enough.

Reading local values correctly

LCP: The most useful clue sits under the number: the LCP element. Hovering highlights it on the page, and clicking opens it in the Elements panel (Chrome for Developers). On desktop it is often an image, on mobile not necessarily: across all pages, an image is the LCP element on 76 percent (Web Almanac 2025) of mobile pages and on 85.3 percent (Web Almanac 2025) of desktop pages. Check both views before optimizing an image that is not even the largest element on a phone.

INP: Only mouse clicks, taps on a touchscreen, and key presses are measured; hovering, zooming, and scrolling do not count (web.dev). As long as you only scroll, the INP card stays empty. The value reflects the slowest interaction of the visit, ignoring outliers when there are very many interactions (web.dev). For testing, that means every click path starts with a fresh page load, otherwise a slow click from earlier carries the value forward.

CLS: Shifts are counted in groups called session windows. Less than one second passes between two shifts, the whole window lasts at most 5 seconds (web.dev), and the value is the window with the highest total. Shifts within 500 milliseconds of an interaction do not count (Chrome for Developers). A filter that rebuilds the list right after the click is therefore not a CLS problem; a banner that slides in a second later is. Up to 0.1 counts as good, above 0.25 as poor (web.dev).

The subparts help you classify what you see. For LCP, they show whether time to first byte, resource loading, or rendering drives the value; for INP, whether input delay, processing in the event handler, or presentation afterwards takes the time. Only that breakdown tells you whether the work belongs on the server, the image, or the script.

Adding field data from CrUX

Next to the local values sits the field data section. Clicking Set up opens a dialog that configures the request, and the documentation explicitly asks you to note the privacy disclosure there (Chrome for Developers). Its wording is in the DevTools source code: while DevTools is open, the URLs you visit are sent to Google to query field metrics, and these requests are not tied to your Google account (Chrome DevTools, source code).

Do not send preview URLs along

If you turn on field data and then open a staging environment or a preview with a secret parameter, those addresses are sent to Google as well. For test environments, the dialog offers a mapping from development to production addresses: the screen then shows, for example, the field data for example.com/page1 when you are on localhost:8080/page1 (Chrome for Developers). Whether the test address itself is transmitted in that case is not described in the documentation. When in doubt, only turn on field data while you are checking public pages.

The data comes from the public CrUX API and aggregates 28 days of real visits (Chrome for Developers). The screen shows the 75th percentile value and, on hover, the share of visits in each of the three rating levels (Chrome for Developers). In the field data section, you can switch between data for the URL and for the whole origin, where both exist, and between desktop and mobile (Chrome for Developers). By default, the screen picks the same URL and device type as your local measurement; if data for one device type is missing, it falls back to data aggregated over all devices (Chrome for Developers).

Not every page has field data. A page must be publicly discoverable, which means it returns status 200 after redirects and does not carry noindex, and it must be sufficiently popular; Google does not disclose the exact minimum number of visitors (Chrome for Developers). The product page of a niche item therefore often only has origin data. CrUX strips parameters such as ?utm_medium=email and fragments from the address and aggregates the visits (Chrome for Developers); listing URLs with filter parameters thus end up in the same row as the unfiltered category.

The data is updated daily around 04:00 UTC (Chrome for Developers). Reloading several times on the same day therefore does not change the field values, and a fix made today shows up tomorrow at the earliest, in a small part of the window. How CrUX and your own measurement of real visits complement each other is covered in RUM vs. CrUX.

When local and field values diverge

With field data turned on, the screen summarizes notable differences between local and field values (Chrome for Developers). The announcement gives an example: the local LCP was so slow that it resembled only 12 percent of real-user experiences (Chrome for Developers). A gap like that first says something about the test environment, not yet about the page.

ObservationCommon causeNext step
Local LCP much faster than in the fieldFast machine, fast network, files in the cacheApply the recommended throttling, disable the cache, reload
Local LCP much slower than in the fieldMany repeat visits with a warm cache or from the back/forward cache in the fieldMeasure a second load with cache, check back navigation
Local INP good, field INP poorSlower devices, clicks during loading, third-party scripts after consentThrottle the CPU, click early, repeat with consent accepted
Local CLS low, field CLS highShifts while scrolling or after late network responsesScroll to the bottom, throttle the network, read the layout shift log
Different LCP element locally and in the fieldDifferent screen size, login, A/B test, fragment in the URLTurn on device mode, measure as a guest and logged in

The causes are well documented. Lab values are limited to one device, one network, and one location, while field data covers many devices, networks, and behaviors, plus effects such as the back/forward cache (web.dev). The LCP element in the field can differ from the one in the lab, for example because of different screen sizes, logged-in users, A/B tests, or a fragment in the URL (web.dev). For CLS, a lab test only captures shifts above the fold during loading, while in the field every unexpected shift counts until the user leaves the page (web.dev).

One trap affects older templates: without a mobile viewport declaration, browsers wait 300 milliseconds (web.dev) after every tap to detect a double tap for zooming. That delay counts toward INP but does not appear in Lighthouse's Total Blocking Time (web.dev). A shop with good blocking time and a poor field INP should therefore first check that <meta name="viewport"> is in the head of every template.

Setting device, CPU, and network from field data

To bring local values closer to reality, the screen recommends environment settings based on CrUX data: which device, which CPU throttling, and which network throttling to use (Chrome for Developers). Each card has a section called Consider your local test conditions for this; once the local values match the field values, it disappears (Chrome for Developers).

  1. Device: If most visitors use a smartphone, the screen recommends the mobile view. Device mode changes the viewport size and often the LCP element too; if the device setting in the field data section is set to Auto, the field data switches along with it (Chrome for Developers).
  2. Network: The network recommendation, such as Slow 4G, is based on the 75th percentile round trip time of real visits (Chrome for Developers). A throttled network also exposes layout shifts that only happen after a late network response.
  3. CPU: Since Chrome 126, there is a 20x slowdown option (Chrome for Developers), meant for fast developer machines. Throttling is relative to your own computer and cannot truly emulate a mobile device with a different architecture (Chrome for Developers). For low- and mid-tier devices, you can calibrate custom presets on your own machine (Chrome for Developers).
  4. Cache: The same section lets you disable the network cache (Chrome for Developers). That is the right setting for a first visit from an ad, not for regular customers with a warm cache.

What matters is recording the setting you chose. An INP value without throttling and one with a 20x slowdown are two different measurements, not progress and not a setback. Why a fixed reference device is a better yardstick than the fastest machine on the team is explained in Target device, not test device.

Logging interactions and layout shifts

Below the three cards are two tabs, Interactions and Layout shifts. They hold tables of the captured interactions and shifts, with elements, timings, the phases of each interaction, and the score of each shift; Clear empties both lists (Chrome for Developers).

The interactions log is a real-time record of all eligible interactions while DevTools is open (Chrome for Developers). Each entry shows the type, meaning a pointer or keyboard event, the target, and the duration, color-coded by the INP thresholds. Like the LCP element, the target can be hovered and opened in the Elements panel (Chrome for Developers). That makes the slowest interaction more than a number: it becomes a specific button, filter, or input field.

Inputs are where the log shows what a single measurement hides. Typing one character into a text field may be fast, but typing many in quick succession can still cause a poor INP (Chrome for Developers). In the shop search, type a real search term at a normal pace rather than a single letter.

The layout shift log lists the affected elements and the score for each shift (Chrome for Developers). If it shows an entry for the promo banner after loading, the cause is found before anyone starts a recording. How to add such banners without a jump is covered in Promo banner for Black Week without layout shift.

Once the log reliably shows a slow interaction, recording comes next. Under Next steps, Record and reload records the page load for LCP and load-time shifts, while Record captures the page while you repeat the slow interaction by hand (Chrome for Developers). How to find the responsible function in a recording is shown in the article on Long Animation Frames.

Five click paths before Black Week

For the pre-sale check, five routes through the shop are enough, each with a mobile profile, the recommended network throttling, and a slowed-down CPU. The home page alone is not sufficient: on mobile, 80 percent (Web Almanac 2025) of home pages reach a good INP, but only 69 percent (Web Almanac 2025) of secondary pages. The routes therefore deliberately lead through the listing, product page, cart, and search.

  1. Home page with the promotion: Reload the page, check the LCP element (hero image, banner, or heading?), then scroll to the bottom and read the layout shift log. On a phone, also open the menu and tap a category.
  2. Listing with filters: Open a category, set two filters, change the sort order, and page forward or load more. Every click in the interactions log should stay green; how fast facets are built is described in Filters in the shop listing.
  3. Product page: Load a well-selling product page fresh, choose a variant, browse the gallery, and open the zoom. Here the LCP element is often the product image; Product gallery and zoom shows how to make it appear early.
  4. Add to cart: Click the buy button right after loading, while scripts are still running, and again after a few seconds of quiet. What happens after the click and how to speed up the feedback is described in Add to cart without waiting.
  5. Search: Type a real search term at a normal pace, pick a suggestion, and set a filter on the results page. Every key press is a separate interaction in the log; tips on fast suggestions are in Search suggestions without waiting.

For each path, note the three values, the LCP element, the slowest interaction with its target, and the device, CPU, and network settings. In Shopware shops, it pays to walk the same path once as a guest and once logged in, because customer group prices, wish lists, and the cart then deliver different parts of the page. Repeat each path several times: a single interaction can be slow because of a background task that happened to run, and only repeated slowness is a finding. For deeper causes in Shopware projects, see our Shopware performance optimization.

A measurement log that makes comparison possible

A measurement without notes is worth little after the next deploy. The following template fits into a spreadsheet or a ticket and is enough for a before-and-after comparison. The environment lines matter most, because without them two measurements cannot be put side by side:

measurement-log.txt
Date and time:          
Page / click path:      Listing "Women > Jackets", filter color and size
Device / view:          device mode phone, field data mobile
CPU throttling:         as recommended or calibrated preset
Network throttling:     as recommended
Cache:                  disabled / enabled
Login, consent:         guest, consent accepted

LCP local / field:      ___ / ___   element: ___
INP local / field:      ___ / ___   slowest interaction: ___
CLS local / field:      ___ / ___   cause: ___
Field source:           URL or origin, period as shown
Notable:                

The screen shows the collection period of the field data in the field data section (Chrome for Developers). Write it down: later it explains why a field value has not moved yet after a fix. Also note whether the values applied to the URL or only to the origin, because an origin value averages over the home page, categories, and all product pages at once.

For repeat runs, the rule is: same settings, same path, several passes. That matches the reference's advice to start a recording only once an issue repeats consistently (Chrome for Developers). If you keep the log before and after every larger change, you end the season with a series that explains more than any single Lighthouse run.

Where the live view stops

A lab value from one machine: Everything the cards show locally is a measurement on your device, on your network, with your behavior. Throttling approximates real conditions but does not replace a real mid-range smartphone. Statements about all visitors require field data.

Chromium only: The screen is part of Chrome DevTools and measures with Chrome's engine. The field data from CrUX also comes from Chrome users (Web Almanac 2025). How visitors on Safari or Firefox experience the page is shown neither by the local values nor by CrUX; that takes your own measurement of real visits.

Field data only for public pages with traffic: Pages behind a login, new landing pages for the sale week, and rarely viewed products often have no values of their own. What remains is the origin value, which averages over all pages and can hide a single slow template.

Field data reacts slowly: Because CrUX is a rolling window of 28 days (Chrome for Developers), new visits push out old ones only gradually. If you ship a fix on November 18, the field data will only show part of its effect by Black Friday on November 27. Proof before the sale therefore comes from local values under recorded conditions, and confirmation in the field follows in the weeks after.

No root-cause analysis: The cards tell you that a click is slow, not why. That takes a recording and, for loading problems, the network waterfall; how to read it is explained in Reading the network waterfall.

When a technical analysis pays off

Live Metrics is a good self-test. It shows whether the home page, the listing, and the product page respond under realistic conditions, and it makes gaps to the field visible. It gets harder when the local value is good but the field stays red, when INP only spikes for certain customer groups, or when a fix works in the lab but does not reach the field.

That is when an outside view helps. In our technical analysis, we walk through your most important click paths with a fixed reference profile, compare them with field data for URL and origin where available, record conspicuous interactions, and hand over a list with cause, effort, and expected effect for each measure. What sits behind the three metrics and how we improve them is described on our Core Web Vitals page.

Sources and documentation

This article is based on data from: Chrome for Developers (Performance features reference; Performance panel: Analyze your website's performance; What's new in DevTools, Chrome 126 and Chrome 129; Monitor your local and real-user Core Web Vitals performance in DevTools; CrUX methodology; CrUX API); Chrome DevTools (source code of the field data dialog, FieldSettingsDialog.ts); web.dev (Web Vitals; Interaction to Next Paint; Cumulative Layout Shift; Why lab and field data can be different); HTTP Archive Web Almanac 2025 (Performance chapter); HDE 2025 (forecast for Black Friday and Cyber Monday).

Related Articles

Core Web Vitals & measurement

Soft Navigations in CrUX: What SPA Shops Check by May 2027

Since October 2026, CrUX has shown Core Web Vitals with soft navigations. Who is affected, how LCP, INP and CLS shift and what SPA shops should do by May 2027.

17 min read
Fundamentals & strategy

What Does PageSpeed Optimization Cost? Planning the Effort

PageSpeed optimization costs depend on templates, shop system, scripts, server and images. How to plan analysis, fixed price, monitoring and a 2027 budget.

16 min read
Fundamentals & strategy

RUM vs. CrUX: Using Field Data Right for Speed

Lighthouse lab scores do not affect ranking. Google rates Core Web Vitals via CrUX field data at the 75th percentile. How to use RUM, CrUX and budgets.

15 min read