Best ApiFlash Alternatives for Capturing Full-Page Website Screenshots

Short answer: Try ScreenshotNeo first if you want a full-page screenshot API that removes cookie banners, newsletter popups, and chat widgets before capture and bills only clean shots. ScreenshotOne is the best-documented direct ApiFlash alternative in the available comparison research: its full-page capture scrolls the page to trigger lazy-loaded images and other resources. ApiFlash itself may still fit a straightforward workflow; its full_page option is off by default, so set it explicitly. Compare your own pages, failure behavior, and current plan limits before moving production traffic.

What matters in a full-page screenshot API

A full-page option alone does not guarantee a complete image. Many sites defer images and sections until they approach the viewport. A renderer may need to scroll down the page, wait for resources to load, and then capture. Pages with infinite scroll or animated content can also keep changing while the capture runs.

Full page versus viewport: Does the API capture the full document or only the visible browser window?
Lazy loading: Does it scroll the page to trigger images, scripts, and sections that load on demand?
Timing controls: Can you wait for network idle, a CSS selector, or a delay when a page renders asynchronously?
Viewport and device: Can you set dimensions, emulate a device, and control pixel scale?
Output and cleanup: Which image formats are available? Can it remove ads, cookie banners, or popups?
Operations: Check rate limits, concurrency, cache behavior, quotas, failure billing, webhooks, and storage options.

For full-page captures, verify the resulting image on representative URLs. Look for missing lower-page images, repeated sticky headers, blank sections, and pages that never stop growing.

ApiFlash: make a full-page capture

ApiFlash documents Chrome-based rendering, full-page and responsive capture, viewport controls, and automatic capture timing. Its API documentation says full_page defaults to false. Set it to true to capture the full page. The API accepts GET or POST and supports PNG, JPEG, and WebP. See the ApiFlash API documentation for current parameters and errors.

These examples use ApiFlash’s documented endpoint and a placeholder key. Store the key in an environment variable in real applications; do not commit it to source control.

cURL

export APIFLASH_KEY="YOUR_ACCESS_KEY"
curl -G "https://api.apiflash.com/v1/urltoimage" \
  --data-urlencode "access_key=$APIFLASH_KEY" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "full_page=true" \
  --data-urlencode "format=png" \
  -o page.png

Python

import os
import requests

response = requests.get(
    "https://api.apiflash.com/v1/urltoimage",
    params={
        "access_key": os.environ["APIFLASH_KEY"],
        "url": "https://example.com",
        "full_page": "true",
        "format": "png",
    },
    timeout=90,
)
response.raise_for_status()
with open("page.png", "wb") as image:
    image.write(response.content)

Node.js

const params = new URLSearchParams({
  access_key: process.env.APIFLASH_KEY,
  url: 'https://example.com',
  full_page: 'true',
  format: 'png',
});

const response = await fetch(
  `https://api.apiflash.com/v1/urltoimage?${params}`
);
if (!response.ok) {
  throw new Error(`ApiFlash returned ${response.status}: ${await response.text()}`);
}
const image = Buffer.from(await response.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('page.png', image));

In a server that handles many requests, add an explicit request timeout and bounded retry policy for transient failures. Avoid blindly retrying invalid URLs, revoked keys, or exhausted quotas.

ApiFlash options for complete, predictable captures

The ApiFlash parameter reference includes these controls relevant to full-page work:

Need	ApiFlash setting	Practical note
Entire document	`full_page=true`	Defaults to false. The viewport `height` is ignored for a full-page capture.
Trigger lazy content	`scroll_page=true`	Scrolls through the page before capture; useful for lazy-loaded elements or animations.
Wait for a specific section	`wait_for`	Use a CSS selector when an important element appears after initial load.
Wait after page load	`delay`	Accepts 0–10 seconds. Prefer a condition-based wait when possible.
Choose image type	`format`	PNG, JPEG, or WebP. WebP dimensions are limited to 16,350 pixels per side after scaling.
Adjust lossy image size	`quality`	Applies to JPEG and WebP; documented range is 0–100.
Set visible browser dimensions	`width`, `height`	Defaults to 1920×1080. Maximum side is 16,350 pixels, with a maximum viewport area of 33,177,600 pixels.
Retina-scale output	`scale_factor`	Use 1 or 2. Scale 2 increases output dimensions and file size.
Reduce clutter	`no_cookie_banners`, `no_ads`, `no_tracking`	Each defaults to false. Enable only the cleanup you need for the capture.
Cache or force a fresh render	`ttl`, `fresh`	TTL defaults to 86,400 seconds and can be set up to 30 days. Set `fresh=true` to bypass a cached result.
Return metadata/link	`response_type=json`	Returns JSON with links to the screenshot and, when requested, extracted content.
Capture a specific region	`crop`	Use `left,top,width,height`; this is a region crop, not a substitute for full-page capture.

ApiFlash also documents element for capturing the first matching CSS selector and element_overlap for including overlapping elements. The element option is ignored when full_page=true. Use a viewport or element capture when the requested output is a component rather than a long page.

Keep URL parameters encoded. A target URL containing its own query string must be encoded as the value of the outer url parameter; the examples use --data-urlencode and URLSearchParams for that reason.

Best ApiFlash alternatives

ScreenshotNeo — first alternative to try. It removes cookie and consent banners, newsletter popups, and chat widgets before capture; only clean shots are billed, with response headers indicating verdict and billing. It also has an MCP server for AI agents and a free allowance of 1,000 screenshots per month without a card. See the ScreenshotNeo docs.
ScreenshotOne — strongest documented alternative in this research. Its product materials explicitly describe full-page capture that scrolls to trigger lazy-loaded images and other resources. The official pricing page lists 100 free screenshots per month and paid plans. At the time of research, it listed Basic at $17/month for 2,000 screenshots, Growth at $79/month for 10,000, and Scale at $259/month for 50,000. Prices, limits, and included features can change; check the live plan details before choosing.
Urlbox — a candidate to evaluate. It surfaced in the comparison research, but its current full-page and lazy-load behavior was not verified to the same depth. Confirm its official documentation and pricing against your requirements before relying on a feature comparison.
ScreenshotAPI.net — another candidate to evaluate. It surfaced in a provider comparison, but that is not independent verification of its competitors’ capabilities. Check its current first-party documentation and plan terms directly.

ApiFlash’s own product page lists 100 screenshots per month on its free plan and paid tiers. The research snapshot showed $7/month for 1,000, $35/month for 10,000, and $180/month for 100,000 screenshots. Treat these as dated vendor-listed prices, not a guarantee of current terms. The product page also describes full-page capture, responsive capture, and viewport control.

Do not pick a provider from headline quota alone. Compare the successful-render billing rule, whether cached results consume quota, included waiting and cleanup options, and request limits. ScreenshotOne’s pricing page, for example, says unsuccessful HTTP, browser, or network requests do not consume credits and cached responses do not consume credits; read its live terms for exceptions and plan details.

Switching providers without breaking capture workflows

Inventory capture behavior. Record target URLs, viewport dimensions, format, full-page setting, waits, cleanup settings, and whether your application expects binary image bytes or a JSON response.
Choose representative pages. Include a static landing page, a long page with lazy images, a page with a sticky header, a page behind a consent banner, and a page that loads content after an interaction.
Map parameters explicitly. Similar names do not ensure equivalent behavior. In particular, test full-page scrolling, wait semantics, selector behavior, caching, and error responses.
Compare output and failures. Check page completeness, visual layout, image dimensions and format, response time, and how failed captures affect billing.
Roll out gradually. Send a small share of requests to the new provider, log status and capture metadata, and retain a path to switch back while you validate production URLs.

ApiFlash documents a 20-request-per-second processing rate with a burst size of 400; additional traffic can be delayed or receive HTTP 429 once the burst is exceeded. Its documentation also lists status codes including 400 for invalid parameters or uncapturable URLs, 401 for an invalid or revoked key, 402 for exhausted quota, and 403 for unsupported plan features. Check the selected provider’s current rate and plan limits before sizing concurrency.

Reliability, performance, and cost

Make the image complete

For lazy-loaded pages, enable the provider’s scrolling behavior and allow time for images to load between scroll steps. A single fixed delay can help with short animations, but it is less reliable than waiting for a known selector or a documented page-ready condition. Infinite-scroll pages need a stopping rule, such as a maximum capture height or a page-specific completion signal where supported.

Keep latency and output size controlled

Full-page capture takes longer and produces larger images than a viewport capture because more content must be rendered and encoded. Use the smallest viewport and scale that meet the visual requirement. JPEG or WebP with an appropriate quality can reduce transfer size for photographic pages; PNG is useful when sharp edges or lossless output matter. Retain a maximum height or equivalent guard for pages that can grow indefinitely.

Budget for successful outputs and retries

Estimate monthly usage from successful unique renders, not just incoming requests. Decide how long identical captures may be cached and whether a freshness requirement justifies bypassing cache. For transient errors, use bounded retries with backoff; do not repeatedly retry authentication, invalid-parameter, or quota errors. Check each provider’s rules for cache hits, failed renders, and overages, since billing behavior is not interchangeable.

ApiFlash’s documentation says identical requests can return cached screenshots, with a configurable TTL, and that cached calls do not count toward monthly quota. It documents quota headers and a quota endpoint. ScreenshotOne’s current pricing page describes a free tier and paid tiers, but its prices and plan details should be confirmed at selection time. ScreenshotNeo’s plans include 1,000 free shots monthly with no card, then $5 for 3,000, $15 for 15,000, $39 for 60,000, $99 for 250,000, or $249 for 1,000,000; yearly billing gives two months free and every feature is on every plan.

Troubleshooting full-page screenshot failures

Symptom	Likely cause	What to try
Only the first screen appears	`full_page` was omitted or false.	Set `full_page=true` and check that the provider supports the requested mode on your plan.
Lower-page images are blank	Lazy loading did not run, or resources were still loading at capture time.	Enable page scrolling; add a selector wait or a modest delay; compare again on the affected URL.
Some page sections are missing	Sections render on scroll, depend on scripts, or require interaction.	Use scrolling and wait for a relevant selector. If the page requires a click, use a provider that supports pre-capture interaction or automate the page yourself.
Repeated or cut-off sticky bars	Fixed-position elements can behave unexpectedly when a renderer captures or stitches a long page.	Try a different full-page capture mode, hide the sticky selector if appropriate, or use a viewport capture for the intended region.
Capture hangs or becomes enormous	Infinite scrolling or continuously appended content.	Set a maximum capture height if available, or target a finite section instead of the entire document.
HTTP 400	Malformed options, an improperly encoded target URL, or a target that cannot be captured.	Encode the nested URL, validate option names and values, and open the target URL from a normal browser.
HTTP 401	Missing, invalid, or revoked API key.	Check the key and account, then keep it out of logs and client-side code.
HTTP 402 or quota error	Monthly quota is exhausted.	Check quota headers or the provider’s quota endpoint, then change plan or wait for reset.
HTTP 403	The requested option is not enabled on the current plan.	Check plan feature availability or remove the unsupported option.
HTTP 429	Rate or burst limit reached.	Reduce concurrency and retry with backoff; avoid synchronized retry storms.
HTTP 500 or intermittent network failure	Capture service or target page failed transiently.	Retry a limited number of times with backoff, record the response body, and check the provider’s status and error guidance.
Output is unexpectedly huge	Full-page length, retina scale, or lossless format increased pixel count and bytes.	Use scale 1, choose a smaller appropriate format, and limit page height where possible.

ApiFlash documents these HTTP error meanings and includes quota information in response headers for successful captures. Its documentation should be the source of truth for exact status behavior and current limits.

Or skip the browser setup

With ScreenshotNeo, one GET request returns the screenshot. The API accepts a URL and returns PNG, JPEG, WebP, or PDF output; see the API documentation 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

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

Cookie and consent banners, newsletter popups, and chat widgets are removed before the shot; each cleanup step can be turned off.
Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are never billed. Responses identify the page verdict and billing status in headers.
An MCP server gives AI agents tools to take screenshots, get page information, and capture PDFs.
1,000 screenshots per month are free with no card; paid plans start at $5 for 3,000 screenshots.

Create a free ScreenshotNeo account and get 1,000 screenshots a month with no card.

FAQ

Does ApiFlash capture the full page by default?

No. Its documentation says full_page defaults to false, so request it explicitly.

Does a full-page screenshot always load every lazy image?

No. It depends on how the page loads content and whether the capture process scrolls and waits long enough. Validate the output for your actual pages.

Should I use a full-page image for visual regression tests?

Use it when the whole document is the unit you need to compare. For stable component tests, a selector or fixed viewport can reduce unrelated differences.

Are the listed provider prices guaranteed to remain current?

No. The ApiFlash and ScreenshotOne figures are vendor-listed snapshots from the research period. Check each provider’s live pricing and plan terms before adopting it.