Lazy images and full-page captures, measured
A page of 16 pictures, five ways to load them on scroll, seven ways to scroll. Pick a combination and see which pictures were on screen. The first one shown is a scroll that came back with 2 of 16.
When the scroll ends
2 of 16
- picture 1 showing
- picture 2 showing
- picture 3 empty
- picture 4 empty
- picture 5 empty
- picture 6 empty
- picture 7 empty
- picture 8 empty
- picture 9 empty
- picture 10 empty
- picture 11 empty
- picture 12 empty
- picture 13 empty
- picture 14 empty
- picture 15 empty
- picture 16 empty
Two seconds later
2 of 16
- picture 1 showing
- picture 2 showing
- picture 3 empty
- picture 4 empty
- picture 5 empty
- picture 6 empty
- picture 7 empty
- picture 8 empty
- picture 9 empty
- picture 10 empty
- picture 11 empty
- picture 12 empty
- picture 13 empty
- picture 14 empty
- picture 15 empty
- picture 16 empty
Scroll listener with renderer scroll: 2 of 16 pictures show in the end, and the scroll took 1.3 s. A scroll listener waits 150 ms after the last scroll event, then loads the pictures near the window.
The whole result in one grid
Pictures showing out of 16, with each picture answering after 300 ms. Two numbers with an arrow mean the count when the scroll ended, then two seconds later. The renderer column is the real scroll of CurlShot, run in plain Playwright.
| Page loads pictures with | No scroll | Jump to the bottom | Renderer scroll | Steps, no eager switch | Steps, no pause | Big steps | Steps, 500 ms pause |
|---|---|---|---|---|---|---|---|
| Native lazy loading | 6 → 7 | 6 → 13 | 16 | 16 | 6 → 16 | 12 → 16 | 16 |
| IntersectionObserver loader | 2 | 2 → 3 | 16 | 16 | 2 → 8 | 6 → 9 | 16 |
| Debounced scroll listener | 2 | 2 | 2 | 2 | 2 | 2 | 16 |
| Fade-in on scroll | 2 | 2 → 3 | 12 → 16 | 12 → 16 | 2 → 5 | 2 → 9 | 16 |
| Virtual list | 3 | 0 → 3 | 0 → 3 | 0 → 3 | 0 → 3 | 0 → 3 | 0 → 3 |
Read the table by column. With no scroll, the best page showed 7 of 16: the native page, whose first pictures load before they reach the window. The page's load event does not wait for lazy pictures, so a capture taken on load finds the rest empty.[1] The renderer column is full for native lazy loading and the IntersectionObserver page. It is nearly empty for the scroll listener and the virtual list, and the fade-in page needs two seconds to finish.
Two columns show why the step matters. A single jump to the bottom reached 13 on the native page, and steps of 2,400 px reached 16 on it and 9 on the observer page, because a step bigger than the window leaves rows nobody looked at. With no pause between steps, 16 and 8.
Slow pictures cost time, not pictures
The renderer scroll ends by waiting for pictures that are still arriving, up to 4 s. With every picture taking 1.5 s, the native page still came back with 16 of 16, and the scroll took 4.3 s instead of 1.3 s.
Pictures slower than that wait were not tested here. The docs say that very long pages with slow images can still miss a few, and that a delay does not extend the scroll. Full-page captures explain the budget.
Renderer scroll: pictures showing, by answer time
Native lazy loading
- At once
- 161.3 s
- 300 ms
- 161.3 s
- 1,500 ms
- 164.3 s
IntersectionObserver loader
- At once
- 161.3 s
- 300 ms
- 161.4 s
- 1,500 ms
- 164.7 s
Debounced scroll listener
- At once
- 21.3 s
- 300 ms
- 21.3 s
- 1,500 ms
- 21.3 s
Fade-in on scroll
- At once
- 12 → 161.3 s
- 300 ms
- 12 → 161.3 s
- 1,500 ms
- 12 → 161.3 s
Virtual list
- At once
- 31.3 s
- 300 ms
- 0 → 31.3 s
- 1,500 ms
- 0 → 34.6 s
What the renderer scroll does
Read from the renderer source on 12 November 2026. A full-page capture runs it unless full_page_scroll is off.
- Switches every
loading="lazy"picture and frame to eager. - Moves down in steps of 90% of the window height, at least 200 px: 720 px in a 800 px window.
- Waits 90 ms after each step.
- Stops at the end of the page or at
full_page_max_height: 20,000 px by default, 30,000 px at most. - Waits up to 4 s for pictures that have not finished, all inside a 12 s budget.
- Goes back to the top and takes the picture.
Step 1 is why native lazy loading is safe: nothing is left to the browser's distance rule. It cannot help a page that loads through its own script.
Why the scroll listener got 2 of 16
The test page waits 150 ms after the last scroll event before it loads anything, a common way to keep a scroll handler cheap. The renderer steps every 90 ms, so the page never sees a quiet moment until the scroll is over and the window is back at the top. Same page, steps of 720 px, with the pause changed:
| 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 |
Time the scroll took on the listener page
- 90 ms pause1.3 s
- 200 ms pause3.2 s
- 500 ms pause6.6 s
The 200 ms row is a separate run of two repeats that gave the same counts. The fade-in page gave 15 there, one block short of full.
You cannot change the renderer's pause. If you own the page, a listener that fires within 90 ms, or an IntersectionObserver, works with it. If you only capture the page, the next section shows what to try.
Two cases that stayed short, and what moved them
The scroll listener page and the virtual list, each with one change. Answer time 300 ms, two runs each with the same result.
| 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 listener page. A script that sets each src from its data-src got all 16, and it did so at the end of the scroll, because the scroll waits for pictures on their way. Without the scroll the same script showed 2 at first and 16 two seconds later. The scripts option runs JavaScript on the page before the capture; the customize page describes it. Every page has its own attribute names, so the script is yours to write; this one is the one used in the test:
document.querySelectorAll('img[data-src]').forEach((i) => { i.src = i.dataset.src; i.removeAttribute('data-src') })The virtual list. It removes pictures that are more than 800 px from the window, so the scroll back to the top removes them again. A window 4,320 px tall, the largest the viewport allows, raised the count from 3 to 10 of 16. It never reached all 16. Capturing such a page in parts, or finding a version of it without the list, were not tested here.
Not tested through the API
The fade-in page looked worse than it was
When the scroll ended, only 12 of 16 blocks counted as fully visible: the last ones were still fading in over 0.6 s. Each block starts to fade when an observer reports that half of it is in the window.[2] The count does not say what a picture would show, so the same run took a full-page picture right away and read the colour of each block from the file.
With animations left on, the faintest block held 93% of its colour at worst (3 repeats). With animations disabled, every block held 100% each time. Taking the picture is slow enough for a 0.6 s fade to finish. The reduced_motion option is the safe setting for pages that slide or fade things in.
Faintest block in the picture, share of its colour
Animations on
Repeat 199%Repeat 293%Repeat 393%Animations disabled
Repeat 1100%Repeat 2100%Repeat 3100%
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 pages are small and made for one question each, so the numbers show what Chromium does with that page, not with yours. The second complete run gave the same two counts in 100 of 105 cells; the five that moved are the cases with no pause or a single jump, where timing decides. The grid is that second run, the one that recorded which pictures loaded.
The renderer scroll is the function of the CurlShot renderer, read from its source file and run unchanged in the lab. The page has no network noise and no ads, and the window is 1280 x 800. Pages with more pictures, a slow network or a window of another height may differ. One successful render is one screenshot whatever its length, so a longer scroll costs no extra screenshots; see pricing for the free plan.
Related reading
Questions people ask
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. Checked .
- [2]MDN Web Docs, IntersectionObserver: the callback and thresholds. Checked .
Read next
- Field guideWhy website screenshots look wrong, and the fixesA 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.
- How-toFull-page screenshot on every device and browserExact keys and menu names to screenshot a whole web page in Chrome, Firefox, Edge, Safari, iPhone, iPad and Android, checked against each vendor.
- Myth listSix screenshot myths, tested in ChromiumSix beliefs about website screenshots, run through Chromium on test pages: width, height, retina size, transparency, full page and repeatability.