ScreenshotOne vs ScreenshotAPI for Website Screenshots

Short answer: ScreenshotOne and ScreenshotAPI.com are hosted APIs that turn web pages into screenshots. ScreenshotOne publishes monthly plans with request-per-minute limits; ScreenshotAPI.com advertises pay-as-you-go pricing and prepaid shot packs. Choose based on your expected volume, required capture controls, integration needs, and how each handles failed and cached requests. There is no independent evidence here that one produces universally better screenshots.

Which ScreenshotAPI do you mean? This article compares ScreenshotOne with ScreenshotAPI.com. ScreenshotAPI.net is a separate service with a similar name; its pricing and capabilities should not be attributed to ScreenshotAPI.com.

If you want to try a screenshot API first, start with ScreenshotNeo: it removes cookie banners, popups, and chat widgets before capture, bills only clean shots, and its paid plans start at $5.

1. At a glance

Question	ScreenshotOne	ScreenshotAPI.com
Billing model	Monthly plans with included screenshots and published overage rates.	Pay per shot or buy prepaid shot packs.
Published entry price	100 screenshots per month free; Basic lists $17/month for 2,000 screenshots.	First 100 shots free, then $0.001 per shot; packs are available.
Published throughput figure	Plan-level request-per-minute limits are listed.	The pricing page says daily speed and call-count limits can be adjusted in account settings; a comparable published per-minute plan table was not established.
Capture options	URL, HTML, and Markdown inputs; viewport, element, and full-page captures; image formats, PDFs, animated captures, and optional page content or metadata.	URL-to-image capture with PNG, JPEG, and GIF outputs, adjustable resolution and browser settings, and controls to block page elements.
Independent quality comparison	No side-by-side benchmark establishes a universal quality or reliability winner. Test both on representative pages.

These are vendor-published feature and pricing statements, not independent performance findings. Check the providers’ current documentation and account terms before committing to a budget.

2. Identify the exact ScreenshotAPI service

“ScreenshotAPI” can refer to more than one provider. The figures and endpoint examples below refer to ScreenshotAPI.com, whose API uses api.screenshotapi.com. Do not use these details for ScreenshotAPI.net or another similarly named product.

3. Pricing and billing: compare your actual workload

Published pricing snapshots are volatile. The following figures reflect vendor pricing pages accessed for this comparison; verify them before publication or purchase.

Provider and tier	Published allowance or price	Rate information
ScreenshotOne free	100 screenshots/month	—
ScreenshotOne Basic	$17/month for 2,000; $0.009 per overage screenshot	40 requests/minute
ScreenshotOne Growth	$79/month for 10,000; $0.006 per overage screenshot	80 requests/minute
ScreenshotOne Scale	$259/month for 50,000; $0.004 per overage screenshot	150 requests/minute
ScreenshotAPI.com metered	First 100 free, then $0.001/shot	Vendor says daily speed and request count can be adjusted in account settings.
ScreenshotAPI.com prepaid	2,000 for $2; 5,000 for $5; 10,000 for $9; 25,000 for $22; 50,000 for $40; 100,000 for $80	Effective per-shot price varies by pack.

ScreenshotOne says failed requests with HTTP, browser, or network errors do not count. Its pricing page also says cached captures generally do not count, though a cache miss can cause a counted rerender. ScreenshotAPI.com says captures that fail because of a server interruption or a page failing to load are not credited as successful shots. Confirm the precise billing rules in each provider’s current terms. See the providers’ ScreenshotOne pricing and ScreenshotAPI.com pricing.

Estimate cost before choosing

Estimate monthly requested captures, including retries and distinct option combinations.
Separate routine pages from burst workloads, such as batch jobs or scheduled audits.
For ScreenshotOne, compare the monthly plan allowance and published overage rate with the 100-shot free tier.
For ScreenshotAPI.com, compare metered use with the prepaid pack sizes and their effective unit prices.
Model failures and cache hits using the provider’s stated billing rules, and leave room for workload growth.
Check whether your request rate fits the published limits or account settings you can actually use.

Do not infer that either service is always cheaper from the unit price alone. Monthly included volume, overages, cache behavior, failure handling, and your traffic pattern change the result. ScreenshotOne’s pricing page says prices exclude VAT.

4. Capture options and input types

ScreenshotOne

ScreenshotOne documents URL, HTML, and Markdown inputs. Its options include viewport, timing, scrolling, page modification, and output format. It documents viewport, element, and full-page captures, multiple image formats, PDF, animated capture, and optional rendered page content or metadata. Large HTML or Markdown input belongs in a JSON POST body rather than a query string; the documented maximum body size is 100 MiB. See the ScreenshotOne options reference.

ScreenshotAPI.com

ScreenshotAPI.com describes URL-to-image screenshots in PNG, JPEG, and GIF, with adjustable resolution and browser settings. Its pricing page also describes adjusting page content and blocking unwanted elements such as ads or cookie banners. Check its current documentation for the exact parameter names and plan-specific constraints before building around a particular option.

Match required output to the service

Need HTML or Markdown as input, a PDF, animated capture, or returned page content? ScreenshotOne explicitly lists these capabilities in its docs.
Need a straightforward URL-to-image request with resolution controls? ScreenshotAPI.com describes that workflow.
Need predictable full-page output, dynamic-page timing, or a particular viewport? Confirm the exact setting and test the target page with each provider.
Need a feature not described in the reviewed sources? Verify it in the live docs before selecting a service.

5. Runnable requests

Keep API keys in environment variables or a secret manager. Avoid committing keys to source control or placing them in browser-side code. These examples save the binary image response to disk; if the service returns an error, inspect the HTTP status and response body rather than treating it as an image.

ScreenshotOne with cURL

curl --fail --show-error --silent \
  -G "https://api.screenshotone.com/take" \
  --data-urlencode "access_key=$SCREENSHOTONE_ACCESS_KEY" \
  --data-urlencode "url=https://example.com" \
  --output screenshot.jpg

The endpoint and access_key parameter follow ScreenshotOne’s getting-started docs. The API returns the requested image format; use documented parameters when you need a different format or capture behavior.

ScreenshotOne with Python

import os
import requests

response = requests.get(
    "https://api.screenshotone.com/take",
    params={
        "access_key": os.environ["SCREENSHOTONE_ACCESS_KEY"],
        "url": "https://example.com",
    },
    timeout=90,
)
response.raise_for_status()
with open("screenshot.jpg", "wb") as image_file:
    image_file.write(response.content)

ScreenshotOne with Node.js

const key = process.env.SCREENSHOTONE_ACCESS_KEY;
if (!key) throw new Error("Set SCREENSHOTONE_ACCESS_KEY first");

const query = new URLSearchParams({
  access_key: key,
  url: "https://example.com",
});
const response = await fetch(`https://api.screenshotone.com/take?${query}`, {
  signal: AbortSignal.timeout(90_000),
});
if (!response.ok) {
  throw new Error(`ScreenshotOne returned ${response.status}: ${await response.text()}`);
}
const fs = await import("node:fs/promises");
await fs.writeFile("screenshot.jpg", Buffer.from(await response.arrayBuffer()));

ScreenshotAPI.com with cURL

curl --fail --show-error --silent \
  -G "https://api.screenshotapi.com/take" \
  --data-urlencode "apiKey=$SCREENSHOTAPI_KEY" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "type=png" \
  --output screenshot.png

The endpoint, apiKey, url, and type parameters are shown in ScreenshotAPI.com’s official examples on its website.

ScreenshotAPI.com with Python

import os
import requests

response = requests.get(
    "https://api.screenshotapi.com/take",
    params={
        "apiKey": os.environ["SCREENSHOTAPI_KEY"],
        "url": "https://example.com",
        "type": "png",
    },
    timeout=90,
)
response.raise_for_status()
with open("screenshot.png", "wb") as image_file:
    image_file.write(response.content)

ScreenshotAPI.com with Node.js

const key = process.env.SCREENSHOTAPI_KEY;
if (!key) throw new Error("Set SCREENSHOTAPI_KEY first");

const query = new URLSearchParams({
  apiKey: key,
  url: "https://example.com",
  type: "png",
});
const response = await fetch(`https://api.screenshotapi.com/take?${query}`, {
  signal: AbortSignal.timeout(90_000),
});
if (!response.ok) {
  throw new Error(`ScreenshotAPI.com returned ${response.status}: ${await response.text()}`);
}
const fs = await import("node:fs/promises");
await fs.writeFile("screenshot.png", Buffer.from(await response.arrayBuffer()));

6. How to choose: a practical decision process

Write down the output contract. Specify format, dimensions, full-page or viewport capture, PDF or animation needs, and whether you need HTML or Markdown input.
List representative targets. Include a static page, a JavaScript-rendered page, a long or lazy-loaded page, and an authenticated page if your workload includes one.
Check controls in the current docs. Verify viewport, timing, scroll, page changes, and element blocking rather than assuming similarly named controls behave alike.
Calculate total cost at your expected volume. Include overages or prepaid credits, failures, cache behavior, and burst requirements.
Review integration needs. Check authentication, API key handling, request-rate constraints, SDK availability, and whether your job can tolerate synchronous capture latency.
Run the same representative requests against both. Compare the output for your own pages and requirements. This article does not claim to have run such a benchmark.
Recheck commercial details before production. Pricing, limits, and billing treatment can change.

7. Performance, reliability, and cost in production

Performance

Screenshot latency depends on the target site, its scripts and assets, capture settings, and output size. The reviewed sources do not establish comparable latency benchmarks. Measure end-to-end time on representative pages, including slow pages, and record percentiles rather than relying on a single successful request.

For throughput, ScreenshotOne lists plan-level limits of 40, 80, and 150 requests per minute for Basic, Growth, and Scale in the pricing snapshot above. ScreenshotAPI.com’s page says its users can adjust speed and daily call limits in account settings, but the reviewed evidence does not establish a directly comparable per-minute limit. Confirm the limit for your account before sending bursts.

Reliability and retries

Set a client timeout appropriate to your pages and avoid unlimited waits.
Retry transient network errors and server errors with bounded exponential backoff and jitter. Do not retry authentication, invalid-parameter, or other permanent errors unchanged.
Use a maximum attempt count and a queue for large batches so retries do not create a request storm.
Validate the response status and content type before saving the body as an image.
Record the target URL, options, response status, elapsed time, and retry count, while redacting credentials and sensitive query values.
Test dynamic content and lazy-loaded images with the same timing and scroll conditions you expect in production.

Published documentation and marketing do not establish comparative real-world uptime or capture fidelity. Your production monitoring should track successful outputs and failures for the pages that matter to you.

Cost controls

Use caching where repeat captures do not need fresh content, and verify how each provider bills cache hits and misses.
Keep retries bounded; otherwise a failing target can multiply requests.
Set account-side usage or spending controls where available and alert before reaching a quota.
Test output dimensions and formats: unnecessarily large images can increase storage and delivery costs in your own system.
Reconcile provider usage with your own request logs to catch differences in cache and failure classification.

8. Troubleshooting common capture problems

Symptom	Likely cause	What to do
HTTP error or JSON/text saved as an image	Authentication, parameter validation, or capture failure returned an error body.	Check the status code and response body before writing the file; verify key, URL encoding, and parameter names.
Blank or incomplete screenshot	The page is slow, client-rendered, or dependent on delayed content.	Check the provider’s timing and wait controls; test with the site’s real load behavior and avoid assuming navigation completion means all content is ready.
Images missing near the bottom	Lazy-loaded content may require scrolling or full-page behavior.	Confirm the service’s full-page and scroll options and compare results on a long representative page.
Different layout than a user sees	Viewport, browser settings, locale, or responsive breakpoints differ.	Set the required resolution and browser options explicitly, then compare against the intended device size.
Cookie banner or overlay hides content	The page displays a consent layer or other popup.	Use the provider’s documented blocking or page modification controls where available; verify that the page remains representative after modification.
Timeouts or intermittent failures	The target is slow, network-dependent, or temporarily unavailable.	Choose a suitable client timeout, record failures, retry transient cases with backoff, and test the target independently.
Unexpected bill or quota usage	Unique option combinations, cache misses, retries, or provider-specific failure rules affected counting.	Compare API logs to provider usage and confirm the current billing definition for successful, cached, and failed captures.
Requests fail only in a browser	Cross-origin restrictions or exposing a secret key in client code.	Call the API from a server you control and keep the key out of public JavaScript.

9. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. One GET request returns a screenshot or PDF; its API documentation covers the request options.

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

Python:

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)

Node.js:

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

Cookie banners, popups, and chat widgets are removed before the shot; each cleanup step can be turned off.
Bot checks, blank pages, and failed loads are never billed; response headers report the page verdict and billing status.
An MCP server lets AI agents use take_screenshot, get_page_info, and capture_pdf.
1,000 screenshots a month are free with no card; paid plans start at $5 for 3,000. Yearly billing gives two months free, and every feature is on every plan.

Create a free ScreenshotNeo account and get 1,000 screenshots a month with no card.

10. FAQ

Is ScreenshotAPI the same as ScreenshotAPI.net?

No. This comparison uses ScreenshotAPI.com. Verify the domain before applying its endpoint, prices, or feature descriptions.

Which service is better for a small or irregular workload?

Compare ScreenshotOne’s 100 free monthly captures with ScreenshotAPI.com’s first 100 free shots and metered or prepaid options. The right fit depends on how much you capture and how you prefer to pay.

Is there a proven screenshot-quality winner?

Not from the sources reviewed for this article. Run both services against your actual pages and compare the output that matters to your application.

Can I send large HTML directly to ScreenshotOne?

Yes, its docs describe JSON POST bodies up to 100 MiB. Use POST for large HTML or Markdown instead of putting it in a URL query string.

Should API keys be sent from frontend code?

Keep secret keys on a server-side component. Public browser code can expose credentials to anyone who inspects the page.