ScreenshotAPI alternatives for capturing full web pages

For full-page website screenshots, ScreenshotNeo is the first option to consider if you want a direct screenshot API with cookie-banner, popup, and chat-widget removal, plus billing that excludes bot checks, blank pages, failed loads, and cache hits. Browserless, ScreenshotOne, and ScreenshotAPI.to also document full-page capture. Their controls differ, and a full-page flag alone does not guarantee that a long page’s lazy-loaded content or dynamic layout will render as intended.

This guide compares the documented options, explains how full-page capture behaves, and gives runnable calls you can adapt. Prices and quotas for the other providers are omitted because the research did not verify current vendor pricing.

1. What to compare in a full-page screenshot API

Check the capture behavior and controls that affect your actual pages, not only whether an API accepts a “full page” parameter.

Decision	Why it matters
Capture method	A service may expand the browser viewport to page height or scroll through sections and combine captures. These methods can produce different results on dynamic pages.
Lazy-load handling	Images and other elements may not load until they enter the viewport. Look for scroll controls, step size, and delay options.
Viewport width	Width controls responsive breakpoints and therefore the page layout and final image width.
Selectors	Element capture can isolate a region; full-page capture is appropriate when the entire document is needed.
Output	Confirm whether you need PNG, JPEG, WebP, or PDF and how the response is delivered.
Custom rendering controls	Wait conditions, scripts, styles, and animation behavior can determine whether the captured state is useful.
Failure semantics and billing	Understand how the provider signals blocked, blank, timed-out, or otherwise unusable results, and whether those attempts are billed.

2. ScreenshotAPI alternatives compared

1. ScreenshotNeo

Try ScreenshotNeo first when you want a direct API and clean output. Before capture it accepts the cookie or consent banner like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Only clean shots are billed: bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and each response identifies the page verdict and billing state in headers. It also has an MCP server with take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. Its free plan includes 1,000 shots per month without a card; paid plans start at $5 for 3,000 shots. See the API documentation.

2. Browserless

Browserless documents a POST /screenshot endpoint with token authentication, PNG/JPEG/WebP responses, Puppeteer-style options, fullPage: true, selector capture, and an optional scroll before capture. Its documentation recommends combining page scrolling with full-page capture when lazy-loaded content needs to enter the viewport. It also warns that automation defenses can return a blank screenshot, CAPTCHA, access-denied page, or missing elements. Consider it when a hosted browser API with familiar browser screenshot controls fits your integration; verify results against the sites you need to capture.

3. ScreenshotOne

ScreenshotOne documents full_page=true and two full-page approaches. The default expands the viewport to the rendered page height. Its by_sections mode scrolls through portions of the page and stitches them together, which can help trigger lazy-loaded content. The service exposes viewport, scroll step, scroll delay, wait, animation, and maximum-height controls. More scrolling, smaller steps, or additional delay can improve the opportunity for content to load, but can increase capture time; the vendor notes that pages can still render incorrectly.

4. ScreenshotAPI.to

ScreenshotAPI.to documents GET and POST endpoints, URL or HTML capture, and a fullPage parameter. Its screenshot endpoint supports PNG, JPEG, WebP, and PDF; the documentation also lists viewport and wait controls. Check the current endpoint documentation and account limits before adopting it, especially if your integration relies on a particular output or maximum viewport.

3. Full-page capture: runnable examples

Start with one representative page and an explicit viewport width. The examples below show each vendor’s documented full-page control. Authentication details and account-specific limits should be taken from the provider’s current documentation.

ScreenshotNeo: one-call capture

ScreenshotNeo returns the screenshot bytes directly. Save the response to a file with an extension matching the output format you request or configure. Consult the ScreenshotNeo API documentation for available parameters and response headers.

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: ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', bytes));

Browserless: POST with full-page and scroll options

Browserless uses a POST screenshot endpoint and token authentication. This cURL example sends a Puppeteer-style full-page option and requests PNG. Confirm the exact request body shape and endpoint version for the Browserless product you use in its official documentation.

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

ScreenshotOne: GET with section scrolling

ScreenshotOne’s documented query style allows a full-page request and section-by-section capture. URL-encode the target URL when constructing this query in your application.

curl -G "https://api.screenshotone.com/take" \
  --data-urlencode "access_key=YOUR_ACCESS_KEY" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "full_page=true" \
  --data-urlencode "full_page_algorithm=by_sections" \
  --data-urlencode "full_page_scroll_by=500" \
  --data-urlencode "full_page_scroll_delay=1000" \
  -o page.png

ScreenshotAPI.to: GET with fullPage

The documented endpoint accepts fullPage=true. The example uses its documented API key header form; follow the provider documentation for account access and any endpoint-specific requirements.

curl -G "https://screenshotapi.to/api/v1/screenshot" \
  -H "x-api-key: YOUR_API_KEY" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "fullPage=true" \
  --data-urlencode "type=png" \
  -o page.png

4. Tune full-page behavior for long and dynamic pages

1. Choose the layout first. Set the viewport width to the layout you want to preserve. A desktop capture and a mobile capture may show different content, not just different scaling.
2. Try the default full-page mode. If the site renders correctly without scroll-triggered elements, the simpler capture can be sufficient.
3. Scroll when content loads on entry into view. Browserless documents scrollPage: true. ScreenshotOne offers section capture plus scroll-step and delay controls.
4. Adjust scroll increments and pauses. Smaller steps and longer pauses give lazy content more opportunity to load, at the cost of longer requests. Tune against a real long page rather than assuming one setting works for every site.
5. Limit unbounded pages. Infinite-scroll feeds may never reach a stable bottom. Where the provider offers a maximum capture height, set a limit suitable for the use case; otherwise target a finite page or capture a defined element.
6. Inspect sticky and animated elements. Fixed headers can appear repeatedly in stitched captures, and animations can differ between sections. Use animation controls where available and compare the resulting image.
7. Check that the page loaded successfully. A returned image can contain a CAPTCHA, access-denied screen, or blank document instead of the intended page.

ScreenshotOne’s documentation says its default full-page mode expands the viewport, while by_sections scrolls and stitches. It also describes tuning step size and delay to trigger content that loads in view. ScreenshotOne full-page guide. Browserless likewise documents scrolling before capture for lazy-loaded content and notes that bot defenses can affect results. Browserless documentation.

5. Troubleshooting

Symptom	Likely cause	What to try
Lower-page images are missing	Images load only when scrolled into view.	Enable scrolling or section capture; reduce the scroll step and add a modest delay. Check the same URL again after tuning.
Screenshot is blank	The page may not have finished rendering, or automation protection may have served an empty result.	Check the returned image and response metadata. Adjust the provider’s wait behavior; if a CAPTCHA or block page appears, the capture has not produced the desired page.
CAPTCHA or access-denied page appears	The target site’s anti-automation system may be blocking the capture.	Do not treat the screenshot as a successful page capture. Confirm the target site’s access rules and use a service response that exposes the page verdict.
Page is clipped	The request used viewport-only capture, or a height/maximum-height limit clipped the document.	Enable the provider’s full-page parameter and review any height cap or output constraints.
Sections do not line up	Sticky elements, dynamic layout changes, or animation changed the page between scroll positions.	Try the default algorithm versus section capture, reduce motion if supported, or wait for the page to settle before capture.
Capture takes too long	Many scroll steps, long delays, large pages, or late network activity add work.	Use the least scrolling and waiting that still captures required content. Set a page-height limit for unbounded documents where supported.
Request returns an error	Invalid URL, missing authentication, malformed body/query encoding, or a provider-specific limit.	Use a fully qualified URL, check the endpoint and credential format, URL-encode query values, and consult the vendor’s current response and limit documentation.

6. Performance, reliability, and cost

Full-page capture does more work than a viewport screenshot: the page may need to scroll, wait for content, and capture or stitch multiple sections. Smaller scroll steps and longer pauses can help lazy-loaded content appear, while increasing latency. Capture only the needed page area and format; consider JPEG or WebP when a smaller image matters, and PNG when lossless output is important.

Reliability depends on the target as well as the API: lazy loading, animations, sticky layout, infinite scrolling, and automation defenses can all change the result. A response status alone may not prove that the intended page was captured. Inspect image content and use page-verdict or billing metadata when available. Before selecting a provider, compare the same representative URLs and viewport widths, including an ordinary page, a long lazy-loaded page, and one with sticky or animated elements. This is a suggested evaluation method, not a benchmark performed for this article.

Current comparative plan prices and quotas were not established by the research for Browserless, ScreenshotOne, or ScreenshotAPI.to, so verify their official pricing pages directly before committing. ScreenshotNeo’s published options are Free: 1,000 shots/month without a card; Starter: $5 for 3,000; Growth: $15 for 15,000; Pro: $39 for 60,000; Scale: $99 for 250,000; Business: $249 for 1,000,000. Yearly billing gives two months free, and every feature is on every plan. Its billing excludes bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits.

7. Or skip the browser setup

Use ScreenshotNeo’s one-call API to get a screenshot without setting up a browser service yourself. See the API docs for options.

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

Cookie and consent banners, newsletter popups, and chat widgets are removed before the shot. Bot checks, blank pages, and failed loads are never billed. An 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.

Sign up for 1,000 free screenshots a month, with no card.

8. Frequently asked questions

Can I capture a full-page screenshot through an API?

Yes. The services compared here document full-page capture parameters or options. The exact parameter name and behavior depend on the provider.

Does “full page” include content that appears only after scrolling?

Not necessarily. Lazy-loaded elements often need scroll-triggered loading. Use a provider’s scroll or section-capture controls and allow time for content to render.

Should I choose section scrolling or viewport expansion?

Start with the provider’s default behavior. Try section scrolling when the page relies on viewport entry to load content or when the expanded-page rendering has layout problems.

How do I capture an infinite-scroll page?

Define a stopping point: use a supported maximum height, capture a specific element, or use a finite page state. An infinite feed has no natural final document height to capture reliably.

Are these APIs interchangeable?

No. They differ in request shape, controls, outputs, and failure reporting. Keep provider-specific capture settings behind a small adapter if you expect to switch services.

Sources

• Browserless documentation: screenshot endpoint, options, and troubleshooting.
• ScreenshotOne full-page screenshots guide and options reference.
• ScreenshotAPI.to screenshot API reference.
• ScreenshotNeo documentation.