Is ApiFlash Free? Pricing, Screenshot Quotas, and API Limits

Yes. ApiFlash lists a free plan with 100 screenshots per month at $0, with no credit card required. Its documented API rate limit is separate: 20 requests per second with a burst capacity of 400. Monthly quota measures eligible captures across a billing period; the rate limit governs how quickly requests can be processed. Plan terms can change, so check the ApiFlash pricing page before committing to a workload.

ApiFlash’s documentation says unique successful screenshots count toward the monthly quota; cached and failed captures do not. After the quota is exceeded, the API returns HTTP 402. Requests above the steady rate may be delayed, while requests exceeding the burst capacity can be terminated with HTTP 429. Those are distinct limits and need separate handling.

ApiFlash pricing and monthly screenshot quotas

The following prices and allowances are displayed by ApiFlash and may change:

Plan	Displayed price	Monthly screenshots
Free	$0	100
Lite	$7/month	1,000
Medium	$35/month	10,000
Large	$180/month	100,000
Custom Enterprise	Custom	Custom volume

The listed self-serve tiers include PNG, JPEG, and WebP, full-page and mobile screenshots, ad blocking, cookie-banner hiding, and S3 export. ApiFlash lists different support levels across paid tiers; Enterprise is customizable and lists managed proxies and IP geolocation. These are provider-published plan details, not a guarantee that every parameter or capability is available on every plan. Check current terms and feature availability before selecting a tier. ApiFlash pricing

What counts against the monthly quota?

ApiFlash says a unique successful screenshot counts. Failed captures and cached screenshots do not. Repeating an identical request while its result is cached can therefore avoid another quota charge. Its FAQ says it sends an email warning at 80% of the monthly quota. ApiFlash FAQ

For quota planning, estimate the number of distinct successful captures that need a fresh result, rather than counting every HTTP call. A changed URL or capture setting may produce a different result; whether a particular request matches a cached result depends on ApiFlash’s cache behavior and request parameters.

Monthly quota versus request-rate limits

Limit	Documented value	What happens
Monthly screenshot quota	Depends on plan; Free lists 100	HTTP 402 when the plan quota is exceeded
Steady request rate	20 requests per second	Requests above this rate are delayed
Burst capacity	400 requests	Requests exceeding burst capacity are terminated with HTTP 429

The rate limit is not another monthly allowance. A workload can stay under its monthly quota and still send requests too quickly. Conversely, requests can be paced below 20 per second while consuming the monthly quota over time. ApiFlash documents a leaky-bucket rate limit with a 400-request burst size. ApiFlash API documentation

ApiFlash API request example

The endpoint is https://api.apiflash.com/v1/urltoimage. The API accepts GET and POST, requires an access key and a fully qualified URL including https:// or http://, and returns image data by default. With response_type=json, it returns a JSON response with screenshot links. Keep the access key server-side; do not place it in public browser code.

curl -G 'https://api.apiflash.com/v1/urltoimage' \
  --data-urlencode 'access_key=YOUR_API_KEY' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'format=png' \
  -o screenshot.png

The example saves the default binary image response to a file. Use an access key from your ApiFlash account, and verify the current parameter names and plan access in the official documentation.

Cache behavior and fresh captures

ApiFlash documents a configurable ttl from 0 seconds to 30 days. A cached screenshot does not count toward monthly quota. Set fresh=true to force a new capture. Use a longer TTL when the page changes infrequently and a shorter TTL when visual freshness matters. A forced fresh capture defeats the quota savings of serving a cached result.

curl -G 'https://api.apiflash.com/v1/urltoimage' \
  --data-urlencode 'access_key=YOUR_API_KEY' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'ttl=3600' \
  -o screenshot.png

This asks for a cache lifetime of one hour, subject to the provider’s current cache semantics. For a forced capture, add --data-urlencode 'fresh=true'.

Dimensions, formats, and capture timing

• Formats: JPEG, PNG, and WebP are documented.
• Dimensions: Width and height may each reach 16,350 pixels, subject to a maximum total area of 33,177,600 pixels. WebP has a 16,350-pixel limit per dimension after the scale factor.
• Readiness: The documented default waits for network idle. delay can add up to 10 seconds, wait_for can wait up to 15 seconds for a CSS selector, and wait_until_timeout can be set between 1 and 30 seconds.
• Capture options: The docs describe full-page and mobile capture, viewport sizing, element selection, cookie and user-agent inputs, CSS injection, geolocation, ad and cookie-banner blocking, and text or HTML extraction. Confirm support for each option on the plan in use.

Large captures can be constrained by both the maximum pixel area and per-dimension ceilings. Check the final dimensions after applying any scale factor. For dynamic pages, choose a readiness condition that matches the page: a selector can be more predictable than waiting for all network activity to stop on a page that keeps polling.

Track quota and handle API responses

ApiFlash documents the response headers X-Quota-Limit, X-Quota-Remaining, and X-Quota-Reset, as well as a quota endpoint. Read these values where available and record them with request outcomes. They let a service warn before a monthly limit is reached and distinguish quota exhaustion from rate limiting.

Response or signal	Likely meaning	Action
HTTP 402	Monthly plan quota exceeded	Wait for quota reset or choose a suitable plan; use caching for repeated results.
HTTP 429	Burst capacity exceeded	Reduce concurrency and retry with backoff and jitter.
HTTP 403	Requested feature may not be supported by the current plan	Check the plan and feature requirements before retrying.
Failed capture	Page load or capture did not succeed	Check target accessibility and readiness settings; ApiFlash says failed screenshots do not count toward quota.
Quota remaining falls faster than expected	More unique successful captures or fresh requests than expected	Inspect URL and parameter variation, cache TTL, and use of fresh=true.

Plan a workload and control cost

1. Estimate unique successful screenshots required per month, separating repeated requests that can use cache.
2. Estimate the peak request rate and burst size independently of monthly volume.
3. Choose a cache TTL that reflects how often the target pages change; force freshness only when needed.
4. Confirm that the chosen tier supports required capture options and export features.
5. Monitor quota headers and the provider’s quota endpoint, and set an application alert before the documented 80% email warning.
6. Recheck the pricing page before launch and before expanding usage; listed quotas and prices can change.

For reliability, use a bounded concurrency queue instead of releasing a large batch at once. Retry transient network failures and 429 responses with exponential backoff and jitter, but do not retry a 402 continuously: it indicates a quota condition that needs a reset or plan change. Make retries idempotent at the application level where possible, and avoid setting fresh=true on every retry because it can trigger additional captures.

Cost is driven primarily by the plan’s monthly allowance and how many unique successful captures require fresh output. Cache hits can reduce quota use; repeated requests that bypass cache cannot. Large dimensions, long waits, and complex pages may also affect latency and workload behavior, although the cited ApiFlash sources do not provide comparative performance benchmarks.

Troubleshooting

HTTP 402: payment or quota error

ApiFlash documents 402 for exceeding the current plan’s monthly screenshot quota. Inspect quota headers and the reset value, then wait for reset, reduce fresh unique captures, or move to a plan with sufficient monthly volume.

HTTP 429: too many requests

The documented burst capacity is 400, with a steady rate of 20 requests per second. Queue requests, cap concurrency, and retry with backoff and jitter. Increasing monthly quota alone does not address a request-rate spike.

HTTP 403: a capture option is unavailable

The documentation says 403 can mean a requested feature is unsupported by the current plan. Remove or replace that option only if it is not needed, or select a plan that supports it; verify current terms.

The screenshot shows a loading state or misses content

The default readiness behavior is network idle. Add a selector wait for a known content element, or a bounded delay for a short client-side transition. Keep within the documented limits: up to 15 seconds for wait_for, up to 10 seconds for delay, and 1–30 seconds for wait_until_timeout.

The image request fails or saves an unexpected response

Check that the target URL includes its scheme, the access key is valid, and the response is being treated according to the selected mode. The default is image data; response_type=json changes the response to JSON with screenshot links. Do not save JSON bytes under a PNG or JPEG filename.

A large image is rejected or clipped

Check width and height limits and the maximum pixel area together. For WebP, account for the 16,350-pixel per-dimension ceiling after scale factor. Reduce viewport dimensions or scale while staying within the page area needed.

Usage rises despite repeated calls

Confirm that requests are actually identical for cache purposes, that TTL is nonzero, and that fresh=true is not being added. ApiFlash says cached screenshots do not count, but a forced fresh capture asks for a new result.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from ScreenshotNeo. It returns PNG, JPEG, WebP, or PDF from one GET request. Cookie banners are accepted like a visitor and 60+ known consent platforms, newsletter popups, and chat widgets are removed before capture; each step can be turned off. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and response headers report page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for AI agents and MCP clients.

For a direct call, replace the target URL and key. See the ScreenshotNeo API documentation for its options.

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

Python:

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

Node.js:

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

ScreenshotNeo includes an MCP server so AI agents can take screenshots. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000. Cookie banners, popups, and chat widgets are removed before the shot, while bot checks, blank pages, and failed loads are never billed. Create a free account and get 1,000 screenshots a month with no card.

FAQ

Does ApiFlash require a credit card for its free plan?

Its pricing page says the free plan requires no credit card. Check the current signup terms before registering.

Does every API call use one screenshot from the monthly allowance?

No. ApiFlash says unique successful screenshots count; failed and cached captures do not.

Does a paid plan remove the request-rate limit?

The documentation separately specifies a 20-request-per-second rate and burst size of 400. Confirm with ApiFlash whether your specific plan or custom agreement changes those terms.

Can I force a new screenshot when the page is cached?

Yes. ApiFlash documents fresh=true for requesting a new capture.

Where should I verify current prices and parameter support?

Use the ApiFlash pricing page for displayed tiers and the API documentation for endpoint behavior and options.