ScreenshotAPI vs ScreenshotOne for HTML to Image

Short answer: For HTML-to-image work, both ScreenshotAPI.com and ScreenshotOne offer hosted webpage rendering, but ScreenshotOne explicitly documents HTML input and supports POST requests for large HTML payloads. ScreenshotAPI.com publishes metered and prepaid pricing and says it supports image rendering and page adjustment; confirm its current HTML input method and options in its documentation before building around them. If your priority is documented HTML input and a recurring monthly quota, start by evaluating ScreenshotOne. If you prefer usage-based or prepaid billing, price ScreenshotAPI.com against your expected successful captures. Neither provider has been established here as more accurate or reliable on your specific pages, so test representative inputs before committing.

ScreenshotNeo is the first alternative to try: it offers a one-call screenshot API, clean shots that remove consent banners and popups, and charges only for clean shots. See ScreenshotNeo.

1. Identify the two services correctly

This comparison means ScreenshotAPI.com (screenshotapi.com) versus ScreenshotOne (screenshotone.com). Several distinct services have similar names, including ScreenshotAPI.net and ScreenshotAPI.to; check the domain before copying an API key, code sample, or pricing figure.

The comparison below uses vendor documentation and pricing pages, reviewed October 4, 2026. These are changeable commercial terms. Check the live pages before choosing a plan or shipping an integration.

2. At-a-glance comparison

Question	ScreenshotAPI.com	ScreenshotOne
HTML-to-image support	Its pricing page describes webpage rendering and page adjustment. Verify direct HTML input and request details in current product docs.	Documents URL, HTML, or Markdown input; image and other output formats.
Request shape	Use the official documentation for current endpoint and parameter names.	`GET https://api.screenshotone.com/take` or POST JSON to that endpoint.
Published billing	Metered pay-as-you-go and prepaid shot packs; displayed metered price is $0.001 per shot, with lower pack unit rates shown.	100 free screenshots/month; Basic $17/month for 2,000, Growth $79 for 10,000, Scale $259 for 50,000. Extra-use prices and limits vary by plan.
Failure and cache accounting	The pricing FAQ says failed captures caused by interruption or page-load failure are not charged.	HTTP, browser, and network errors are excluded; successfully rendered images with visual issues can count. Cached responses generally do not count, though a cache miss may trigger a billed render.
Documented request rate	The pricing FAQ says daily call speed/count can be adjusted in account settings; ask the provider about the limit that applies to your account.	40, 80, and 150 request starts per minute for Basic, Growth, and Scale, respectively, on the current pricing page.
Feature availability	Check the current docs and account terms for the exact options needed.	Plan pages enumerate included features; some capabilities, including IP location selection and scrolling screenshots, appear on Growth and Scale.

Sources: ScreenshotAPI.com pricing, ScreenshotOne pricing, ScreenshotOne getting started, and ScreenshotOne options reference.

3. Send HTML to ScreenshotOne

ScreenshotOne accepts HTML using the html option. Use POST with a JSON body for substantial HTML. Its documentation gives a maximum request body size of 100 MiB; for larger content, host the document and pass its URL. The service returns binary image data for an image request, so save the response body to a file rather than printing it as text.

cURL

curl -X POST "https://api.screenshotone.com/take" \
  -H "Content-Type: application/json" \
  -H "X-Access-Key: $SCREENSHOTONE_ACCESS_KEY" \
  -H "Accept: image/png" \
  --data '{"html":"<!doctype html><html><body><h1>Hello from HTML</h1></body></html>","format":"png","viewport_width":1280,"viewport_height":800}' \
  --output output.png

ScreenshotOne allows the access key in the X-Access-Key header, query parameters, or POST JSON body. A header keeps the key out of the URL. See the request and response documentation and option reference.

Python

import os
import requests

html = """<!doctype html>
<html>
  <head><meta charset="utf-8"><title>Card</title></head>
  <body><h1>Hello from HTML</h1></body>
</html>"""

response = requests.post(
    "https://api.screenshotone.com/take",
    headers={
        "X-Access-Key": os.environ["SCREENSHOTONE_ACCESS_KEY"],
        "Accept": "image/png",
    },
    json={
        "html": html,
        "format": "png",
        "viewport_width": 1280,
        "viewport_height": 800,
    },
    timeout=90,
)
response.raise_for_status()
with open("output.png", "wb") as image_file:
    image_file.write(response.content)

Install the HTTP client with python -m pip install requests and set SCREENSHOTONE_ACCESS_KEY in the process environment.

Node.js

const html = `<!doctype html>
<html>
  <head><meta charset="utf-8"><title>Card</title></head>
  <body><h1>Hello from HTML</h1></body>
</html>`;

const response = await fetch("https://api.screenshotone.com/take", {
  method: "POST",
  headers: {
    "X-Access-Key": process.env.SCREENSHOTONE_ACCESS_KEY,
    "Content-Type": "application/json",
    "Accept": "image/png"
  },
  body: JSON.stringify({
    html,
    format: "png",
    viewport_width: 1280,
    viewport_height: 800
  })
});

if (!response.ok) {
  throw new Error(`ScreenshotOne returned ${response.status}: ${await response.text()}`);
}
const image = Buffer.from(await response.arrayBuffer());
await import("node:fs/promises").then(fs => fs.writeFile("output.png", image));

Run this as an ES module on a Node.js version with built-in fetch. Keep the access key in a server environment variable, not browser-side JavaScript.

Using URL input instead

If your HTML is already hosted, send its URL instead of embedding the markup. A basic ScreenshotOne request looks like this:

curl -G "https://api.screenshotone.com/take" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "access_key=$SCREENSHOTONE_ACCESS_KEY" \
  --data-urlencode "format=png" \
  --output page.png

The endpoint supports GET and POST. For HTML or Markdown inputs that are large or contain characters awkward to encode in a URL, POST JSON avoids URL length and encoding problems. The documented 100 MiB maximum applies to the POST body.

4. What to verify about ScreenshotAPI.com

ScreenshotAPI.com’s current pricing page says the service renders webpages to PNG, JPG, or GIF, permits page adjustment and blocking unwanted page elements, and offers metered billing and prepaid shot packs. Its page does not provide enough technical detail to responsibly invent an HTML payload format, endpoint, parameter names, or runnable direct-HTML request here. Before choosing it for HTML input, check the provider’s current product and documentation links for:

Whether raw HTML is accepted directly or must first be hosted at a URL.
How the HTML is submitted (GET parameters, form data, or JSON POST) and maximum payload size.
Supported image formats, viewport sizing, full-page behavior, and device emulation.
How authentication should be sent and how keys are protected.
What counts as a successful, billable capture, and which limits apply to your account.

Do not use ScreenshotOne’s option names or endpoint for ScreenshotAPI.com. Similar product categories do not imply compatible request schemas.

5. Which one should you choose?

Your situation	Starting point	Why
You need documented raw HTML input and clear plan quotas	ScreenshotOne	Its docs describe HTML input and POST JSON, and its pricing page gives monthly quotas and per-plan request rates.
Usage fluctuates and you prefer metered or prepaid billing	ScreenshotAPI.com	Its pricing page publishes pay-as-you-go metering and prepaid packs without a recurring subscription model.
You need page-specific controls or a particular format	Evaluate both against a test set	Check exact options and plan availability; do not infer rendering parity from headline feature lists.
You want cleaned screenshots, explicit clean-shot billing, and an API plus MCP	ScreenshotNeo	Cookie banners, popups, and chat widgets are removed before capture; only clean shots are billed.

These are fit-based recommendations from published terms, not a performance ranking. The research available for this comparison does not establish an independent head-to-head rendering or reliability benchmark.

6. Compare the real cost for your workload

Estimate monthly successful, uncached renders, then include retries, unique option combinations, and any paid overage. The following examples use published list prices seen October 4, 2026; they do not predict your actual bill.

Very low or irregular volume: ScreenshotAPI.com’s page currently displays $0.001 per metered shot and prepaid packs starting at 2,000 for $2. However, the same page conflicts about the free allowance: the headline says the first 100 shots are free while its signup links and footer mention 1,000. Confirm the applicable offer before relying on it.
Steady monthly volume: ScreenshotOne lists 100 free/month, Basic at $17 for 2,000, Growth at $79 for 10,000, and Scale at $259 for 50,000. Extra use is listed at $0.009, $0.006, and $0.004 per capture for those plans, respectively. Extra-use charging is subject to account settings and a hard limit; prices exclude VAT.
Caching: ScreenshotOne says unique screenshots not served from cache count, but a cache miss may cause another render and count. Build your estimate around cache misses, not just application requests.
Failed or visually wrong renders: ScreenshotOne excludes HTTP, browser, and network errors, but a successfully rendered screenshot with a visual defect may count. ScreenshotAPI.com says page-load failures and service interruptions are not charged. Inspect outputs and track quality failures separately from HTTP success.

For either provider, calculate a range: normal month, peak month, and retry-heavy month. Verify the live account-specific rate and terms before procurement.

7. HTML-to-image details that affect the result

Set the viewport deliberately

Viewport width and height determine responsive breakpoints and the visible composition. Use the same dimensions as the destination (for example, a social card, thumbnail, or report preview). A full-page image is a different requirement from a viewport screenshot; confirm the relevant option and maximum output dimensions.

Wait for the page to be ready

HTML can reference external fonts, images, stylesheets, and scripts. A capture that begins before those resources finish can contain fallback fonts, missing images, or a loading state. ScreenshotOne documents readiness controls such as wait_until, delay, timeout, and wait_for_selector. Prefer waiting for a meaningful element over adding a large fixed delay when the page has a reliable ready marker.

Consider external resources and network access

If your HTML uses relative asset paths, the rendering browser needs a base URL or absolute resource URLs. Private network resources, expiring links, and authentication-dependent assets may not be reachable without appropriate request headers or cookies. Test those dependencies from the capture service’s context.

Choose image format and quality

PNG is a useful starting point for text, diagrams, and sharp edges; JPEG can reduce size for photographic content, while WebP may be suitable when supported by the receiving system. ScreenshotOne’s pricing page lists PNG, WebP, JPEG, and more. ScreenshotAPI.com lists PNG, JPG, and GIF. Check output support and quality parameters for the selected account and plan.

Be careful with large documents

Long pages, large images, and high device scale factors increase output dimensions and transfer size. For ScreenshotOne, keep JSON POST bodies below the documented 100 MiB maximum. If the markup is very large, host it and submit the URL. For ScreenshotAPI.com, check its current input and output limits directly.

8. Reliability, throughput, and production practices

Use HTTPS and protect keys. Store credentials in server-side environment variables or a secret manager. Avoid putting keys in client bundles, shared logs, or public image URLs.
Set explicit timeouts. Rendering time depends on page load and resource behavior. Give the HTTP request a finite timeout and handle timeout/network failures distinctly from an image response.
Validate the response. Check HTTP status and content type before writing a file. Error responses may be JSON, not image bytes; save only a successful image body.
Retry selectively. Retry transient network errors and server errors with a small bounded exponential backoff and jitter. Do not retry invalid options, authentication failures, or persistent page errors without changing the cause. Retries may create additional successful renders and costs.
Limit concurrency. Respect plan-level request-start limits. ScreenshotOne currently lists 40/80/150 per minute on Basic/Growth/Scale. Queue work and apply backpressure rather than launching an unbounded burst. Confirm ScreenshotAPI.com account-specific limits.
Cache by inputs that affect pixels. A cache key should include the source content/version, viewport, format, and rendering options. Reuse images for unchanged input; invalidate when the HTML or referenced assets change.
Keep a small visual regression set. Capture representative pages after changing templates, fonts, or rendering settings. Compare output dimensions and images, because a successful HTTP response alone does not prove the result looks right.

9. Troubleshooting

Symptom	Likely cause	What to do
HTML request returns an option or validation error	Wrong input field, malformed JSON, or an option unsupported by the endpoint or plan.	Read the JSON error body; compare option names with ScreenshotOne’s current reference. For ScreenshotAPI.com, use its own docs rather than copying ScreenshotOne parameters.
Response saved as an unreadable image	An error body was written to a PNG/JPEG file.	Check status and `Content-Type` before saving; log a bounded portion of a non-image error response.
Text or styles are missing	External CSS, fonts, or images failed to load; relative paths have no usable base URL.	Use absolute asset URLs or host the HTML with its dependencies, verify access and authentication, and wait for the relevant element/resources.
Capture shows a loading skeleton	Rendering occurred before application content was ready.	Wait for a stable selector or add a modest delay after the page is otherwise ready.
Output is clipped	Viewport capture used where full-page output was needed, or the page exceeds an output limit.	Enable the documented full-page behavior, inspect maximum height/size constraints, or split the document into sections.
Wrong responsive layout	Viewport dimensions or device emulation differ from the intended display.	Set explicit width and height; verify the relevant device options and responsive breakpoint.
429 or rate-limit response	Too many request starts for the plan or account.	Queue requests, reduce concurrency, add backoff, and choose a plan or limit appropriate to measured peak traffic.
Unexpected usage charge	Successful renders, cache misses, retries, or enabled overage exceeded estimates.	Review usage and cache behavior, deduplicate identical jobs, set a hard limit where available, and recheck the current billing rules.
ScreenshotAPI.com free allowance differs by page section	The live pricing page currently shows inconsistent free-shot wording.	Confirm the actual account offer before budgeting; do not treat either number as guaranteed from that page alone.

10. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. Make one GET request to receive an image or PDF; its documentation covers the available 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 per month are free with no card; paid plans start at $5 for 3,000.

11. FAQ

Can ScreenshotOne render HTML without hosting a webpage?

Yes. Its documentation describes HTML as an input and supports POST JSON. Keep the body within the documented 100 MiB limit.

Does the comparison prove which service produces better images?

No. Published feature lists and pricing do not establish output quality on your templates. Run the same representative inputs through each candidate and inspect the files.

Can I use ScreenshotAPI.com and ScreenshotOne interchangeably?

Not safely by assuming identical endpoints or parameter names. Treat them as separate APIs and adapt your integration to each provider’s documentation.

Are listed prices guaranteed?

No. Pricing and plan features change. The figures here reflect the official pages reviewed October 4, 2026; verify the current terms before purchasing.