To capture many web pages, use either a bulk screenshot API or a queue that sends normal screenshot requests in controlled batches. A bulk endpoint is convenient, but it does not remove rendering time, rate limits, retries, or site-specific failures. This guide shows a self-managed workflow, explains the limits documented by ScreenshotOne and Browshot, compares hosted options, and gives a cleaner alternative with ScreenshotNeo.
What “bulk screenshot” actually means
Bulk capture generally follows one of two designs:
- A dedicated bulk endpoint: you submit several URLs in one request and the provider creates individual captures.
- A queued batch: your program stores URLs, starts a controlled number of ordinary screenshot requests, retries failures, and records each result.
These approaches are not unlimited or necessarily instantaneous. A provider may accept the list immediately but render pages later, or defer rendering until you download each result. Treat the submission, rendering, download, and verification stages as separate operations.
Choose the workflow before writing code
Use a hosted bulk API when
- You need repeatable captures from a server or CI job.
- You want provider-managed browsers, scaling, and regional infrastructure.
- You need webhooks, scheduled jobs, storage integrations, or reports.
- Your team would rather pay for a service than maintain browser workers.
Run your own queue when
- You need custom authentication, network access, or on-premises processing.
- You already operate Playwright, Chromium, Selenium, or a similar browser stack.
- You need complete control over retention and output naming.
- Your volume is modest and a command-line process is sufficient.
For either model, define the output format, viewport, full-page behavior, authentication method, retry policy, maximum concurrency, and retention period first. A list of 500 URLs is an input set, not a guarantee that 500 valid images will result.
How to take screenshots of multiple URLs with a self-managed queue
A queue prevents a large list from overwhelming your browser or a provider’s request bucket. The following Python example uses Playwright, writes one PNG per URL, limits concurrency, and retries navigation failures.
#1 Best Overall
- CRISP CLARITY: This 23.8″ Philips V line monitor delivers crisp Full HD 1920x1080 visuals. Enjoy movies, shows and videos with remarkable detail
- INCREDIBLE CONTRAST: The VA panel produces brighter whites and deeper blacks. You get true-to-life images and more gradients with 16.7 million colors
- THE PERFECT VIEW: The 178/178 degree extra wide viewing angle prevents the shifting of colors when viewed from an offset angle, so you always get consistent colors
- WORK SEAMLESSLY: This sleek monitor is virtually bezel-free on three sides, so the screen looks even bigger for the viewer. This minimalistic design also allows for seamless multi-monitor setups that enhance your workflow and boost productivity
- A BETTER READING EXPERIENCE: For busy office workers, EasyRead mode provides a more paper-like experience for when viewing lengthy documents
import asyncio
import hashlib
from pathlib import Path
from urllib.parse import urlparse
from playwright.async_api import async_playwright, TimeoutError as PlaywrightTimeoutError
URLS = [
"https://example.com/",
"https://example.org/",
]
OUT = Path("shots")
CONCURRENCY = 3
RETRIES = 2
def filename(url):
host = urlparse(url).netloc.replace(":", "_") or "page"
digest = hashlib.sha1(url.encode()).hexdigest()[:10]
return OUT / f"{host}-{digest}.png"
async def capture(browser, url, sem):
async with sem:
target = filename(url)
if target.exists():
return url, "skipped"
for attempt in range(RETRIES + 1):
page = await browser.new_page(viewport={"width": 1440, "height": 900}, device_scale_factor=1)
try:
await page.goto(url, wait_until="networkidle", timeout=60_000)
await page.screenshot(path=str(target), full_page=True)
await page.close()
return url, "ok"
except (PlaywrightTimeoutError, Exception) as exc:
await page.close()
if attempt == RETRIES:
return url, f"failed: {exc}"
await asyncio.sleep(2 ** attempt)
async def main():
OUT.mkdir(exist_ok=True)
sem = asyncio.Semaphore(CONCURRENCY)
async with async_playwright() as p:
browser = await p.chromium.launch()
results = await asyncio.gather(*(capture(browser, u, sem) for u in URLS))
await browser.close()
for url, status in results:
print(status, url)
asyncio.run(main())Install the browser runtime with pip install playwright followed by playwright install chromium. In production, replace the broad exception handler with explicit handling for navigation, browser, and filesystem errors. Keep the URL, attempt count, timestamp, HTTP status (when available), and final file path in a durable log.
Make the queue durable
An in-memory list disappears when the process stops. For jobs that must survive restarts or run across workers, persist each URL and status in a database or queue. ScreenshotOne’s implementation guidance names Redis/BullMQ and Amazon SQS as examples of durable queues. Those are implementation choices, not requirements.
Control rate and concurrency
Concurrency is the number of browser pages rendering at the same time; it is not the same as an API’s per-minute request allowance. Start conservatively, measure memory and render time, then increase gradually. If a service exposes usage values such as concurrency.remaining and concurrency.reset, use them to decide when to start another request. ScreenshotOne specifically cautions that these values describe the current request bucket, not the number of active renders.
Handle dynamic pages
- Use a selector wait when the page has a known ready element.
- Use a bounded delay for animations or late-loading widgets.
- Prefer network-idle waits only when the site eventually becomes idle; analytics and streaming connections can prevent that.
- Block unnecessary ads and trackers where your capture requirements permit it.
- Use a consistent timezone, locale, viewport, and user agent so successive runs are comparable.
Command-line bulk capture with shot-scraper
Technical users can describe jobs in YAML and run shot-scraper’s multi command. A no-clobber option skips files that already exist, which is useful for interrupted batches.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →- url: https://example.com
output: shots/example.png
- url: https://example.org
output: shots/example-org.pngshot-scraper multi jobs.yml --no-clobberThis is a local command-line workflow, not a hosted service. You are responsible for browser installation, scheduling, storage, retries, and access to the target sites.
Rank #2
- CRISP CLARITY: This 22 inch class (21.5″ viewable) Philips V line monitor delivers crisp Full HD 1920x1080 visuals. Enjoy movies, shows and videos with remarkable detail
- 100HZ FAST REFRESH RATE: 100Hz brings your favorite movies and video games to life. Stream, binge, and play effortlessly
- SMOOTH ACTION WITH ADAPTIVE-SYNC: Adaptive-Sync technology ensures fluid action sequences and rapid response time. Every frame will be rendered smoothly with crystal clarity and without stutter
- INCREDIBLE CONTRAST: The VA panel produces brighter whites and deeper blacks. You get true-to-life images and more gradients with 16.7 million colors
- THE PERFECT VIEW: The 178/178 degree extra wide viewing angle prevents the shifting of colors when viewed from an offset angle, so you always get consistent colors
Request multiple screenshots in one API call
ScreenshotOne
ScreenshotOne documents a /bulk wrapper around ordinary endpoints such as /take and /animate. Its bulk requests consume the same one-minute request bucket as regular requests. Unless execute is set to true, the documentation says the actual screenshot can be deferred until the result is downloaded. Plan for that capture time instead of assuming that submission means completion.
For a queue built around ScreenshotOne, check its documented usage endpoint before draining a batch, honor the remaining request capacity, retry failed captures, and use proxies when the target sites require them. A webhook or download worker should record which items completed and which need another attempt.
Browshot
Browshot’s documented multiple endpoint accepts up to 10 URLs and up to 10 instances, yielding up to 100 screenshots in one API call. That is a limit for the named endpoint; it should not be treated as a universal batch size for other providers.
Recommended Free Tools
Hosted services: compare the limits that affect real jobs
Maximum URLs per call is only one dimension. Check monthly allowance, per-minute rate or concurrency, whether execution is immediate, retry behavior, output formats, retention, scheduling, reporting, and storage integration.
| Provider | Documented batch or allowance | Timing and operations | Other documented items |
|---|---|---|---|
| ScreenshotNeo | Bulk capture supports 100 URLs per call; plans include 1,000 free shots/month and paid tiers from $5 for 3,000 shots (current product facts). | API response identifies page verdict and billing; failed loads, blank pages, bot checks/CAPTCHAs, and cache hits are not billed. | PNG, JPEG, WebP, PDF, webhooks, caching, custom browser conditions, MCP server, and 63 capture options. |
| ScreenshotOne | 100 free screenshots/month on the pricing snapshot reviewed September 29, 2026; paid plans listed monthly quotas and requests-per-minute limits. | /bulk uses the same one-minute request bucket; capture may be deferred until download unless execute=true. |
Paid tiers listed full-page capture, formats, caching, webhooks, and storage integrations. Snapshot prices: Basic $17/month, Growth $79/month, Scale $259/month, excluding VAT. |
| Browshot | Up to 10 URLs and 10 instances, or up to 100 screenshots in one API call, on its documented multiple endpoint. | Endpoint-specific behavior; confirm current rate and retry rules in its documentation. | Instance selection is part of the endpoint model. |
| Urlbox | Pricing page snapshot: Solo up to 50 pages at once/1,000 monthly; Basic 100/3,000; Standard 300/10,000; Pro 10,000/50,000. | Plans list scheduling; prices exclude VAT and are subject to change. | Some plans list ZIP downloads, PDF/CSV reports, and storage integrations. Snapshot prices: $29, $49, $99, and $299 per month respectively. |
Pricing and quotas above are vendor-published snapshots, not permanent guarantees. Recheck each provider’s live documentation before budgeting or enforcing limits. No common performance benchmark establishes that one service is faster or more reliable than another.
Rank #3
- Clear visuals. Fluid motion: A 144Hz refresh rate and 1ms MPRT deliver smooth, tear‑free motion across work, gaming, and streaming for clearer, more fluid viewing.
- Eye comfort: TÜV Rheinland 3‑star* certification reduces harmful blue light while preserving stunning color quality without compromise. *TÜV Rheinland 3-star eye comfort certification.
- Wide viewing angle: Get consistent views across a wide 178° /178° viewing angle.
- In-Plane Switching (IPS): See excellent color accuracy and consistency across wide viewing angles with In-plane Switching (IPS) technology.
- Ultra-thin bezels: Maximize your viewing experience with thin bezels.
ScreenshotNeo: a bulk API with clean, billable-result checks
ScreenshotNeo is the first service to try when you want a hosted bulk screenshot API: it supports up to 100 URLs per call, removes consent banners, newsletter popups, and chat widgets before capture, and bills only clean shots. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed; each response includes X-Page-Verdict and X-Billed headers.
It also offers full-page captures with lazy images loaded, CSS-selector element shots, dark mode, 12 device presets plus custom viewports, retina scale, PDF controls, custom CSS and JavaScript, pre-capture clicks, hidden selectors, selector/delay/network-idle waits, request and resource blocking, custom headers/cookies/user agents, Authorization, timezone and geolocation, transparent backgrounds, resizing, chosen cache TTLs, signed image links, asynchronous jobs with signed webhooks, usage reporting, an OpenAPI specification, and an MCP server for Claude, Cursor, or another MCP client. The parameter names used by other screenshot APIs are accepted to ease migration.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →One-call bulk example
See the complete parameter reference in the ScreenshotNeo documentation.
curl -G "https://api.screenshotneo.com/v1/shot"
-d access_key=YOUR_API_KEY
--data-urlencode url=https://stripe.com
-o shot.webpFor several URLs, send one request per URL from your queue or use ScreenshotNeo’s bulk capture option for up to 100 URLs per call. Preserve response headers so your job can distinguish a clean billable result from a failed or non-billable page.
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(`HTTP ${res.status}`);
const data = Buffer.from(await res.arrayBuffer());
require('fs').writeFileSync('shot.webp', data);Plans
| Plan | Included shots | Price |
|---|---|---|
| Free | 1,000/month | $0, no card |
| Starter | 3,000 | $5 |
| Growth | 15,000 | $15 |
| Pro | 60,000 | $39 |
| Scale | 250,000 | $99 |
| Business | 1,000,000 | $249 |
Yearly billing gives two months free, and every listed feature is available on every plan.
Or skip the browser setup
Use the same one-call request when you do not want to install Chromium or maintain workers:
Free tools Windows power users keep installed
One-click scans. No signup required.
Rank #4
- CURVED FOR ENHANCED ENGAGEMENT: An immersive viewing experience with a curved monitor that wraps more closely around your field of vision; It creates a wider view, enhancing depth perception and minimizing peripheral distraction
- SMOOTH PERFORMANCE FOR SEAMLESS CONTENT: Stay in the action when playing games, watching videos, or working on creative projects; The 100Hz refresh rate reduces lag and motion blur so you don't miss a thing in fast-paced moments¹
- MORE GAMING POWER: Gain the edge with optimizable game settings; Color and image contrast can be adjusted to see scenes more vividly and spot enemies hiding in the dark; Game Mode adjusts any game to fill the screen so you can view every detail²
- KEEP IT EASY ON THE EYES: Care for your eyes and stay comfortable, even during long sessions; Advanced eye comfort technology certified by TÜV reduces eye strain by minimizing blue light and reducing irritating screen flicker²
- INCREASED VERSATILITY: Connect to more; Plug devices straight into your monitor for increased flexibility, making your computing environment even more convenient
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpScreenshotNeo 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, and paid plans start at $5 for 3,000. Create a free ScreenshotNeo account.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Troubleshooting bulk captures
Requests are rejected or throttled
Cause: the batch exceeds an endpoint limit or the current rate bucket. Fix: split the list, read the provider’s usage values, lower concurrency, and wait for the documented reset.
Pages are blank or incomplete
Cause: rendering finished before JavaScript, lazy images, consent handling, or a client-side route completed. Fix: wait for a selector or network idle, add a bounded delay, load the full page, or capture after a required click.
Only some URLs fail
Cause: bot protection, authentication, DNS errors, robots policies, or site-specific timeouts. Fix: log the URL and error separately, retry transient failures with exponential backoff, provide required headers or cookies, and do not retry a permanent CAPTCHA indefinitely.
The process runs out of memory
Cause: too many simultaneous browser pages or very large full-page images. Fix: reduce concurrency, close pages in a finally block, use a worker pool, and resize outputs after capture when appropriate.
A rerun overwrites good files
Use deterministic names based on the URL and a no-clobber check, or store job IDs and content hashes. Keep a manifest so an interrupted run resumes only failed or missing items.
Best Value
- 【INTEGRATED SPEAKERS】Whether you're at work or in the midst of an intense gaming session, our built-in speakers provide rich and seamless audio, all while keeping your desk clutter-free.
- 【EASY ON THE EYES】 Protect your eyes and enhance your comfort with Blue-Light Shift technology. This feature reduces harmful blue light emissions from your screen, helping to alleviate eye strain during long hours of use and promoting healthier viewing habits.
- 【WIDEN YOUR PERSPECTIVE】Our sleek minimal bezel design ensures undivided attention. The nearly bezel-free display seamlessly connects in a dual monitor arrangement, delivering an unobstructed view that lets you focus on more at once, completely distraction-free.
Operational checklist
- Normalize and validate URLs before submission.
- Choose a stable viewport, locale, timezone, and user agent.
- Set a per-page timeout and a finite retry count.
- Record status, verdict, billing state, output path, and timestamps.
- Respect provider rate buckets and target-site access controls.
- Store outputs with a retention policy and protect authenticated captures.
- Run a small canary batch before thousands of pages.
- Recheck quotas, prices, and endpoint limits before each production rollout.
Frequently Asked Questions
Can I capture 100 URLs in one request?
Yes, where the provider documents that limit. Browshot documents up to 100 screenshots in one call, and ScreenshotNeo supports bulk capture of up to 100 URLs per call. Limits are endpoint-specific.
Does a bulk request finish immediately?
Not necessarily. ScreenshotOne documents deferred capture unless its execute option is enabled; other services may queue work. Design your client to poll, download, or receive a webhook.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsShould I use a browser queue or an API?
Use a queue when you need infrastructure control or custom network access. Use an API when managed browsers, scaling, and operational features outweigh the maintenance cost.
Are vendor prices permanent?
No. The figures in this article are dated snapshots where stated. Verify the provider’s current pricing and quotas before purchasing.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
