ScreenshotAPI.net Free Plan Limits and What Counts as a Request

Short answer: ScreenshotAPI.net’s pricing page describes a seven-day free trial with 100 screenshots. Its help center separately describes 100 free screenshots “in a month” and says they reset on the same day of the prior month as signup. Those public descriptions do not clearly resolve whether the allowance renews monthly or how that reset relates to the seven-day trial. Check your account’s terms and dashboard for the allowance and reset date that apply to you. Pricing · Help Center.

For accounting, distinguish an HTTP request from a successful render. The vendor says failed attempts do not count. It defines screenshot identity by the exact URL and render parameters; a matching cached result can be served without another credit, while fresh=true bypasses the cache and triggers a new render. [Help Center · Cached and fresh screenshot docs]

1. What is the free offer?

The two official pages use different language:

Official source	Published description	What it establishes
Pricing page	Seven-day free trial; 100 screenshots	The trial duration and its stated screenshot allowance
Help Center	100 free screenshots in a month; reset on the same day of the prior month as registration	A monthly allowance and signup-date reset wording

The sources do not explain how these statements fit together. In particular, do not assume from the help wording alone that every account gets 100 screenshots every month, or from the pricing page alone that no later allowance applies. Before designing a production budget, look in your account for the active quota, trial end date, and next reset. The offer and paid-plan terms can change, so verify the live pricing page when you sign up.

2. What counts as a screenshot request?

An HTTP call is not automatically one consumed credit. The vendor’s help center says successful screenshots count and failed attempts do not. A fresh successful render is therefore the event most likely to use an allowance credit. An error response, timeout, or other failed attempt should not consume quota under that stated rule, though you should inspect account usage if a result is unclear.

ScreenshotAPI.net documents a GET endpoint at https://shot.screenshotapi.net/v3/screenshot. It takes a token, a target URL, and optional rendering parameters. A request is the transport operation; the rendered screenshot is the quota-relevant output. The exact rules for edge cases should be checked against the service’s current dashboard and documentation. [Render a screenshot docs · Help Center]

3. How unique screenshots and cache hits affect quota

The Help Center defines a unique screenshot by the exact URL and parameters used for the render. In practical terms, changing a rendering option may create a different screenshot identity: for example, a different target query string or capture configuration should not be presumed to share the same cached result.

When caching is enabled, the documented behavior is:

The first request for a URL and parameter set renders the page and stores the result.
A subsequent request with identical URL and parameters can return that stored result when fresh=false.
The vendor says cached screenshots do not count toward quota or consume an additional credit.
Passing fresh=true bypasses the stored result and forces a live render.

Cache reuse depends on there being a matching stored result and on the cache options used. A changed URL, changed parameters, disabled caching, or a forced fresh render may result in another render. Do not build quota estimates on the assumption that any two visually similar pages are the same screenshot.

When to use fresh rendering

Use fresh=true when a current page state matters, such as a frequently updated dashboard or price page. It costs more processing time than returning a cached result and should be budgeted as a fresh successful capture. For repeatable monitoring, choose a cache policy that matches how often the target actually changes, and use fresh captures only when freshness is required. [Cached and fresh screenshot docs]

4. Minimal runnable examples

Replace YOUR_API_TOKEN with the API key from your account. These examples request a PNG image directly, avoiding JSON metadata output. URL encoding matters: encode the target URL as a query parameter, especially when it contains its own query string. The endpoint, token parameter, URL parameter, and image output options follow the vendor’s render documentation. [Render a screenshot docs]

cURL

curl -G 'https://shot.screenshotapi.net/v3/screenshot' \
  --data-urlencode 'token=YOUR_API_TOKEN' \
  --data-urlencode 'url=https://example.com/' \
  --data-urlencode 'output=image' \
  --data-urlencode 'file_type=png' \
  --output screenshot.png

Python

import os
import requests

endpoint = "https://shot.screenshotapi.net/v3/screenshot"
params = {
    "token": os.environ["SCREENSHOTAPI_TOKEN"],
    "url": "https://example.com/",
    "output": "image",
    "file_type": "png",
}
response = requests.get(endpoint, params=params, timeout=90)
response.raise_for_status()
with open("screenshot.png", "wb") as image_file:
    image_file.write(response.content)

Node.js

const endpoint = new URL("https://shot.screenshotapi.net/v3/screenshot");
endpoint.searchParams.set("token", process.env.SCREENSHOTAPI_TOKEN);
endpoint.searchParams.set("url", "https://example.com/");
endpoint.searchParams.set("output", "image");
endpoint.searchParams.set("file_type", "png");

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

Cache-aware request parameters

The cache docs show enable_caching=true and fresh=true as request options. Adapt the examples’ parameter maps or query strings when you need this behavior:

enable_caching=true
fresh=false

Use the exact parameter names and combinations supported by the current API documentation. To force a new capture rather than reuse an available matching cached result, set fresh=true. A fresh capture is intended to give current page content; it is not a way to avoid consuming a successful-render credit.

5. Quota is different from throughput

ScreenshotAPI.net separately documents a plan-dependent throughput limit of 20–80 requests per minute. That is a rate limit, not a screenshot allowance. You can hit the rate limit while quota remains, or use the monthly quota over time without ever exceeding the per-minute cap. The error reference distinguishes monthly quota exhaustion (screenshots_limit_reached, HTTP 403) from RPM exhaustion (HTTP 429). [Help Center · Errors docs]

Constraint	What it measures	Documented signal
Screenshot allowance	Quota over the account’s applicable period	`screenshots_limit_reached`; HTTP 403
Requests per minute	Short-term request throughput	HTTP 429

For batch work, pace requests below the plan’s documented rate limit and handle 429 responses with backoff. Rate limiting does not make failed calls count as screenshots, and staying under RPM does not guarantee remaining screenshot quota.

6. Troubleshooting quota surprises

Symptom	Likely cause	What to do
You expected the free allowance to reset, but it did not	The public pricing and help wording differ, and the exact account terms may depend on the trial or subscription state.	Check the account dashboard for current quota, trial status, and reset date; use the account terms as authoritative for your plan.
A repeated call used another capture	The request may not match the cached URL and parameters, caching may be off, there may be no stored result, or the call used `fresh=true`.	Compare the full encoded URL and every option; confirm caching is enabled and that the request is not forcing freshness.
You got HTTP 403 and cannot capture	The errors docs identify monthly screenshot quota exhaustion as `screenshots_limit_reached`.	Check quota and reset details in the account; adjust volume or plan if more successful renders are needed.
You got HTTP 429	Requests per minute exceeded the plan’s rate limit.	Reduce concurrency, queue work, and retry with backoff; check the plan’s RPM cap.
Changing one option appears to use quota separately	Screenshot identity uses the exact URL and parameters.	Keep parameters stable when you intend to reuse a cached result; expect a changed capture configuration to require a separate render.
An error appears to have reduced quota	The vendor says failed attempts do not count, but the request may have returned a successful image or been retried by application code.	Check the response status and account usage. Log each attempt and distinguish successful image responses from errors.

7. Estimate usage without confusing calls and credits

For a rough budget, count distinct successful renders that must be generated during the applicable quota period. Then account for cache behavior:

Repeated identical requests can reuse a matching cached result under the documented cache settings.
Changed URLs or render parameters can produce distinct screenshot identities.
fresh=true asks for a new live render and should be included in capture estimates.
Failed attempts are stated not to count, but retries can still produce a successful render later.
Request pacing is a separate calculation against the 20–80 RPM limit documented for plans.

Track both successful renders and HTTP attempts in your own logs. Include the target URL, normalized parameter set, status code, and whether the request forced freshness. Avoid logging API tokens or sensitive query values. This makes it easier to reconcile application behavior with the account’s usage display.

8. Or skip the browser setup

If you need screenshots without managing a browser-capture integration, ScreenshotNeo is a website screenshot API and MCP server. One GET request returns a PNG, JPEG, WebP, or PDF, with options for full-page captures, element captures, custom waits, and more. See the ScreenshotNeo API docs.

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 and consent banners, newsletter popups, and chat widgets are removed before capture; each cleanup step can be turned off.
Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are never billed; responses report the page verdict and billing state.
An MCP server lets AI agents, including Claude, Cursor, and other MCP clients, take screenshots.
The free plan includes 1,000 screenshots each month with no card. Paid plans start at $5 for 3,000 screenshots.

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

9. Frequently asked questions

How many free screenshots does ScreenshotAPI.net give you?

The pricing page says 100 screenshots in a seven-day free trial. The Help Center says 100 free screenshots in a month and describes a signup-date reset. Since the public pages do not reconcile those terms, confirm your account’s allowance and renewal timing.

Do cached ScreenshotAPI.net requests count toward the free limit?

The vendor says cached screenshots do not count toward quota, and that serving a stored result does not consume another credit. This depends on a matching cached URL and parameter set being available and the cache behavior applying.

Does a failed screenshot use a credit?

The Help Center says failed screenshot attempts do not count. A successful render after a retry may count even if an earlier attempt failed.

Is the free plan 100 screenshots per month or only a seven-day trial?

The published pages say both things in different ways. The documentation reviewed does not settle the conflict; use the terms and quota display in your account.

Can I send more calls if I have credits left?

Possibly, but quota and rate limiting are separate. The documented plan-dependent throughput limit is 20–80 requests per minute, and exceeding it is documented as HTTP 429.