ApiFlash does one thing deliberately well: a single, small, easy-to-read screenshot endpoint at the lowest paid entry price in this category. People leave not because it is bad at that, but because their requirements outgrew a single endpoint — usually the day someone asked whether a page changed, or asked an AI assistant to look at one.
ApiFlash Medium and Snapshot Site Ultra are the closest comparable tiers by volume, at 10,000 and 15,000 captures per month respectively.
| Snapshot SiteEUR | ApiFlashUSD | |
|---|---|---|
| Comparable plan | Ultra — €20/mo | Medium — $35/mo |
| Requests included | 15,000 / month | 10,000 / month |
| Cost per capture | €0.0013 | $0.0035 |
| Free tier | 50 captures / month, no card | 100 captures / month |
| Visual diff endpoint | Native POST /api/v3/compare — pixel mismatch score plus a hosted diff image | Not documented — No comparison endpoint in the API documentation |
| AI page analysis | POST /api/v3/analyze — summary, topics, quality signals, page metadata | Not documented — No page-analysis endpoint in the API documentation |
| MCP server | Hosted server at mcp.snapshot-site.com/mcp with OAuth sign-in — no local process, no key in the client config | Not documented — No official MCP server found at the time of checking |
| PDF rendering | format: pdf on the screenshot endpoint | Not documented — Not documented in the API reference we reviewed |
| Output formats | PNG, JPEG, WebP, PDF, HTML | PNG, JPEG and WebP per the plan feature list; response_type=json for a JSON envelope |
| Official SDKs | TypeScript, Python, PHP, CLI, MCP server, and an n8n node verified by n8n | Code examples in C#, Go, Java, Node, PHP, Python and Ruby, but no maintained client libraries |
Competitor pricing checked on 2026-07-28 on their official pages. Subject to change — verify at the source: https://apiflash.com/
Prices are shown in the currency each vendor publishes — Snapshot Site bills in EUR, ApiFlash publishes in USD. No conversion is applied, so the per-capture figures are not a like-for-like exchange-rate comparison.
ApiFlash is a capture API. Snapshot Site is a capture API plus the two things people most often build on top of one — comparison and analysis — with the AI access layer already wired in.
POST /api/v3/compare takes two URLs, renders both and returns a mismatch percentage plus a hosted diff image marking the changed pixels. On ApiFlash this is a project: capture twice, store the baseline, pull in an image comparison library, handle pages that changed height, tune a threshold. Everything you would build is the thing we sell, which is why release QA, competitor monitoring and defacement alerts are one call here rather than a service you maintain.
POST /api/v3/analyze returns a summary, topics, quality signals — blank page, CAPTCHA present, HTTP status, readability score — and the page's metadata. Quality signals in particular pay for themselves in monitoring: they tell you the difference between 'the capture worked' and 'the capture worked and the page was real', which is the difference between an archive of screenshots and an archive of CAPTCHA challenge pages.
We could not find an official MCP server for ApiFlash. Ours is hosted at mcp.snapshot-site.com/mcp — paste the URL into Claude Code, Cursor, Codex or ChatGPT, sign in with your account, approve access, and your assistant can capture, compare and analyse pages inside its normal workflow. No local process, no API key copied into a config file.
format: html returns the complete rendered DOM alongside the image. That single option is what turns a screenshot API into an extraction pipeline: render the page, clean the markup, hand it to a model, get structured records. It is the basis of every extraction workflow in our n8n collection.
TypeScript, Python and PHP SDKs, a CLI, an MCP server and an n8n node verified by n8n. ApiFlash publishes code examples in several languages, which is not the same thing as a library someone keeps up to date for you.
A comparison with no trade-offs is not a comparison. Here is where ApiFlash's scope works in its favour.
Writing captures straight to your own bucket is included from the free plan up. We return a link to the produced file, which you download and store wherever you like — if pushing directly to a bucket with no intermediate step is a hard requirement, that is a point in ApiFlash's favour.
ApiFlash is a GET endpoint with query parameters and an access key in the URL. Snapshot Site is a POST with a JSON body and the key in a header. The concepts map almost one to one — this is typically an hour of work including tests.
| ApiFlash | Snapshot Site | Notes |
|---|---|---|
| access_key | x-snapshotsiteapi-key header | Out of the URL, into a header. |
| url | url | Identical. Full URL with scheme. |
| format | format | png, jpeg, webp — plus pdf and html, which ApiFlash does not document. |
| width | width | 100–8000, default 1280. |
| height | height | 100–20000, default 720. |
| full_page | fullSize | Boolean, same meaning. |
| delay | delay | Integer seconds, 0–10. ApiFlash also uses seconds, so values carry over. |
| no_cookie_banners | hideCookie | Boolean, same meaning. |
| element_to_hide | hide | Comma-separated CSS selectors in one string. |
| response_type=json | (default) | Snapshot Site always returns JSON with a link field pointing at the artefact. |
curl "https://api.apiflash.com/v1/urltoimage\ ?access_key=YOUR_KEY\ &url=https%3A%2F%2Fexample.com\ &format=png\ &width=1280\ &full_page=true\ &no_cookie_banners=true\ &response_type=json"
curl --request POST \
--url https://api.prod.ss.snapshot-site.com/api/v2/screenshot \
--header 'Content-Type: application/json' \
--header 'x-snapshotsiteapi-key: YOUR_API_KEY' \
--data '{
"url": "https://example.com",
"format": "png",
"width": 1280,
"fullSize": true,
"hideCookie": true
}'
# Response: { "status": "success", "url": "...", "width": 1280,
# "height": 720, "link": "https://.../capture.png" }
The migration path here has a very consistent shape, and it starts with a feature request rather than a complaint.
ApiFlash gets chosen for good reasons: it is cheap to start, the API fits on a napkin, and it does not make you learn a platform to take a screenshot. Teams run it happily for a year. Then one of two things happens. Marketing asks to be told when a competitor changes their pricing page. Or engineering starts building with AI assistants and wants them to be able to look at a URL.
Neither request is unreasonable, and neither is a capture problem. The first is a comparison problem; the second is an access problem. That is the point at which a single-endpoint API becomes the wrong shape, and it is worth recognising early — because the alternative is quietly building both capabilities in-house on top of a vendor that will never own them.
It is not the diffing algorithm. Image comparison libraries are mature and you will have something working in an afternoon.
It is everything around it. You need a durable place for baselines, and a policy for when a baseline is replaced. You need both captures taken with identical viewport and settling behaviour, or you are diffing noise. You need to handle pages that changed height, which is most pages, and which breaks the naive path immediately. You need a threshold, and you will discover the hard way that the change you care about — a price, a date, a legal clause — moves a fraction of a percent of the pixels, while an image carousel moves several percent. So you add masking. Then you need a way to see what changed, which means storing and serving diff images.
That is a small internal product. POST /api/v3/compare returns summary.mismatchPercentage, both render dimensions, and a diff.link to a hosted image with the changed regions marked, and none of that becomes yours to run.
The second common trigger is agents. Once developers start working inside Claude Code, Cursor or ChatGPT, the natural question is whether the assistant can see the page it is talking about.
You can wire that up against any HTTP API with enough glue. The hosted MCP server removes the glue: one URL in the client configuration, an OAuth sign-in, and capture, compare and analyse become tools the assistant can use directly. Because the connection is account-based rather than key-based, adding a teammate does not mean distributing a secret, and removing access does not mean rotating one.
For the same reason, our n8n node is worth a look if your automations live there rather than in code — it is verified by n8n, and the workflow gallery has ready-made templates for monitoring and extraction.
format: html returns the full rendered DOM, not the raw HTTP response. On a client-side-rendered page those are completely different documents: the raw response is a shell, and the rendered DOM has the content a visitor actually sees.
That output is why extraction pipelines work here without a second vendor. Render the page, strip scripts and styles, hand the cleaned markup to a model with a schema, and get structured records — job listings, product prices, directory entries. It is the same capture you were already paying for, used differently.
ApiFlash's entry price matches ours almost exactly — $7 for 1,000 captures against €7 — so at the very bottom of the ladder this is not a cost decision. Their S3 export is a genuine convenience we answer differently, by returning a link you store where you like.
What that similarity hides is the ceiling. One tier up, our Ultra covers 15,000 captures for €20 against their $35 for 10,000. And the endpoints you would eventually build on top of a capture API — comparison, quality checking, AI access — already exist here. Starting on the cheaper single-endpoint API is only cheaper until the first time someone asks what changed.
Switch when the work stops being about the image: when you need to know what changed, when you need to know whether the page was worth capturing, or when you want an assistant to do the looking.
For the endpoint-by-endpoint version of this, read Snapshot Site vs ApiFlash. If AI access is your reason for switching, the MCP server page covers the connection flow in detail.
At the entry level they are effectively the same: ApiFlash Lite is $7 for 1,000 captures and our Pro is €7 for 1,000. The difference appears above that — ApiFlash Medium is $35 for 10,000 while our Ultra is €20 for 15,000. Figures are from each vendor's own pricing page, in their own currency, with no conversion applied.
It was not documented in the API reference we reviewed, so we do not claim either way — check their current documentation before relying on it. Snapshot Site renders PDF with format: pdf on the same endpoint as image capture.
Neither is documented in their API reference at the time we checked. ApiFlash's scope is capture. Snapshot Site exposes comparison at /api/v3/compare and page analysis at /api/v3/analyze.
Only if you use the extra endpoints. A basic capture is one POST with a url and a format — no signing, no session, no SDK required. The compare and analyze endpoints exist when you need them and cost you nothing conceptually until then.
ApiFlash includes S3 export on every plan. Snapshot Site returns a link to the produced file, which you download and store wherever you like. If pushing straight to your bucket without an intermediate step is a hard requirement, that is a point in ApiFlash's favour.
Our free tier is 50 captures a month with no card, and ApiFlash's is 100. Point both at ten of your real pages and compare the output and the failure modes — that is a better decision input than any comparison table, including this one.
If ApiFlash covers everything you need, staying is a perfectly good decision. If you have started building comparison or extraction on top of it, start free with 50 captures and see what it looks like when those are endpoints.