DEV Community: alekseykazandaev

Site-Shot in August: an MCP server, Node + Python SDKs, and scheduled captures

alekseykazandaev — Tue, 01 Sep 2026 18:17:12 +0000

Three things shipped on Site-Shot in August that change how you wire website screenshots into an agent or a backend. Here is each one, with the code.

1. An official MCP server

If your agent runs in an MCP-capable client — Claude Desktop, Cursor, Cline, VS Code — it can take screenshots now without you writing an HTTP layer at all.

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

Restart the client, then ask it to "take a full-page screenshot of https://news.ycombinator.com".

Two tools ship: capture_screenshot and capture_full_page. block_ads and block_cookie_banners both default to true, which matters more than it sounds — a cookie wall covering the fold is simultaneously a useless image and a bill for vision tokens.

2. Node and Python SDKs

Both are zero-dependency and fully typed.

npm install site-shot-sdk

import { SiteShot } from "site-shot-sdk";
import fs from "node:fs/promises";

const client = new SiteShot(process.env.SITESHOT_API_KEY);

const png = await client.capture({ url: "example.com", full_size: true });
await fs.writeFile("shot.png", png); // png is a Buffer

pip install site-shot

from site_shot import SiteShot

client = SiteShot()  # reads SITESHOT_API_KEY from the env

png = client.capture("example.com", full_size=True)  # png is bytes
with open("shot.png", "wb") as f:
    f.write(png)

One capture concept, four return modes — you pick the method rather than a flag: capture() for bytes, captureToFile() / capture_to_file(), captureBase64() / capture_base64() for data URLs and LLM vision payloads, and captureJson() / capture_json() for the image plus metadata (add source_code and you get the rendered HTML alongside the pixels).

There is also buildUrl() / build_url(), which returns the request URL without executing it. It embeds your API key, and there is no signed-URL scheme — so it is for debugging and server-side proxying, never for an <img src>.

3. Scheduled captures

Point a schedule at a URL and it re-captures on a cadence, filing every shot in your library as a dated series. Finest cadence hourly, coarsest weekly. Every plan carries a weekly allowance — from 35 captures a week on the smallest plan to 12,000 a week on the largest — and each scheduled capture counts as one screenshot, like any other.

A schedule also compares each capture with the previous one and can email you when the changed share of the page crosses a threshold you set. Worth being precise about the boundaries, because "change detection" gets oversold:

it measures how much of the page moved, not what changed — there is no text or element diff;
email is the only destination, and alerts are deduped to at most one per schedule per day;
the soonest anything can reach you is the schedule's own cadence;
alerts stay off until you switch them on per schedule.

If you need element-level diffs or a ping within minutes, a dedicated change-detection service is the right tool. What this gives you instead is the comparable, timestamped series — what the page actually looked like before and after.

Geotargeting: 49 countries

Add country=DE and the render goes through a real IP in that country, with the language, time zone and geolocation defaults that belong to it. It takes an ISO 3166-1 alpha-2 code; full country names are not valid values.

png = client.capture("https://example.com/", country="DE", strict_country=True)

strict_country is the part worth knowing about. Without it, an exhausted country pool quietly falls back to a US render and you get a screenshot that looks plausible and is wrong. With it, you get an in-band country_unavailable error instead — which is the failure you actually want, because a silently-wrong geo screenshot is undetectable downstream.

Where to start

The free browser tool at site-shot.com needs no signup. The API needs a key; plans start at $5/month for 2,000 screenshots. Agent-facing docs live at site-shot.com/ai-agents/.

Numbers here are current as of 2026-09-01 — the country count moves with verified proxy capacity, so check /countries/ for today's list.

AI Agent vs. Screenshot API: Who Should Capture the Page (2026)

alekseykazandaev — Sun, 16 Aug 2026 15:50:44 +0000

Originally published on the Site-Shot blog.

Your agent already has a browser. It can navigate, wait, and call a screenshot function, and in the demo it
works: you ask for a picture of a landing page and a PNG comes back. So the natural next thought is that a
screenshot API is a box you no longer need — the agent is general-purpose, and a screenshot is a special case
of "use a browser".

Then the job grows. Five hundred URLs instead of one. The same page every morning for a quarter. The German
version of a pricing page, not the German-language version served to a US datacenter IP. A run nobody is
watching, where the thing you file turns out to be a cookie wall.

The useful question is not whether a general-purpose agent can take a screenshot — it can — but whether it
should be the component that takes it. Does the job need a browser driven, or a URL turned into an image?

Disclosure: this comparison is published by Site-Shot, a screenshot API. We've tried to keep the
numbers accurate and the trade-offs honest — including a section on the jobs where a general-purpose agent
is the right tool and we are not. Our prices and country count were checked in August 2026; confirm on the
pricing page before you buy.

The short answer

Should an AI agent take its own screenshots? Only when the page has to be driven to reach the state you
want — signed into, stepped through a flow, interacted with. When the job is "this URL, these options, give
me the image", a screenshot API is the better component: it runs the same pipeline on every request, renders
from another country, scores the result before returning it, captures in parallel, and costs a fraction of a
cent instead of a few thousand image tokens per glance. The strongest setup is not one or the other — it is an
agent that decides what to capture and delegates the capturing.

The two architectures, side by side

	General-purpose agent driving a browser	Dedicated screenshot API
What you ask for	A goal, in a prompt	A URL plus explicit parameters
Same request twice	A new plan each run	The same pipeline each run
"Is the page ready?"	The model judges	Explicit waits (`delay_time`), fixed timeouts
Country of the exit IP	Wherever the sandbox runs	48 countries, `country=DE&strict_country=1`
Locale, time zone, geolocation	Yours to set, per country	Move with the country automatically
Failure handling	Whatever the model tries next	A fixed retry ladder, then an error
Result checked before you get it	No	Scored by an image classifier
Concurrency	Serial by construction	10–100 dedicated workers by plan
Cost per capture	Image tokens on every step it looks	From $2.50 per 1,000, down to $0.80
Can log in / click through a flow	Yes	No

Cost per 1,000 comes from Site-Shot's cheapest and largest paid plans ($5/mo for 2,000 and $500/mo for
625,000, checked August 2026).

Predictability: the same request, twice

An agent's plan is a sample, not a contract. Ask the same agent for the same screenshot on Monday and Friday
and you may get a different viewport, a different moment in the page's load, a different decision about the
cookie banner. That variance is what makes an agent useful on messy one-off work — and what you do not want
in the thing that produces your archive. A capture call goes through the same pipeline every time, so when
today's frame differs from yesterday's, the page changed, not the plan.

That compounds as captures pile up: a daily series is only comparable if every frame was taken the same way.
With an agent, "same settings" is something you hope the model repeats. With parameters, it is something you
typed.

Capturing from a specific country

This is where the two architectures stop being interchangeable.

A general-purpose agent renders from wherever it happens to run: your laptop, a CI container, or a cloud
sandbox with a datacenter IP in the provider's region. For plenty of pages that is fine. For anything
geo-targeted — offers, prices, ad creatives, region-limited content, localized landing pages — it is the
wrong vantage point, and the failure is silent: the page renders, the screenshot looks plausible, and it is
simply not what a user in that country sees.

Closing that gap yourself means running proxy infrastructure — exits per country, kept alive as they get
blocked — plus the rest of the vantage point, because an IP alone is not a country. A real German browser
also sends German language preferences, sits in a Central European time zone, and reports plausible
geolocation coordinates; get one of those wrong and sophisticated sites serve you the "something is off"
version of the page.

Site-Shot ships that as one parameter. Add country=DE and the capture is rendered through an exit in that
country with the locale, time zone and geolocation defaults that belong to it — 48 countries as of August
2026, on any paid plan. Add strict_country=1 and you also get the
guarantee that matters more than the feature: if no exit is available for that country at that moment, the
API returns an in-band "error": "country_unavailable" instead of quietly falling back to a US render. A
wrong-country screenshot you know about is a retry. One you don't is a bad decision with a picture
attached. The step-by-step version — including the free browser tool, where the default is a direct
connection and you have to select United States explicitly — is in the
guide to screenshots from another country.

Knowing the screenshot is actually a screenshot

An agent's browser returns whatever rendered: the page, or a bot-check interstitial, a consent wall, a 404
skinned like a homepage, a blank frame because the exit never reached the host. The agent may notice — vision
models are decent at spotting a Cloudflare page — but only if looking is in its plan, and in an unattended
run "the browser returned an image" is usually treated as success.

Site-Shot treats a returned image as a hypothesis. Every capture is scored by an image classifier trained on
our own corpus of renders, which sorts a frame three ways: a valid page, an invalid render, or a page whose
content is the target site's own error. A capture that fails that check is not what you get back — it
triggers the next rung of a retry ladder instead. Up to three attempts escalate strategy rather than repeat
it: a plain fast render first, then a render that handles interstitial challenges, then a render through a
country exit, with the starting rung chosen from what has worked for that host before.

Two honest limits:

If the whole ladder fails, you still get the best image it produced, unvalidated. We would rather hand you a questionable frame you can check than fail a job a human eye could have salvaged.
One case is not salvageable and comes back as an error instead: a capture where no page was fetched at all. That guard exists because of a real incident — captures through exits that could not reach the host returned a 3 KB white PNG with a 200 status, and a caller storing what it was given would have filed a blank rectangle as that day's evidence.

None of that makes a capture legally special. It is ordinary specialization: a service that does one thing a
few million times learns what its own failures look like, and can afford a model whose only job is to
recognize them.

Cost per look

A general-purpose agent pays for pixels twice: once to render the page, and again — every step it looks — to
feed the image to the model. That second cost is easy to underestimate because it is invisible in the code,
and the arithmetic is public. Claude reads an image in 28×28-pixel patches, so an image costs
⌈width / 28⌉ × ⌈height / 28⌉ visual tokens: a 1920×1080 screenshot is 2,691 visual tokens on the
high-resolution tier, and a 4K frame is capped at 4,784 (Anthropic's vision documentation, checked August
2026). A ten-step agent run that looks after each action spends on the order of 27,000 tokens on pixels
before reasoning about any of them. Other vision models price differently, but all of them charge by image
size, and every step of a browsing loop re-sends one.

Against that, a capture on Site-Shot's entry plan costs $0.0025 — $5/mo for 2,000 screenshots, falling to
$0.80 per 1,000 on the largest plan. An agent glance and a capture are simply different purchases: image
tokens are worth paying so a model can see a page and act on it, and are waste when the deliverable is a
file no model needs to look at. When the agent does look, no_ads=1 and no_cookie_popup=1 mean it
encodes less junk.

Throughput and recovery

An agent loop is serial by construction: think, act, look, think. Five hundred URLs is five hundred round
trips through a model, and the wall-clock cost is the sum. You can fan out several agents — but every
parallel lane is another model running, so agent parallelism scales the bill, not just the throughput.
Capture workers are the cheap kind of parallel: 10 dedicated workers on the two entry tiers, 25 on Optimal,
100 on Professional, so a batch is bounded by your plan's parallelism rather than by one conversation's
pace. Recovery differs the same way: a failed render inside an agent is
handled by whatever the model improvises, while a failed capture walks a fixed ladder and then reports a
specific failure you can branch on.

Where a general-purpose agent is genuinely the right tool

One case, and it is a real one: pages that must be driven to reach the state you want. Signing in and
passing a second factor, walking a checkout to step three, opening the account screen of a dashboard,
applying filters until the view you need exists — a URL-in, image-out API cannot do any of those steps by
design. When the screenshot's subject only exists after authorization and a chain of interactions, you need
something that drives a browser: an agent, or your own Playwright script. That is the boundary, and it is not
a small territory — it covers most captures of your own logged-in product.

Everything on the public side of that boundary is delegable, which is the hybrid: the agent decides what to
capture and hands off the capture. Over MCP that is a tool call — our official server (npx -y site-shot-mcp)
exposes capture_screenshot and capture_full_page, so the model asks for a picture and never touches HTTP
plumbing. See the MCP setup guide and the
AI agents page.

Handing the job over

It is one GET — no SDK required, though Node.js and Python have official ones (npm install site-shot-sdk
and pip install site-shot):

curl -o de.png "https://api.site-shot.com/?url=whatismycountry.com&country=DE&strict_country=1&no_ads=1&no_cookie_popup=1&width=1280&height=800&user_key=YOUR_KEY"

Add full_size=1 for the whole scrollable page (up to 20,000 pixels tall with max_height), or
response_type=json to get the image as base64 alongside the target's response headers. To hand the same
capabilities to the agent instead, drop the MCP server into your client config with a SITESHOT_API_KEY and
the model calls them as tool arguments.

API keys come from the pricing page, from $5/mo for 2,000 screenshots.
For where a capture API sits among the alternatives, see the
8-tool screenshot API comparison and the
screenshot MCP server roundup.

FAQ

Can an AI agent take website screenshots on its own?
Yes. Any agent with browser access can navigate to a URL and capture the viewport. The limits are not
capability but consistency, geography, and cost: an agent re-plans on every run, renders from whatever IP its
sandbox has, and pays image tokens each time it looks at the page.

When should an AI agent call a screenshot API instead of screenshotting the page itself?
When the job is "this URL, these options, give me the image" rather than "drive this browser". A screenshot
API runs the same capture pipeline with the same parameters on every request, can render from a specific
country, validates the result before returning it, and runs captures in parallel. Keep the agent in charge only when the page must be driven to reach the
state you want — signed into, stepped through a multi-step flow, interacted with.

How do I screenshot a page as it appears in another country?
Render it through an exit in that country with matching locale, time zone and geolocation. On Site-Shot that
is one parameter — country=DE — across 48 countries as of August 2026, on any paid plan; adding
strict_country=1 makes an exhausted country pool return an in-band "error": "country_unavailable" instead
of silently falling back to a US render. A general-purpose agent renders from wherever it runs, so a
geo-targeted page comes back plausible and wrong.

How do I know a screenshot is the real page and not a bot check?
Site-Shot scores every capture with an image classifier that sorts a frame as a valid page, an invalid
render, or the target site's own error page. A frame that fails triggers the next rung of a retry ladder — up
to three attempts escalating from a plain render to challenge handling to a country exit — rather than being
returned. If every attempt fails you still receive the best image, unvalidated, with one exception: a capture
that fetched no page at all is returned as an error, never as a blank rectangle.

Is a screenshot API cheaper than having the agent do it?
For producing image files, usually by a wide margin. A vision model bills by image size — Claude reads images
in 28×28-pixel patches, so a 1920×1080 screenshot is 2,691 visual tokens (Anthropic's vision documentation,
checked August 2026) — and a browsing loop re-sends one on every step. A Site-Shot capture costs $0.0025 on
the entry plan ($5/mo for 2,000) and $0.80 per 1,000 at the largest tier. Image tokens are worth paying when
the model needs to see the page; they are waste when the deliverable is a file.

What can a screenshot API not do that a browsing agent can?
It cannot drive the page: signing in, passing a second factor, filling forms, and clicking through a
multi-step flow are all out of scope for a URL-in, image-out service. A page state that only exists after
authorization and a chain of interactions has to be captured by whatever performs those interactions — a
browsing agent or your own browser automation.

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 from $5/mo, and read the
API docs.

How to Take Website Screenshots from Another Country

alekseykazandaev — Mon, 27 Jul 2026 08:08:59 +0000

Originally published on the Site-Shot blog.

The web you see is not the web everyone sees. The same URL serves different ads in Berlin and Boston, different prices in São Paulo and Stockholm, a cookie-consent wall in Paris and none in Singapore — and sometimes a "not available in your region" page instead of any content at all. If you need proof of what a page really shows in a given market, you need a screenshot taken from that market.

Site-Shot renders screenshots through real country-specific IP addresses in 49 countries. Geotargeting is included with any paid plan, and the free no-signup browser tool captures from the United States. Since July 2026 you can pick the country right in the browser tool — no code required — or automate it with one API parameter.

This guide covers both paths, plus the four jobs people actually need this for.

The quick way: your browser, no signup

Open site-shot.com and paste the URL you want to capture.
In the Country dropdown, select United States. (The default is Direct connection, which renders from our data center without geo routing — pick a country explicitly to get a geo-targeted view.)
Capture. The page is rendered in a real Chromium browser behind a US IP address, with US language, time zone, and geolocation defaults applied automatically.

US captures are free and require no account. Every other country in the dropdown unlocks with any paid plan — the selector shows exactly what's available right now, and every plan on the pricing page includes geotargeting for all supported countries.

A good first test: capture whatismycountry.com. It prints the detected country and city above the fold, so you can see the geo routing working with your own eyes.

What country-based screenshots are for

Verifying geo-targeted ad campaigns

If you run country-targeted campaigns — or sell ad placements — you need evidence that the right creative actually appears in the right market. A screenshot captured through a German IP shows the ads a German visitor is served, not what your office network gets.

One practical note: Site-Shot can block ads with no_ads=1 for clean captures, but for ad verification you want the opposite — leave ad blocking off so the creatives render.

Checking localized prices and content

Stores and SaaS products localize prices, currencies, promotions, and sometimes whole product catalogs by visitor location. Screenshots from each target market let you audit what's actually being shown: the currency symbol, the regional promo banner, the shipping notice. Capture the same product page from a few countries and compare them side by side.

Testing geo-blocking and region availability

When content is supposed to be restricted (or supposed to be available) in specific regions, a screenshot from inside the region is the test. This is the one use case where you should always set strict mode (strict_country=1, covered below): a silent fallback to a US IP would show you the US view and quietly invalidate the conclusion.

Auditing cookie and consent banners by region

A page loaded from an EU IP address typically greets you with a GDPR consent dialog that US visitors never see; other regions have their own variants. Capturing your pages from an EU country shows exactly which banner fires and what it covers. (For the opposite need — clean captures without consent walls — add no_cookie_popup=1.)

Localization QA

Beyond prices and banners, a country-routed capture exercises the whole localized experience: the country parameter automatically sets the matching browser language, time zone, and geolocation coordinates, so date formats, translated UI, and locale-dependent layout render as a local would see them. Screenshots from each market make translation gaps and text-overflow bugs visible at a glance — including right-to-left rendering (for example country=EG with Arabic).

Automating it: the API

The browser tool is the fastest way to check one page. To monitor pages on a schedule or capture in bulk, use the API — plans start at $5/month for 2,000 screenshots (pricing), and every plan includes geotargeting.

One parameter does the work — use two-letter ISO country codes:

curl -o berlin.png "https://api.site-shot.com/?url=https://example.com&userkey=YOUR_API_KEY&country=DE&strict_country=1&format=png"

The same request in Python:

import requests

response = requests.get("https://api.site-shot.com/", params={
    "url": "https://example.com",
    "userkey": "YOUR_API_KEY",
    "country": "DE",           # two-letter ISO code
    "strict_country": 1,
    "format": "png",
}, timeout=70)

data = response.content
if data.startswith(b"{") and b'"error"' in data[:200]:
    # e.g. {"error": "country_unavailable"} — no capacity in that country right now
    raise RuntimeError(data.decode())

with open("berlin.png", "wb") as f:
    f.write(data)

And in Node.js:

const params = new URLSearchParams({
  url: "https://example.com",
  userkey: "YOUR_API_KEY",
  country: "DE",
  strict_country: "1",
  format: "png",
});

const res = await fetch(`https://api.site-shot.com/?${params}`);
const buf = Buffer.from(await res.arrayBuffer());

if (buf.subarray(0, 200).includes('"error"')) {
  throw new Error(buf.toString()); // e.g. {"error": "country_unavailable"}
}
await require("node:fs/promises").writeFile("berlin.png", buf);

Why `strict_country` matters

By default, if no proxy is available for the requested country at that moment, the request silently falls back to a US IP — you always get a screenshot, but not necessarily from where you asked. With strict_country=1 the request fails fast instead: you get an error response with "error": "country_unavailable" rather than a screenshot from the wrong country.

Rule of thumb: for casual previews, leave strict mode off. For anything where the country is the point — geo-blocking tests, ad verification, compliance evidence — always set strict_country=1, so a capture that couldn't be routed correctly fails loudly instead of lying quietly.

Fine-tuning the locale

country sets sensible defaults; three companion parameters override them independently:

Parameter	What it controls	Example
`country`	Proxy IP location + default language, time zone, geolocation	`country=DE`
`strict_country`	Fail fast instead of falling back to a US IP	`strict_country=1`
`language`	Browser language / `Accept-Language` header	`language=ja`
`time_zone`	Browser time zone	`time_zone=Asia/Tokyo`
`geolocation`	GPS coordinates reported by the browser	`geolocation=48.8566,2.3522`

So country=BR&language=en renders through a Brazilian IP with English browser language — useful for checking what an English-speaking traveler in Brazil would see. The full country list with each country's default settings lives on the countries reference page.

Any ISO 3166-1 alpha-2 code with live proxy capacity can be requested — 49 countries as of August 2026.
The offered list is not a static table: Site-Shot verifies each proxy pool's real exit country against a
majority vote of independent GeoIP sources and only offers countries with verified capacity, so the
country selector on the homepage and the countries page always
show the current list.

For more Python patterns — full-page captures, batching, mobile emulation — see How to Take a Website Screenshot with Python. To see how other screenshot APIs handle geotargeting (most require bringing your own proxies or gate it behind premium tiers), see our screenshot API comparison. AI agents can do all of the above through the official MCP server — see Site-Shot for AI agents.

FAQ

Can I take a screenshot of a website from another country for free?
You can capture from the United States free in your browser with no signup at site-shot.com. All other supported countries are available on any paid plan — both in the browser tool and via the API.

How do I make sure the screenshot really comes from the right country?
Site-Shot verifies each proxy pool's real exit country against a majority vote of independent GeoIP sources before offering it, and quarantines ambiguous exits. On top of that: set strict_country=1 so the request fails with "error": "country_unavailable" instead of silently falling back to a US IP, and spot-check your setup by capturing a geo-echo page like whatismycountry.com, which prints the detected country in the screenshot itself.

Which countries does Site-Shot support?
49 countries as of August 2026, across North and South America, Europe, Asia, Africa, and Oceania — including the US, UK, Germany, France, Japan, Brazil, and Singapore. The offering is derived from live verified proxy capacity, so the current list with per-country defaults is always on the countries page.

What's the difference between country and geolocation?
country routes the request through an IP address in that country — it changes what servers detect about the visitor's network location. geolocation sets the GPS coordinates the browser reports to sites that ask for them. They can be combined to simulate both network and physical presence.

Do language and time zone follow the country automatically?
Yes. Setting country applies that country's default browser language, time zone, and geolocation. Any of them can be overridden by passing language, time_zone, or geolocation explicitly.

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

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 August 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. One pricing-basis note:
Urlbox's cheapest plan (Lo-Fi, $19/mo) renders third-party sites as thumbnails only — it's scoped to sites
you own — so its row uses the first plan that fully captures other people's sites, Hi-Fi at $49/mo for
5,000 (checked August 2026).

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	25/day	✅	✅	Pro (verify for screenshots)
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	✅	✅	Stealth, no country pick
ScreenshotOne	$8.50	$5.18	100/mo	✅	✅	Growth+
ScreenshotAPI.net	$9.00	$1.75	100 (7-day trial)	✅	✅	Paid tiers
Urlbox	$9.80 (Hi-Fi)	~$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 (its docs don't scope it for
screenshots — verify against your workload), an official MCP server, and a global edge 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 25 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, and scheduled captures are built in on every paid plan
(how it works). 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: the official client SDKs cover Node.js (npm install site-shot-sdk) and
Python (pip install site-shot); in other languages 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 server. 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)
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 mode (residential proxies with fingerprint rotation — no country selection) is included
on all plans. 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, priced for compliance work

Urlbox is the most expensive at entry and the only option here with no free
tier — just a 7-day trial and a $100/10K refund guarantee. Mind which plan you price against: the
cheapest tier (Lo-Fi, $19/mo for 2,000) is scoped to sites you own and renders third-party pages as
thumbnails only, so the practical entry for screenshotting arbitrary sites is Hi-Fi at $49/mo for 5,000
renders ($9.80/1,000, checked August 2026). What you pay for is compliance-grade context: tamper-evident
timestamps/hashes (their claim), 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 a 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+), ScreenshotAPI.net (higher tiers), and ApiFlash
(Enterprise only); CaptureKit's stealth mode offers no country selection. 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). ScreenshotOne and Urlbox (github.com/urlbox/urlbox-mcp-server) have official servers too. For CaptureKit,
ApiFlash, ScreenshotAPI.net, and Thum.io we could not find an official MCP server in the MCP registry or
on npm as of August 2026.

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 August 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	$49/mo · 5,000 (Hi-Fi)	$9.80	✅
Microlink	✅ Official	$49/mo · 46,000	$1.07	✅
CaptureKit	❌ None found (registry/npm, Aug 2026)	$7/mo · 1,000	$7.00	✅
ApiFlash	❌ None	$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 — except Urlbox, whose $19/mo Lo-Fi tier is
scoped to sites you own and returns third-party pages as thumbnails only, so its row uses Hi-Fi, the
first plan an agent can point at arbitrary URLs ($49/mo for 5,000, checked August 2026). 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: the official client SDKs cover Node.js
(npm install site-shot-sdk) and Python (pip install site-shot) — elsewhere the HTTP API is a plain
GET you call directly from non-MCP code.

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
compliance-grade output: tamper-evident timestamps and hashes (their claim), change detection, and many
formats. There's no free tier — a 7-day trial and a $100/10K refund guarantee instead — and an agent
pointing at arbitrary URLs needs Hi-Fi at $49/mo for 5,000 renders ($9.80/1,000, checked August 2026);
the cheaper $19 Lo-Fi tier is scoped to sites you own and returns third-party pages as thumbnails.
Best for: agents in legal, compliance, or archival workflows where a defensible 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 25-req/day tier. Best for: high-volume agents that want headless-browser
control and the lowest full-featured price at scale.

CaptureKit

CaptureKit pairs screenshots with a Page
Content API (HTML/Markdown/AI summaries) and stealth mode, from $7/mo for 1,000 credits — though we
could not find a CaptureKit MCP server in the MCP registry or on npm as of August 2026, so agent
integration there is DIY today. 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 we
could not find an official ApiFlash MCP server in the MCP registry or on npm as of August 2026. 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 defensible, compliance-grade captures for legal 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), ScreenshotAPI.net (broad params), or Thum.io (cheapest thumbnails) — expect to write the tool wrapper yourself.

For more detail, see our screenshot MCP server roundup,
the 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?
A screenshot API for AI agents is 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, and Microlink ship
official servers too. For CaptureKit, ApiFlash, ScreenshotAPI.net, and Thum.io we could not find one in
the MCP registry or on npm as of August 2026.

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, and Node.js and
Python projects can install the official site-shot-sdk or site-shot package instead.

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 compliance and
archival captures, Urlbox. For cheapest at volume, Microlink. For screenshots plus clean page content,
CaptureKit (no MCP found as of August 2026 — the agent wiring is DIY there).

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 August 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. One
pricing-basis note: Urlbox's cheapest plan (Lo-Fi, $19/mo) is scoped to sites you own and renders
third-party pages as thumbnails only, so its row uses the first plan that properly captures other
people's sites — Hi-Fi at $49/mo for 5,000 (checked August 2026).

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)	✅	✅ all plans	✅ (official)
ScreenshotOne	100/mo	$17/mo · 2,000	$8.50	✅	✅	Growth+ only	✅
Urlbox	7-day trial (no free tier)	$49/mo · 5,000 (Hi-Fi)	$9.80	✅	✅	BYO proxy (Ultra+)	✅
ApiFlash	100/mo	$7/mo · 1,000	$7.00	✅	✅	Enterprise only	❌
ScreenshotAPI.net	100 (trial)	$9/mo · 1,000	$9.00	✅	✅	BYO ($29+ tiers)	❌
CaptureKit	100/mo	$7/mo · 1,000	$7.00	✅	✅	Stealth, no country pick	❌
Microlink	25/day	$49/mo · 46,000	$1.07	✅	✅	Pro (verify for screenshots)	✅
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, and automatic ad + cookie-banner removal (no_ads,
no_cookie_popup) that also keeps images clean for AI vision pipelines. Geotargeting is built in on
every paid plan: the country parameter routes the render through a real country-specific IP address
in 49 countries as of August 2026 (with matching language, time zone, and geolocation — each pool's exit country is
verified against a majority vote of independent GeoIP sources), a strict_country=1 mode fails
fast with "error": "country_unavailable" instead of silently falling back, and since July 2026 the
free browser tool has a country selector too (US captures free) — see the
geo screenshots guide. An official MCP server (npx -y site-shot-mcp) exposes the same
capture tools to Claude, Cursor, and other AI agents. Scheduled captures are built in on every paid
plan too — set a cadence in the browser and every shot files into your library
(how it works). 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: the official SDKs cover Node.js (npm install site-shot-sdk) and Python
(pip install site-shot) — in every other language 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 compliance-grade context —
tamper-evident timestamps/hashes (their claim), change detection — plus bring-your-own proxy support
(route through your own provider; gated to Ultra, $99/mo, and above) with built-in geolocation emulation,
and many output formats. No free tier — a 7-day trial and a $100/10K guarantee instead. Mind which plan
you price against: the cheapest tier (Lo-Fi, $19/mo for 2,000) is scoped to sites you own and renders
third-party pages as thumbnails only, so capturing other people's sites starts at Hi-Fi — $49/mo for
5,000 renders ($9.80/1,000, checked August 2026).
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). IP geolocation and managed proxies are Enterprise-only (a
bring-your-own proxy parameter is self-serve). 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 scheduled screenshots; plans start at $9/mo (1,000), and bring-your-own proxy
support arrives on its higher tiers ($29/mo Startup and up — no country selection). 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) and stealth mode (residential proxies with fingerprint rotation — no country selection) from
$7/mo (1,000 credits). 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 25 req/day. Geo caveat: Microlink's docs used to scope Pro's automatic proxy resolution
away from screenshots and PDFs (their FAQ, June 2026); as of August 2026 that note is gone and the docs
don't state the scope — test geo screenshots on your own workload before relying on them. 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, and Microlink ship official MCP servers right now — Site-Shot's is npx -y site-shot-mcp (API key from the pricing page).
Need the same page captured on a schedule, without code? Site-Shot's scheduled captures are built into every paid plan; ScreenshotAPI.net advertises scheduled screenshots too. Elsewhere you drive the API from your own cron.
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. Get one on the
pricing page.

Which screenshot APIs work with AI agents / MCP?
Site-Shot, ScreenshotOne, Urlbox (github.com/urlbox/urlbox-mcp-server), and Microlink ship official
MCP servers today — Site-Shot's is npx -y site-shot-mcp (registry id io.github.site-shot/site-shot-mcp).
For ApiFlash, CaptureKit, ScreenshotAPI.net, and Thum.io we could not find an official MCP server in the
MCP registry or on npm as of August 2026.

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.

Which screenshot API can capture a website from another country?
Site-Shot includes country-IP routing on every paid plan — a country parameter (two-letter ISO code)
plus strict_country=1 to fail fast rather than silently fall back to a US IP; its free browser tool
captures from the US with no signup. ScreenshotOne offers built-in IP location (18 countries, datacenter
proxies) on its Growth and Scale tiers; Urlbox routes through a proxy you bring yourself; ApiFlash gates
geo behind Enterprise. See the
step-by-step geo guide.

Which screenshot APIs can capture on a schedule?
Site-Shot has scheduled captures built into every paid plan — set a cadence in the browser, every shot
files into your library, no cron or code needed. ScreenshotAPI.net advertises scheduled screenshots as
a product too. ScreenshotOne has no built-in scheduler — recurring captures there run through Zapier,
Make, n8n, or your own cron. For the other tools, check their docs; where nothing is built in, driving
the API from cron works with any of them.

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/

DEV Community: alekseykazandaev

Site-Shot in August: an MCP server, Node + Python SDKs, and scheduled captures

1. An official MCP server

2. Node and Python SDKs

3. Scheduled captures

Geotargeting: 49 countries

Where to start

AI Agent vs. Screenshot API: Who Should Capture the Page (2026)

The short answer

The two architectures, side by side

Predictability: the same request, twice

Capturing from a specific country

Knowing the screenshot is actually a screenshot

Cost per look

Throughput and recovery

Where a general-purpose agent is genuinely the right tool

Handing the job over

FAQ

How to Take Website Screenshots from Another Country

The quick way: your browser, no signup

What country-based screenshots are for

Verifying geo-targeted ad campaigns

Checking localized prices and content

Testing geo-blocking and region availability

Auditing cookie and consent banners by region

Localization QA

Automating it: the API

Why strict_country matters

Fine-tuning the locale

FAQ

Cheapest Screenshot API in 2026 (Free Tiers Compared)

Ranked by price per 1,000 (cheapest first)

The tools, cheapest first

Thum.io — cheapest raw price, but thumbnails only

Microlink — cheapest full-featured option at volume

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

ApiFlash — cheap, fast, but geo costs extra

CaptureKit — cheap, with content extraction for LLMs

ScreenshotOne — premium, deepest features, priced accordingly

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

Urlbox — no free tier, priced for compliance work

How to choose the cheapest option for your needs

FAQ

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

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

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

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

Which screenshot APIs ship an official MCP server?

The MCP-ready options, one by one

Site-Shot

ScreenshotOne

Urlbox

Microlink

CaptureKit

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

How to choose for an AI agent

FAQ

Best Website Screenshot API in 2026 — 8 Tools Compared

Quick comparison table

The tools, one by one

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

ScreenshotOne — the developer-favorite premium API

Urlbox — premium, compliance-grade

ApiFlash — cheap and fast

ScreenshotAPI.net — broad feature set, developer-focused

CaptureKit — cheap, with content extraction

Microlink — cheapest at volume, full headless control

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

How to choose

FAQ

How to Take a Website Screenshot with PHP

Prerequisites

Basic Screenshot Capture

Full Page Screenshot

JSON Response with Base64

Serving Screenshots in a Web Application

WordPress Integration

Summary

How to Take a Website Screenshot with Node.js

Prerequisites

Why `strict_country` matters