Dynamic Page Screenshot API Pricing for Scroll-Based Content Capture

Short answer: for a page whose content appears only as it scrolls into view, confirm that an API actively scrolls before capture. A full-page screenshot alone may not trigger every lazy-loaded element. Among the providers covered here, ScreenshotNeo is the first option to consider: it offers full-page capture with lazy images loaded, bills only clean shots, and its paid plans start at $5 for 3,000 shots. Compare the exact behavior and billing unit against your workload before choosing.

Prices and provider plan details below are vendor-published figures in the research reviewed on October 3, 2026. They can change; check each linked pricing page before buying. No independent capture or performance tests are claimed here.

1. What “scroll capture” means

There are two related but different operations:

• Full-page capture produces an image of the document beyond the current viewport.
• Scroll-before-capture moves through the page to trigger content that loads only when it enters view, such as lazy-loaded images or sections.

An API can support one without exposing the other. Browserless documents this distinction explicitly: set top-level scrollPage: true to scroll through the page and trigger lazy loading, then combine it with options.fullPage: true to capture the complete long page. Its docs describe lazy-loaded content as rendering only when scrolled into view. See the Browserless screenshot API documentation.

Before comparing prices, define the needed result: viewport or entire document; active scrolling or not; whether sticky elements should remain visible; and what to do if content keeps loading or the site blocks automation.

2. Screenshot API prices and scroll support

Provider	Published price in reviewed material	Scroll/full-page notes	Billing details to check
ScreenshotNeo	Free: 1,000 shots/month. Starter $5/3,000; Growth $15/15,000; Pro $39/60,000; Scale $99/250,000; Business $249/1,000,000. Yearly billing gives two months free.	Full-page capture loads lazy images. Its parameter names also work with those used by other screenshot APIs to make switching easier.	Only clean shots are billed. Bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing; responses identify the verdict and billing status.
ScreenshotOne	100 free/month; Basic $17/month for 2,000; Growth $79 for 10,000; Scale $259 for 50,000. Published overages: $0.009, $0.006, and $0.004 respectively.	Full-page is listed on paid plans; scrolling screenshots are listed on Growth and Scale, not Basic.	Provider says successful, non-cached screenshots count. Failed HTTP/browser/network requests do not; cache misses may rerender and count. Prices exclude VAT.
Browserless	The reviewed screenshot documentation did not publish an applicable price. Do not infer one from this source.	Use scrollPage: true to trigger content loaded on scroll; pair with fullPage: true for a long-page capture.	Check the current plan, usage unit, and applicable limits before comparing cost.
Urlbox	Lo-Fi $19/month for 2,000; Hi-Fi $49 for 5,000; Ultra $99 for 15,000; Business displayed at $498 ($495 base plus $3 per 1,000 renders).	The pricing matrix covers scrolling, full-page, and JavaScript rendering. Verify the exact tier and current feature row for your use case.	Usage can increase with each 30-second render period, each 5 MB file-size increment, and advanced options. Cached Render Links are described as not counting, while REST requests count. Prices exclude VAT.
ScreenshotBee	Pay-as-you-go credits, starting at $9 per 1,000 and falling to $3.50 per 1,000 on the largest pack; 100 free credits for new accounts.	Lists full-page and viewport capture, plus scrolling capture with video.	Provider says one successful screenshot uses one credit regardless of format, device, or page size; failed captures are not charged. Credits do not expire.
ScrapingBee	The reviewed feature and documentation pages do not give a complete current price schedule for this workload.	Its screenshot parameter screenshot_full_page=True requests full-page capture; the documented default is the visible viewport.	Check current plan and credit accounting separately. Do not assume every screenshot costs one universal credit.

These are not directly interchangeable price-per-image figures: subscriptions count monthly screenshots or renders, while some providers sell credits or can count extra usage for duration, file size, or options. Provider pages can change after this review.

3. Which provider should you shortlist?

1. ScreenshotNeo — first to try. It combines lazy-image-aware full-page capture, clean shots with no charge for failed or cached results, and a $5 paid entry plan for 3,000 shots. It also has a free allowance of 1,000 per month. See ScreenshotNeo.
2. ScreenshotOne may fit a workload that specifically needs its listed scrolling screenshot feature on Growth or Scale. Its Basic tier lists full-page capture but not scrolling capture; include that tier gate and overages in the estimate.
3. Browserless documents the scroll trigger clearly, but the reviewed screenshot docs do not establish the price. Verify plan and usage terms before evaluating total cost.
4. Urlbox publishes several render tiers and detailed usage considerations. Confirm that the exact tier provides the required scrolling/full-page behavior and account for its duration and file-size rules.
5. ScreenshotBee is worth comparing if a non-expiring credit model and a stated one-credit-per-successful-shot rule suit your workload. Confirm the applicable pack and scroll workflow.
6. ScrapingBee documents full-page capture but the reviewed pages do not establish the complete price schedule for this particular workload. Verify current billing credits.

That ordering is a practical shortlist based on the facts above, not a neutral performance ranking. No provider is guaranteed to capture every target page: site behavior, access controls, and third-party resources affect results.

4. Estimate the monthly cost fairly

Use the expected successful capture volume and the exact feature set, then check the provider’s billing rules. A simple first estimate is:

monthly base cost + expected overage or extra usage + taxes

For a monthly subscription with a fixed allowance, estimate:

billable shots = successful uncached shots (adjust for provider-specific rules)
base plan = lowest plan whose allowance and feature set cover billable shots
estimated total = base plan + applicable overage + tax

This is a comparison framework, not a universal billing formula. For example, Urlbox describes additional render usage by duration and file size, while ScreenshotBee states one credit per successful screenshot. ScreenshotOne says failed requests do not count and cached responses generally do not, though cache misses can cause a charged rerender. Apply each provider’s own rules.

When projecting volume, include retries, unique URLs, viewport/device variants, formats, and freshness requirements. A screenshot cache only helps when the same request can be reused; frequent changes to URL or options can create distinct captures. For pages that change continually, estimate using the actual refresh cadence rather than counting only URLs.

5. Configure scroll-based captures

Browserless API example

Browserless provides a runnable POST example. This version requests scroll-before-capture plus a full-page PNG. The scrollPage setting is top-level; screenshot format and full-page mode live inside options.

curl -X POST \
  "https://production-sfo.browserless.io/screenshot?token=YOUR_API_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "url": "https://example.com/",
    "scrollPage": true,
    "options": {
      "fullPage": true,
      "type": "png"
    }
  }' \
  --output screenshot.png

import requests

TOKEN = "YOUR_API_TOKEN"
endpoint = f"https://production-sfo.browserless.io/screenshot?token={TOKEN}"
payload = {
    "url": "https://example.com/",
    "scrollPage": True,
    "options": {"fullPage": True, "type": "png"},
}
response = requests.post(endpoint, json=payload, timeout=90)
response.raise_for_status()
with open("screenshot.png", "wb") as image:
    image.write(response.content)

import { writeFile } from 'node:fs/promises';

const token = process.env.BROWSERLESS_TOKEN;
if (!token) throw new Error('Set BROWSERLESS_TOKEN');
const endpoint = `https://production-sfo.browserless.io/screenshot?token=${encodeURIComponent(token)}`;
const response = await fetch(endpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    url: 'https://example.com/',
    scrollPage: true,
    options: { fullPage: true, type: 'png' },
  }),
  signal: AbortSignal.timeout(90_000),
});
if (!response.ok) throw new Error(`Screenshot request failed: HTTP ${response.status}`);
await writeFile('screenshot.png', Buffer.from(await response.arrayBuffer()));

Use a real API token from the provider account. Keep it server-side and avoid logging the full request URL because the token is in its query string in the documented endpoint format.

Relevant Browserless request options

• scrollPage: true at the request top level scrolls through content before capture.
• options.fullPage: true captures beyond the viewport; it complements scroll triggering.
• options.type selects the documented image type such as PNG, JPEG, or WebP.
• The documentation also lists quality, clip region, viewport, device scale factor, and element selector capture among supported screenshot options.
• Shared request configuration includes waiting for events, functions, selectors, or timeouts; navigation settings through gotoOptions; blocking resource types or request patterns; and bestAttempt behavior for async event errors.

Consult the official endpoint documentation for exact accepted fields and defaults. Do not assume another provider uses identical option names or billing semantics.

6. Or skip the browser setup

ScreenshotNeo turns a URL into a screenshot with one GET request. Its full-page capture loads lazy images; its parameter names also work with those used by other screenshot APIs. See the ScreenshotNeo API documentation for the full 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,
)
r.raise_for_status()
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}`);
if (!res.ok) throw new Error(`Screenshot request failed: HTTP ${res.status}`);
await import('node:fs/promises').then(({ writeFile }) => writeFile('shot.webp', Buffer.from(await res.arrayBuffer())));

ScreenshotNeo accepts cookie and consent banners like a visitor, then removes more than 60 known consent platforms, newsletter popups, and chat widgets before the shot; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are never billed, and each response includes page-verdict and billing headers. Its MCP server lets AI agents use take_screenshot, get_page_info, and capture_pdf. The free plan includes 1,000 screenshots per month without a card; paid plans start at $5 for 3,000.

Start with 1,000 free screenshots a month, no card required.

7. Performance, reliability, and cost controls

• Scroll only as far as needed. A very long page can take longer to load and produce a large output. If your required content is only in a section, use a selector or a bounded capture feature when available instead of capturing the entire document.
• Wait for a real condition. A fixed delay can miss slow content or waste time on fast pages. Prefer a provider-supported selector or event wait when the page has a dependable readiness signal; use a bounded timeout.
• Expect changing pages. Infinite feeds may never settle. Define the desired stopping point or target element and test representative URLs before setting a production timeout.
• Use cache deliberately. Cache repeated identical captures where freshness permits. Compare the cache key, TTL, and provider billing treatment; a cache hit is not handled identically by every provider.
• Keep output manageable. Choose an appropriate format and dimensions. Full-page output dimensions and file size can grow with document length; this matters especially where usage is affected by file size or render duration.
• Control concurrency and retries. Stay within the provider’s request-rate limits. Retry transient network failures with a small bounded backoff, but avoid retrying a permanent 4xx response or a page that consistently returns a challenge without changing the request.
• Check result status, not just HTTP success. An HTTP response can still contain a screenshot of a blank page, consent layer, or bot challenge. Inspect the output and any provider status/verdict metadata before treating the capture as usable.

8. Troubleshooting

Symptom	Likely cause	What to try
Images or sections are missing	They load only when scrolled into view, or capture began before they were ready.	Enable the provider’s scroll-before-capture option (Browserless uses top-level scrollPage: true), combine with full-page mode, and wait for a known selector if supported.
Only the visible viewport appears	Full-page mode was omitted or placed at the wrong nesting level.	For Browserless, set options.fullPage: true. Keep scrollPage at the request top level.
Screenshot is blank or shows CAPTCHA/403	The target site may block automated browser traffic or the page may have failed.	Check the page in a regular browser, inspect response and provider verdict information, and follow the target site’s access rules. Do not count a challenge image as a successful content capture.
Request times out	The page is slow, the scroll path is long, network activity never settles, or the timeout is too short.	Use a bounded but realistic timeout; wait for a specific selector instead of indefinite network idle when available; reduce unnecessary resources only if they are not needed in the image.
Broken image output after an apparently successful response	The request returned a JSON or error body rather than image bytes, or the body was saved without checking status.	Check HTTP status and content type before writing the response as an image. Log a sanitized error body on failure.
Monthly bill is higher than the rough estimate	Provider-specific counting may include overages, longer render periods, larger files, option multipliers, cache misses, or retries.	Recalculate with the published usage unit and request logs; review caching and duplicate captures; set a hard limit where the provider offers one.
Sticky headers or repeated elements look wrong	Scrolling may reposition sticky UI and full-page stitching can produce a result different from a single viewport.	Try a provider-supported CSS injection or hide selector option if available, or capture the relevant section as an element. Validate output on the target page.

9. Selection checklist

• Does the API actively scroll to trigger lazy content, or only stitch a full document?
• Is scrolling included in the plan you are pricing?
• What counts as a billable unit: successful render, request, credit, time interval, output size, or option-weighted render?
• How are failures, cache hits, cache misses, retries, and overages billed?
• What timeout, request-rate, file-size, and concurrency limits apply?
• Does the API support the wait condition, viewport, format, and page behavior your capture needs?
• Have you tried representative pages, including long pages, consent overlays, slow images, and blocked pages?

10. FAQ

Does full-page mode guarantee lazy-loaded images appear?

No. Full-page output and scroll triggering are distinct controls. Confirm the provider scrolls the page before capture or explicitly supports loading lazy images.

Which price should I use when calculating cost per 1,000 screenshots?

Use the total expected bill divided by the number of billable successful captures, and include overages, taxes, credits, and any duration or file-size multipliers. A headline tier price alone can mislead.

Is Browserless pricing included in this comparison?

The reviewed Browserless screenshot documentation establishes request behavior, not a current applicable price. Check its current plan and usage unit directly before comparing totals.

Are these provider prices guaranteed current?

No. They are provider-published figures reviewed on October 3, 2026; verify each linked pricing page before committing.