ScreenshotMachine vs ScreenshotOne: API Features and Pricing Compared

Short answer: Both ScreenshotMachine and ScreenshotOne offer hosted APIs that render web pages, but they differ in API inputs, documented capture options, output formats, and billing rules. ScreenshotMachine lists plans in euros and a separate webpage-to-PDF API; ScreenshotOne lists plans in US dollars, accepts URL, HTML, or Markdown input, and documents image, PDF, HTML, and Markdown outputs. For a fair choice, estimate fresh monthly captures, peak request starts, required output types, and how each service treats cache hits and overages.

This is a comparison of vendor documentation and listed plans, not a head-to-head rendering test. Prices and plan features were checked on October 3, 2026 and can change; recheck the vendor pages before choosing a plan. No evidence here establishes which service renders more accurately, runs faster, or is more reliable.

At a glance

Question	ScreenshotMachine	ScreenshotOne
Request style	GET with query parameters to api.screenshotmachine.com	GET or POST over HTTPS to api.screenshotone.com/take
Input types	Website URL	URL, HTML, or Markdown
Documented outputs	JPG, PNG, GIF; separate webpage-to-PDF API	PNG, JPEG, WebP, GIF, JP2, TIFF, AVIF, HEIF, PDF, HTML, or Markdown
Free tier	100 fresh screenshots/month	100 screenshots/month
First paid tier	Basic: €9/month for 2,500 fresh screenshots	Basic: $17/month for 2,000 screenshots
Cache billing	Pricing page says cached impressions are unlimited	Cached responses do not consume credits; cache misses may render and count
Overages	Additional captures priced by tier; billed in 1,000-capture blocks rounded down, according to the pricing page	Paid overages are off by default; enable them with a hard limit to control total use

Sources: ScreenshotMachine pricing, ScreenshotMachine API documentation, ScreenshotOne pricing, ScreenshotOne Getting Started, and ScreenshotOne credits.

Pricing and included usage

The figures below are vendor-listed monthly prices observed October 3, 2026. ScreenshotMachine bills in euros; ScreenshotOne bills in US dollars. They are not directly comparable without considering exchange rates and tax treatment. ScreenshotOne says its prices exclude VAT. ScreenshotMachine says VAT may be added for non-business EU customers. Confirm current terms for your billing location.

Vendor	Plan	Monthly price	Included use	Additional pricing or request rate
ScreenshotMachine	Free	€0	100 fresh screenshots	Cached impressions listed as unlimited
ScreenshotMachine	Basic	€9	2,500 fresh screenshots	€0.004 per additional screenshot; additional use grouped and rounded down by thousands
ScreenshotMachine	Pro	€59	20,000 fresh screenshots	€0.003 per additional screenshot
ScreenshotMachine	Enterprise	€99	50,000 fresh screenshots	€0.002 per additional screenshot
ScreenshotOne	Free	$0	100 screenshots	No card required, according to the plan page
ScreenshotOne	Basic	$17	2,000 screenshots	40 request starts/minute; $0.009 per extra
ScreenshotOne	Growth	$79	10,000 screenshots	80 request starts/minute; $0.006 per extra
ScreenshotOne	Scale	$259	50,000 screenshots	150 request starts/minute; $0.004 per extra

ScreenshotMachine’s pricing page says extra captures are tallied at period end and billed in blocks of 1,000, rounded down; its example says 999 or fewer additional captures do not incur another block charge. ScreenshotOne describes overages as off by default and configurable with a hard usage limit. Its credits refresh each billing cycle and unused credits do not roll over. Check the current plan page and account settings before relying on any threshold or rate.

Do not assume a plan’s “screenshot” means the same billable event across providers. ScreenshotMachine distinguishes fresh captures and cached impressions. ScreenshotOne says cached responses do not consume credits, while a cache miss may trigger a render that does. ScreenshotOne’s documentation currently says each available output type—including a full-page screenshot, PDF, scrolling capture, or video—costs one credit. The provider’s plan page says failed HTTP, browser, or network requests do not count, but a successfully rendered image with a visual defect can count.

Feature and API comparison

ScreenshotMachine: URL capture with detailed browser controls

ScreenshotMachine documents a GET endpoint at https://api.screenshotmachine.com/. Supply a customer key and a target URL as query parameters, then add optional settings for the capture. Documented controls include viewport width and height (up to 1,920 pixels wide and 9,999 high, with full accepted for page height), device presets for desktop, phone, or tablet, JPG/PNG/GIF formats, cache age from zero to 14 days, wait delay, zoom, CSS selector capture, crop, cookies, click actions, language, and user agent. Its guide recommends a longer delay for long pages with images or animation.

For PDF output, ScreenshotMachine documents a separate webpage-to-PDF API with paper-size and orientation options. It also documents signed public-page requests using a hash derived from the URL and a secret phrase. Invalid or incomplete screenshot requests can return an error image and an X-Screenshotmachine-Response header carrying an error code, so clients should not assume every image response is a successful capture.

See the ScreenshotMachine API guide and its PDF API guide.

ScreenshotOne: GET or POST, multiple inputs, and more output formats

ScreenshotOne supports GET and POST requests to https://api.screenshotone.com/take. It accepts a URL, HTML, or Markdown input. The access key can be supplied in a GET parameter, a POST JSON body, or the X-Access-Key header. The documentation advises HTTPS because plain HTTP does not protect API keys or other sensitive request data in transit. For large HTML or Markdown inputs, use POST JSON; the documented maximum body size is 100 MiB.

Its options reference lists PNG, JPEG/JPG, WebP, GIF, JP2, TIFF, AVIF, HEIF, PDF, HTML, and Markdown formats. Available controls include CSS selector capture, image quality, regional IP routing, and PDF settings. It also documents signed requests. The pricing page lists full-page capture, caching, HTML rendering, PDF rendering, webhooks, S3 uploads, signed links, and stealth mode. Country selection, scrolling screenshots, video generation, GPU rendering, and priority support are listed on higher plans; verify the current plan gates for any feature you require.

ScreenshotOne documents HTTP status codes and JSON error bodies for failures. A successful image or other binary response uses a content type appropriate to the selected format. For full details, see ScreenshotOne’s options reference, Getting Started, and pricing.

Runnable request examples

These examples save an image response. Replace the placeholder key and URL, and store credentials in environment variables in production. The endpoints return binary image data for successful image requests; handle errors according to each service’s documented response behavior.

ScreenshotMachine with cURL

curl -G 'https://api.screenshotmachine.com/' \
  --data-urlencode 'key=YOUR_API_KEY' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'dimension=1024x768' \
  --data-urlencode 'format=png' \
  -o screenshotmachine.png

The API key parameter is named key in ScreenshotMachine’s API. Consult its current API guide for the exact option names and supported values before adding advanced settings.

ScreenshotOne with cURL

curl -G 'https://api.screenshotone.com/take' \
  --data-urlencode 'access_key=YOUR_API_KEY' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'format=png' \
  -o screenshotone.png

ScreenshotMachine with Python

import os
import requests

response = requests.get(
    "https://api.screenshotmachine.com/",
    params={
        "key": os.environ["SCREENSHOTMACHINE_KEY"],
        "url": "https://example.com",
        "dimension": "1024x768",
        "format": "png",
    },
    timeout=90,
)
response.raise_for_status()

# ScreenshotMachine may return an error image for an invalid or incomplete
# request. Inspect its documented X-Screenshotmachine-Response header too.
error_code = response.headers.get("X-Screenshotmachine-Response")
if error_code:
    raise RuntimeError(f"ScreenshotMachine returned error code: {error_code}")

with open("screenshotmachine.png", "wb") as output:
    output.write(response.content)

ScreenshotOne with Python

import os
import requests

response = requests.get(
    "https://api.screenshotone.com/take",
    params={
        "access_key": os.environ["SCREENSHOTONE_KEY"],
        "url": "https://example.com",
        "format": "png",
    },
    timeout=90,
)
response.raise_for_status()

with open("screenshotone.png", "wb") as output:
    output.write(response.content)

ScreenshotMachine with Node.js

const q = new URLSearchParams({
  key: process.env.SCREENSHOTMACHINE_KEY,
  url: 'https://example.com',
  dimension: '1024x768',
  format: 'png',
});
const response = await fetch(`https://api.screenshotmachine.com/?${q}`);
if (!response.ok) {
  throw new Error(`ScreenshotMachine HTTP error: ${response.status}`);
}
const errorCode = response.headers.get('X-Screenshotmachine-Response');
if (errorCode) {
  throw new Error(`ScreenshotMachine capture error: ${errorCode}`);
}
const image = Buffer.from(await response.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('screenshotmachine.png', image));

ScreenshotOne with Node.js

const q = new URLSearchParams({
  access_key: process.env.SCREENSHOTONE_KEY,
  url: 'https://example.com',
  format: 'png',
});
const response = await fetch(`https://api.screenshotone.com/take?${q}`);
if (!response.ok) {
  const detail = await response.text();
  throw new Error(`ScreenshotOne HTTP ${response.status}: ${detail}`);
}
const image = Buffer.from(await response.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('screenshotone.png', image));

These samples use GET because the inputs are short. ScreenshotOne also supports POST with JSON options, which is preferable for large HTML or Markdown payloads and avoids placing those bodies in a URL. Keep API keys out of browser code, public repositories, and logs. A key in a URL can also be exposed in request logs, so use the provider’s supported header or POST-body credential method where appropriate.

How to choose for your workload

1. Estimate uncached monthly volume. Separate repeat captures likely to be served from cache from captures that must be fresh. Include how often URLs or option sets change, since unique settings can affect cache reuse.
2. Estimate peak starts, not just monthly average. ScreenshotOne lists request-start limits per minute on paid tiers. If a queue can burst above the applicable limit, throttle it and handle rate-limit responses. Do not treat the published starts-per-minute figure as a claim about simultaneous browser sessions.
3. List required outputs and controls. If you need HTML or Markdown input, or a broad list of image formats from one documented endpoint, ScreenshotOne’s options reference explicitly lists those. If ScreenshotMachine’s specific query parameters, device controls, or its separate PDF API match your workflow, include those in a small integration trial.
4. Model the bill in the vendor’s currency. Include subscription cost, likely overages, tax, and currency conversion. ScreenshotMachine’s extra-use block rule and ScreenshotOne’s opt-in overages work differently; confirm the current behavior and configure limits.
5. Test error and cache behavior with your own options. Use representative URLs, authenticated pages if allowed by your workflow, long pages, pages with delayed images, and any selector or wait settings. Measure the actual output quality and your own end-to-end latency. The dossier does not provide a controlled comparison.
6. Protect credentials and output handling. Keep keys server-side, set reasonable timeouts, validate response status and content type, and avoid overwriting a good stored screenshot until a new response is confirmed valid.

Choose ScreenshotMachine to evaluate first if its documented GET parameters, device and selector controls, cache-age setting, and separate PDF endpoint fit your needs and a euro-denominated plan suits your billing. Choose ScreenshotOne to evaluate first if you need its documented URL/HTML/Markdown inputs, GET/POST integration, output format range, or request-start tiers. This is workflow guidance, not a rendering-quality ranking.

Performance, reliability, and cost considerations

Performance

Neither the research nor the cited pages establish comparative latency or throughput. A full-page capture, delayed page, image-heavy layout, selector wait, or browser interaction can take longer than a simple viewport shot. ScreenshotMachine recommends a longer delay on long pages with images or animation. Benchmark the URLs and options you actually plan to use, then set client timeouts comfortably above the observed high-percentile duration. For queued work, cap concurrency and retry gradually rather than starting a large burst.

Reliability and output validation

Do not equate an HTTP response with a valid screenshot. ScreenshotMachine can use an error image plus a response header for invalid or incomplete requests, so inspect that header and validate the returned content. ScreenshotOne uses HTTP status semantics and JSON for errors; check status before writing an image file. For either API, check content type, file size, and whether the resulting image can be decoded before publishing or replacing an existing artifact.

Retries should be limited to transient network or server failures. Avoid blindly retrying invalid parameters, missing credentials, quota exhaustion, or target pages that consistently fail. If a request may have succeeded but the client timed out before receiving the response, think through duplicate captures and billing implications before retrying; caching behavior may affect the result.

Cost

Cache repeated results when freshness allows, but set cache policy according to the age your application can tolerate. Track requested captures, successful outputs, cache behavior, and monthly spend separately. ScreenshotMachine lists cached impressions as unlimited, while ScreenshotOne says cache responses do not use credits and warns that cache misses may cause a counted render. For ScreenshotOne, paid overages are off by default and can be bounded with a hard limit; for ScreenshotMachine, review how its thousand-capture grouping applies to your tier and usage.

Troubleshooting

Symptom	Likely cause	What to do
ScreenshotMachine response is an image but looks like an error	Its API can return an error image for invalid or incomplete requests	Inspect X-Screenshotmachine-Response, correct the reported request issue, and do not treat any image bytes as success automatically.
ScreenshotOne request returns JSON instead of an image	The request failed, an option is invalid, or usage limits were reached	Check the HTTP status and parse the JSON error code and message before saving binary output.
API key appears invalid or unauthorized	Wrong key field, malformed key, or key sent to the wrong endpoint	Confirm ScreenshotMachine uses its documented key parameter and ScreenshotOne uses access_key or a supported header/body. Rotate a key if it was exposed.
Long page is cut off or images are missing	Lazy-loaded content or animation had not finished when capture began	Use the appropriate full-page option and longer wait settings; verify the resulting height and content against the source page.
Selector capture is empty or fails	Selector does not match, element is hidden, or it appears after the capture wait	Check the selector in the page, wait for the element to render, and test a broader selector before narrowing it.
Unexpected usage or cost	Fresh captures, cache misses, changed option combinations, or enabled overages	Review usage and cache settings, set a hard spending/usage limit where offered, and compare billed events with the service’s current definitions.
Timeouts during batches	Too many request starts at once or complex pages taking longer	Queue work, respect per-minute start limits, apply backoff to transient failures, and test a longer timeout on representative pages.
API key exposed in client code or logs	Credentials placed in public JavaScript or query URLs recorded by infrastructure	Move requests to a server-side component, restrict log capture of query strings, and rotate exposed credentials.

Or skip the browser setup

If you would rather make one request than wire up a browser-capture integration, ScreenshotNeo is a website screenshot API and MCP server for developers. Its API accepts a URL and returns PNG, JPEG, WebP, or PDF. The one-call examples below use the documented endpoint and parameters; see the ScreenshotNeo API documentation.

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

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

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

• Cookie banners are accepted like a visitor, and 60+ known consent platforms, newsletter popups, and chat widgets are removed before capture; each step can be turned off.
• Bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed; response headers identify the page verdict and billing result.
• An MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients.
• 1,000 screenshots a month are free with no card; paid plans start at $5 for 3,000. Every feature is on every plan.

Sign up for ScreenshotNeo and get 1,000 free screenshots a month with no card.

FAQ

Can I compare the vendors’ free plans directly?

Both list 100 free screenshots per month, but their counting rules and cache behavior differ. Confirm what each service counts for the specific request options you will use.

Does either API support PDF output?

Yes. ScreenshotMachine documents a separate webpage-to-PDF API. ScreenshotOne lists PDF as an output format with PDF-specific options.

Which one has better screenshot quality?

The available research does not include a controlled rendering comparison. Capture your representative pages with the same viewport, timing, and output settings, then inspect the outputs yourself.

Can I send HTML instead of a public URL?

ScreenshotOne documents HTML and Markdown inputs as well as URLs. ScreenshotMachine’s cited screenshot API documentation is centered on URL capture.

Sources and scope

Pricing and features above are based on the vendors’ listed materials checked October 3, 2026: ScreenshotMachine pricing, ScreenshotMachine screenshot API, ScreenshotMachine PDF API, ScreenshotOne pricing, ScreenshotOne Getting Started, ScreenshotOne options, and ScreenshotOne credits. This comparison is based on documentation and listed-plan information; it is not a benchmark or hands-on test.