SingleFile Not Capturing Lazy-Loaded Images: How to Load Them Before Saving

If SingleFile saves a page but some images are missing, first let the page finish loading, scroll through the image-heavy sections, and wait for placeholders to resolve. Then save again. If that does not work, enable SingleFile’s deferred-content option, usually labeled save content loaded while scrolling, and try simulated scrolling or a longer maximum idle time as needed. These features are best-effort: a page’s custom loader, slow or failed requests, or content the browser never receives can still leave gaps.

SingleFile saves a web page and its resources into one HTML file. Its deferred-content setting is designed to include content such as images and frames that load while scrolling, but the project notes that this can take longer and may not work on every site. SingleFile’s official site describes the extension and its page-saving features; see the SingleFile help documentation for the relevant options.

1. Check whether the images load in the page

Before changing settings, distinguish a capture problem from a source-page problem:

Reload the page and wait for its initial load to finish.
Scroll slowly through the sections with missing images. Pause where placeholders appear so the site has time to fetch and display the images.
Check whether each image actually appears in the live page. If it never appears there, SingleFile cannot save an image that the page has not exposed to the browser.
Once the live page looks complete, click the SingleFile toolbar button and let the save finish.
Open the resulting HTML file and revisit the affected sections to verify the saved copy.

Manual scrolling is a practical first check. It can trigger sites that load content in response to ordinary scroll events, but it does not guarantee that every image will be available or saved.

2. Enable deferred-content saving

When manual scrolling is not enough, open SingleFile’s options and look for the setting commonly described as Images → save content loaded while scrolling. The exact label or menu location can vary by browser and extension version. Enable it, save the page again, and allow extra time for capture.

This option asks SingleFile to load deferred content before saving. The documentation describes it as a best-effort feature that can include images and frames, and notes that it increases save time. It can also account for content that a page unmounts while scrolling. It does not repair broken source-page requests or guarantee a complete offline copy.

3. Try simulated scrolling when a site needs scroll events

Some pages reveal images only after their own scroll listener runs. In SingleFile’s options, try simulate scrolling if available. The documented behavior dispatches scroll events while SingleFile waits, which can trigger page code that does not respond to other deferred-content handling.

Use this setting selectively: simulated scrolling can cause unexpected scrolling behavior, and site implementations differ. Save again and inspect the result. If it makes the page behave strangely or does not help, turn it off and use the other steps.

4. Increase maximum idle time for slow pages

If images eventually load but the capture starts too soon, increase SingleFile’s maximum idle time and retry. This gives deferred requests more time to settle when the network or device is slow. It also makes saving take longer. Extra wait time helps with timing; it will not fix a permanently failed request, an inaccessible resource, or a loader that requires page-specific actions.

5. Verify the saved HTML and narrow down the failure

After each attempt, open the saved HTML file and check the exact sections that were incomplete. If one image-heavy area still fails, compare it with the live page:

Image absent in the live page: investigate the site’s own loading, access, or network behavior first.
Image appears only after scrolling: try deferred-content saving, then simulated scrolling.
Image appears live but is absent from the saved copy: increase the idle time, recapture, and inspect whether the site uses a custom loader.
Images appear intermittently: wait longer for the page and requests to settle, then repeat the capture and inspect it again.

SingleFile’s FAQ explains that it can retrieve resources not displayed or cached but present in the page, and notes that disabling deferred-image saving can result in missing resources. Treat the setting as a capture aid rather than a promise to recover every resource. See the project FAQ.

6. Advanced option: page-specific preparation with a user script

For a site with an unusual loader, developers can investigate SingleFile’s asynchronous pre-capture user-script hook. A configured script can perform page-specific preparation and delay the capture request until that work finishes. This requires enabling and configuring the hook and writing code, so it is an escalation for readers comfortable debugging the page. Follow the project’s user-script documentation; do not assume a generic script can handle every site.

Common errors and fixes

Symptom	Likely cause	What to try
Images are missing in both the live page and saved file	The page has not loaded them, or their requests are failing.	Wait, scroll the live page, and check whether the images appear before capturing. SingleFile cannot save resources the browser never receives.
Images load after manual scrolling but not in the saved file	Deferred-content saving may be disabled, or capture may not be waiting long enough.	Enable “save content loaded while scrolling,” increase maximum idle time, then save and inspect again.
A scroll-triggered section remains empty	The site may depend on scroll events handled by its own script.	Try “simulate scrolling.” If it causes unexpected scrolling, disable it and try manual scrolling or another capture attempt.
Capture takes a long time	Deferred content and a longer idle period add waiting time.	Use the longer wait when completeness matters; for a quick save, turn off options you do not need and accept that some deferred content may be omitted.
One page still fails after these steps	The page may use a custom loader or other site-specific behavior.	Inspect the live page and saved copy, repeat the manual sequence, and consider the advanced user-script hook if you can configure page-specific preparation.

Performance, reliability, and cost considerations

Deferred-content saving and simulated scrolling can add time because SingleFile waits and may trigger more page activity. Increasing maximum idle time also extends the capture. For a long, image-heavy page, allow the page and save operation to finish before judging the result.

Reliability depends on how the site loads content. A straightforward scroll listener may respond to simulated scrolling; a custom loader may need different preparation. Network or system delays can justify a longer idle time, but waiting longer cannot make an inaccessible or failed source image appear. Check the resulting HTML rather than assuming that a completed save contains every image.

SingleFile’s documented workflow is to wait for the page to load and use the extension. The Chrome Web Store listing also describes that toolbar workflow, but cloud destinations such as Drive or Dropbox are storage choices; they do not make lazy images load. See the Chrome Web Store listing.

Or skip the browser setup

If your goal is a screenshot rather than a self-contained HTML archive, ScreenshotNeo is a website screenshot API and MCP server for developers. It returns PNG, JPEG, WebP, or PDF from one GET request. Use the API directly or connect an AI agent through its MCP server; the available tools include take_screenshot, get_page_info, and capture_pdf. See the ScreenshotNeo documentation for API options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

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)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

ScreenshotNeo removes cookie banners, newsletter popups, and chat widgets before capture. Bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The Free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 screenshots. Only clean shots are billed, and response headers identify the page verdict and billing status. A screenshot is an image or PDF, not a replacement for SingleFile’s offline HTML archive.

FAQ

Does SingleFile guarantee that every lazy-loaded image will be saved?

No. Deferred-content loading is best-effort, and some site-specific loaders or unavailable resources can still fail.

Should I scroll manually or enable simulated scrolling?

Start with manual scrolling to see whether the page loads images at all. Try simulated scrolling if the site appears to require scroll events during capture.

Will a longer maximum idle time fix missing images?

It can help when loading is simply slow. It does not fix a failed request or content the page never makes available.

Does SingleFile save the page as an image?

SingleFile saves a page and its resources into an HTML file. ScreenshotNeo can return a screenshot image or PDF when that is the output you need.