URLbox Pricing for Screenshot API Usage: How Credits and Plans Work

URLbox bills screenshot API usage in monthly renders, not necessarily one render per API request. Runtime, output size, GPU acceleration, archive storage, and some advanced features can increase the number of renders a request uses. The published plan prices and limits below were listed by URLbox on October 3, 2026; check the official pricing page before choosing a plan because prices and terms can change.

What a URLbox render credit means

URLbox uses “render” as its quota unit for generated outputs such as screenshots, PDFs, and videos. A request can consume more than one render. The pricing page describes these factors:

Duration: one render for each 30-second period a request takes to render.
File size: one render for each 5 MB of output.
GPU acceleration: twice the renders of a non-GPU request.
Certified Archive: one additional render per year of archive storage.
Advanced features: may use additional renders.

Consequently, “number of requests” is only a starting estimate. A short, small screenshot may use fewer renders than a long-running or large output, and a GPU request may multiply usage. URLbox’s API reference describes the render endpoint and output types.

URLbox plans and listed prices

These are URLbox’s published monthly figures as observed on October 3, 2026. The page says prices exclude VAT at the prevailing rate.

Plan	Published price	Published allowance or note	Requests per minute	Timeout	File-size limit
Lo-Fi	$19/month	Up to 2,000 renders	30	30 seconds	2.5 MB
Hi-Fi	$49/month	Up to 5,000 renders	60	90 seconds	10 MB
Ultra	$99/month	Up to 15,000 renders	250	300 seconds	No limit listed
Business	$495 base; page also displays $498/month	$3 per 1,000 renders; comparison table lists at least 1,000 successful renders. The page does not establish a broader base allowance.	1,000	300 seconds	No limit listed
Enterprise	From $3,000/month	Custom capture limits and features	No limit stated	No limit stated	No limit stated

The pricing page also displays unit costs of $9.50 per 1,000 renders for Lo-Fi, $9.80 for Hi-Fi, and $6.60 for Ultra. Those figures are based on the listed plan price and allowance; they are not a guarantee that each API request costs that amount, since a request can consume multiple renders. URLbox offers a seven-day trial for Lo-Fi, Hi-Fi, and Ultra, and says a three-month Business trial is available on application. Confirm trial eligibility and current terms on the pricing page.

Estimate monthly render usage

Estimate successful captures. Count the screenshots, PDFs, and videos your application expects to generate in a month.
Account for request shape. Note expected render duration and output size. Apply URLbox’s stated duration and size rules when estimating their extra render consumption.
Include optional multipliers. Identify GPU acceleration, Certified Archive retention, and advanced features that may raise usage.
Keep a variance allowance. Production pages can differ in load time and output size. Avoid selecting a plan that only fits an optimistic average.
Compare operational limits too. Check requests per minute, timeout, file-size limit, storage destination, support needs, and required capture features.

A useful estimate is monthly renders ≈ sum of the renders consumed by each output. Do not substitute raw request count unless you have confirmed that the request mix consistently uses one render each.

For example, if a workload creates 1,200 outputs a month and each consumes one render, its baseline is 1,200 renders before multipliers or additional feature usage. If some outputs take longer, exceed size increments, use GPU acceleration, or require archive storage, the actual total may be higher. This is an estimate method, not a published benchmark.

Cache behavior and failed requests

URLbox documents two cache paths with different quota behavior:

Render Links: screenshots are cached for 30 days by default. URLbox says cached screenshots do not count against the monthly plan quota. TTL and force options can change or bypass that cache behavior.
Synchronous REST API render endpoint: URLbox says these requests are not cached or deduplicated. Do not assume repeated REST API calls share the Render Link cache or avoid usage.

URLbox’s pricing FAQ defines a successful render as one that returns an image and says failed requests are not charged. This is the vendor’s stated policy; check the live terms for the current definition and behavior. See the API reference for endpoint details and the pricing FAQ for its billing statement.

Monitor usage, rate limits, and overages

Monthly render quota and per-minute request limits are separate constraints. A workload can be within its monthly allowance but still exceed its requests-per-minute limit. URLbox’s usage documentation lists these response headers:

Header	Meaning
`x-renders-used`	Renders used
`x-renders-allowed`	Renders allowed
`x-renders-remaining`	Renders remaining
`x-renders-reset`	When the usage period resets

Read these headers in your integration or log them with request IDs so usage spikes can be traced to a workload. URLbox documents rate-limit headers separately. Its pricing FAQ says it emails alerts at 80%, 90%, and 100% usage, and says service continues after quota is exceeded through automatic movement to the next tier with volume pricing. It does not publish one universal overage price for every plan, so check the applicable terms instead of budgeting from a single assumed rate. See URLbox usage documentation.

Storage and plan selection

URLbox says it stores images on Google Cloud Storage by default. It supports saving to a customer’s own Amazon S3 bucket on Hi-Fi and above, and any S3-compatible storage provider on Ultra and above. Confirm current plan availability and storage terms before designing a workflow around a specific destination.

Choose a plan by comparing these dimensions:

Expected monthly renders after duration, file-size, GPU, archive, and feature usage.
Peak request rate against the plan’s per-minute limit.
Longest expected render against the timeout limit.
Largest expected output against the file-size limit.
Storage location and retention needs.
Required features and support level.

For a small workload, Lo-Fi’s listed allowance may be enough if its limits fit the captures. Hi-Fi and Ultra raise capacity and operational limits. Business and Enterprise list higher throughput or custom terms, but the published Business price/allowance presentation requires checking with URLbox rather than inferring an unlisted included quota.

Run a URLbox capture and inspect usage

Use the credentials and parameters from your URLbox account and the current Quickstart. The following Python example sends a request, saves a successful image response, and prints documented render-usage headers when present. Supply the endpoint and authentication parameters exactly as specified by your account and current API documentation.

import requests

endpoint = "URLBOX_RENDER_ENDPOINT_FROM_CURRENT_DOCS"
params = {
    # Add the authentication and capture parameters from your URLbox account.
    "url": "https://example.com",
}
response = requests.get(endpoint, params=params, timeout=120)

for name in (
    "x-renders-used",
    "x-renders-allowed",
    "x-renders-remaining",
    "x-renders-reset",
):
    if name in response.headers:
        print(f"{name}: {response.headers[name]}")

response.raise_for_status()
with open("capture.png", "wb") as image_file:
    image_file.write(response.content)

The placeholder is deliberate: the research sources establish the quickstart and usage headers but do not provide the authentication parameter names or a complete request URL. Copy those from URLbox’s current documentation rather than guessing them. The same rule applies when implementing cURL or Node.js calls.

Or skip the browser setup

ScreenshotNeo is the alternative to try first for a screenshot API: cookie banners, popups, and chat widgets are removed before capture, and only clean shots are billed. The request is a single GET; 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}`);
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, 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 use take_screenshot, get_page_info, and capture_pdf. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Sign up free for ScreenshotNeo.

Troubleshooting URLbox billing questions

Usage is higher than the request count

Cause: renders are not always one per request; duration, file size, GPU, archive retention, and advanced features can add usage.
Fix: inspect the usage headers, group requests by workload, and compare output duration and size with the pricing rules.

Repeated captures still count

Cause: the synchronous REST API endpoint is documented as uncached and not deduplicated. Render Link caching is a separate feature.
Fix: confirm which endpoint your code uses and consult URLbox’s cache controls; do not assume REST calls use Render Link cache behavior.

Requests are throttled while quota remains

Cause: per-minute rate limits are independent of the monthly render allowance.
Fix: compare request rate with your plan limit, then use bounded concurrency or schedule work across time.

A request times out or its output is rejected

Cause: the render may exceed the plan timeout or output-size limit.
Fix: compare the request and output against the current plan limits; reduce page complexity or output size, or choose a plan whose published limits fit.

The overage amount is unclear

Cause: URLbox describes tier progression and volume pricing but does not give one universal overage price for all plans.
Fix: review the current plan terms and ask URLbox to confirm the cost for your expected usage before relying on an overage estimate.

Performance, reliability, and cost controls

Track actual render consumption. Log the usage headers alongside your job identifiers and compare monthly totals with estimates.
Control peak traffic. Keep concurrency within your plan’s request-per-minute limits and retry transient failures with bounded backoff.
Set realistic timeouts. Client timeouts should account for the plan’s maximum render timeout and transfer time, while avoiding unbounded waits.
Use cache deliberately. Render Links can reduce quota use for cached screenshots under the documented cache rules; REST endpoint requests should be budgeted as uncached.
Budget for expensive outputs. Large files, long renders, GPU use, archive storage, and advanced features can change render consumption.
Verify volatile terms. Prices, allowances, limits, and trials are vendor-published terms that can change; recheck the pricing and API pages when deploying or renewing.

FAQ

Does one URLbox API call always use one render?

No. Duration, file size, GPU acceleration, Certified Archive storage, and some advanced features can add render usage.

Are failed URLbox requests billed?

URLbox’s pricing FAQ says failed requests are not charged and defines a successful render as one that returns an image. Check the live pricing terms for current wording.

Do cached REST API captures count?

The synchronous REST render endpoint is documented as uncached and not deduplicated. The separate Render Links feature has a 30-day default cache, and URLbox says cached screenshots do not count against quota.

What is the Business plan’s included allowance?

The page lists at least 1,000 successful renders in its comparison table and also shows a $495 base plus $3 per 1,000 renders. It does not support inferring a larger base allowance; confirm the applicable terms with URLbox.

Sources and price date

Plan figures and billing rules above were taken from URLbox’s official pricing page, observed October 3, 2026. Technical billing definitions and output types are in the API reference; usage headers are in the usage documentation; trial setup is described in the Quickstart. Recheck those sources because commercial terms may change.