Lazy loading tells the browser to wait on an image or iframe until the visitor scrolls near it. Used below the fold, it saves data and frees bandwidth for what people see first. Used on the hero image, it makes the page slower.
Our guide to fixing a slow largest contentful paint says never to lazy-load the hero and moves on. This piece answers the next question: what should be lazy-loaded, and how do you check what your CMS does? It covers the native attribute, WordPress and Drupal defaults, plugins, decoding="async", embeds, ads and testing.
The short version: use the browser’s built-in loading="lazy" on images and iframes below the fold, and nothing else. Keep the first images in view eager. Give every lazy image a width and height. WordPress and Drupal both lazy-load by default, so the work is finding the images they get wrong, usually a hero built by a page builder, a slider or a custom template.
How native lazy loading works
The loading attribute takes two values. MDN’s img element reference describes eager as the default: the image loads right away. lazy defers it "until it reaches a calculated distance from the viewport, as defined by the browser."
The browser picks that distance, not you. web.dev’s browser-level lazy loading article says Chrome starts lazy images 1,250 pixels from the viewport on fast connections and 2,500 pixels on slower ones. In Chrome tests on Android over 4G, "97.5% of lazy-loaded images were fully loaded within 10ms of becoming visible."
Three rules catch people out:
- JavaScript off means no lazy loading. MDN calls this an anti-tracking measure. Otherwise a server could track scroll position from image requests.
- Hidden images wait. web.dev says major browsers do not load images inside
display: noneelements. Images hidden withopacity: 0still load. - Carousels load sooner. Since Chrome 121, horizontal scrollers use the same distances as vertical scrolling.
Why lazy loading the LCP image hurts
A lazy image does not start downloading until layout confirms it is near the viewport. For the largest element on screen, that wait is pure delay. web.dev’s LCP guide says: "Never lazy-load your LCP image, as that will always lead to unnecessary resource load delay."
Some of the evidence comes from WordPress. web.dev’s article on the performance effects of too much lazy loading compared Chrome field data. The median page without lazy loading had a 75th percentile LCP of 2,922 ms. The median page with it had 3,546 ms. The authors call that correlation, not proof.
Their lab test on a default WordPress theme was clearer. Turning lazy loading off cut median LCP on archive pages by 13% on desktop and 15% on mobile. Lazy-loading only below-the-fold images "results in a complete reversal of the LCP regression," with the same image bytes saved.
How WordPress core decides what to lazy-load
WordPress built its behavior over several releases, each with a dev note.
| Version | Change | Source |
|---|---|---|
| 5.5 (2020) | Adds loading="lazy" to images in post content, excerpts, text widgets, avatars and wp_get_attachment_image() |
5.5 dev note |
| 5.7 (2021) | Same for iframes in content, excerpts and text widgets | 5.7 dev note |
| 5.9 (2022) | Skips the first content image or iframe, set by wp_omit_loading_attr_threshold (default 1) |
5.9 dev note |
| 6.1 (2022) | Adds decoding="async" to images by default |
Trac ticket 53232 |
| 6.3 (2023) | Skip count raised from 1 to 3; fetchpriority="high" on the first large image |
6.3 dev note |
The 5.5 and 5.7 notes say WordPress only adds the attribute when the tag has both width and height. For oEmbed iframes, that depends on the provider’s markup. The 5.9 note reports LCP gains across 50 popular themes from that skip, up to 30% faster.
In 6.3, the function wp_get_loading_optimization_attributes() returns either fetchpriority="high" or loading="lazy" for an image, never both.
Overriding WordPress core’s lazy loading choices
Core does not override attributes you set yourself, according to the 6.3 note. That cuts both ways: a theme that hard-codes loading="lazy" on its hero keeps it.
Where core guesses wrong, there are filters:
- More images above the fold: raise
wp_omit_loading_attr_threshold. - One image or iframe should load eagerly: return false from
wp_img_tag_add_loading_attrorwp_iframe_tag_add_loading_attr. - Custom header areas: the 6.4 dev note added
wp_loading_optimization_force_header_contextsto mark custom contexts as above the fold.
The usual problem is markup that never passes through these functions. Page builders, slider plugins and hand-written hero templates print their own <img> tags. Check those in DevTools before blaming core.
Lazy loading on Drupal image fields
Drupal core has lazy-loaded images by default since 9.1. The 9.1 change record made the image formatter configurable as lazy or eager.
Responsive images followed in 10.1. Its change record says the formatter can toggle the attribute and now outputs image dimensions. New fields default to lazy. Existing responsive image formatters were set to eager, so upgraded sites kept their old behavior.
What to check:
- Hero and banner fields: set the formatter to eager in the view mode that renders them, including Views and Layout Builder blocks.
- Responsive image fields on sites upgraded through 10.1: they may still be eager everywhere. Set below-the-fold fields to lazy.
- Images in body text: comments on the 9.1 change record report that CKEditor strips
loading="eager"unless the text format allows it.
Core has no simple control for fetchpriority, according to a contributed module’s page. A template override or that kind of module fills the gap.
JavaScript lazy-load plugins versus native lazy loading
Before browsers supported the attribute, lazy loading meant a script that swapped a data-src value into src on scroll. Many sites still run one through a performance plugin or an old theme.
web.dev’s lazy loading article says you "probably don’t need a third-party library or script to lazy-load images." It sees two uses left: a fallback for old browsers, and finer control over distances.
Scripts have costs:
- The browser finds images late. The LCP guide lists a JavaScript library that hides
srcorsrcsetas a cause of slow LCP. - No JavaScript, no images. Native lazy images still load with scripts off.
- Double handling. A plugin on top of core can undo core’s eager choice for the hero.
If core already covers the same images, turn the plugin’s lazy loading off.
What decoding="async" does and does not do
decoding is a hint about when the browser decodes an image, not when it downloads it. MDN says: "In practice, async means that the next paint does not wait for the image to decode." The default, auto, lets the browser decide.
MDN adds that the effect on static images is often hard to see. WordPress has added decoding="async" by default since 6.1. Treat it as a small hint. It does not replace lazy loading.
Lazy loading YouTube and other embeds
Iframes take the same attribute. web.dev’s iframe lazy loading article says "Lazy-loading YouTube video embeds saves around 500KB on initial page load."
A facade goes further. The Lighthouse page on lazy loading third-party resources with facades defines one as "a static element that looks similar to the embedded third-party, but is not functional." The real player loads when the visitor clicks. The page lists lite-youtube-embed and lite-vimeo-embed among its examples. It also notes trade-offs: autoplay may not work reliably, and chat badges may not show until the real widget loads.
That Lighthouse audit is gone. Chrome’s April 2025 post on moving Lighthouse to insights listed it for removal in Lighthouse 13, citing concerns about "non-affiliated third-party facades." A clean report no longer means your embeds are handled, so check them yourself. Our case against page-turn flipbook embeds covers an even heavier embed.
Lazy loading, ad viewability and layout shift
Ads are where lazy loading touches revenue. AdSense’s viewability help page says "50% of the ad’s pixels need to be on screen for at least one continuous second" for a viewable impression.
Google’s Publisher Ads Audits include "Lazily load ads below the fold." It flags more than three ads loaded below the fold at the start, and says loading too many "can lower viewability rates."
Google Publisher Tag’s ad best practices add: "Ads that will be visible as soon as the page loads should be given the highest priority." The rule matches images. Load the top slot early and lazy-load the rest. In GPT, fetchMarginPercent and renderMarginPercent set how close a slot must be before it is fetched and rendered.
Lazy loading can also cause layout shift. web.dev warns that lazy images without dimensions save data "at the risk of these increased layout shifts." Ad slots without reserved space push content down too. Our cumulative layout shift guide covers reserving that space.
Testing lazy loading in Chrome DevTools
Five checks cover most sites:
- Find the LCP element. Record a load in the Performance panel. Chrome’s LCP request discovery insight flags it if it is lazy or lacks
fetchpriority=high. - Watch requests as you scroll. In the Network panel, filter to images and reload. Below-the-fold images should appear only as you scroll.
- Throttle the connection to a slow preset and see whether images arrive late.
- List lazy images in the Console with
document.querySelectorAll('img[loading="lazy"]'). None of the first few should be in view. - Turn on Layout Shift Regions under Rendering and scroll. A flash as an image or ad arrives means missing dimensions.
Test mobile and desktop. The first image in view often differs.
Dated facts, as of October 2026
These details change with browser and tool releases. They were checked in October 2026.
| Item | Status as of October 2026 | Source |
|---|---|---|
loading on images |
Chrome 77, Edge 79, Firefox 75, Safari 15.4 | web.dev lazy loading article |
loading on iframes |
Chrome 77, Edge 79, Firefox 121, Safari 16.4 | web.dev iframe article |
| Lighthouse facades and offscreen images audits | Removed in Lighthouse 13 | Chrome blog and Lighthouse docs |
| Drupal 10 | End of life December 9, 2026 | Drupal release schedule |
Lighthouse dropped "Defer offscreen images" because the browser already deprioritizes offscreen images. Lazy loading still saves data for visitors who never scroll. For images that do load, see our guide to AVIF and WebP image formats and our Core Web Vitals guide.
Frequently Asked Questions
Should I lazy-load every image?
No. Lazy-load images below the fold only. Images in the first screen, especially the hero, should load eagerly.
Why is lazy loading bad for the LCP image?
The browser waits until the image is near the viewport before downloading it. For the largest element on screen, that is pure delay.
Does WordPress lazy-load images automatically?
Yes, since 5.5 for images and 5.7 for iframes. Since 6.3 it skips the first three content images by default.
How do I turn off lazy loading for one Drupal image field?
Set that field’s image or responsive image formatter to eager in the view mode that renders it.
Do I still need a lazy loading plugin?
Usually not. Native lazy loading works in current major browsers, and scripts can hide images from early discovery.
Should I add decoding=”async” to my images?
It is harmless, and WordPress adds it already. Do not expect it to fix a slow page.
What is a YouTube facade?
A static preview that looks like the player. The real embed loads only when someone clicks it.
Does lazy loading ads help viewability?
For ads below the fold, Google’s ad audits say it can. Ads in the first screen should load early, and every slot needs reserved space.