Can Thumbalizr Capture Pages That Load Content on Scroll?

Short answer: Thumbalizr documents full-page screenshots on eligible plans and a delay that waits after the page loads. Its reviewed documentation does not say that it scrolls the page to trigger lazy-loaded images, infinite-scroll feeds, or other scroll-dependent content. A full-page image may therefore include the page’s full dimensions without proving that everything below the fold was loaded.

If scroll-loaded content matters, test the exact page and inspect the relevant sections. For repeatable results, use a browser workflow that explicitly scrolls through the page or relevant container and waits for the content you expect.

1. What Thumbalizr documents

Thumbalizr’s API documents a size setting for page or screen. Its free plan is limited to screen-sized output; full-page capture is listed for eligible paid memberships. The API also documents a delay of 1–30 seconds after page load. The documented defaults are five seconds for Free and Silver, while Gold and Platinum allow a custom delay. Check the current [Thumbalizr API documentation](https://www.thumbalizr.com/api/documentation) and [plan summary](https://www.thumbalizr.com/demo) for the applicable membership details.

Those settings address capture extent and time after load. The reviewed docs do not describe dispatching scroll events, stepping down the document, triggering an infinite-scroll feed, handling nested scroll containers, or waiting for a particular selector. The available status headers (QUEUED, OK, or FAILED) report job status; they do not say whether scroll-triggered sections were activated.

2. Why full-page does not necessarily mean scroll-loaded

A full-page screenshot describes how much of a document the capture includes. Playwright describes its full-page mode as capturing “the full scrollable page”; that describes extent, not a guarantee that every page script has run. [Playwright’s screenshot documentation](https://playwright.dev/mcp/tools/screenshots) distinguishes viewport, element, and full-page captures.

Some sites defer images until the visitor scrolls near them. Others append feed items on scroll, load content inside an independently scrolling panel, or reveal a section after an interaction. Chrome’s guidance on [image loading](https://developer.chrome.com/docs/aurora/image-component) explains that lazy-loaded images can load as a user scrolls toward them. Merely waiting after the initial page load may not trigger that behavior.

3. Check a Thumbalizr capture

1. Confirm the plan supports page size. The free plan is documented as screen-only. Use an eligible membership for full-page output.
2. Set a documented delay if needed. The API delay is post-load waiting time, from 1 to 30 seconds where custom delay is available. It can help with ordinary resources that need more time, but it does not establish that scrolling happened.
3. Capture the exact target page. Use the same URL, account state, and relevant query parameters as the real use case. Dynamic pages can behave differently across routes and sessions.
4. Inspect the output itself. Check the lower sections where images, text, or feed entries are expected. A tall output alone does not verify their presence.
5. Repeat the capture if the content is variable. Compare whether the same items appear each time; one successful image does not establish repeatable loading behavior.

4. A reliable workflow for scroll-dependent pages

If the requirement is to capture content that appears only after scrolling, choose a workflow that spells out the steps: scroll through the relevant area, wait for content to appear, and stop at a defined condition. For an infinite feed, decide whether to stop after a known item count, after a maximum number of scrolls, or when no new items appear. For a nested panel, scroll that panel rather than only the document.

Browser automation can make this sequence explicit. The following Playwright example opens a page, scrolls the main document in viewport-sized steps, waits briefly between steps, and then saves a full-page screenshot. It is a starting point: adjust the number of steps and wait condition to match the site. Sites that load inside a nested container need a locator for that container and scrolling within it.

import { chromium } from 'playwright';

const browser = await chromium.launch({ headless: true });
const page = await browser.newPage({ viewport: { width: 1440, height: 900 } });

try {
  await page.goto('https://example.com', { waitUntil: 'domcontentloaded' });
  await page.locator('body').waitFor();

  // Scroll in bounded steps so viewport-based lazy loaders can react.
  const steps = 12;
  for (let i = 0; i < steps; i++) {
    await page.evaluate(() => window.scrollBy(0, window.innerHeight));
    await page.waitForTimeout(500);
  }

  // Return to the top if the desired output should begin there.
  await page.evaluate(() => window.scrollTo(0, 0));
  await page.screenshot({ path: 'page.png', fullPage: true });
} finally {
  await browser.close();
}

Install Playwright with npm install playwright and install its browser with npx playwright install chromium. For stronger readiness checks, replace fixed sleeps with a wait for a known selector or a change in item count. A fixed number of scrolls is intentionally bounded: blindly scrolling forever is unsafe for feeds that keep appending content.

Handle nested containers and infinite scroll

For a nested scroll area, identify its selector and scroll that element. For example, replace the window scroll call with a locator evaluation that increments the container’s scrollTop, and verify that its scrollHeight or visible item count changes. For infinite scroll, stop when the expected final item appears or when repeated scrolls add no new items. Also consider a maximum duration or iteration count so a continuously growing feed cannot make the job run indefinitely.

5. Common problems and fixes

Symptom	Likely cause	What to try
The screenshot ends at the viewport	The request uses screen size, or the membership does not include page size.	Check the requested size and confirm the plan supports full-page output.
The image is tall, but lower images are blank	Lazy loading was not triggered before capture, or images are blocked or failing.	Scroll through the page in a browser workflow, wait for expected images, and inspect the target page’s network and console behavior.
Feed entries are missing	The feed appends items only after scroll events or requires a particular scroll container.	Scroll the correct container and wait for the item count or a known item to change.
A longer delay makes no difference	Waiting does not trigger a scroll handler or interaction.	Use an explicit scroll-and-wait workflow; delay alone is not documented as scroll simulation.
Capture status is QUEUED	The job has not completed yet.	Follow the API’s documented status flow and retrieve the result after completion.
Capture status is FAILED	The capture job failed; the status does not identify scroll behavior.	Check the request and target availability, then retry or use browser automation to inspect the page failure directly.
Different runs show different lower content	The page or feed is dynamic, personalized, or timing-sensitive.	Use a stable session where possible and wait for a specific readiness condition rather than relying on a single fixed delay.

6. Performance, reliability, and cost considerations

Full-page captures can take longer and produce larger files than viewport captures, especially on long pages. Scrolling through the page adds navigation and waiting time. Keep the workflow bounded, use the smallest viewport and output dimensions that meet the need, and wait for the content that matters instead of adding a large arbitrary pause.

Reliability depends on how the target implements loading. A page-level scroll may not activate a nested panel; a feed may keep growing; and a page may require consent, authentication, or an interaction. Validate the specific page and define a completion condition. Thumbalizr’s documented status headers help distinguish queued, completed, and failed jobs, but do not certify content completeness.

For cost planning, check the current Thumbalizr membership and quota documentation. Its feature table lists plan-dependent monthly screenshot quantities; those quotas describe account limits, not success rates for scroll-loaded content. A trial against the target page is the practical way to assess whether its documented options meet the requirement.

7. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. Its API returns an image or PDF from one GET request. It supports full-page capture with lazy images loaded, along with selector waits, delays, network-idle waits, custom JavaScript, and other capture controls. See the ScreenshotNeo API documentation.

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

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://example.com"},
    timeout=90,
)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://example.com'
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
const image = Buffer.from(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', image));

Cookie and consent banners, newsletter popups, and chat widgets are removed before the shot, and each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed; response headers report the page verdict and billing status. Its MCP server lets AI agents using Claude, Cursor, or another MCP client call screenshot and page-information tools. 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 1,000 screenshots a month, with no card.

8. FAQ

Does Thumbalizr’s delay trigger lazy loading?

The documented delay waits after page load. The reviewed documentation does not say that it scrolls the page or triggers scroll events.

Does full-page mode capture below-the-fold content?

It requests page-sized output on eligible plans, but that alone does not establish that content requiring scrolling has loaded.

What is the safest way to verify a scroll-loaded capture?

Inspect the exact output for the expected lower-page content, and repeat the capture if the page changes between runs.