To bulk screenshot long pages without missing below-the-fold images, scroll each page in increments before capture, give deferred content time to load, verify the images or sections you need, and then take a full-page screenshot. A full-page option captures the document’s scrollable extent; it does not, by itself, guarantee that lazy-loaded images have been requested or rendered.
Why full-page screenshots can still have blank images
Many pages defer loading images or other content until the relevant area approaches the viewport. A screenshot tool can capture the entire scrollable page while still recording blank or unfinished areas if those resources were never triggered or had not finished rendering.
As an Amazon Associate I earn from qualifying purchases.
Keep two jobs separate: scrolling prompts the page to load deferred content, while the full-page screenshot setting determines how much of the page is captured. Playwright describes its fullPage option as capturing the full scrollable page, not as a lazy-loading readiness check. Playwright Page API
PC 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 & 11Outdated 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 matchChoose a browser automation library
| Library | Relevant capability | What to keep in mind |
|---|---|---|
| Playwright | Full-page screenshots and browser examples for Chromium, Firefox, and WebKit. | Its navigation options include load, domcontentloaded, networkidle, and commit. Navigation completion is only an initial milestone; add page-specific readiness checks. Playwright Page API |
| Puppeteer | Page.screenshot(), element screenshots, and page interactions including locator scrolling. |
Use scrolling and explicit checks for the target page before capture. The screenshot guide does not prescribe a universal lazy-image completion assertion. Puppeteer Screenshots Puppeteer Page interactions |
The documentation establishes useful capabilities, not a universal winner for speed or reliability. Choose the library that fits your runtime, browser needs, and existing project.
#1 Best Overall
Build a repeatable bulk-capture workflow
- Navigate to one URL. Choose a navigation event suited to the page. Treat a successful navigation as the start of readiness checks, not proof that all visible content is complete.
- Scroll progressively from top to bottom. Move through the page in increments so viewport-triggered content can be requested. Puppeteer documents locator scrolling through mouse-wheel events. Puppeteer Page interactions
- Allow loading to settle and verify the target. Wait for the images or dynamic sections that matter to your task. For ordinary
imgelements, a page-specific check can inspectcompleteandnaturalWidth; this will not cover every case, such as CSS background images, responsive image sources, or content requiring interaction. - Capture the full page. Use Playwright’s full-page option or the equivalent screenshot method in your chosen library. Puppeteer Screenshots
- Record the outcome for every URL. Log navigation, readiness checks, screenshot success, and the failure reason. This makes it possible to retry pages with failed navigation, missing images, timeouts, or file-write errors without silently treating them as successful captures.
Playwright example: scroll, check images, then capture
This Node.js example uses Playwright to process a list of URLs sequentially. It scrolls in viewport-sized steps, waits briefly between steps, checks regular img elements, and writes a full-page PNG. The scroll pause and timeout are starting values for this script, not universal timings; adjust them to the sites you capture. Responsive images may change their source as the page scrolls, and CSS background images need separate, site-specific checks.
const { chromium } = require('playwright');
const fs = require('node:fs/promises');
const path = require('node:path');
const urls = [
'https://example.com/page-one',
'https://example.com/page-two',
];
const outputDir = path.resolve('screenshots');
const results = [];
function safeName(url, index) {
const host = new URL(url).hostname.replace(/[^a-z0-9.-]/gi, '_');
return `${String(index + 1).padStart(3, '0')}-${host}.png`;
}
(async () => {
await fs.mkdir(outputDir, { recursive: true });
const browser = await chromium.launch();
try {
const page = await browser.newPage();
for (const [index, url] of urls.entries()) {
const result = { url, status: 'failed' };
try {
await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 45000 });
// Trigger viewport-based loading by moving down the document.
await page.evaluate(async () => {
const step = Math.max(300, Math.floor(window.innerHeight * 0.8));
for (let y = 0; y < document.documentElement.scrollHeight; y += step) {
window.scrollTo(0, y);
await new Promise(resolve => setTimeout(resolve, 250));
}
window.scrollTo(0, document.documentElement.scrollHeight);
});
// Allow the page to process the final scroll, then check ordinary img elements.
await page.waitForTimeout(500);
const imageStatus = await page.locator('img').evaluateAll(images =>
images.map(img => ({
src: img.currentSrc || img.src,
complete: img.complete,
naturalWidth: img.naturalWidth,
}))
);
const failedImages = imageStatus.filter(img => !img.complete || img.naturalWidth === 0);
const file = path.join(outputDir, safeName(url, index));
await page.screenshot({ path: file, fullPage: true, type: 'png' });
result.status = failedImages.length ? 'captured_with_image_warnings' : 'captured';
result.file = file;
result.imageCount = imageStatus.length;
result.failedImages = failedImages;
} catch (error) {
result.error = String(error);
}
results.push(result);
}
} finally {
await browser.close();
}
await fs.writeFile('screenshot-results.json', JSON.stringify(results, null, 2));
console.log(results);
})();Install the dependencies with npm install playwright. Playwright may also require its browser binaries to be installed in the environment where the script runs. The example records image warnings separately from navigation or screenshot errors: a screenshot can be written even if some image checks fail, so inspect the result log before treating a capture as complete.
Rank #2
![Free Fling File Transfer Software for Windows [PC Download]](https://m.media-amazon.com/images/I/41Vq6ZqHfjL._SL160_.jpg)
- Intuitive interface of a conventional FTP client
- Easy and Reliable FTP Site Maintenance.
- FTP Automation and Synchronization
Adjust the readiness check to the page
- If only certain images matter, query those images rather than failing a capture because of an unrelated tracking pixel or optional asset.
- If content appears only after clicking, expanding a section, or accepting a site prompt, add that interaction before the check.
- If image URLs change after scrolling, perform the image check after the scroll pass, as the example does.
- If a page keeps changing size while content loads, repeat the scroll pass or wait for a page-specific stable condition. Avoid an arbitrary fixed delay as the only completeness test.
Do not use network idle as the only readiness signal
Playwright defines networkidle as having no network connections for at least 500 ms and discourages using it as the sole test-readiness criterion. A quiet network does not prove that all images rendered correctly. Puppeteer’s Page.waitForNetworkIdle() likewise waits for a network condition, not visual completeness. Playwright Page API Puppeteer waitForNetworkIdle API
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Use network-idle only as one possible signal alongside checks for the images, text, or sections you actually need. Some pages maintain ongoing requests; others may finish their requests before an image is visibly ready.
Bulk reliability, performance, and cost considerations
- Keep per-page records. Save the URL, navigation result, readiness outcome, screenshot path, and any error. Separate failed navigation, timed-out pages, failed or missing images, and screenshot-write errors so retries can target the right stage.
- Use deliberate timeouts. Pick limits that fit your target sites and execution environment. There is no universal timeout or scroll delay established for all pages.
- Plan for resource use. Full-page captures of long pages and large images can require more memory and time than viewport screenshots. The reviewed documentation does not establish a throughput figure or a universally optimal batch size.
- Control concurrency cautiously. Running several browser pages at once may increase throughput, but also increases browser and network load. Measure against your own target pages and infrastructure rather than assuming a fixed safe level.
- Respect access and usage constraints. Whether you may capture, store, or redistribute a third-party page depends on context; the browser API documentation does not grant those rights.
Troubleshooting missing or incomplete images
The screenshot is full length but images below the fold are blank
The capture extent and content readiness are separate. Add a progressive scroll pass before capture, wait for the relevant assets, and inspect image status or page-specific content instead of relying on the full-page option alone.
The script reports network idle, but images are still missing
Network idle only describes network activity. Check the target images’ completion and dimensions, and add checks for site-specific content or image formats that a basic img query does not cover.
Some images remain incomplete after scrolling
Confirm that the page actually encountered the relevant elements and that the images do not depend on an interaction, responsive source change, or CSS background. Capture the failed image details in your per-URL log and handle the specific page behavior rather than increasing every delay blindly.
A page never reaches network idle
Some pages keep network connections active. Use an appropriate navigation milestone and explicit readiness assertions rather than waiting indefinitely for network idle; Playwright explicitly discourages treating it as a general readiness criterion. Playwright Page API
Best Value
The batch stops after one bad page
Wrap navigation, readiness checks, and screenshot writing in per-URL error handling. Continue through the list, record each failure, and retry only the URLs and stages that need attention.
Or skip the browser setup
ScreenshotNeo is a website screenshot API and MCP server. Its full-page capture option loads lazy images; a single GET request returns an image or PDF. For example, save this response as a WebP screenshot:
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 API documentation for request options and response details. Before capture, ScreenshotNeo can accept cookie or consent banners and remove more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers identify the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for 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 screenshots.
Sign up for ScreenshotNeo’s free plan.
Frequently Asked Questions
Does a full-page screenshot automatically trigger lazy-loaded images?
No. It captures the scrollable page extent, but deferred content may need to be triggered by scrolling and verified before capture.
Does network idle mean every image is visible and complete?
No. It indicates a period without network connections, not that the page rendered all content successfully.
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.
