How to capture a long webpage with URLbox when lazy-loaded images are missing

To capture a long page with URLbox when lazy-loaded images are missing, request a full-page screenshot in the default stitch mode and keep the initial scroll enabled. If images still fail to load, reduce scroll_increment so the browser visits more positions, then increase scroll_delay to give deferred images time to appear. Do not set skip_scroll=true: URLbox uses that initial traversal to trigger lazy loading and measure the page. [URLbox full-page screenshots; render options]

Start with a full-page stitch capture

URLbox supports two full-page modes. Its default stitch mode scrolls through the page, captures sections and composites them into one image. Its native mode uses browser-native full-page capture and can be faster, but URLbox describes stitch as more reliable across varied websites. Because lazy loaders commonly depend on content approaching the viewport, start with stitch.

{
  "url": "https://example.com/long-page",
  "full_page": true,
  "full_page_mode": "stitch"
}

Use URLbox’s supported request format for your integration and include these options. The JSON above shows the settings, not a complete authenticated URLbox request. See the full-page screenshots guide and render options reference for request syntax and account-specific authentication details.

Tune scrolling when images are still missing

Keep scrolling enabled. The default traversal gives scroll-triggered loaders a chance to run. skip_scroll=true skips it and is meant to speed up captures where traversal is unnecessary.
Reduce scroll_increment. A large jump can pass a lazy-loaded image without triggering the site’s loading threshold. URLbox documents 400 px as an example for pages that need smaller increments. It is a starting point, not a universal setting.
Increase scroll_delay. A pause after each scroll gives deferred content and animations time to finish. This adds render time, so increase it only as needed.
Use a meaningful selector wait if available. If a known image or readiness element appears in the DOM, set wait_for and an appropriate wait_timeout. A selector wait does not trigger images that load only when scrolled into view, so keep scrolling enabled.
Inspect section seams if the output looks inconsistent. Enable show_seams=true to examine the individual sections used by stitch mode.

{
  "url": "https://example.com/long-page",
  "full_page": true,
  "full_page_mode": "stitch",
  "scroll_increment": 400,
  "scroll_delay": 500
}

The 400 px increment is a documented example. The 500 ms delay is a reasonable experiment to try, not a documented requirement or a guaranteed value. Adjust based on the page and the result. [URLbox render options]

Understand what each readiness option does

Option	What it controls	Use it when
`full_page`	Requests a capture of the whole page.	The target extends beyond the initial viewport.
`full_page_mode=stitch`	Scrolls, captures multiple sections and combines them.	You need scroll-triggered loading or more consistent full-page coverage.
`full_page_mode=native`	Uses browser-native full-page capture.	Speed matters and the page renders correctly without the stitch traversal.
`skip_scroll`	Skips the initial scroll traversal.	Only when scroll-triggered loading is not needed; avoid it for this issue.
`scroll_increment`	Sets the distance between scroll positions.	A smaller step may be needed to trigger a page’s lazy loader.
`scroll_delay`	Sets the pause between section captures.	Images, animations or deferred content need more time after scrolling.
`wait_for` and `wait_timeout`	Waits for a selector to be present or visible; documented default timeout is 30,000 ms.	A specific DOM element reliably signals page readiness.
`wait_until`	Waits for a browser loading condition such as `loaded`, `domloaded`, `requestsfinished` or `mostrequestsfinished`.	The page needs a broader loading condition before capture.
`show_seams`	Shows the captured stitch sections for diagnosis.	You need to find where a section missed content or joined poorly.

Loading conditions and selector waits solve different problems. A page can reach a network condition while an image that loads on scroll has not yet been requested. Combine an appropriate wait with stitch scrolling when both conditions matter. [URLbox render options]

Run captures from cURL, Python or Node.js

Use the request mechanism from your URLbox account or integration, then pass the full-page and scroll options shown above. The dossier’s official documentation identifies these render options but does not specify authenticated endpoint syntax or SDK calls, so these examples focus on how to express the capture settings rather than inventing credentials or a URLbox endpoint.

cURL

# Add full_page=true, full_page_mode=stitch, scroll_increment=400,
# and scroll_delay=500 using the request format in your URLbox account docs.
# Keep skip_scroll unset (or false) so the initial traversal runs.

Python

# In your URLbox request, pass these render options:
options = {
    "url": "https://example.com/long-page",
    "full_page": True,
    "full_page_mode": "stitch",
    "scroll_increment": 400,
    "scroll_delay": 500,
}
# Send `options` using the authenticated request pattern for your URLbox account.
# Keep skip_scroll unset (or False).

Node.js

// In your URLbox request, pass these render options:
const options = {
  url: 'https://example.com/long-page',
  full_page: true,
  full_page_mode: 'stitch',
  scroll_increment: 400,
  scroll_delay: 500,
};
// Send `options` using the authenticated request pattern for your URLbox account.
// Keep skip_scroll unset (or false).

For runnable URLbox request examples, use its screenshots documentation and options reference with your account’s authentication method. For long captures, see its async renders and webhooks guide.

Handle infinite scroll, fixed elements and long renders

Infinite scroll: A page that adds content as it scrolls may never settle. URLbox says it detects infinite scrolling and limits capture to three sections by default. allow_infinite=true overrides that limit; use it only when the page has a bounded amount of content or you can accept the additional work.
Fixed and sticky headers or footers: They can recur in stitched sections. URLbox says stitch mode uses heuristics to capture most fixed elements once. Setting freeze_fixed=false disables that behavior.
Long render time: Full-page stitch captures multiple sections and can take longer as page length and scroll pauses grow. URLbox recommends async rendering for heavy work such as long full-page captures; queue the render and check its status or receive a webhook instead of holding a request open.
Image format: URLbox’s screenshots guide recommends PNG for full-page use because image-size limitations affect JPEG and WebP.

See URLbox’s full-page guide, options reference and async guide for these controls.

Troubleshoot missing images and bad captures

Symptom	Likely cause	What to try
Images below the fold are absent	The page’s lazy loader was not triggered, or the scroll jumped past its trigger range.	Use stitch mode, keep initial scrolling enabled, and reduce `scroll_increment`.
Some images appear, but others do not	Different sections may need more time after scrolling, or the site uses different loading triggers.	Increase `scroll_delay` gradually; inspect sections with `show_seams=true`.
The selector wait times out	The selector may be wrong, absent on that page, or not visible before the timeout.	Check the selector and choose a real readiness element; remember a selector wait does not replace scrolling.
The capture is unexpectedly short	The page may use infinite scroll and hit URLbox’s default three-section limit.	Decide whether the page is bounded; if appropriate, try `allow_infinite=true`.
A sticky header repeats or a seam looks wrong	Fixed elements can overlap section boundaries or the page layout changes while scrolling.	Inspect with `show_seams=true`; review the fixed-element behavior and `freeze_fixed` option.
The capture takes too long or the request stays open	Many sections, small increments and long pauses add work.	Use async rendering for long captures. Reduce pauses only after confirming images still load.
JPEG or WebP output is incomplete or constrained	URLbox notes image-size limitations for these formats on full-page captures.	Use PNG for the full-page image.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. Its one-call API can capture a URL as an image or PDF, with full-page capture and lazy images loaded. Here is the cURL request; see the ScreenshotNeo API documentation for the available options.

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

ScreenshotNeo removes cookie and consent banners, newsletter popups and chat widgets before the shot. 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. Sign up for free and get 1,000 screenshots a month with no card.

Frequently asked questions

Should I switch to native mode to fix missing lazy images?

Usually start with stitch: it scrolls the page, which is the relevant behavior for scroll-triggered loaders. Native mode may be faster, but URLbox says it may not work as well across all sites.

Does waiting for a selector guarantee every image has loaded?

No. It confirms the selected element is present or visible, not that every image’s bytes have finished loading. Keep the scroll traversal and use a selector that reflects the page state you care about.

What scroll delay should I use?

There is no universal value in the cited documentation. Start with a modest pause, inspect the output, and add time only where the page needs it.

Can I capture an unbounded feed in full?

There may be no finite full-page result if the site keeps adding content. URLbox’s default infinite-scroll limit is three sections; override it only when you have a practical stopping point.