Do Screenshot APIs Have a Free Tier for Testing?

Yes. Several screenshot API providers advertise free ways to test, but “free” can mean a recurring monthly quota, a finite starting allowance, a short trial, or a few watermarked samples. Compare the quota and reset period, card requirement, rate limit, watermark, failed-render rules, and what happens when you run out before wiring an API into a test loop.

Provider offers below were stated on their own pricing, documentation, or terms pages as of October 3, 2026. These plan details can change; check the provider’s current pricing and account flow before relying on them.

Free screenshot API offers at a glance

Provider	Provider-stated free access	What to verify
ScreenshotNeo	1,000 screenshots per month, no card required. Its API returns PNG, JPEG, WebP, or PDF. ScreenshotNeo	Choose the output and capture settings you need, and inspect each response’s page-verdict and billed headers when evaluating usage. See the API documentation.
Screenshot API (screenshot-api.org)	500 screenshots per month; says no credit card is required. Its pricing page also describes overage billing. Pricing	Whether overage can be avoided, rate limits, and the current quota terms.
Screenshot API (screenshotapis.app)	100 billable renders per month; says no credit card is required. It defines billable usage as a successful uncached render and excludes failed renders and cache hits. Provider site	How its definition maps to your request pattern and current account terms.
ScreenshotAPI.com	Advertises the first 1,000 screenshots free to start; its FAQ says a free trial is available for 30 days. Pricing	Whether the starting allowance and trial are separate offers or subject to different conditions.
appScreenshotAPI	Free accounts start with three watermarked screenshots and no card; paid packs remove the watermark. Provider site	Whether a watermark is acceptable for your test.

The numbers are examples from different providers, not a market average. They may count usage differently and can change. In particular, screenshot-api.net has conflicting published limits: its documentation lists 500 monthly screenshots and 60 requests per minute for the free plan, while terms effective September 4, 2026 describe 100 renders per month. Check its live pricing or account flow rather than treating either figure as definitive. Documentation · Terms

What “free” means when you test

A quota is useful only if its counting rules fit your test. A recurring monthly allowance can support low-volume evaluation over time. A one-time balance or time-limited trial gives you an initial test window, after which access may end or require a paid plan. Watermarked output can confirm that a request works, but may not be suitable for visual QA or previews.

Before choosing a provider, check these terms in its official pricing, docs, and account settings:

• Allowance and reset: How many captures are included, when the counter resets, and whether unused quota rolls over.
• Payment card: Is a card needed to start, or only when upgrading?
• Rate limit: How many requests are allowed per second or minute, independent of the monthly quota?
• What counts: Does a request count when it is submitted, when rendering starts, or only after a successful uncached result?
• Failed requests and cache: Are timeouts, failed page loads, and cache hits charged or deducted?
• Watermarks and settings: Are outputs branded or limited in size, format, viewport, or other capture options?
• Exhaustion and overage: Does the API stop with a quota error, or can usage continue and incur charges?

For example, screenshot-api.org lists a 60 requests-per-minute free-plan rate limit alongside its 500 monthly screenshot limit. Those are separate ceilings: staying under the monthly quota does not mean a burst of requests will be accepted. Provider documentation

How to test a free tier without surprise usage

1. Read the current plan terms. Record the quota, reset cadence, card requirement, rate limit, failure accounting, and overage or hard-stop behavior.
2. Start with a small, known URL set. Use pages you are allowed to capture, and avoid launching a large loop before you know how retries and failures are counted.
3. Make one request at a time first. Save the response and inspect its status, content type, and body. A successful HTTP response alone does not prove the result is the expected screenshot.
4. Test a representative page. Include the page conditions your app will encounter, such as a slow load or a page that requires a particular viewport. Verify output dimensions and visual content.
5. Observe quota and rate behavior. Compare the provider’s usage dashboard or response metadata before and after a few controlled requests. Do not assume that retries, cache hits, or failed jobs are free unless the provider says so.
6. Set a stopping point. Add a request limit to any script and stop on quota, authentication, or rate-limit errors. This prevents a test loop from turning into unexpected usage.

Example: make a controlled test request with cURL

There is no universal screenshot API request format: use the endpoint and parameter names in the provider’s documentation. For ScreenshotNeo, this request saves a WebP screenshot of a sample page. Replace the key with your API key; find the available options in 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

Run a single request before automating it. Confirm the file is an image and inspect the API response headers for page verdict and billing information. Keep API keys out of source control and public client-side code.

Python example

This example uses requests and a finite timeout. Install the dependency with python -m pip install requests.

import requests

response = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={
        "access_key": "YOUR_API_KEY",
        "url": "https://stripe.com",
    },
    timeout=90,
)
response.raise_for_status()

content_type = response.headers.get("content-type", "")
if not content_type.startswith("image/"):
    raise RuntimeError(
        f"Expected an image, received {content_type}: {response.text[:500]}"
    )

with open("shot.webp", "wb") as output:
    output.write(response.content)

print("Saved shot.webp")

Node.js example

On a recent Node.js version with built-in fetch, build the query with URLSearchParams so the target URL is encoded safely.

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://stripe.com',
});

const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`, {
  signal: AbortSignal.timeout(90_000),
});

if (!res.ok) {
  throw new Error(`Screenshot request failed: HTTP ${res.status} ${await res.text()}`);
}

const contentType = res.headers.get('content-type') ?? '';
if (!contentType.startsWith('image/')) {
  throw new Error(`Expected an image, received ${contentType}`);
}

const image = Buffer.from(await res.arrayBuffer());
await import('node:fs/promises').then(({ writeFile }) =>
  writeFile('shot.webp', image)
);
console.log('Saved shot.webp');

For another provider, replace the URL and parameters with its documented endpoint and authentication scheme. Do not assume that every provider returns image bytes directly; some APIs return a job ID or a URL to fetch later.

Read results and errors correctly

For a useful trial, distinguish request delivery from capture success. Check HTTP status, content type, body, and provider-specific usage indicators. A 200 response can still be the wrong kind of result if the API returns JSON metadata or an error document. A failed render may or may not consume quota, depending on the provider’s published policy.

• Authentication error: Confirm the key is valid, active, and sent using the documented parameter or header.
• Rate limit: Reduce concurrency, add backoff, and retry only when the provider’s guidance allows it.
• Quota exhausted: Stop requests and check whether the plan resets, hard-stops, or permits paid overage.
• Render failure or timeout: Check the target page, load conditions, and the provider’s retry and billing rules before retrying repeatedly.
• Unexpected output: Verify format, viewport, and content type; a page may have loaded differently than expected.

ScreenshotNeo as a free option for testing

ScreenshotNeo includes 1,000 screenshots per month on its free plan with no card required. Its API accepts one GET request with a URL and can return PNG, JPEG, WebP, or PDF. The product is a website screenshot API and MCP server from ScreenshotNeo; its capture settings and request options are documented at the API docs.

It is particularly useful when your test needs more than a raw browser render: before capture, it accepts cookie or consent banners like a visitor and removes 60+ known consent platforms, newsletter popups, and chat widgets. Each cleanup step can be turned off. Responses identify page verdict and billing status with X-Page-Verdict and X-Billed headers; bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing.

The same service provides an MCP server with take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. If your test is an agent workflow, that can avoid building a separate screenshot integration for the agent.

Or skip the browser setup

Call the ScreenshotNeo API directly; the API docs list the available capture options.

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

Cookie banners, popups, and chat widgets are removed before the shot. Bot checks, blank pages, and failed loads are never billed. An MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 screenshots. Sign up free for ScreenshotNeo.

Cost, performance, and reliability considerations

Cost

Estimate expected monthly captures, but also account for retries, cache behavior, and overage. A plan with a larger headline quota can still cost more if failed requests count or if overage is enabled. ScreenshotNeo’s listed plans are Free: 1,000 per month; Starter: $5 for 3,000; Growth: $15 for 15,000; Pro: $39 for 60,000; Scale: $99 for 250,000; and Business: $249 for 1,000,000. Yearly billing gives two months free. Every feature is available on every plan. Check current terms before purchasing.

Performance

Browser rendering takes longer than a simple metadata request because the service must load and capture a page. Use a finite client timeout, keep concurrency within the provider’s rate limit, and avoid launching duplicate captures where caching can serve the same result. For large batches, use a provider’s documented asynchronous or bulk workflow rather than sending an uncontrolled burst. ScreenshotNeo supports chosen-TTL caching, async jobs with signed webhooks, and bulk capture of up to 100 URLs per call.

Reliability

Web pages can be slow, unavailable, blocked, or visually different across time and viewport. Make test inputs deterministic where possible, record the target URL and capture settings, validate output type, and retry selectively with a cap. Do not equate an HTTP success with a meaningful screenshot. Inspect the provider’s failure accounting and response signals so your usage report and test results agree.

Troubleshooting a free-tier test

Symptom	Likely cause	What to do
401 or 403 response	Missing, invalid, expired, or incorrectly placed API key.	Check the provider’s required authentication method, key status, and account permissions. Keep the key private.
429 or rate-limit error	Requests are arriving faster than the plan allows.	Lower concurrency and add bounded exponential backoff; check per-minute limits as well as monthly quota.
Quota error before the month ends	Failed jobs may count, the quota may be a one-time allowance, or your account may have a different plan limit.	Inspect usage and plan terms. Stop automated retries until you know whether attempts are billable.
Request times out	The page or its resources are slow, or the client timeout is too short.	Use a reasonable finite timeout, check provider guidance, and retry sparingly. Confirm whether the failed attempt affects quota.
Saved file is JSON or HTML	The API returned an error or job response rather than image bytes.	Check status and content type before saving. If the provider uses asynchronous jobs, poll or fetch the result as documented.
Screenshot is blank or incomplete	The site failed to load, renders late, needs a particular viewport, or relies on content that appears after initial load.	Check the target in a browser, set the needed wait behavior or viewport if supported, and inspect the returned verdict or error details.
Unexpected charge	Overage may be enabled, or the provider counts requests differently than expected.	Review billing and usage records, disable overage or set a hard limit if available, and contact the provider for account-specific billing questions.
Watermark appears	The provider’s free output is branded by plan design.	Check whether a paid plan removes it; do not treat a watermarked sample as production-ready.

Frequently asked questions

Can I test a screenshot API without a credit card?

Some providers explicitly say no card is required for their free access, including ScreenshotNeo, screenshot-api.org, screenshotapis.app, and appScreenshotAPI in the offers summarized above. Verify the current signup flow because terms can change.

Is a free screenshot API suitable for production?

It can be suitable for low-volume production if the provider’s limits, reliability expectations, support, and billing behavior fit your use. A test allowance alone does not establish production suitability.

Does a failed screenshot count against the free quota?

It depends on the provider. Screenshotapis.app says failed renders and cache hits do not count; other providers may use different rules. Check the relevant plan terms and response metadata.

What should I test before choosing?

Capture a representative page and verify output correctness, quota accounting, rate behavior, and failure handling. If the result will be shown to users, also check watermark and the exact options available on the free plan.