Screenshot API Free Tier Limits for Bulk URL Captures

A bulk request can reduce the number of calls your client has to orchestrate, but it does not necessarily make many URLs count as one screenshot or let you bypass a provider’s rate limit. ScreenshotOne’s documentation says its bulk endpoint uses the same one-minute request bucket as ordinary screenshot requests; plan for both the monthly successful-render allowance and the allowed request starts. Check your account’s usage endpoint for the current remaining capacity before scheduling a batch.

This guide uses ScreenshotOne’s published plan details checked on October 3, 2026. Quotas, prices, and account limits can change; check the live pricing page and your authenticated usage endpoint before relying on exact figures.

1. What the free tier and bulk limits mean

As of the research check date, ScreenshotOne lists 100 screenshots per month on its Free plan. The allowance includes URL captures, HTML rendering, and PDF rendering. Its Basic plan lists 2,000 screenshots per month and 40 requests per minute for $17 per month; Growth lists 10,000 and 80 requests per minute for $79; Scale lists 50,000 and 150 requests per minute for $259. These are published plan details, not guaranteed account-specific limits.

The bulk API accepts multiple screenshot request options in one submission. Depending on how it is called, it can return screenshot URLs without executing them immediately; setting execute: true asks it to execute before responding. Bulk submission does not turn a list of URLs into one billable screenshot. It also uses the same one-minute request bucket as ordinary requests, according to the bulk documentation.

ScreenshotOne says successful renders not served from cache count toward quota. Failed screenshots do not count, while a visual issue may still count; a cache miss can cause a rerender and quota use. Treat the usage response and provider documentation as authoritative for your key and current plan.

2. Read your current usage before submitting a batch

The usage endpoint reports total, available, used, and concurrency. In this context, the concurrency fields describe how many requests can be started during the current one-minute bucket, not how many browser renders are actively running at the same time:

• concurrency.limit: request starts allowed in the current bucket.
• concurrency.remaining: starts left before the bucket resets.
• concurrency.reset: when that bucket resets.

Fetch usage with the account’s authenticated credentials using the exact endpoint and authentication method shown in the [ScreenshotOne usage documentation](https://screenshotone.com/docs/usage/). Do not hard-code a quota from a blog post: use the response for your key to decide how much work to submit now. Keep API keys in environment variables or a secret manager, never in client-side code or a checked-in script.

3. A reliable queue for multiple URL captures

1. Normalize and validate the URL list. Deduplicate URLs when duplicate output is not needed, and decide whether query parameters represent distinct pages.
2. Read the current usage values and monthly availability. Reserve enough allowance for retries and other jobs using the same key.
3. Submit no more request starts than concurrency.remaining allows in the current bucket. If the remainder is zero, wait until concurrency.reset and read usage again.
4. Choose whether to execute the bulk request immediately or generate screenshot URLs for later execution. The bulk API’s execute: true option requests immediate execution.
5. Record each URL’s result independently. A batch response does not imply that every page rendered successfully.
6. Retry transient failures with bounded exponential backoff and jitter. Before retrying, determine whether the failure consumed quota, whether the response was a cache hit, and whether the target itself is temporarily unavailable.
7. Persist progress so a process restart does not repeat successful captures. Store the target, output location, status, attempt count, and provider request/result identifiers where available.

For a large batch, run a worker queue rather than launching every URL at once. The queue should pause at the rate bucket boundary and refresh the usage response before resuming. ScreenshotOne’s batching guide also recommends pacing from concurrency.remaining and concurrency.reset.

4. How to compare free screenshot API allowances

Compare the operational details that affect a real batch, not just the monthly headline number:

Question	Why it matters
How many successful renders are included per month?	Shows whether the monthly allowance covers your expected URL volume.
How many requests can start per minute or bucket?	Determines how quickly the batch can be submitted.
Do failed renders and cache hits consume quota?	Changes the expected allowance needed for unreliable targets or repeated captures.
Does bulk execute now or return URLs for later work?	Changes how you manage execution, result collection, and retries.
Can you inspect account-specific usage?	Lets workers schedule from actual remaining capacity instead of stale plan assumptions.

For context, Urlbox’s pricing page checked October 3, 2026 lists Lo-Fi at 2,000 renders and 30 requests per minute, Hi-Fi at 5,000 and 60, Ultra at 15,000 and 250, and Business at 1,000 and 1,000; the page says it has no free plan. This is a comparison of published quotas and request rates only, not a service-quality comparison. Recheck the live pages before selecting a provider.

5. Performance, reliability, and cost planning

Estimate the batch time

For a first approximation, divide the number of request starts by the allowed starts per minute, then account for any queue pauses, render duration, retries, and the provider’s execution behavior. A bulk wrapper can reduce client orchestration overhead, but it does not remove the documented request bucket. Do not interpret the field named concurrency as a promise of simultaneous browser sessions.

Budget the monthly quota

Estimate successful uncached renders, then add a buffer for retryable failures that later succeed and cache misses that trigger a render. Avoid assuming every failed visual result is free: the provider notes that a visual issue can still count. Track actual usage over a representative batch and compare it with the authenticated usage response.

Keep the queue recoverable

• Use bounded retries; repeated retries against a broken or blocked target waste time.
• Use exponential backoff with jitter for transient network errors and rate-limit responses.
• Persist completed results and make the worker safe to restart.
• Separate permanent input errors from temporary provider or target failures.
• Refresh usage after a bucket reset, after a plan change, or when multiple workers share the same key.

6. Common problems and fixes

Symptom	Likely cause	Fix
The batch is throttled even though it is one bulk call.	Bulk calls use the same one-minute request bucket as ordinary requests.	Schedule request starts from concurrency.remaining; resume after concurrency.reset.
The requested batch is larger than the free allowance.	The monthly allowance counts successful uncached renders, not submitted batches.	Check available, split the work across quota periods, or select a suitable plan.
A retry appears to use quota unexpectedly.	The earlier attempt may have been a cache miss or may have rendered despite a visual defect.	Inspect the result and usage endpoint; avoid blind retries and use bounded backoff.
Some URLs have no usable output.	Individual pages can fail even when the batch request itself was accepted.	Track results per URL, classify permanent versus transient errors, and retry only eligible failures.
A worker starts too many jobs after a pause.	It relied on an old remainder value or treated the bucket as active-render concurrency.	Refresh usage after reset and coordinate workers sharing the same API key.

7. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. One GET request captures a URL as PNG, JPEG, WebP, or PDF. Its documented features include bulk capture for up to 100 URLs per call and a usage API. For a single capture, use the API key from your account and the [ScreenshotNeo API documentation](https://screenshotneo.com/docs/):

cURL

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,
)
r.raise_for_status()
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}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', bytes));

• Cookie banners are accepted like a visitor and more than 60 known consent platforms are removed before capture; newsletter popups and chat widgets are also removed. Each step can be turned off.
• Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing; response headers report the page verdict and billing status.
• An MCP server gives AI agents tools for screenshots, page information, and PDF capture.
• The free plan includes 1,000 shots per month with no card; paid plans start at $5 for 3,000. Every feature is on every plan.

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

8. FAQ

Does a bulk request count as one screenshot?

No. A batch submission is an orchestration method; each rendered URL is still subject to the provider’s render allowance and applicable request limits.

Does the usage field named concurrency show active browser jobs?

For ScreenshotOne’s documented usage response, it describes request starts allowed in the current one-minute bucket.

Are the quota and price figures permanent?

No. They are a snapshot checked October 3, 2026. Check the live pricing page and the usage endpoint for your account before planning a production batch.