# Lazy images and full-page captures, measured

> Five ways a page loads pictures on scroll, seven scroll rules, 105 runs in Chromium: which full-page captures come back with every picture.

Measured test by Serghei Pogor, founder of CurlShot (https://curlshot.com/about/serghei-pogor). Published 12 November 2026. Page for people: https://curlshot.com/blog/lazy-images-full-page-scroll-test

The scroll of the CurlShot renderer got all 16 pictures on pages that use loading="lazy" or an IntersectionObserver, at every answer time tested. It got 2 of 16 on a page whose scroll listener waits 150 ms after the last scroll event, and at most 3 on a virtual list. Chromium 153, test pages, 12 November 2026.

## Key facts

- Without any scroll, a page with loading="lazy" showed 7 of 16 pictures and a page that loads on an IntersectionObserver showed 2. A full-page capture needs the scroll.
- The renderer scroll loaded all 16 pictures on both, even when each picture took 1.5 s to arrive. The scroll then took 4.3 s, because it waits for pictures still on their way.
- A scroll listener that waits 150 ms after the last scroll event got 2 of 16: steps 90 ms apart never leave it that long. With 200 ms between steps it got all 16, and the scroll took 3.2 s instead of 1.3 s.
- Steps of 2,400 px, three times the window, left an IntersectionObserver page with 9 of 16 pictures. The step has to be smaller than the window.
- Seeing every picture is not the same as a complete capture: a virtual list that removes pictures outside the window gave at most 3 of 16 however the page was scrolled. A taller window raised that to 10.
- CurlShot counts one successful render as one screenshot whatever its length, so a longer scroll does not cost more screenshots.

## The result in one grid
Pictures showing out of 16, at a picture answer time of 300 ms. "12 then 16" means 12 when the scroll ended and 16 two seconds later.
| Page | No scroll | One jump to the bottom | The renderer scroll | Same steps, no eager switch | Steps with no pause | Steps of 2,400 px | Steps with a 500 ms pause |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Native lazy loading | 6 then 7 | 6 then 13 | 16 | 16 | 6 then 16 | 12 then 16 | 16 |
| IntersectionObserver loader | 2 | 2 then 3 | 16 | 16 | 2 then 8 | 6 then 9 | 16 |
| Debounced scroll listener | 2 | 2 | 2 | 2 | 2 | 2 | 16 |
| Fade-in on scroll | 2 | 2 then 3 | 12 then 16 | 12 then 16 | 2 then 5 | 2 then 9 | 16 |
| Virtual list | 3 | 0 then 3 | 0 then 3 | 0 then 3 | 0 then 3 | 0 then 3 | 0 then 3 |
## Does the answer time of the pictures matter?
The renderer scroll on each page, at three answer times.
| Page | At once | 300 ms | 1,500 ms | Scroll took at 1,500 ms |
| --- | --- | --- | --- | --- |
| Native lazy loading | 16 | 16 | 16 | 4.3 s |
| IntersectionObserver loader | 16 | 16 | 16 | 4.7 s |
| Debounced scroll listener | 2 | 2 | 2 | 1.3 s |
| Fade-in on scroll | 12 then 16 | 12 then 16 | 12 then 16 | 1.3 s |
| Virtual list | 3 | 0 then 3 | 0 then 3 | 4.6 s |
## What the renderer scroll does
CurlShot scrolls a page before a full-page capture unless full_page_scroll is off. Read from the renderer source on 12 November 2026: it switches loading="lazy" pictures to eager, then moves down in steps of 90% of the window height (at least 200 px) with 90 ms between steps, stops at the end of the page or at full_page_max_height (default 20,000 px, largest 30,000 px), waits up to 4 s for pictures still arriving, within a 12 s budget, and goes back to the top.
## Pause between steps
Steps of 720 px, answer time 300 ms, pictures showing in the end out of 16.
| Page | 0 ms | 90 ms | 200 ms | 500 ms |
| --- | --- | --- | --- | --- |
| Native lazy loading | 16 | 16 | 16 | 16 |
| IntersectionObserver loader | 8 | 16 | 16 | 16 |
| Debounced scroll listener | 2 | 2 | 16 | 16 |
| Fade-in on scroll | 5 | 16 | 16 | 16 |
A scroll with 2 of 16 at 90 ms and 16 at 200 ms: the scroll listener waits 150 ms after the last scroll event, and a 90 ms step never leaves it that long. The scroll took 1.3 s at 90 ms, 3.2 s at 200 ms and 6.6 s at 500 ms.
## Two fixes tried
| Page | What was done | When the scroll ended | Two seconds later |
| --- | --- | --- | --- |
| Scroll listener | Renderer scroll only | 2 | 2 |
| Scroll listener | A script sets each src, then the renderer scroll | 16 | 16 |
| Scroll listener | The same script, no scroll | 2 | 16 |
| Virtual list | Renderer scroll, window 800 px tall | 0 | 3 |
| Virtual list | Renderer scroll, window 4,320 px tall | 3 | 10 |
| Virtual list | No scroll, window 4,320 px tall | 9 | 9 |
The script was: `document.querySelectorAll('img[data-src]').forEach((i) => { i.src = i.dataset.src; i.removeAttribute('data-src') })`. With full_page_scroll on, the scroll waits for pictures still arriving, so a script that sets each src shows up in the capture. A virtual list that removes what is out of the window stays short whatever the window height.
## The fade-in page
The scroll ended with 12 of 16 blocks fully visible and 16 two seconds later. A full-page picture taken at once after the scroll found every block at 93% of its colour or more with animations left on, and at 100% with animations disabled (3 repeats each). The reduced_motion option of CurlShot turns animations off for the capture.
## How it was run
On 12 November 2026. Each test page is 9,600 px tall and holds 16 pictures, one every 600 px. A new Chromium 153.0.8010.12 context opened each page in a 1280 x 800 window through Playwright 1.63.0, on a Linux server; a local server answered each picture after a set time. The scroll rule ran, and the pictures on screen were counted twice: when the scroll ended and 2 seconds later. A picture counts only if it had finished loading and neither it nor its parents were faded out. The scroll rule called the renderer scroll is the function of the CurlShot renderer, read from its source file and run in plain Playwright. No call to the API was sent. A second complete run gave the same two counts in 100 of 105 cells; the cells that moved are the ones with no pause or a single jump, where timing decides.

## Questions

### Does a full-page screenshot load lazy images?

It does when the page is scrolled first. In a run on 12 November 2026, the CurlShot renderer scroll loaded all 16 pictures on a page with loading="lazy" and on a page that loads through an IntersectionObserver. Without the scroll, those pages showed 7 and 2 of 16.

### Why is part of my full-page capture empty?

The page loads its pictures in a way the scroll does not reach. In the test, a scroll listener with a 150 ms debounce, and a virtual list that removes what is out of the window, were the two cases that stayed short. A page whose loader needs a longer pause between steps can be helped with the scripts option, which can set the sources directly.

### How long should a scroll pause between steps?

When pictures answered within 300 ms, 90 ms was enough for native lazy loading and an IntersectionObserver, and 200 ms was enough for a scroll listener that waits 150 ms. Longer pauses cost time: the scroll took 1.3 s at 90 ms and 6.6 s at 500 ms on a 9,600 px page.

### Should I turn full_page_scroll off?

Only for a short page without lazy pictures, or a page that changes as you scroll, such as an endless feed. Otherwise leave it on, because without it the pages in the test showed between 2 and 7 of 16 pictures. Adding a delay does not extend the scroll.

### Do fade-in effects show half-faded in the picture?

Barely. The scroll ended while 4 of 16 blocks were still fading, but a full-page picture taken right after found every block at 93% of its colour or more. Setting reduced_motion on CurlShot turns animations off for the capture.

## Sources

1. MDN Web Docs, "Lazy loading": https://developer.mozilla.org/en-US/docs/Web/Performance/Guides/Lazy_loading (checked 12 November 2026)
2. MDN Web Docs, "IntersectionObserver: the callback and thresholds": https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver/IntersectionObserver (checked 12 November 2026)

## Go deeper

- [Full-page screenshot tool](https://curlshot.com/tools/full-page-screenshot)
- [Full-page captures](https://curlshot.com/docs/full-page)
- [Waiting and timing](https://curlshot.com/docs/waiting)
- [Pricing](https://curlshot.com/pricing)

## Read next

- [Why website screenshots look wrong, and the fixes](https://curlshot.com/blog/why-website-screenshots-look-wrong.md): A field guide to 11 ways a website screenshot goes wrong, from blank lazy images to cookie banners and cut-off pages, with the cause and the fix for each.
- [Full-page screenshot on every device and browser](https://curlshot.com/blog/full-page-screenshot-every-device.md): Exact keys and menu names to screenshot a whole web page in Chrome, Firefox, Edge, Safari, iPhone, iPad and Android, checked against each vendor.
- [Six screenshot myths, tested in Chromium](https://curlshot.com/blog/screenshot-myths-tested.md): Six beliefs about website screenshots, run through Chromium on test pages: width, height, retina size, transparency, full page and repeatability.
