Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Image lazy loading tells the browser to postpone fetching an image that is currently off-screen. Add loading="lazy" to noncritical images, reserve their layout space with dimensions, and leave important imagery in the initial viewport eager unless measurement shows otherwise. The browser—not your HTML—decides exactly when a deferred request is close enough to the viewport to start.
What lazy loading changes
Without a loading value, an <img> is eager: the browser generally requests its resource as it parses the page. With loading="lazy", you give the browser permission to delay an off-screen request until it is reasonably likely that the reader will need the image.
This is a scheduling hint, not a command with a universal distance threshold. Each browser can choose its own proximity estimate and revise it as scrolling, connection conditions and page state change. If a reader never reaches a gallery at the bottom of an article, those images may never be downloaded, saving network transfer and some decoding work. A reader who scrolls quickly toward them may see requests begin before the images enter the viewport.
MDN describes the purpose plainly: lazy loading avoids the network and storage bandwidth needed to handle an image until it is reasonably certain the image will be needed. That does not guarantee a faster page in every case; image sizes, page structure, browser heuristics, network quality and user behavior determine the result.
#1 Best Overall
The minimal HTML implementation
For a normal below-the-fold image, use native HTML:
<img
src="gallery/photo.jpg"
alt="A red fox in a snowy field"
width="1200"
height="800"
loading="lazy"
>The src URL identifies the resource, alt supplies a text alternative, and width and height describe its intrinsic dimensions. The browser can reserve a 1200:800 (3:2) box before downloading, reducing layout movement. The native attribute needs no JavaScript library or plugin.
When to use loading="eager"
loading="eager" requests an image without waiting for viewport proximity; that is also the practical default when the attribute is omitted. Use eager behavior for imagery that is genuinely needed immediately, such as a prominent hero image visible on the initial screen. If that image becomes the page’s Largest Contentful Paint (LCP) element, deferring it can delay the most important visual content.
Do not lazy-load by rule alone
“Add lazy loading to every image” is an unsafe blanket policy. Classify images by whether they are needed for the initial viewport and by their likely visual importance. A below-the-fold article illustration, product thumbnail list or footer logo is usually a good candidate. A logo or headline image visible immediately usually is not. Validate the choice with measurements from the real page rather than assuming a library or a particular browser threshold.
Choosing images for eager or lazy loading
| Image situation | Starting choice | Reason |
|---|---|---|
| Hero or lead image visible on first load | Eager (omit loading or use loading="eager") |
It may be the LCP element and delaying it can postpone meaningful content. |
| Image clearly below the fold | loading="lazy" |
A visitor who leaves early may never need its bytes. |
| Image inside a long gallery or feed | loading="lazy", with dimensions |
Defers items not yet reached while preserving the layout. |
| Decorative CSS background | Handle separately | The HTML loading attribute applies to replaced elements such as <img>, not every CSS resource. |
Above-the-fold is a visual and layout decision, not simply “the first image in the source.” Responsive designs can move an image into or out of the initial viewport at different widths, so inspect representative mobile and desktop layouts.
Why width and height matter
Lazy images without dimensions can have no reserved box until they intersect the viewport. As the resource arrives, surrounding content moves, producing cumulative layout shift and an unpleasant reading jump. Set the image’s real intrinsic dimensions:
Rank #2
- HTML CSS Design and Build Web Sites
- Comes with secure packaging
- It can be a gift option
<img src="map.webp" alt="Trail map of the north route" width="1600" height="900" loading="lazy">If you cannot use attributes, reserve an equivalent aspect ratio in CSS:
.card-image {
aspect-ratio: 16 / 9;
width: 100%;
height: auto;
object-fit: cover;
}The ratio must match the delivered image. Reserving the wrong shape can create a different jump when the file is decoded.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Lazy loading is not image-size optimization
Deferral and file selection solve different problems. Lazy loading decides when to request an image. Responsive images decide which resource to request. Use srcset and sizes when several resolutions are available:
<img
src="photo-1200.jpg"
srcset="photo-480.jpg 480w, photo-800.jpg 800w, photo-1200.jpg 1200w"
sizes="(max-width: 700px) 100vw, 700px"
alt="A red fox in a snowy field"
width="1200"
height="800"
loading="lazy"
>For art direction or format changes, use <picture> and one or more <source> elements. The browser can then choose a suitable file for viewport width, pixel density and media conditions. A smaller appropriate file reduces transferred bytes even when the request is eager; it does not replace lazy loading.
Accessibility requirements remain unchanged
Lazy loading changes timing, not meaning. Keep useful alt text for informative images so assistive technology has a textual replacement. If an image is purely decorative, an empty alt="" can mark it as decorative; do not omit the attribute accidentally. A caption, nearby text or an accessible name may still be needed when the image conveys complex information.
Native deferral is applied only when JavaScript is enabled, an anti-tracking measure documented for the loading attribute. With JavaScript disabled, images fall back to eager behavior. Your page therefore still needs correct markup and dimensions without relying on script execution.
Rank #3
What the browser actually does
- It parses the
<img>element and records its source, dimensions and loading hint. - For a lazy image outside the viewport, it may postpone the network request.
- Using browser heuristics, it estimates when the image is close enough to be useful and starts fetching it. There is no author-facing universal pixel distance to rely on.
- It decodes and paints the image when available. Scrolling, connection changes and other work can alter the timing.
Because the trigger is implementation-dependent, do not write application logic that assumes “lazy means exactly N pixels.” If a component must load at a custom intersection point or perform another action, use an explicit script rather than depending on an undocumented threshold.
When Intersection Observer is justified
For the common case, native loading="lazy" is simpler and less error-prone. A custom implementation can use the Intersection Observer API when you need a bespoke trigger, analytics at intersection time, a legacy compatibility strategy or coordinated loading of a non-image widget.
const observer = new IntersectionObserver((entries, obs) => {
for (const entry of entries) {
if (!entry.isIntersecting) continue;
const img = entry.target;
img.src = img.dataset.src;
img.removeAttribute('data-src');
obs.unobserve(img);
}
});
document.querySelectorAll('img[data-src]').forEach(img => observer.observe(img));This pattern requires careful handling of srcset, dimensions, errors, accessibility and browsers without Intersection Observer. MDN lists a polyfill or scroll, resize and orientation handlers as fallbacks where compatibility requires them. Do not add this complexity merely to duplicate native behavior.
Does loading="lazy" improve page speed?
It can reduce initial network use and work, particularly on long pages where many images are never viewed. It can also hurt performance when applied to images needed immediately. The outcome depends on the number and size of images, their position, connection conditions, browser decisions and how far users scroll.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
web.dev’s historical analysis of HTTP Archive data (reported in 2022 and last updated March 31, 2022) found browser-level lazy loading on 29% of websites. Among sites using that technique, 84% used WordPress, 2% another CMS and 14% had no known CMS. Those are adoption snapshots, not current benchmarks and not evidence that lazy loading caused any performance result.
The same analysis warned that overuse can be harmful and described a combination that often makes sense: load initial-viewport images eagerly while lazy-loading the rest. Its LCP comparisons were correlational, so they do not prove causation. Treat the findings as implementation guidance, then measure your own pages with lab and field data. An A/B test that changes only the loading policy can reveal whether your users gain or lose.
Rank #4
- Brand: Wiley
- Set of 2 Volumes
- A handy two-book set that uniquely combines related technologies Highly visual format and accessible language makes these books highly effective learning tools Perfect for beginning web designers and front-end developers
A practical implementation and testing checklist
- Mark only noncritical, likely-below-the-fold images with
loading="lazy". - Leave the initial hero or LCP candidate eager unless measurements support another choice.
- Provide accurate
widthandheight, or an equivalent CSS aspect ratio. - Keep meaningful
alttext and decorative images explicitly empty-alt when appropriate. - Use
srcset/sizesor<picture>to select an appropriate file independently of timing. - Test slow and fast connections, mobile and desktop widths, keyboard and screen-reader flows, JavaScript enabled and disabled, and a page where the reader never scrolls to the images.
- Inspect layout shift and LCP before and after; do not infer success from a smaller initial request count alone.
- Use a custom Intersection Observer only when native behavior cannot express a real requirement.
Troubleshooting common failures
The image still downloads immediately
Check whether it is actually in or near the initial viewport, whether a script or framework replaced the markup, and whether you are testing with JavaScript disabled (native deferral falls back to eager there). Browser heuristics can also begin a request earlier than your visual estimate.
The page jumps when images appear
Add the correct intrinsic dimensions or an exact aspect-ratio box. Check that responsive sources share the expected ratio and that CSS is not overriding the reserved size.
Free tools Windows power users keep installed
One-click scans. No signup required.
The hero image renders late
Remove loading="lazy" from that initial-viewport image, verify its selected resource is not unnecessarily large, and compare LCP with real measurements.
Images never appear after a custom implementation
Inspect the console and network panel for an incorrect data-src, a missing observer, an unsupported browser or a blocked URL. Ensure your observer is created before observing targets and that your fallback handles browsers without the API.
Bandwidth did not fall
Users may be scrolling far enough to request every image, or the browser may preload resources for its own heuristics. Lazy loading is not compression; use responsive sources and appropriately encoded files as a separate step.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
If your goal is to capture a page while checking how its images load, ScreenshotNeo provides a website screenshot API and MCP server. It accepts a URL and returns PNG, JPEG, WebP or PDF. Its full-page capture can load lazy images before the shot, and you can wait for a selector, delay or network idle when a page needs time to settle.
One call is enough:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo documentation for all parameters. The same request in Python:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)And Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);- Cookie banners, newsletter popups and chat widgets are removed before the shot; each cleanup step can be turned off.
- Bot checks, blank pages, failed loads, timeouts and cache hits are not billed as clean shots, and response headers identify the page verdict and billing status.
- An MCP server exposes
take_screenshot,get_page_infoandcapture_pdfto Claude, Cursor and other MCP clients. - The Free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 shots.
Start with ScreenshotNeo’s free plan.
Bottom line
Use native loading="lazy" for images that are not needed initially, reserve their dimensions, and keep prominent initial-viewport imagery eager. The browser controls the trigger distance, so verify the real page with measurements instead of promising a fixed speedup or applying lazy loading indiscriminately.
Frequently Asked Questions
Can I set the browser’s lazy-loading distance in HTML?
No. The native attribute does not define a universal author-controlled pixel threshold; the browser chooses and can revise its proximity heuristic.
Is a JavaScript lazy-loading library required?
No. Native loading="lazy" handles the common image case. JavaScript such as Intersection Observer is appropriate only for custom behavior or compatibility needs.
Does lazy loading work for CSS background images?
The HTML loading attribute is for elements such as <img>. Background-image resources need a different strategy.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
