Urlbox Full-Page Screenshots Cut Off Content: How to Fix It

If a Urlbox full-page screenshot ends before the page does, first request full_page=true and use the default stitch mode. Then check capture limits, make sure the page can scroll to load content, wait for the content to become ready, and account for infinite scroll and layout constraints. Urlbox documents native mode as faster, but recommends stitch as the general-purpose full-page approach. Actual behavior depends on the page.

This guide follows the documented options in the Urlbox screenshots guide and render options reference. If the exact documentation paths have changed, use the corresponding Screenshots and Render Options pages in Urlbox’s documentation.

1. Confirm full-page mode and start with stitch

Check that the request explicitly includes full_page=true. Urlbox’s default full-page mode is stitch: it scrolls through the page, captures sections, and stitches them together. The process can trigger lazy-loaded elements and animations, and freezes fixed or sticky elements to avoid repeating them in every section.

The alternative, native, uses the browser’s native full-page capture and is faster. Urlbox cautions that it may not work well on all sites. If the output is incomplete, diagnose with stitch before trying native.

2. Check section and height limits

A screenshot can stop early because the capture is bounded by an option. Inspect the request for all of the following:

max_sections limits the number of sections in a stitched capture.
max_height limits the overall capture height.
max_section_height sets a per-section ceiling.
When height is used with full_page, it sets the browser viewport height and caps individual screenshot sections at that height.

Remove accidental limits or raise them enough for the intended page. Keep limits deliberate for very long or unbounded pages; removing every bound can increase work and can be unsuitable for infinite-scroll pages.

3. Let scroll-triggered content load

Urlbox scrolls to the bottom by default before capturing. This helps trigger lazy loading and establishes the final scrollable page height. During diagnosis, do not set skip_scroll=true: that option skips the initial scroll and can leave below-the-fold content unloaded.

If content still appears only after scrolling, adjust scroll_increment and scroll_delay. Smaller increments can trigger lazy loading or animations that larger steps miss; a longer delay gives the page more time between steps. These settings trade capture time for a better chance of catching delayed, scroll-driven content. There is no universal best value: tune against the target page.

Scroll-triggered loading and content that appears late after navigation are different problems. Use wait_until to select a readiness event or network-quiet condition. If a specific content element indicates that rendering is complete, use wait_for to wait for that selector. Use wait_to_leave when a known loading indicator should disappear, and wait_timeout to set the wait duration.

A missing wait_for element does not necessarily fail the screenshot request by default, so check the result visually rather than assuming a successful response means the intended element appeared. Prefer a selector tied to the content you need over an arbitrary delay when possible; this is practical guidance based on the documented wait controls, not a guarantee that every site exposes a reliable selector.

5. Inspect seams, sticky elements, and fixed UI

If sections overlap, leave a gap, repeat a strip, or stop lining up, temporarily set show_seams=true. It exposes the captured sections to help locate where the problem begins.

Urlbox heuristically detects fixed elements so sticky headers and footers are captured only once. If that handling contributes to an unexpected result, test freeze_fixed=false. Compare the output with and without it; fixed-element behavior depends on the page layout.

6. Handle infinite scroll deliberately

Urlbox detects infinite-scroll pages and limits capture to three sections by default to avoid continuing forever. If more content is intentionally needed, allow_infinite=true permits continued capture. Pair it with a sensible max_sections bound, since the page may keep extending as it is scrolled.

If you only need the initial content of a feed, leave infinite-scroll continuation disabled. If the missing portion is a finite lazy-loaded section, first try the normal scroll and wait controls rather than treating it as an infinite page.

7. Rule out layout and output constraints

Viewport-height backgrounds: For layouts using 100% height or 100vh backgrounds, Urlbox’s detection attempts to avoid stretched sections by limiting section and viewport height. The detect_full_height option controls this check. If the page looks stretched or its sections are unexpectedly sized, inspect this behavior.
Horizontal overflow: If the page scrolls sideways and the right side is missing, try full_width=true.
Image format limits: The screenshots guide lists dimension limits for JPEG and WebP and recommends PNG for full-page captures when size limits are a concern. If a long capture is clipped or cannot be represented in the selected format, try PNG and review output dimensions.

8. Diagnostic sequence

Set full_page=true and use stitch mode.
Review max_sections, max_height, max_section_height, and any supplied height.
Keep initial scrolling enabled; do not use skip_scroll=true while checking for lazy content.
Try smaller scroll_increment and longer scroll_delay if content appears as the page scrolls.
Set a relevant wait_until or wait for a content selector / loading indicator as appropriate.
Use show_seams=true to locate stitching problems; test freeze_fixed=false if fixed UI behaves unexpectedly.
For an infinite feed, decide whether continued scrolling is needed; if enabled, retain a section bound.
Check viewport-height detection, horizontal width, and format dimensions.
Compare stitch with native only after the page’s loading behavior and limits are understood.

9. Common symptoms and fixes

Symptom	Likely cause	What to try
Screenshot ends at a consistent height	A section, total-height, or viewport-height limit	Review `max_sections`, `max_height`, `max_section_height`, and `height`.
Images or cards below the fold are absent	Lazy loading did not run, scrolling was skipped, or steps were too large	Keep initial scrolling enabled; avoid `skip_scroll=true`; try smaller `scroll_increment` and longer `scroll_delay`.
Top content is present but newly rendered sections are missing	Navigation readiness ended before the content appeared	Adjust `wait_until`, wait for a relevant selector, or wait for the loading indicator to leave; set an appropriate `wait_timeout`.
A feed stops after a few sections	Infinite-scroll protection	Use `allow_infinite=true` only when continued content is required, and set a sensible `max_sections`.
Headers or footers repeat, or joins look wrong	Sticky/fixed positioning or a stitch boundary	Inspect with `show_seams=true`; compare behavior with `freeze_fixed=false`.
Backgrounds stretch or section heights look wrong	A full-height layout such as `100vh` interacting with section sizing	Review `detect_full_height` and the supplied height settings.
Right edge is missing	Horizontal scrolling is not included in the capture width	Try `full_width=true`.
Long capture is constrained by image output	Format-specific dimension limits	Try PNG for full-page output and review the documented format limits.

10. Performance, reliability, and cost considerations

Stitching and scrolling take more work than a native full-page capture. Smaller scroll increments and longer delays can improve the chance of triggering delayed content, but add time. Waiting for a specific selector can avoid waiting longer than necessary when the page provides a dependable readiness marker. Skipping scroll can save time, but reduces coverage for content that loads on scroll.

For repeatable captures, use the same readiness condition, scroll settings, and bounds for the same page type, and inspect representative output after changing them. Infinite scrolling and unbounded dimensions need explicit limits. The dossier provides no independent benchmark, universal reliability figure, or Urlbox pricing detail, so costs and timing should be checked against your own plan and workload.

11. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. One GET request returns a screenshot or PDF. For a WebP shot of the same example page:

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

See the ScreenshotNeo API documentation for request options. ScreenshotNeo removes cookie banners, popups, and chat widgets before the shot; those steps can be turned off. Bot checks, blank pages, and failed loads are never billed, and the response identifies the page verdict and billing status. Its MCP server lets AI agents use take_screenshot, get_page_info, and capture_pdf. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 shots. Sign up for the free plan.

12. FAQ

Should I always use stitch mode?

Use stitch first when diagnosing missing content because it scrolls through the page and captures sections. Native mode is faster, but Urlbox says it may not work well on every site.

Does a successful screenshot response prove all page content loaded?

No. In particular, a missing selector in wait_for does not necessarily fail the request by default. Check that the expected content is visible in the result.

Why does an infinite page stop after three sections?

Urlbox’s infinite-scroll detection uses a three-section default limit to avoid an endless capture. Enable allow_infinite=true only if continuing is intended, and cap the capture with max_sections.

Which image format should I try for a very tall page?

The Urlbox screenshots guide recommends PNG for full-page captures when image dimension limits are a concern; check the documented limits for JPEG and WebP as well.