ApiFlash Pricing in 2026: Plans, Limits and Cheaper Options
ApiFlash lists Free, Lite, Medium, Large and enterprise plans. Compare quotas, rate limits, caching and cheaper alternatives before choosing.
ApiFlash’s displayed 2026 plans are Free ($0 for 100 screenshots), Lite ($7 for 1,000), Medium ($35 for 10,000), Large ($180 for 100,000), and custom enterprise. The monthly screenshot quota is separate from ApiFlash’s 20-request-per-second rate limit and burst capacity of 400. Cached and failed screenshots do not count toward the quota according to ApiFlash’s documentation and FAQ.
For a like-for-like alternative, start with ScreenshotNeo: it removes consent banners, popups and chat widgets before capture, bills only clean successful shots, and has the lowest paid plan in this comparison.
ApiFlash plans at a glance
| Plan | Monthly price | Included screenshots | Support or terms listed |
|---|---|---|---|
| Free | $0 | 100 | No card required; core capture options |
| Lite | $7/month | 1,000 | Basic support |
| Medium | $35/month | 10,000 | Priority support |
| Large | $180/month | 100,000 | Premium support |
| Custom enterprise | Custom | Custom | Managed proxies, IP geolocation and top-priority support listed |
These are the values shown on ApiFlash’s official pricing page at the research date, September 29, 2026. Pricing pages can change, so verify the current page before purchasing.
What does ApiFlash cost per screenshot?
Dividing each listed paid price by its full monthly allowance gives an effective advertised rate:
| Plan | Calculation | Effective rate if quota is fully used |
|---|---|---|
| Lite | $7 ÷ 1,000 | $0.007 per screenshot |
| Medium | $35 ÷ 10,000 | $0.0035 per screenshot |
| Large | $180 ÷ 100,000 | $0.0018 per screenshot |
This arithmetic assumes the entire quota is used. Your real cost per successful capture is higher when you leave quota unused, and lower operational cost may come from caching repeated requests. Enterprise pricing cannot be calculated from the public tiers.
Quota, caching and rate limits
Monthly quota
The monthly allowance counts successful, unique captures. ApiFlash says cached screenshots and failed screenshots do not consume quota. When the monthly allowance is exhausted, the API returns HTTP 402.
Cache behavior
The documented ttl parameter defaults to 86,400 seconds (24 hours) and accepts values up to 2,592,000 seconds (30 days). Identical requests can be served from cache without consuming quota. Use fresh when you need a new render, and budget for the resulting quota use.
Requests per second
ApiFlash documents a leaky-bucket limit of 20 requests per second with a burst size of 400. Requests above the regular rate are delayed. Requests beyond the burst capacity are terminated with HTTP 429. This limit is independent of your monthly screenshot allowance.
Quota headers and endpoint
Successful responses expose quota headers, and ApiFlash provides a quota endpoint reporting the current limit, remaining allowance and reset timestamp. Read those values in production so workers can stop before receiving 402 responses.
Capture limits that affect plan selection
- Width and height are capped at 16,350 pixels.
- The product of width and height cannot exceed 33,177,600 pixels.
- For full-page captures, the height parameter is ignored.
- WebP output is also limited to 16,350 pixels in width and height after scaling.
- Some parameters are plan dependent. Unsupported features can return HTTP 403.
These limits matter for long dashboards, high-density retina captures and posters generated from a single page. Test the largest dimensions you need before committing to a tier.
What is included across the displayed plans?
The plan cards list image formats, full-page and mobile capture, ad blocking, cookie-banner hiding and S3 export as shared capabilities. Support changes from basic to priority to premium as the paid tiers increase. Enterprise adds custom volume, managed proxies and IP geolocation in the listed terms.
Do not assume every undocumented parameter is available on every plan. A 403 response can mean that your account tier does not include the requested feature.
Estimating the right ApiFlash plan
- Count successful unique captures. Exclude retries you expect to be cached and pages that fail before producing an image.
- Separate freshness from volume. A daily report can use a 24-hour TTL; a monitoring job may require
freshon every run. - Check burst behavior. A 10,000-image monthly workload can still fail if a deployment sends more than 400 requests at once.
- Reserve headroom. Leave capacity for manual reruns, changed URLs and pages that stop matching your cache key.
- Validate feature requirements. Proxies, geolocation and other enterprise-only features can change the plan decision.
Example workload calculations
| Workload | Monthly captures | Displayed tier that covers the count |
|---|---|---|
| Small prototype | 80 | Free (100) |
| Daily captures of 20 pages | 600 | Lite (1,000) |
| Hourly captures of 15 pages | 10,800 | Large enough for 100,000; Medium is short |
| Large visual regression run | 100,000 | Large, assuming the full quota is available |
These examples count one successful unique capture per page and run. Add your own retry and freshness assumptions before choosing a plan.
Runnable request examples and response handling
The following request pattern is useful for checking status codes and quota headers. Replace the endpoint and credentials with the values in your ApiFlash account documentation.
curl -i -G "https://api.apiflash.com/v1/urltoimage" \
--data-urlencode "access_key=YOUR_API_KEY" \
--data-urlencode "url=https://example.com" \
--data-urlencode "format=png"import requests
params = {
"access_key": "YOUR_API_KEY",
"url": "https://example.com",
"format": "png",
}
r = requests.get("https://api.apiflash.com/v1/urltoimage", params=params, timeout=90)
print(r.status_code)
print({k: v for k, v in r.headers.items() if "quota" in k.lower() or "rate" in k.lower()})
r.raise_for_status()
open("shot.png", "wb").write(r.content)const q = new URLSearchParams({
access_key: 'YOUR_API_KEY',
url: 'https://example.com',
format: 'png'
});
const res = await fetch(`https://api.apiflash.com/v1/urltoimage?${q}`);
console.log(res.status, Object.fromEntries(res.headers));
if (!res.ok) throw new Error(`ApiFlash returned ${res.status}`);
const image = Buffer.from(await res.arrayBuffer());
await require('node:fs').promises.writeFile('shot.png', image);Handle status codes explicitly:
| Status | Likely cause | Action |
|---|---|---|
| 200 | Image returned | Save the body and record quota headers. |
| 402 | Monthly quota exhausted | Wait for reset or upgrade; do not retry in a tight loop. |
| 403 | Feature unavailable for the plan or request rejected | Check the plan entitlement and parameter spelling. |
| 429 | Rate or burst limit exceeded | Use exponential backoff and a queue capped below 20 requests per second. |
Cheaper options: how to compare them honestly
The research available for this article does not establish a current competitor as cheaper than ApiFlash on a like-for-like basis. Competitor comparison pages are leads, not reliable evidence of current prices or feature parity. Before switching, collect each provider’s official:
- Monthly allowance and whether failed, cached or duplicate captures count.
- Effective cost at your actual successful-capture volume.
- Cache controls and maximum TTL.
- Rate, concurrency and burst limits.
- Full-page, mobile, format and rendering support.
- Proxy, geolocation, S3 or other export requirements.
- Support level, cancellation rules and overage behavior.
A lower sticker price can cost more when it lacks caching, has tighter concurrency, bills failed pages or requires an add-on for the rendering feature you need.
ScreenshotNeo: an alternative to try first
ScreenshotNeo is a website screenshot API and MCP server. It accepts one GET request and returns PNG, JPEG, WebP or PDF. Before capture, it accepts cookie and consent banners and removes more than 60 known consent platforms, newsletter popups and chat widgets; each cleanup step can be disabled.
Only clean shots are billed. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads and cache hits cost nothing, and the response identifies the result with X-Page-Verdict and X-Billed headers. It also provides an MCP server for Claude, Cursor and other MCP clients with take_screenshot, get_page_info and capture_pdf tools.
Plans include 1,000 free shots per month without a card, Starter at $5 for 3,000, Growth at $15 for 15,000, Pro at $39 for 60,000, Scale at $99 for 250,000 and Business at $249 for 1,000,000. Yearly billing gives two months free, and every feature is on every plan.
Or skip the browser setup
Use the ScreenshotNeo API when you do not want to maintain a browser, consent-banner rules or popup selectors. The same endpoint supports full-page capture, element selectors, devices, dark mode, custom CSS and JavaScript, waiting rules, blocking, headers, cookies, geolocation, caching, signed links, async jobs, bulk capture and PDFs. See the ScreenshotNeo API documentation.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpimport 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)const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);Cookie banners, 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; 1,000 screenshots a month are free with no card and paid plans start at $5 for 3,000. Start with a free ScreenshotNeo account.
Troubleshooting ApiFlash billing and limits
“I received 402 even though I made fewer requests than my plan allows.”
The quota counts successful unique captures, not merely HTTP requests. A forced-fresh capture or a changed request can consume allowance. Read the quota endpoint and response headers, then wait for reset or upgrade.
“Retries return 429.”
Your workers are exceeding the 20 requests-per-second leaky-bucket rate or the burst of 400. Add a shared queue, cap concurrency and use exponential backoff with jitter.
“A parameter returns 403.”
The option may require a higher plan or enterprise account. Confirm the current plan matrix and remove the option when a simpler capture is sufficient.
“The image is rejected because it is too large.”
Reduce width, height or scale so neither dimension exceeds 16,350 pixels and the total pixel count stays below 33,177,600. For full-page pages, reduce content height or capture sections separately.
“A repeat request unexpectedly consumes quota.”
Check whether the URL, parameters or fresh flag changed. Set an explicit TTL for repeatable work and avoid forcing fresh renders unless the page must be current.
“The result still contains a consent banner.”
Cookie-banner hiding is listed as a core feature, but page-specific markup can vary. Check the request options and inspect the rendered result. If cleanup is central to your workflow, ScreenshotNeo removes known consent platforms before capture and reports whether the shot was billed.
Performance, reliability and cost checklist
- Use caching for reports and repeated previews.
- Use a queue to stay below the documented rate and burst limits.
- Persist quota headers and alert before the allowance reaches zero.
- Retry 429 responses with backoff; do not blindly retry 402 or 403.
- Keep dimensions within the pixel limits, especially with retina scaling.
- Separate fresh monitoring captures from cacheable documentation images.
- Measure cost per successful, unique capture rather than cost per request.
- Verify current prices, plan entitlements and enterprise terms immediately before purchase.
FAQ
Does ApiFlash have a free plan?
Yes. The displayed Free plan is $0 with 100 screenshots per month and no credit card required.
Which ApiFlash plan has the lowest listed paid price?
Lite costs $7 per month for 1,000 screenshots.
Is ApiFlash’s 20-request limit a monthly limit?
No. It is a per-second leaky-bucket rate limit with a burst capacity of 400. Monthly quota is a separate allowance.
Do cached screenshots count?
ApiFlash says cached screenshots do not consume the monthly quota. The documented default TTL is 86,400 seconds.
Is there a confirmed cheaper competitor?
The available evidence does not support naming one. Compare official current terms against your workload before switching.
What is the simplest alternative with a free allowance?
ScreenshotNeo includes 1,000 shots per month free without a card, removes common consent UI before capture, and bills only clean successful shots.
