Best ScreenshotMachine Alternatives for Bulk Website Screenshots

Short answer: For managed bulk website screenshots, start with ScreenshotNeo if you want an API that accepts up to 100 URLs per call, clean captures, and billing that excludes bot checks, blank pages, failed loads, timeouts, and cache hits. ScreenshotOne has a documented bulk endpoint, but it supports up to 20 requests per call and its default workflow is lazy. Urlbox Capturedeck is designed for scheduled batches, ZIP downloads, and reports. ScreenshotMachine documents a flexible single-capture GET API; its inspected documentation does not establish a dedicated batch endpoint, so verify your intended workflow with the vendor before committing to a large migration.

The right choice depends on more than batch size. Compare the API’s queue behavior, per-minute and concurrency limits, monthly quota, failed-capture billing, delivery format, and the rendering options your pages need. A batch accepted by an endpoint is not automatically a batch completed at the same time.

1. ScreenshotNeo: best place to start for API-driven bulk captures

ScreenshotNeo is a website screenshot API and MCP server. Its bulk capture supports up to 100 URLs per call. It is the first alternative to try when you want clean screenshots with little browser infrastructure: it accepts cookie and consent banners as a visitor would, removes more than 60 known consent platforms plus newsletter popups and chat widgets, and lets you turn off each cleanup step. Only clean shots are billed; bot checks, CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing. Each response identifies the page verdict and billing status in headers.

ScreenshotNeo also supports full-page screenshots with lazy images loaded, CSS element capture, device and viewport settings, retina scale, dark mode, PDFs, HTML/CSS rendering, custom CSS and JavaScript, click-before-capture, selector waits, delay and network-idle waits, request blocking, headers, cookies, user agent, authorization, timezone, geolocation, transparent backgrounds, resizing, configurable caching, signed image links, async jobs with signed webhooks, a usage API, and an OpenAPI spec. An MCP server exposes take_screenshot, get_page_info, and capture_pdf to Claude, Cursor, and other MCP clients. The parameter names used by other screenshot APIs also work, which can ease a migration.

Pricing: Free includes 1,000 shots per month with no card. Starter is $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.

For the required one-call API form, send a GET request per URL. For bulk work, submit up to 100 URLs per bulk call using the product’s bulk workflow; see the ScreenshotNeo API documentation for request details.

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,
)
r.raise_for_status()
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}`);
await Bun.write('shot.webp', res);

The API returns an image or PDF response. Keep the access key on a server, check the HTTP status before saving a file, and inspect the page-verdict and billing headers when you need to distinguish a clean capture from a bot check or other unsuccessful page state.

2. ScreenshotOne: documented bulk endpoint with lazy execution by default

ScreenshotOne’s POST /bulk endpoint accepts a list of screenshot requests, shared defaults, and per-request overrides. The documentation currently limits a bulk request to 20 items. By default, the endpoint returns screenshot URLs and captures are produced when those URLs are downloaded. Set execute: true to request execution before the bulk response, then allow enough time for the captures to complete. Bulk requests use the same one-minute request bucket as regular requests, and the docs describe concurrency-limit errors. See the bulk endpoint documentation.

This runnable cURL example submits two requests with common viewport and ad-blocking defaults. Replace the key and target URLs. With execute: false, download each URL from the JSON response to trigger rendering. Setting it to true asks for execution before the response.

curl --request POST 'https://api.screenshotone.com/bulk' \
  --header 'Content-Type: application/json' \
  --data '{
    "access_key": "YOUR_SCREENSHOTONE_ACCESS_KEY",
    "execute": false,
    "options": {
      "viewport_width": 1280,
      "viewport_height": 900,
      "block_ads": true
    },
    "requests": [
      {"url": "https://example.com"},
      {"url": "https://stripe.com", "block_cookie_banners": true}
    ]
  }'

ScreenshotOne’s published monthly pricing currently lists 100 free screenshots, Basic at $17 for 2,000, Growth at $79 for 10,000, and Scale at $259 for 50,000. The listed request rates are 40, 80, and 150 per minute on those paid plans, respectively; paid plans list extra-usage rates. Its pricing page says failed requests are not billed and explains how caching affects quota accounting. Pricing and plan details change, so confirm the current pricing page before choosing a tier.

3. Urlbox Capturedeck: scheduled batch jobs and downloadable output

Capturedeck is a separate Urlbox product focused on bulk workflows. Its pricing page currently lists Basic at $49 per month for up to 3,000 captures and 100 webpages at a time, with scheduled daily, weekly, or monthly captures and ZIP downloads. Standard is listed at $99 for up to 10,000 captures and 300 webpages at a time, adding PDF and CSV reports and storage integrations. The page lists one-year data retention for these plans. The Pro plan lists up to 10,000 webpages at a time and 50,000 captures monthly. See Capturedeck pricing for current terms.

Choose Capturedeck when operators need repeatable schedules, ZIP archives, reports, or a dashboard-oriented workflow. Do not treat these Capturedeck plans as equivalent to Urlbox’s separate screenshot API plans: the products have different workflows and billing units. Urlbox says successful renders return an image and failed requests are not charged on its API pricing page.

4. What ScreenshotMachine’s documented API does—and leaves open

ScreenshotMachine documents an HTTP GET capture API with URL, dimensions, output format, cache age, delay, zoom, CSS-selector click, cookies, and language options. Its documented dimension range is 100–1,920 pixels wide and 100–9,999 pixels high, with full accepted for full-length captures. Its public API page does not establish a dedicated bulk endpoint. That is a limit of the documentation reviewed here, not proof that no account feature or separate workflow exists. Ask ScreenshotMachine how it recommends submitting and tracking your expected batch size before replacing it.

A single-request call looks like this; repeat it for each URL only after deciding how your script will throttle requests, retry transient failures, and store results:

curl -G 'https://api.screenshotmachine.com' \
  --data-urlencode 'key=YOUR_CUSTOMER_KEY' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'dimension=1366x768' \
  --data-urlencode 'device=desktop' \
  --data-urlencode 'format=png' \
  --data-urlencode 'cacheLimit=0' \
  --data-urlencode 'delay=2000' \
  --data-urlencode 'zoom=100' \
  -o example.png

For a full-length image, use a dimension such as 1024xfull. ScreenshotMachine advises increasing delay for long pages with images or animations. Its API documentation lists JPG, PNG, and GIF output, a 0–10,000 ms set of allowed delays, and zoom from 10 to 400 percent. Consult the ScreenshotMachine API documentation for parameter details.

5. Compare providers against your actual batch

Option	Batch model	Best fit	Operational point to check
ScreenshotNeo	Up to 100 URLs per bulk call; API and MCP server	Clean captures, varied screenshot options, or agent workflows	Use verdict and billing headers; test your page types and capture settings.
ScreenshotOne	Up to 20 requests per bulk call; lazy by default, optional execute	Small API batches or shared options with per-URL overrides	Plan around its shared one-minute request bucket and concurrency limits.
Urlbox Capturedeck	Scheduled batch workflow; plan-dependent simultaneous batch sizes	Recurring runs, ZIP delivery, reports, and dashboard operation	Compare monthly capture quota, retention, and the right Capturedeck tier.
ScreenshotMachine	Documented GET capture API; reviewed docs do not establish a batch endpoint	Existing integrations that use its capture parameters	Confirm supported batch orchestration and expected throughput with the vendor.

Use this checklist before migrating:

1. Count outputs, not just URLs. If each URL needs desktop and mobile captures, 500 pages may mean 1,000 rendered screenshots.
2. Measure the recurring workload. Record average and peak URL counts, schedule frequency, and the time window in which results must be ready.
3. Choose execution semantics. Decide whether a call should wait for images, return job handles, or create downloadable links that trigger rendering later.
4. Check limits and quota accounting. Confirm batch size, per-minute request rate, concurrent renders, monthly credits, overages, and whether failures or cache hits count.
5. Match capture controls to the sites. Test full-page behavior, lazy-loaded images, viewport, cookies, login headers, selector waits, and consent banners.
6. Plan file delivery. Decide whether results should be returned to the caller, saved to object storage, bundled in a ZIP, or delivered by webhook.
7. Run a representative pilot. Include short and long pages, JavaScript-heavy pages, redirects, consent banners, and known bot-protected sites. Compare correctness and total cost, not just a single render time.

6. Build a reliable bulk capture pipeline

Even when the provider accepts a list in one API call, treat individual page captures as separate outcomes. Persist the input URL, a stable job identifier, start time, attempt count, output location, status, and error category. This makes interrupted runs resumable and prevents a single bad page from losing the rest of a batch.

Queue and retry policy

• Keep a bounded number of requests in flight. Respect the provider’s published rate and concurrency limits; for ScreenshotOne, its docs recommend reading the usage endpoint’s remaining concurrency and reset values before draining a large queue.
• Retry transient network failures, timeouts, and retryable server responses with exponential backoff and jitter. Set a maximum attempt count and move persistent failures to a review queue.
• Do not blindly retry invalid options, authentication failures, or inaccessible pages. Fix the request or mark that URL for review.
• Use idempotent output names or a manifest so a retry does not create confusing duplicates. If output depends on time-sensitive page content, include the capture timestamp in the path.
• For asynchronous jobs and webhooks, verify the signature where supported, acknowledge quickly, and make webhook handling idempotent because deliveries may be repeated.

Preserve useful diagnostics

Save response status and relevant provider headers with the output metadata. Separate errors into authentication, invalid configuration, rate or concurrency limit, target-site failure, bot check, timeout, and storage failure. On ScreenshotNeo, the page-verdict and billing headers clarify whether an attempt produced a clean, billable shot. Avoid logging secrets from authorization headers, cookies, or API keys.

7. Performance, reliability, and cost

Throughput: Estimate batch duration from your real pages and the provider’s concurrency and request-rate limits. Large pages, slow scripts, long waits, and full-page scrolling all change render time. None of the cited plan limits is a guarantee that every page completes within a particular duration. Run a pilot with your own URL mix.

Reliability: A bulk request can return successfully while some individual pages later fail, especially in lazy workflows. Track status per URL and make the run resumable. For synchronous or execute-before-response workflows, set client timeouts high enough for the expected batch and handle partial execution results. Avoid launching a second full batch just because one caller timed out; first check job or output state.

Cost: Model expected monthly outputs as pages × viewports × schedules, then add PDFs or other outputs as applicable. Compare the resulting count with included quota and overage rates. Include failure billing and cache semantics: ScreenshotOne’s current price page says failed requests do not consume credits and cache misses can count; ScreenshotNeo says bot checks, blank pages, failed loads, timeouts, and cache hits cost nothing; Urlbox API pricing describes unsuccessful renders as uncharged. Capturedeck has its own monthly capture allowances and warns that advanced scenarios may use additional credits. Recheck live terms before purchase.

ScreenshotNeo’s plans begin with 1,000 free shots monthly without a card, then $5 for 3,000 shots; every feature is on every plan. For a small batch, the simplest comparison is not only per-shot price: include engineering time spent on consent handling, queue management, retries, and delivery.

8. Troubleshooting common bulk-capture problems

Symptom	Likely cause	Fix
Bulk API returns URLs but no image files	The provider uses lazy execution and capture begins when a returned URL is fetched.	Download each returned URL, or request execute-before-response if supported and appropriate. ScreenshotOne documents lazy behavior by default.
Concurrency or rate-limit error	Workers are draining the queue faster than the account limit permits.	Reduce in-flight work, pace requests, inspect usage/reset information, and retry after the limit window.
Some pages are missing from an otherwise successful batch	Per-URL render failures, malformed entries, or partial execution.	Store and inspect each result separately; retry only transient failures and correct invalid requests.
Screenshot is blank or shows a consent dialog	Page scripts did not finish, consent was not handled, or the site presents bot protection.	Try an appropriate delay or selector wait; verify cookies and headers. Use a service with consent cleanup when that is part of the requirement.
Full-page image cuts off content	Lazy-loaded sections appear only after scrolling, or the target page keeps expanding.	Use a full-page mode that loads lazy images, test a realistic wait, and inspect the page’s behavior with dynamic content.
403, CAPTCHA, or access denied	The target site blocks automated traffic or requires authentication.	Confirm you are authorized to capture the page; provide supported cookies or authorization headers, or exclude the URL. Do not treat a challenge page as a valid screenshot.
Saved file is JSON or HTML instead of an image	The response is an API error body or job summary, not image bytes.	Check HTTP status and content type before saving; parse JSON responses and fetch the actual image URL if returned.
Timeouts on long pages	Large assets, slow scripts, excessive delay, or a batch that waits for every capture.	Capture fewer items per synchronous operation, set a suitable timeout, and use asynchronous jobs or a scheduled batch workflow where available.
ScreenshotMachine requests work individually, but migration batching is unclear	The reviewed public API guide documents parameterized GET captures but does not establish a bulk endpoint.	Ask the vendor whether your account has another batch mechanism; otherwise build a bounded queue with retries and result tracking or select a documented bulk workflow.

9. Or skip the browser setup

ScreenshotNeo returns a screenshot from one GET request. For bulk work, its bulk capture workflow accepts up to 100 URLs per call. Start with one URL using the API call below, then send the URL list through the bulk workflow described in the documentation.

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

ScreenshotNeo removes cookie banners, popups, and chat widgets before the shot. Bot checks, blank pages, and failed loads are never billed. Its 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. Create a free ScreenshotNeo account.

FAQ

Does ScreenshotMachine definitely have no bulk feature?

The documentation reviewed for this guide does not establish a dedicated bulk endpoint. That does not rule out another account feature or workflow; confirm with ScreenshotMachine before relying on that conclusion.

Should I choose the largest advertised batch size?

Only if you need that many pages in one operation. A smaller batch can be easier to resume, throttle, and diagnose. Compare total completion time and monthly quota as well as batch size.

Can I mix per-page settings in one batch?

ScreenshotOne documents shared defaults plus per-request overrides. Other providers may have different rules; verify that your intended combinations are accepted by the endpoint.

How can I compare costs fairly?

Count all outputs across devices and schedules, then include overages, failure billing, cache behavior, storage, and any additional credits required by advanced captures. Confirm current plan pages immediately before purchase.

Can an AI agent run captures without custom browser code?

ScreenshotNeo’s MCP server provides screenshot, page-info, and PDF-capture tools for MCP clients including Claude and Cursor.