Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteTo screenshot multiple URLs with Browserless, send one authenticated POST request to the regional /screenshot endpoint for each URL, then save each binary image response to a distinct filename. You can run requests concurrently; use bounded concurrency for larger lists and keep a URL-to-file mapping so failed captures can be retried individually.
How Browserless captures a list of URLs
Browserless’s REST endpoint handles one page per request. Put the target URL and optional screenshot settings in a JSON body, pass your API token as the token query parameter, and treat the response as image bytes. [Browserless screenshot endpoint] [Browserless concurrent sessions]
As an Amazon Associate I earn from qualifying purchases.
- Get a Browserless API token and select the correct regional endpoint for your account. Browserless documents the token as a query parameter. [Browserless connection URLs]
- For each URL, send a
POSTrequest to that region’s/screenshotendpoint with a JSON body containingurland, if needed,options. - Check the HTTP response status before treating the body as an image.
- Save each successful response under a unique filename, preserving its relationship to the input URL.
The documented response is PNG by default in the example; the current REST documentation also describes JPEG and WebP. Each REST request opens an independent browser session, so requests for separate URLs can run concurrently. [Screenshot endpoint] [Concurrent sessions]
JavaScript: capture multiple URLs concurrently
This example uses Node.js with a recent version that provides built-in fetch. It writes one PNG per URL. Set the region-specific endpoint and token for your account, and replace the example URLs with your own.
#1 Best Overall
- 14" diagonal, 1366x768 resolution, HD BrightView LED, Glossy NON-TOUCH Display
import { writeFile } from "node:fs/promises";
const urls = ["https://example.com/", "https://example.org/"];
const token = process.env.BROWSERLESS_TOKEN;
const endpoint = "https://production-sfo.browserless.io/screenshot";
if (!token) throw new Error("Set BROWSERLESS_TOKEN before running this script.");
await Promise.all(urls.map(async (pageUrl, index) => {
const response = await fetch(
`${endpoint}?token=${encodeURIComponent(token)}`,
{
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
url: pageUrl,
options: { fullPage: true, type: "png" }
})
}
);
if (!response.ok) {
throw new Error(`Screenshot failed for ${pageUrl}: HTTP ${response.status}`);
}
const image = Buffer.from(await response.arrayBuffer());
await writeFile(`screenshot-${index + 1}.png`, image);
}));The endpoint shown is an example regional URL from Browserless’s documentation; use the connection URL for your account’s region. [Connection URLs] Promise.all starts all captures together, which is convenient for a short list. For a large list, use a queue or worker pool rather than creating an unlimited number of simultaneous browser sessions. Browserless demonstrates concurrent requests but does not establish a universally safe concurrency limit. [Concurrent sessions]
Python: capture a list with a worker pool
Python’s ThreadPoolExecutor can overlap HTTP requests while keeping the number of simultaneous captures bounded. Install the HTTP client with python -m pip install requests, set BROWSERLESS_TOKEN, and run:
import os
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
import requests
TOKEN = os.environ["BROWSERLESS_TOKEN"]
ENDPOINT = "https://production-sfo.browserless.io/screenshot"
URLS = ["https://example.com/", "https://example.org/"]
OUTPUT = Path("screenshots")
OUTPUT.mkdir(exist_ok=True)
def capture(item):
index, page_url = item
response = requests.post(
ENDPOINT,
params={"token": TOKEN},
json={"url": page_url, "options": {"fullPage": True, "type": "png"}},
timeout=90,
)
response.raise_for_status()
path = OUTPUT / f"screenshot-{index + 1}.png"
path.write_bytes(response.content)
return page_url, str(path)
with ThreadPoolExecutor(max_workers=4) as pool:
futures = [pool.submit(capture, item) for item in enumerate(URLS)]
for future in as_completed(futures):
try:
page_url, path = future.result()
print(f"Saved {page_url} to {path}")
except requests.RequestException as error:
print(f"Capture request failed: {error}")The worker count of four is an example configuration, not a Browserless-prescribed limit. Choose concurrency based on your account and workload, and reduce it if requests fail or your available session capacity is reached. Browserless documents a Python ThreadPoolExecutor pattern for concurrent screenshots. [Concurrent sessions]
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Choose capture options for the page
Browserless accepts optional Puppeteer-style screenshot settings under options. Use only the settings relevant to the capture; viewport images, full-page images, and element captures answer different needs. [Screenshot endpoint]
| Need | Setting or approach | What to account for |
|---|---|---|
| Capture beyond the visible viewport | fullPage: true |
Captures the full document rather than only the current viewport. |
| Choose output image format | type: PNG, JPEG, or WebP |
PNG is the documented example’s default; the REST docs also describe JPEG and WebP. Confirm accepted values in the endpoint documentation. |
| Set image quality | quality |
Relevant to lossy formats such as JPEG or WebP; not a way to improve page rendering. |
| Fix capture dimensions | viewport and deviceScaleFactor |
Set these when consistent viewport or pixel density matters across captures. |
| Capture only a page element | Selector-related options | Use when the desired output is a specific element rather than the page. |
| Capture a defined rectangle | clip |
Use explicit bounds when the capture should be limited to a region. |
| Wait for delayed content | Endpoint wait options | Choose a readiness condition appropriate to the page; a fixed delay can be wasteful or too short. |
| Include lazy-loaded sections | scrollPage: true |
Browserless documents this option to scroll before capture; content that loads only after interaction may still need a different approach. |
Lazy-loaded images and sections may not exist in the page until it is scrolled. Set scrollPage: true when that behavior is relevant, then inspect a sample output before running a large batch. [Screenshot endpoint]
Make batch runs recoverable
- Assign filenames from stable input indices or sanitized identifiers; do not derive filenames by blindly inserting a full URL.
- Keep a manifest mapping each input URL to its output path and status. This makes partial runs resumable and lets you retry only failures.
- Check every response status and record the URL, status code, and error details for non-success responses.
- Use bounded concurrency for large batches. The documentation illustrates parallel work but does not specify a generally safe maximum.
- Set client timeouts appropriate to your pages, and distinguish a client-side timeout from a returned HTTP error.
- For repeat runs, consider whether overwriting files is safe; otherwise include a run identifier or write to a fresh output directory.
Browserless’s concurrent-session page says its example’s total time is roughly the duration of the slowest single request. That is an illustrative explanation of parallel execution, not a guaranteed service-level result; actual completion time depends on the pages and execution conditions. [Concurrent sessions]
Rank #2
- 256 GB SSD of storage.
- Multitasking is easy with 16GB of RAM
- Equipped with a blazing fast Core i5 2.00 GHz processor.
REST screenshots or BrowserQL?
For a straightforward URL list where each result should become an image file, the REST endpoint maps naturally to one URL, one request, and one binary response. Browserless also supports screenshots through BrowserQL, which uses a BQL mutation and returns the screenshot as a base64 field. Use the interface that fits your existing integration and result-handling needs. [REST screenshot endpoint] [BrowserQL screenshots] [REST API overview]
Troubleshooting Browserless screenshot batches
Authentication or endpoint errors
If the endpoint rejects the request, verify that the token is present as the token query parameter and that you are using the regional connection URL associated with your account. Avoid printing the token in logs or committing it to source control. [Connection URLs]
Files contain an error instead of an image
Check the HTTP status before writing response data as an image. A failed request may return an error response rather than a screenshot; save or log its status and diagnostic text separately instead of assigning it a .png extension.
Screenshot is blank or shows a CAPTCHA or access-denied page
This can indicate that the destination site is blocking automated access, rather than a failure to serialize the screenshot. Browserless documents /unblock as a separate route for certain bot-detection cases. Follow the target site’s access rules and do not treat that route as a guarantee of access. [Screenshot endpoint]
Content is missing from a full-page capture
Full-page capture extends the image beyond the viewport, but it does not necessarily cause every lazy-loaded item to load. Try the documented scrollPage: true option and use an appropriate wait behavior for content that appears after loading. [Screenshot endpoint]
Recommended Free Tools
Some URLs fail while others succeed
Keep failures associated with their original URLs and retry only those entries. If a large batch is producing errors, lower concurrency and check the individual response codes rather than rerunning every successful capture.
Rank #3
- WINDOWS 11 | STABLE PERFORMANCE: Powered by Intel Celeron N4020 processor and Windows 11 system, this laptop delivers stable performance for everyday computing tasks. It supports web browsing, online learning, document editing, email communication, and basic office work with optimized power efficiency, providing a practical and reliable experience for essential daily use for daily use.
- 15.6” FHD IPS DISPLAY: Features a 15.6-inch Full HD IPS display with narrow bezels, offering wider viewing angles and clearer image details compared to standard panels. The improved screen-to-body ratio enhances visual experience for study, reading, document work, and video playback, making it suitable for both productivity and entertainment use.
- 4GB DDR4 + 128GB eMMC STORAGE: Equipped with 4GB DDR4 memory and 128GB eMMC storage for everyday basics such as browsing, documents, email, and online learning platforms. The built-in TF card slot supports storage expansion up to 1TB, giving you more flexibility for files, photos, videos, and daily documents. TF card not included.
- CONNECTIVITY & PORTS: Includes 1× TF card slot, 2× USB 3.2 Gen1 ports, and 2× full-featured Type-C ports (USB 3.2 Gen1). The Type-C ports support data transfer, charging, and video output, enabling flexible connection with external devices such as monitors, storage, and peripherals for daily work and study use.
- LIGHTWEIGHT DESIGN | ONLINE COMMUNICATION: Designed with a slim, portable profile, this laptop is easy to carry for school, commuting, and travel. A built-in 1MP front camera supports online classes, video meetings, remote communication, and everyday conferencing. The 3300mAh battery works with the low-power system design to support practical daily use, while thermal optimization helps maintain quieter operation during extended tasks.
Or skip the browser setup
ScreenshotNeo is a website screenshot API and MCP server. One GET request can return a PNG, JPEG, WebP, or PDF. For multiple URLs, repeat the call per URL and save each response separately.
cURL example, using the supplied target URL as a starting point:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for request details. ScreenshotNeo removes cookie banners, newsletter 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 screenshots. Sign up for free and get 1,000 screenshots a month with no card.
Frequently Asked Questions
Does one Browserless screenshot request capture every URL in a list?
No. The REST pattern uses one request per URL; submit separate requests and associate each response with its corresponding input.
Can I choose PNG, JPEG, or WebP?
The current Browserless REST documentation describes all three formats. PNG is the default in its documented example; verify the endpoint’s accepted option values when configuring another format.
Can Browserless screenshot a page without saving it as an image file?
Yes. Browserless also documents BrowserQL screenshots, where the result is returned in a base64 field rather than as the REST endpoint’s binary image response.
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.
