Published: August 8, 2019, Last updated: September 4, 2025
Largest Contentful Paint (LCP) is an important, stable Core Web Vital metric for measuring perceived load speed because it marks the point in the page load timeline when the page's main content has likely loaded—a fast LCP helps reassure the user that the page is useful.
Historically, it's been a challenge for web developers to measure how quickly the main content of a web page loads and is visible to users. Older metrics like load or DOMContentLoaded don't work well because they don't necessarily correspond to what the user sees on their screen. And newer, user-centric performance metrics like First Contentful Paint (FCP) only capture the very beginning of the loading experience. If a page shows a splash screen or displays a loading indicator, this moment isn't very relevant to the user.
In the past, we've recommended performance metrics like First Meaningful Paint (FMP) and Speed Index (SI) (both available in Lighthouse) to help capture more of the loading experience after the initial paint, but these metrics are complex, hard to explain, and often wrong—meaning they still don't identify when the main content of the page has loaded.
Based on discussions in the W3C Web Performance Working Group and research done at Google, we've found that a more accurate way to measure when the main content of a page is loaded is to look at when the largest element is rendered.
What is LCP?
LCP reports the render time of the largest image, text block, or video visible in the viewport, relative to when the user first navigated to the page.
What is a good LCP score?
To provide a good user experience, sites should strive to have Largest Contentful Paint of 2.5 seconds or less. To ensure you're hitting this target for most of your users, a good threshold to measure is the 75th percentile of page loads, segmented across mobile and desktop devices.
To learn more about the research and methodology behind this recommendation, see: Defining the Core Web Vitals metrics thresholds.
What elements are considered?
As specified in the Largest Contentful Paint API, the types of elements considered for Largest Contentful Paint are:
<img>elements (the first frame presentation time is used for animated content such as GIFs or animated PNGs)<image>elements inside an<svg>element<video>elements (the poster image load time or first frame presentation time for videos is used—whichever is earlier)- An element with a background image loaded using the
url()function, (as opposed to a CSS gradient) - Block-level elements containing text nodes or other inline-level text element children.
Note that restricting the elements to this limited set was intentional in order to reduce complexity. Additional elements (like the full <svg> support) may be added in the future as more research is conducted.
As well as only considering some elements, LCP measurements use heuristics to exclude certain elements that users are likely to see as "non-contentful". For Chromium-based browsers, these include:
- Elements with an opacity of 0, that are invisible to the user
- Elements that cover the full viewport, that are likely considered as background rather than content
- Placeholder images or other images with a low entropy, that likely don't reflect the true content of the page
Browsers are likely to continue to improve these heuristics to ensure we match user expectations of what the largest contentful element is.
These "contentful" heuristics may differ from those used by First Contentful Paint (FCP), which may consider some of these elements, such as placeholder images or full viewport images, even if they are ineligible to be LCP candidates. Despite both using "contentful" in their name, the aim of these metrics is different. FCP measures when any content is painted to screen and LCP when the main content is painted so LCP is intented to be more selective.
How is an element's size determined?
The size of the element reported for LCP is typically the size that's visible to the user within the viewport. If the element extends outside of the viewport, or if any of the element is clipped or has non-visible overflow, those portions don't count toward the element's size.
For image elements that have been resized from their intrinsic size, the size that gets reported is either the visible size or the intrinsic size, whichever is smaller.
For text elements, LCP considers only the smallest rectangle that can contain all text nodes.
For all elements, LCP doesn't consider margins, paddings, or borders applied using CSS.
When is LCP reported?
Web pages often load in stages, and as a result, it's possible that the largest element on the page might change.
To handle this potential for change, the browser dispatches a PerformanceEntry of type largest-contentful-paint identifying the largest contentful element as soon as the browser has painted the first frame. But then, after rendering subsequent frames, it will dispatch another PerformanceEntry any time the largest contentful element changes.
For example, on a page with text and a hero image the browser may initially just render the text—at which point the browser would dispatch a largest-contentful-paint entry whose element property would likely reference a <p> or <h1>. Later, once the hero image finishes loading, a second largest-contentful-paint entry would be dispatched and its element property would reference the <img>.
An element can only be considered the largest contentful element after it has rendered and is visible to the user. Images that haven't yet loaded aren't considered "rendered". Neither are text nodes using web fonts during the font block period. In such cases, a smaller element might be reported as the largest contentful element, but as soon as the larger element finishes rendering, another PerformanceEntry is created.
In addition to late-loading images and fonts, a page may add new elements to the DOM as new content becomes available. If any of these new elements is larger than the previous largest contentful element, a new PerformanceEntry will also be reported.
If the largest contentful element is removed from the viewport, or even from the DOM, it remains the largest contentful element unless a larger element is rendered.
For analysis purposes, you should only report the most recently dispatched PerformanceEntry to your analytics service.
Load time versus render time
For security reasons, the render timestamp of images was not originally exposed for cross-origin images that lack the Timing-Allow-Origin header. Instead, only their load time was exposed (since this is already exposed through many other web APIs).
The load time will usually be slightly after the resource download ends (