Skip to content
Measured testBy 7 min read

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.

1. How the page loads its pictures
2. How the capture scrolls
3. How long a picture takes to arrive

When the scroll ends

2 of 16

  1. picture 1 showing
  2. picture 2 showing
  3. picture 3 empty
  4. picture 4 empty
  5. picture 5 empty
  6. picture 6 empty
  7. picture 7 empty
  8. picture 8 empty
  9. picture 9 empty
  10. picture 10 empty
  11. picture 11 empty
  12. picture 12 empty
  13. picture 13 empty
  14. picture 14 empty
  15. picture 15 empty
  16. picture 16 empty

Two seconds later

2 of 16

  1. picture 1 showing
  2. picture 2 showing
  3. picture 3 empty
  4. picture 4 empty
  5. picture 5 empty
  6. picture 6 empty
  7. picture 7 empty
  8. picture 8 empty
  9. picture 9 empty
  10. picture 10 empty
  11. picture 11 empty
  12. picture 12 empty
  13. picture 13 empty
  14. picture 14 empty
  15. picture 15 empty
  16. 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.

Measured testRun on 12 November 2026Chromium 153105 cases

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 withNo scrollJump to the bottomRenderer scrollSteps, no eager switchSteps, no pauseBig stepsSteps, 500 ms pause
Native lazy loading6 → 76 → 1316166 → 1612 → 1616
IntersectionObserver loader22 → 316162 → 86 → 916
Debounced scroll listener22222216
Fade-in on scroll22 → 312 → 1612 → 162 → 52 → 916
Virtual list30 → 30 → 30 → 30 → 30 → 30 → 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.

  1. Switches every loading="lazy" picture and frame to eager.
  2. Moves down in steps of 90% of the window height, at least 200 px: 720 px in a 800 px window.
  3. Waits 90 ms after each step.
  4. Stops at the end of the page or at full_page_max_height: 20,000 px by default, 30,000 px at most.
  5. Waits up to 4 s for pictures that have not finished, all inside a 12 s budget.
  6. 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:

Page0 ms90 ms200 ms500 ms
Native lazy loading16161616
IntersectionObserver loader8161616
Debounced scroll listener221616
Fade-in on scroll5161616

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.

PageWhat was doneWhen the scroll endedTwo seconds later
Scroll listenerRenderer scroll only22
Scroll listenerA script sets each src, then the renderer scroll1616
Scroll listenerThe same script, no scroll216
Virtual listRenderer scroll, window 800 px tall03
Virtual listRenderer scroll, window 4,320 px tall310
Virtual listNo scroll, window 4,320 px tall99

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 renderer scroll ran in plain Playwright, and the script and window changes were run the same way. No request was sent to the API of CurlShot in this run, so the numbers describe the scroll code and not the service. Try a page of your own on the full-page screenshot tool, which needs no account.

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

For the bigger list of reasons a capture differs from your own browser, read why website screenshots look wrong. For other claims about full-page captures that were run through a browser, read six screenshot myths, tested in Chromium.

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. [1]MDN Web Docs, Lazy loading. Checked .
  2. [2]MDN Web Docs, IntersectionObserver: the callback and thresholds. Checked .

Screenshot any page in one step

Paste an address into CurlShot and download the screenshot. A free account gives you 100 screenshots every month. No card needed.