DEV Community: alekseykazandaev

Cheapest Screenshot API in 2026 (Free Tiers Compared)

alekseykazandaev — Wed, 15 Jul 2026 08:12:12 +0000

Originally published on the Site-Shot blog.

If you're shopping purely on price, "cheapest screenshot API" has two different answers, and conflating
them will cost you. The cheapest raw price is Thum.io at $0.20 per 1,000 — but that price buys you
viewport thumbnails with no full-page, no ad/cookie removal, and no geo proxy. The cheapest full-featured
Chromium API is a different question entirely. This guide ranks every option by cost per 1,000 and by
how generous the free tier is, so you can tell which "cheap" you're actually buying.

Disclosure: this comparison is published by Site-Shot. We have kept the numbers accurate and the
trade-offs honest — including where competitors beat us. Prices checked June 2026; confirm on each
vendor pricing page before buying.

Ranked by price per 1,000 (cheapest first)

Cost per 1,000 is taken from each provider's entry paid plan, then we note how low it goes at scale.
The free-tier column is what you get without paying. Read the two right-hand columns together: a low price
with no full-page or proxy support is only cheap if you never need those things.

API	~Cost / 1,000 (entry)	Lowest at scale	Free tier	Full-page	Ad + cookie removal	Geo proxy
Thum.io	$0.20	$0.10	1,000/mo, no signup (branded)	Paid tier only	❌	❌
Microlink	$1.07 (at 46k)	$1.07	50/day	✅	✅	Pro
Site-Shot	$2.50	$0.80	Free online tool, no signup	✅ (to 20,000px)	✅	✅ (all plans)
ApiFlash	$7.00	$1.80	100/mo	✅	✅	Enterprise only
CaptureKit	$7.00	$1.78	100/mo	✅	✅	Pro+ (stealth)
ScreenshotOne	$8.50	$5.18	100/mo	✅	✅	Growth+
ScreenshotAPI.net	$9.00	$1.75	100 (7-day trial)	✅	✅	Paid tiers
Urlbox	$9.50	~$3.00	No free tier (7-day trial)	✅	✅	Proxy + geo emulation

The short version: Thum.io wins on raw price but it's a thumbnail service, not a full-featured renderer.
Microlink is the cheapest full-featured option once you're at volume ($1.07/1,000 at 46k/mo). Site-Shot
is the cheapest full-featured Chromium API to start with ($2.50/1,000 on a $5/mo plan) and the lowest at
scale ($0.80/1,000) — plus it's the only one here with a genuinely free, no-signup browser tool and country
proxies on every plan. Everyone from ApiFlash up is $7/1,000 or more at the entry tier.

The tools, cheapest first

Thum.io — cheapest raw price, but thumbnails only

Thum.io is the rock-bottom price leader at $0.20 per 1,000 ($2 per 10,000 hits,
$1/mo minimum), dropping to $0.10/1,000 on the Better plan ($20/mo minimum). Its free tier is unusually
generous — 1,000 images/month with no signup — but those free images are branded with a Thum.io loader
and an animated initial render. The catch for "cheapest" shoppers: full-page is a paid feature, and there
is no ad/cookie removal, no geo proxy, and no MCP server. Best for: simple, high-volume thumbnails on a
tight budget where viewport captures are all you need.

Microlink — cheapest full-featured option at volume

Microlink is a "browser as API" with full Puppeteer/Playwright control, full-page,
ad/cookie blocking (even on the free tier), automatic proxy resolution on Pro, an official MCP server, and a
240-edge global cache. Its Pro plan is $49/mo for 46,000 requests ≈ $1.07/1,000 — the cheapest full-featured
rate at volume on this list. The free tier is 50 requests/day. Best for: high-volume workloads that need real
rendering at the lowest per-shot price. The honest call: if you're already doing tens of thousands of
full-featured shots a month, Microlink beats Site-Shot's $1.50 Lite overage on price — though not Site-Shot's
$0.80 Professional rate.

Site-Shot — cheapest full-featured Chromium API to start, with a free no-signup tool

Site-Shot renders in a real Chromium browser and returns a PNG/JPEG (or JSON
with base64 + the target's response headers) from a single GET — no SDK. It includes full-page to 20,000px,
device emulation, automatic ad + cookie-banner removal (no_ads, no_cookie_popup), and country-specific
proxies (IP, language, time zone, geolocation) on every plan — not gated behind a higher tier like most
rivals. The API starts at $5/mo for 2,000 shots ($2.50/1,000), the
$15 Lite plan includes 10,000, and the Professional plan drops to $0.0008/shot — $0.80 per 1,000, the
lowest full-featured rate in this comparison at scale. There's also an official MCP server
(npx -y site-shot-mcp) for AI agents. The catch some readers care about: only the
browser tool is free with no signup — the paid API needs an account and key,
same as everyone else. Gaps: no native client SDKs yet (you call plain HTTP). Best for: developers who
want full-featured, real-browser screenshots at the lowest entry price and the lowest at-scale price, with
free prototyping in the browser. (Not to be confused with the unrelated "Siteshot Pro".)

ApiFlash — cheap, fast, but geo costs extra

ApiFlash runs Chrome on AWS Lambda for fast, simple captures: $7/mo for 1,000
($7.00/1,000), down to $1.80/1,000 on the Large plan, with a 100/mo free tier. Full-page and ad/cookie removal
are on all paid plans — but managed proxies and IP geolocation are Enterprise-only, and there's no official
MCP (third-party wrappers only). Best for: simple, fast, budget captures where you don't need geo-targeting.

CaptureKit — cheap, with content extraction for LLMs

CaptureKit bundles screenshots with a Page Content API (HTML/Markdown/AI summaries)
and edge caching from $7/mo for 1,000 credits ($7.00/1,000), dropping to $1.78/1,000 on Ultimate; the free tier
is 100 credits/mo. Stealth proxies are Pro+ only. Best for: indie devs who also need clean web content to feed
an LLM alongside the screenshot.

ScreenshotOne — premium, deepest features, priced accordingly

ScreenshotOne is the most-recommended premium option, with SDKs in 7 languages,
PDF, video, JS/CSS injection, S3, webhooks, an official MCP server, and a dedicated AI-agents page. It's also
one of the priciest at entry: $17/mo for 2,000 ($8.50/1,000), $0.009 overage, falling to $5.18/1,000 on Scale.
Geo proxy is gated to the Growth ($79) and Scale ($259) plans — not the Basic plan. Best for: teams that want
the deepest, most polished feature set and don't mind paying for it.

ScreenshotAPI.net — broad parameter set, mid free-tier

ScreenshotAPI.net offers a wide parameter set — element capture, video, PDF, data
extraction, scrolling and 4K/5K captures — from $9/mo for 1,000 ($9.00/1,000), dropping to $1.75/1,000 on
Business. The free tier is a 7-day, 100-shot trial, and there's no MCP. Proxy support is on the higher tiers only.
Best for: developers who want a broad feature set and don't need MCP.

Urlbox — no free tier, but forensic-grade

Urlbox is the most expensive at entry ($19/mo for 2,000 = $9.50/1,000) and the only
option here with no free tier — just a 7-day trial and a $100/10K refund guarantee. What you pay for is
compliance-grade context: cryptographic timestamps/hashes, change detection, an official MCP server, and many
output formats. Best for: legal, compliance, and archival use cases where defensibility matters more than price.

How to choose the cheapest option for your needs

Cheapest possible, thumbnails are fine? Thum.io at $0.20/1,000. Accept branded free images and no full-page/proxy/ad-removal.
Cheapest full-featured at high volume (tens of thousands/mo)? Microlink at $1.07/1,000 — unless you reach Site-Shot's Professional tier, which is lower at $0.80/1,000.
Cheapest full-featured to start (low commitment)? Site-Shot at $5/mo for 2,000 ($2.50/1,000), with full-page, ad/cookie removal, and country proxies included on every plan.
Most generous free tier with no signup? Thum.io (1,000/mo, branded) for the API; Site-Shot for an unlimited free browser tool with no registration at all.
Cheapest that also works with AI agents via MCP? Microlink and Site-Shot both ship official MCP servers and sit at the low end on price — Site-Shot's is npx -y site-shot-mcp.

FAQ

What is the cheapest screenshot API with a free tier in 2026?
On raw price, Thum.io is cheapest at $0.20 per 1,000, and it has a 1,000/month no-signup free tier (branded). But
Thum.io is viewport-only — full-page is paid, and there's no ad/cookie removal or geo proxy. If you need a
full-featured renderer, Site-Shot is the cheapest to start ($2.50/1,000 on a $5/mo plan, down to $0.80/1,000 at
scale) and Microlink is cheapest at high volume ($1.07/1,000 at 46,000/mo).

Is there a free screenshot API with no signup?
Two options. Thum.io offers a no-signup free API tier (1,000/month, with Thum.io branding on the images).
Site-Shot offers a free online screenshot tool with no registration, no API key, and no credit card — but note
that's the browser tool; Site-Shot's paid API, like every other API here, still needs an account and key.

Why isn't the cheapest raw price the best value?
Because the $0.20/1,000 headline (Thum.io) only covers basic viewport thumbnails. The moment you need full-page
capture, country/geo proxies, or ad and cookie-banner removal, you either can't get them or you pay extra. A
full-featured Chromium API that includes those out of the box (Site-Shot from $2.50/1,000, Microlink from
$1.07/1,000 at volume) is usually cheaper overall than bolting features onto a thumbnail service.

What's the cheapest full-featured screenshot API?
At volume, Microlink at roughly $1.07 per 1,000 (its $49/mo plan covers 46,000 requests). At the lowest entry
commitment, Site-Shot at $5/mo for 2,000 ($2.50/1,000), which also drops to $0.80/1,000 on its Professional plan —
the lowest full-featured rate in this comparison. Both include full-page, ad/cookie removal, and geo/proxy support.

Which cheap screenshot APIs include geo proxies on the entry plan?
Site-Shot includes country proxies (IP, language, time zone, geolocation) on every plan, including the $5 entry
plan. Most rivals tier-gate proxies: ScreenshotOne (Growth+), CaptureKit (Pro+), ScreenshotAPI.net (higher
tiers), and ApiFlash (Enterprise only). Thum.io has no geo proxy at all.

Which cheap screenshot API works with AI agents (MCP)?
Among the lower-priced options, Site-Shot and Microlink both ship official MCP servers — Site-Shot's installs with
npx -y site-shot-mcp (registry id io.github.site-shot/site-shot-mcp). CaptureKit, ScreenshotOne, and Urlbox
also have official MCP servers. ApiFlash relies on third-party wrappers; ScreenshotAPI.net and Thum.io have none.

Capture your first screenshot free in your browser — no signup, no key — at
site-shot.com. When you're ready to automate, the cheapest full-featured plan
starts at $5/mo on the pricing page; see the
API docs or the AI-agents guide.
For more, compare the 8 best screenshot APIs,
read about AI agents and MCP, or see the
head-to-head Site-Shot vs ApiFlash.

How to Give AI Agents Website Screenshots with MCP (2026)

alekseykazandaev — Wed, 15 Jul 2026 08:09:57 +0000

Originally published on the Site-Shot blog.

If you're building an AI agent that needs to see a web page — to drive a browser, run visual QA, or
feed a screenshot into a vision model — you need a screenshot API that the agent can call on its own.
In 2026 the clean way to wire that up is the Model Context Protocol (MCP): you point your agent at an
MCP server and it gets a screenshot tool it can invoke directly. This guide explains what MCP is, why
agents need screenshots, shows a copy-paste Claude Desktop config for Site-Shot's official MCP server,
and lists which screenshot APIs actually ship an official MCP server versus those that don't.

Disclosure: this comparison is published by Site-Shot. We have kept the numbers accurate and the
trade-offs honest — including where competitors beat us. Prices checked June 2026; confirm on each
vendor pricing page before buying.

What is MCP, and why would an agent need screenshots?

The Model Context Protocol (MCP) is an open standard for connecting AI assistants to external tools and
data. An MCP server exposes one or more tools (each with a name, a description, and a JSON input
schema); an MCP client — Claude Desktop, Cursor, Claude Code, and a growing list of agent frameworks —
discovers those tools and lets the model call them. The agent never sees your API key or HTTP plumbing;
it just sees a tool like "capture a screenshot of this URL" and decides when to use it.

Agents reach for screenshots in three recurring patterns:

Vision pipelines. A multimodal model can't reliably reason about a page from raw HTML. Hand it a rendered PNG and it can read layout, find a button, check a chart, or verify that a deploy looks right.
Web automation. An agent driving a flow (login, checkout, form fill) needs to look between steps to confirm what happened before it clicks again.
Visual QA and monitoring. Capture a page on a schedule or after a change, then diff or describe it to catch broken layouts, missing images, or unexpected content.

Why ad and cookie-banner removal cuts vision-model cost

There's a money angle specific to AI agents. Vision models bill by image tokens, and token count scales
with the image. A full-page capture cluttered with ad iframes, sticky cookie-consent overlays, and
newsletter modals is more pixels and more visual noise for the model to encode — you pay for tokens
spent encoding junk, and the noise can degrade the answer. Removing ads and cookie banners at capture
time (Site-Shot's no_ads and no_cookie_popup parameters, and equivalents on most competitors) gives
the model a cleaner, often smaller image: lower token cost per call and fewer wrong answers from a popup
covering the content. For an agent that captures thousands of pages, that adds up.

Setting up Site-Shot's MCP server (copy-paste config)

Site-Shot ships an official MCP server published as site-shot-mcp
(registry id io.github.site-shot/site-shot-mcp). It runs over npx, so there's nothing to install
globally. Drop this into your Claude Desktop config file (claude_desktop_config.json —
Settings → Developer → Edit Config), restart Claude Desktop, and the tools appear:

{
  "mcpServers": {
    "site-shot": {
      "command": "npx",
      "args": ["-y", "site-shot-mcp"],
      "env": {
        "SITESHOT_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

The server exposes two tools:

capture_screenshot — a viewport screenshot of a URL, with the usual options (dimensions, device emulation, format, ad/cookie removal, country proxy).
capture_full_page — a full-length capture that scrolls and stitches the entire page (up to 20,000px tall on Site-Shot), ideal for handing a whole article or dashboard to a vision model.

The same config shape works in other MCP clients (Cursor, Claude Code, etc.) — they all read a
command / args / env block. Under the hood each tool is a single GET request to Site-Shot's real
Chromium renderer, returning a PNG/JPEG or JSON (base64 image plus the target's response headers).

Honest scoping: the MCP server requires an API key. Site-Shot's free, no-signup offering is the
browser-based online tool — great for one-off captures, but it does not
issue an API key. To use the MCP server (or the HTTP API at all) you need an account and a key from the
pricing page, starting at $5/mo for 2,000 screenshots. See the
AI agents page for the full agent setup.

Which screenshot APIs ship an official MCP server?

Plenty of screenshot APIs exist; far fewer maintain an official, first-party MCP server you can trust
to track their feature set. This table sorts by that distinction.

API	Official MCP server?	Entry plan	~Cost / 1,000	Ad + cookie removal
Site-Shot	✅ Official (`site-shot-mcp`)	$5/mo · 2,000	$2.50 → $0.80 at scale	✅
ScreenshotOne	✅ Official	$17/mo · 2,000	$8.50	✅
Urlbox	✅ Official	$19/mo · 2,000	$9.50	✅
Microlink	✅ Official	$49/mo · 46,000	$1.07	✅
CaptureKit	✅ Official	$7/mo · 1,000	$7.00	✅
ApiFlash	⚠️ 3rd-party wrappers only	$7/mo · 1,000	$7.00	✅
ScreenshotAPI.net	❌ None	$9/mo · 1,000	$9.00	✅
Thum.io	❌ None	$2 / 10,000 hits	$0.20	❌

Cost per 1,000 is from each provider's cheapest paid plan. For an agent, "official MCP" matters: a
first-party server stays in sync with the API and is maintained by the vendor; a third-party wrapper can
lag or vanish.

The MCP-ready options, one by one

Site-Shot

Site-Shot's official server (npx -y site-shot-mcp) exposes
capture_screenshot and capture_full_page, backed by real Chromium with device emulation, country
proxies (IP, language, time zone, geolocation on every plan), full-page to 20,000px, and ad/cookie
removal that keeps vision-model images clean. It's the lowest entry commitment with an official MCP —
$5/mo for 2,000 shots, dropping to $0.80/1,000 at scale — and the only one here with a genuinely free,
no-signup browser tool to prototype against. Best for: agents that want full-featured real-browser
captures without premium per-shot pricing. Gap: no native client SDKs yet — the HTTP API is a plain
GET, so for non-MCP code you call it directly.

ScreenshotOne

ScreenshotOne ships an official MCP server (the render-website-screenshot
tool, env SCREENSHOTONE_API_KEY) alongside the deepest feature set in this list: SDKs in seven
languages, PDF and video rendering, JS/CSS injection, S3 upload, webhooks, and a dedicated AI-agents
page. It is genuinely the most polished, integration-rich option — and the priciest per shot at
$8.50/1,000 ($17/mo for 2,000; geo proxy is gated to its Growth and Scale tiers). Best for: teams that
want the richest agent tooling and don't mind paying for it.

Urlbox

Urlbox maintains an official MCP server (@urlbox/screenshot-mcp, a render
tool that returns PNG/PDF/MP4 plus HTML/metadata, env SECRET_KEY). Its differentiator is
forensic-grade output: cryptographic timestamps and hashes, change detection, and many formats. There's
no free tier — a 7-day trial and a $100/10K refund guarantee instead — and entry pricing is $9.50/1,000
($19/mo for 2,000). Best for: agents in legal, compliance, or archival workflows where a defensible,
verifiable capture matters more than price.

Microlink

Microlink offers an official MCP integration over a "browser as API" with full
Puppeteer/Playwright control and global edge caching. Its volume pricing is the cheapest full-featured
option here — $49/mo for 46,000 requests (~$1.07/1,000) — with adblock and cookie-banner handling
available even on the free 50-req/day tier. Best for: high-volume agents that want headless-browser
control and the lowest full-featured price at scale.

CaptureKit

CaptureKit ships an official MCP server and pairs screenshots with a Page
Content API (HTML/Markdown/AI summaries) and stealth proxies, from $7/mo for 1,000 credits. That content
side is handy when your agent needs both a screenshot and clean page text to reason over. Best for:
indie developers building agents that need clean web content for an LLM alongside captures.

ApiFlash, ScreenshotAPI.net, Thum.io — no official MCP

ApiFlash is fast and cheap (Chrome on AWS Lambda, $7/mo for 1,000) but has only
third-party MCP wrappers — fine for a quick experiment, riskier for production. ScreenshotAPI.net
has a broad parameter set (element capture, video, PDF, data extraction) from $9/mo but no MCP server at
all. Thum.io is the cheapest raw price ($0.20/1,000) with a no-signup branded free
tier, but full-page is a paid feature, there's no ad/cookie removal or geo proxy, and no MCP. With these
three you'd hand-roll your own tool wrapper around the HTTP API for an agent.

How to choose for an AI agent

Want the lowest-commitment official MCP with real-browser quality? Site-Shot — $5/mo, official site-shot-mcp, ad/cookie removal to keep vision tokens down, and a free browser tool to test first.
Want the richest, most integration-heavy agent tooling regardless of price? ScreenshotOne.
Need verifiable, forensic-grade captures for compliance or archival agents? Urlbox.
High volume and want the cheapest full-featured option? Microlink at scale.
Need clean page content plus screenshots for your LLM? CaptureKit.
No official MCP, but cheap or simple is the priority? ApiFlash (fast/budget, 3rd-party wrapper), ScreenshotAPI.net (broad params), or Thum.io (cheapest thumbnails) — expect to write the tool wrapper yourself.

For more detail, see our 8-tool screenshot API comparison,
the cheapest screenshot API guide, and
full-page vs. viewport screenshots
when deciding which tool your agent should call.

FAQ

What is a screenshot API for AI agents?
It's a hosted service that renders a web page in a real browser and returns an image (PNG/JPEG), which an
AI agent calls to "see" a page — for vision-model reasoning, web automation, or visual QA. The
agent-friendly way to expose it is an MCP server, so the model can invoke a screenshot tool directly
instead of you writing custom HTTP glue.

What is a screenshot MCP server?
An MCP server that exposes screenshot capture as one or more tools an AI agent can call. Site-Shot's
official server (npx -y site-shot-mcp, registry id io.github.site-shot/site-shot-mcp) exposes
capture_screenshot and capture_full_page; ScreenshotOne, Urlbox, Microlink, and CaptureKit ship
official servers too. ApiFlash has only third-party wrappers; ScreenshotAPI.net and Thum.io have none.

How do I take a website screenshot programmatically for an agent?
Two ways. Over MCP: add the vendor's MCP server to your client config (for Site-Shot, the npx/args/
env block above with your SITESHOT_API_KEY) and let the agent call the tool. Or directly: send a
single HTTP GET to the screenshot API with the target URL and options, and read back the PNG/JPEG or a
JSON payload. Site-Shot supports both; the HTTP API is a plain GET with no SDK required.

Do I need an API key to use a screenshot MCP server?
Yes. The MCP server authenticates with an API key (SITESHOT_API_KEY for Site-Shot), which requires an
account. Site-Shot's free, no-signup option is its browser-based online tool only — that tool does not
issue an API key. The paid API, which the MCP server uses, starts at $5/mo for 2,000 screenshots.

Why remove ads and cookie banners before sending a screenshot to a vision model?
Vision models bill by image tokens, and ads, cookie overlays, and modals add pixels and visual noise you
pay to encode — and they can hide the content you actually want analyzed. Removing them at capture time
(Site-Shot's no_ads and no_cookie_popup) yields a cleaner, often smaller image: lower token cost per
call and more accurate answers.

Which screenshot API is best for building an AI agent in 2026?
If you want the lowest-commitment official MCP with real-browser quality and ad/cookie removal, Site-Shot
($5/mo, site-shot-mcp). For the richest agent tooling and SDKs, ScreenshotOne. For forensic/compliance
captures, Urlbox. For cheapest at volume, Microlink. For screenshots plus clean page content, CaptureKit.

Capture your first screenshot free in your browser — no signup — at
site-shot.com. Building an agent? See the
AI agents page, grab an API key on the
pricing page, and read the
API docs.

Best Website Screenshot API in 2026 — 8 Tools Compared

alekseykazandaev — Wed, 15 Jul 2026 08:07:27 +0000

Originally published on the Site-Shot blog.

Picking a website screenshot API in 2026 comes down to a few things: price per screenshot at your
volume, whether there's a usable free tier, the quality of full-page rendering, geo/proxy support, and —
increasingly — whether it works with AI agents (MCP). This guide compares eight of the most-recommended
screenshot APIs with current pricing and features, so you can pick the right one fast.

Disclosure: this comparison is published by Site-Shot. We've tried to keep the numbers accurate
and the trade-offs honest — including where competitors beat us. All prices were checked in June 2026;
always confirm on each vendor's pricing page before you buy.

Quick comparison table

Cost per 1,000 is calculated from each provider's cheapest paid plan (lower is cheaper). "Full-page",
"Ad/cookie removal", and "Geo proxy" reflect availability on entry-level plans where noted.

API	Free tier	Entry plan	~Cost / 1,000	Full-page	Ad + cookie removal	Geo proxy	MCP server
Site-Shot	Free online tool, no signup	$5/mo · 2,000	$2.50 → $0.80 at scale	✅ (to 20,000px)	✅	✅	✅ (official)
ScreenshotOne	100/mo	$17/mo · 2,000	$8.50	✅	✅	✅	✅
Urlbox	7-day trial (no free tier)	$19/mo · 2,000	$9.50	✅	✅	BYO proxy	✅
ApiFlash	100/mo	$7/mo · 1,000	$7.00	✅	✅	Enterprise only	3rd-party
ScreenshotAPI.net	100 (trial)	$9/mo · 1,000	$9.00	✅	✅	Paid tiers	❌
CaptureKit	100/mo	$7/mo · 1,000	$7.00	✅	✅	✅ (stealth)	✅
Microlink	50/day	$49/mo · 46,000	$1.07	✅	✅	Pro	✅
Thum.io	1,000/mo, no signup (branded)	$2 / 10,000 hits	$0.20	Paid tier	❌	❌	❌

The short version: ScreenshotOne and Urlbox are the premium, feature-dense options (and the priciest
per shot). Thum.io and Microlink are the cheapest on raw price. Site-Shot sits in the sweet spot — a
full-featured Chromium API (full-page, country proxies, ad/cookie removal, and an official MCP server) at
under a third of ScreenshotOne's or Urlbox's entry price, plus the only genuinely free, no-signup browser
tool in the list.

The tools, one by one

Site-Shot — best value full-featured API, free no-signup tool + MCP

Site-Shot renders pages in a real Chromium browser and returns a PNG/JPEG
(or JSON with base64 + the target's response headers) from a single GET request — no SDK required.
Full-page capture up to 20,000px, device emulation, country-specific proxies (IP, language, time zone,
geolocation), and automatic ad + cookie-banner removal (no_ads, no_cookie_popup) that also keeps
images clean for AI vision pipelines. An official MCP server (npx -y site-shot-mcp) exposes the same
capture tools to Claude, Cursor, and other AI agents. The browser tool is free with no registration;
the API starts at $5/mo for 2,000 screenshots (the $15 Lite
plan includes 10,000) and drops to $0.0008/shot — $0.80 per 1,000 on the Professional plan.
Best for: developers who want full-featured, real-browser screenshots without paying premium per-shot
rates. Gaps: no native SDKs yet (on the roadmap) — you call the plain HTTP API directly.

ScreenshotOne — the developer-favorite premium API

ScreenshotOne is the most-recommended option, with a deep feature set
(PDF, video, JS/CSS injection, dark mode, S3, webhooks), native SDKs in 7 languages, an official MCP
server, and a dedicated AI-agents page. You pay for it: $17/mo for 2,000 shots ($8.50/1,000), $0.009
overage. Best for: teams that want the most polished, integration-rich option and don't mind the price.

Urlbox — premium, compliance-grade

Urlbox targets "revenue-generating businesses" with forensic-grade context
(cryptographic timestamps/hashes), change detection, bring-your-own proxy support (route through your own
provider) with built-in geolocation emulation, and many output formats. No free tier — a 7-day trial and
a $100/10K guarantee instead. From $19/mo for 2,000 renders ($9.50/1,000).
Best for: legal, compliance, and archival use cases where defensibility matters more than price.

ApiFlash — cheap and fast

ApiFlash runs Chrome on AWS Lambda for fast captures, with a simple feature set
and a low $7/mo entry (1,000 shots). Geolocation/managed proxies are Enterprise-only. Best for: simple,
fast, budget screenshots where you don't need geo-targeting.

ScreenshotAPI.net — broad feature set, developer-focused

ScreenshotAPI.net offers a wide parameter set, element capture, video output,
PDF, data extraction, and cron scheduling from $9/mo (1,000); proxy support arrives on its higher tiers.
No MCP. Best for: developers who want a broad parameter set at a low entry price.

CaptureKit — cheap, with content extraction

CaptureKit bundles screenshots with a Page Content API (HTML/Markdown/AI
summaries), stealth proxies, and edge caching from $7/mo (1,000 credits), and now ships an official MCP
server too. Best for: indie devs who also need clean web content to feed an LLM.

Microlink — cheapest at volume, full headless control

Microlink is a "browser as API" with full Puppeteer/Playwright control, an
official MCP server, global edge caching, and excellent volume pricing ($49/mo for 46,000 ≈ $1.07/1,000).
Free tier is 50 req/day. Best for: high-volume workloads and AI agents that want the cheapest
full-featured option at scale.

Thum.io — cheapest raw price, real-time streaming

Thum.io streams an animated render while capturing, with a generous 1,000/mo
no-signup free tier and $0.20/1,000 pricing. But the free tier is branded, full-page is a paid feature,
and there's no ad/cookie removal or geo proxy. Best for: simple, high-volume thumbnails on a tight budget.

How to choose

Want a free screenshot with no signup? Use Site-Shot's online tool (or Thum.io's branded free tier).
Cheapest full-featured API? Microlink at volume; Site-Shot for the lowest entry commitment ($5/mo) — and an even lower $0.80/1,000 at scale — with a free browser tool to prototype against.
Most features / integrations regardless of price? ScreenshotOne or Urlbox.
Building an AI agent today? Site-Shot, ScreenshotOne, Urlbox, Microlink, and CaptureKit all ship official MCP servers right now — Site-Shot's is npx -y site-shot-mcp (API key from the pricing page).
Best value for real-browser quality on a budget? Site-Shot — under a third of the premium APIs' per-shot price, with full-page, proxies, ad/cookie removal, and an official MCP server included.

FAQ

What is the best website screenshot API in 2026?
For most developers it's a trade-off between ScreenshotOne/Urlbox (most features, premium price),
Microlink/Thum.io (cheapest), and Site-Shot (best value for full-featured, real-Chromium screenshots with
a free no-signup tool and an official MCP server). Pick by your volume and whether you need MCP today.

What's the cheapest screenshot API?
On raw per-shot price, Thum.io ($0.20/1,000) is cheapest. Among full-featured Chromium APIs, Site-Shot
starts at $2.50/1,000 on its $5/mo plan and drops to $0.80/1,000 at scale — undercutting Microlink's
$1.07/1,000 — while keeping a free no-signup browser tool.

Is there a free screenshot API with no signup?
Site-Shot offers a free online screenshot tool with no registration; Thum.io offers a no-signup free API
tier (with branding). Most other APIs require a free account to get an API key. Site-Shot's paid API,
like the others, still requires an account and API key (from the
pricing page).

Which screenshot APIs work with AI agents / MCP?
Site-Shot, ScreenshotOne, Urlbox, Microlink, and CaptureKit ship official MCP servers today — Site-Shot's
is npx -y site-shot-mcp (registry id io.github.site-shot/site-shot-mcp). ApiFlash is available via
third-party MCP wrappers. ScreenshotAPI.net and Thum.io have no MCP server.

Can a screenshot API remove ads and cookie banners?
Yes — Site-Shot (no_ads, no_cookie_popup), ScreenshotOne, Urlbox, ApiFlash, ScreenshotAPI.net,
CaptureKit, and Microlink all support removing ads and cookie-consent banners for cleaner captures.

Capture your first screenshot free in your browser — no signup — at
site-shot.com. Ready to automate? Get an API key on the
pricing page, or read the
API docs.

How to Take a Website Screenshot with PHP

alekseykazandaev — Mon, 06 Apr 2026 18:09:26 +0000

PHP still powers a lot of real-world web applications, so screenshot generation fits naturally into CMS plugins, monitoring tools, and link preview workflows. This Dev.to version keeps the original examples intact while tightening the framing for developers who want a straightforward API-based approach.

Prerequisites

PHP 7.4+ with the cURL extension enabled
A Site-Shot API key (sign up here)

Basic Screenshot Capture

<?php

$params = http_build_query([
    'url'     => 'https://example.com',
    'userkey' => 'YOUR_API_KEY',
    'width'   => 1280,
    'height'  => 1024,
    'format'  => 'png',
]);

$ch = curl_init("https://api.site-shot.com/?{$params}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 70);

$image = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode === 200 && $image) {
    file_put_contents('screenshot.png', $image);
    echo "Screenshot saved.\n";
} else {
    echo "Error: HTTP {$httpCode}\n";
}

The API returns the raw image bytes. Just save them to a file or serve them to the browser.

Full Page Screenshot

To capture the entire scrollable page:

$params = http_build_query([
    'url'        => 'https://example.com',
    'userkey'    => 'YOUR_API_KEY',
    'full_size'  => 1,
    'max_height' => 15000,
    'format'     => 'png',
]);

JSON Response with Base64

If you need the image as base64 along with HTTP metadata:

<?php

$params = http_build_query([
    'url'           => 'https://example.com',
    'userkey'       => 'YOUR_API_KEY',
    'width'         => 1280,
    'height'        => 1024,
    'format'        => 'png',
    'response_type' => 'json',
]);

$ch = curl_init("https://api.site-shot.com/?{$params}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 70);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);

if (!empty($data['error'])) {
    die("API error: " . $data['error']);
}

$base64 = $data['image'];
if (strpos($base64, ',') !== false) {
    $base64 = explode(',', $base64, 2)[1];
}

file_put_contents('screenshot.png', base64_decode($base64));
echo "Screenshot saved.\n";

Serving Screenshots in a Web Application

Generate and serve a thumbnail screenshot directly to the browser:

<?php

$targetUrl = $_GET['url'] ?? '';
if (empty($targetUrl)) {
    http_response_code(400);
    die('Missing url parameter');
}

$params = http_build_query([
    'url'          => $targetUrl,
    'userkey'      => 'YOUR_API_KEY',
    'width'        => 1280,
    'height'       => 800,
    'format'       => 'jpeg',
    'scaled_width' => 400,
]);

$ch = curl_init("https://api.site-shot.com/?{$params}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 70);

$image = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode === 200 && $image) {
    header('Content-Type: image/jpeg');
    header('Cache-Control: public, max-age=3600');
    echo $image;
} else {
    http_response_code(502);
    die('Screenshot failed');
}

WordPress Integration

You can integrate the screenshot API into a WordPress plugin or theme:

function site_shot_capture($url, $options = []) {
    $defaults = [
        'url'     => $url,
        'userkey' => defined('SITE_SHOT_API_KEY') ? SITE_SHOT_API_KEY : '',
        'width'   => 1280,
        'height'  => 1024,
        'format'  => 'png',
    ];

    $params = http_build_query(array_merge($defaults, $options));

    $response = wp_remote_get(
        "https://api.site-shot.com/?{$params}",
        ['timeout' => 70]
    );

    if (is_wp_error($response)) {
        return false;
    }

    return wp_remote_retrieve_body($response);
}

// Usage:
$image = site_shot_capture('https://example.com', ['full_size' => 1]);
if ($image) {
    file_put_contents('/tmp/screenshot.png', $image);
}

Summary

Parameter	Description	Example
`url`	Target web page	`https://example.com`
`userkey`	Your API key	`abc123`
`width`	Viewport width (100–8000)	`1280`
`height`	Viewport height (100–20000)	`1024`
`full_size`	Capture full page	`1`
`format`	Output format	`png` or `jpeg`
`response_type`	Response format	`image` or `json`
`scaled_width`	Resize output	`400`

See the full API documentation for all available parameters.

Try Site-Shot free — no registration needed: https://www.site-shot.com/

How to Take a Website Screenshot with Node.js

alekseykazandaev — Mon, 06 Apr 2026 18:07:11 +0000

If you are building link previews, monitoring dashboards, or visual testing tools in Node.js, a screenshot API gives you a clean HTTP-based workflow without browser orchestration. This version is tuned for the Dev.to audience and keeps the examples focused on the most common production use cases.

Prerequisites

Node.js 18+ (for built-in fetch) or any version with axios
A Site-Shot API key (sign up here)

Using Built-in Fetch (Node.js 18+)

const fs = require('fs');

async function captureScreenshot(url, outputPath = 'screenshot.png') {
  const params = new URLSearchParams({
    url,
    userkey: 'YOUR_API_KEY',
    width: '1280',
    height: '1024',
    format: 'png',
  });

  const response = await fetch(
    `https://api.site-shot.com/?${params.toString()}`
  );

  if (!response.ok) {
    throw new Error(`API returned ${response.status}`);
  }

  const buffer = Buffer.from(await response.arrayBuffer());
  fs.writeFileSync(outputPath, buffer);
  console.log(`Screenshot saved to ${outputPath}`);
}

captureScreenshot('https://example.com');

Using Axios

const axios = require('axios');
const fs = require('fs');

async function captureScreenshot(url, outputPath = 'screenshot.png') {
  const response = await axios.get('https://api.site-shot.com/', {
    params: {
      url,
      userkey: 'YOUR_API_KEY',
      width: 1280,
      height: 1024,
      format: 'png',
    },
    responseType: 'arraybuffer',
    timeout: 70000,
  });

  fs.writeFileSync(outputPath, response.data);
  console.log(`Screenshot saved to ${outputPath}`);
}

captureScreenshot('https://example.com');

Full Page Scrolling Screenshot

Capture the entire page, not just the viewport:

const params = new URLSearchParams({
  url: 'https://example.com',
  userkey: 'YOUR_API_KEY',
  full_size: '1',
  max_height: '15000',
  format: 'png',
});

const response = await fetch(
  `https://api.site-shot.com/?${params.toString()}`
);

JSON Response with Base64

Get the screenshot as base64-encoded data along with HTTP metadata:

const params = new URLSearchParams({
  url: 'https://example.com',
  userkey: 'YOUR_API_KEY',
  width: '1280',
  height: '1024',
  format: 'png',
  response_type: 'json',
});

const response = await fetch(
  `https://api.site-shot.com/?${params.toString()}`
);
const data = await response.json();

if (data.error) {
  throw new Error(data.error);
}

// Remove data URL prefix if present
let base64 = data.image;
if (base64.includes(',')) {
  base64 = base64.split(',')[1];
}

const buffer = Buffer.from(base64, 'base64');
fs.writeFileSync('screenshot.png', buffer);

Express.js Integration

Serve screenshots dynamically in an Express app:

const express = require('express');
const app = express();

app.get('/preview', async (req, res) => {
  const targetUrl = req.query.url;
  if (!targetUrl) {
    return res.status(400).send('Missing url parameter');
  }

  const params = new URLSearchParams({
    url: targetUrl,
    userkey: 'YOUR_API_KEY',
    width: '1280',
    height: '800',
    format: 'jpeg',
    scaled_width: '400',
  });

  const response = await fetch(
    `https://api.site-shot.com/?${params.toString()}`
  );

  if (!response.ok) {
    return res.status(502).send('Screenshot failed');
  }

  const buffer = Buffer.from(await response.arrayBuffer());
  res.set('Content-Type', 'image/jpeg');
  res.set('Cache-Control', 'public, max-age=3600');
  res.send(buffer);
});

app.listen(3000);

This creates a /preview?url=https://example.com endpoint that returns a thumbnail screenshot — useful for link preview cards.

Capturing Multiple URLs

const urls = [
  'https://example.com',
  'https://wikipedia.org',
  'https://github.com',
];

const results = await Promise.all(
  urls.map(async (url) => {
    const params = new URLSearchParams({
      url,
      userkey: 'YOUR_API_KEY',
      width: '1280',
      height: '1024',
      format: 'png',
    });

    const response = await fetch(
      `https://api.site-shot.com/?${params.toString()}`
    );
    const buffer = Buffer.from(await response.arrayBuffer());
    const filename = url.replace(/https?:\/\//, '').replace(/\//g, '_') + '.png';
    fs.writeFileSync(filename, buffer);
    return filename;
  })
);

console.log('Saved:', results);

The number of concurrent requests depends on your plan's dedicated worker count.

Summary

Parameter	Description	Example
`url`	Target web page	`https://example.com`
`userkey`	Your API key	`abc123`
`width`	Viewport width (100–8000)	`1280`
`height`	Viewport height (100–20000)	`1024`
`full_size`	Capture full page	`1`
`format`	Output format	`png` or `jpeg`
`response_type`	Response format	`image` or `json`
`scaled_width`	Resize output image	`400`

See the full API documentation and all code samples for more details.

Try Site-Shot free — no registration needed: https://www.site-shot.com/

How to Take a Website Screenshot with Python

alekseykazandaev — Mon, 06 Apr 2026 18:01:28 +0000

If you are building monitoring dashboards, link previews, or visual QA tooling in Python, a screenshot API is a practical way to avoid browser automation overhead. This post walks through the common capture patterns Dev.to readers usually care about: basic screenshots, full-page capture, JSON output, mobile emulation, geolocation, and batch jobs.

Prerequisites

Python 3.7+
The requests library (pip install requests)
A Site-Shot API key (sign up here)

Basic Screenshot Capture

The simplest approach — send a GET request to the API and save the image:

import requests

response = requests.get("https://api.site-shot.com/", params={
    "url": "https://example.com",
    "userkey": "YOUR_API_KEY",
    "width": 1280,
    "height": 1024,
    "format": "png",
}, timeout=70)

with open("screenshot.png", "wb") as f:
    f.write(response.content)

That's it. The API renders the page in a real Chromium browser and returns the screenshot image directly.

Full Page Screenshot

To capture the entire scrollable page, not just the viewport:

response = requests.get("https://api.site-shot.com/", params={
    "url": "https://example.com",
    "userkey": "YOUR_API_KEY",
    "full_size": 1,
    "max_height": 15000,
    "format": "png",
}, timeout=70)

The full_size=1 parameter tells the API to scroll through the entire document. max_height caps the capture at 15,000 pixels (max 20,000).

JSON Response with Base64 Image

If you need the image as base64 along with HTTP response metadata:

import base64
import requests

response = requests.get("https://api.site-shot.com/", params={
    "url": "https://example.com",
    "userkey": "YOUR_API_KEY",
    "width": 1280,
    "height": 1024,
    "format": "png",
    "response_type": "json",
}, timeout=70)

payload = response.json()
if payload.get("error"):
    raise RuntimeError(payload["error"])

image_b64 = payload["image"]
if "," in image_b64:
    image_b64 = image_b64.split(",", 1)[1]

with open("screenshot.png", "wb") as f:
    f.write(base64.b64decode(image_b64))

The JSON response includes the image field (base64-encoded), HTTP status_code, and response_headers from the target URL.

Mobile Device Screenshot

Emulate a mobile viewport by setting width, height, and user agent:

response = requests.get("https://api.site-shot.com/", params={
    "url": "https://example.com",
    "userkey": "YOUR_API_KEY",
    "width": 375,
    "height": 812,
    "zoom": 100,
    "format": "png",
    "user_agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) "
                  "AppleWebKit/605.1.15 (KHTML, like Gecko) "
                  "Version/16.0 Mobile/15E148 Safari/604.1",
}, timeout=70)

Screenshot from a Specific Country

Route the request through a country-specific proxy:

response = requests.get("https://api.site-shot.com/", params={
    "url": "https://example.com",
    "userkey": "YOUR_API_KEY",
    "country": "Germany",
    "language": "de",
    "format": "png",
}, timeout=70)

The country parameter automatically sets a proxy IP, default language, time zone, and geolocation for that country.

Batch Screenshots

To capture multiple URLs, loop through them:

import requests

API_KEY = "YOUR_API_KEY"
urls = [
    "https://example.com",
    "https://wikipedia.org",
    "https://github.com",
]

for url in urls:
    response = requests.get("https://api.site-shot.com/", params={
        "url": url,
        "userkey": API_KEY,
        "width": 1280,
        "height": 1024,
        "format": "png",
    }, timeout=70)

    filename = url.replace("https://", "").replace("/", "_") + ".png"
    with open(filename, "wb") as f:
        f.write(response.content)
    print(f"Saved {filename}")

For higher throughput, use concurrent.futures.ThreadPoolExecutor to capture multiple URLs in parallel — the API supports concurrent requests based on your plan's dedicated worker count.

Summary

The Site-Shot API makes it straightforward to capture website screenshots with Python. Key parameters:

Parameter	Description	Example
`url`	Target web page	`https://example.com`
`userkey`	Your API key	`abc123`
`width`	Viewport width (100–8000)	`1280`
`height`	Viewport height (100–20000)	`1024`
`full_size`	Capture full page	`1`
`format`	Output format	`png` or `jpeg`
`response_type`	Response format	`image` or `json`
`country`	Proxy country	`Germany`
`delay_time`	Wait before capture (ms)	`2000`

Check the full API documentation for all available parameters.

Try Site-Shot free — no registration needed: https://www.site-shot.com/