How to Generate Website Thumbnails in Bulk with Screenshot.rocks

Short answer: Screenshot.rocks’ documented online website-capture flow handles one URL at a time. Its public instructions do not describe uploading a URL list, a batch endpoint, or bulk export. For a few sites, repeat the capture and export steps while keeping the settings consistent. For a long list, use browser automation or a separately verified screenshot service with explicit batch support. That service would be separate from Screenshot.rocks.

This guide explains the manual workflow, gives you a runnable Python batch capture for public pages, covers the limits to check before processing a large list, and shows a ScreenshotNeo option if you want an API instead of managing a browser.

1. What Screenshot.rocks can do for a batch

The Screenshot.rocks website-capture instructions describe entering one address, choosing desktop or mobile, pressing Capture, adjusting the browser frame and background, and exporting. Online capture is a first-screen view. The reviewed public instructions do not document a URL-list upload, batch endpoint, or bulk export, so plan to process each URL separately in the editor.

This describes the public workflow reviewed for this guide; it does not prove that no private or newly released capability exists. If native bulk capture is essential, confirm the current options with Screenshot.rocks.

For a small set of sites, the editor can export PNG, JPEG, WebP, or SVG and supports canvas sides up to 2300 pixels. The exported canvas size, format, frame, and background are useful controls for keeping a set visually consistent. See the Screenshot.rocks mockup editor and export guide.

2. Prepare the URL list and output style

Put one URL per line in a text file. Include https:// where possible, remove duplicates, and check that every address points to the intended page.
Decide whether each page needs desktop, mobile, or both. Screenshot.rocks’ online mobile capture uses a 375 × 812 point viewport at 3× density, producing 1125 × 2436 pixels. Its desktop capture uses 1440 × 800 CSS pixels at 2× density, producing 2880 × 1600 pixels. These are first-screen captures.
Choose the common frame, background, canvas dimensions, and export format before you begin. PNG preserves sharp interface text; JPEG does not support transparency; WebP is suited to websites; SVG contains the finished image and does not become sharper when scaled. Keep the canvas dimensions within the editor’s documented 2300-pixel side limit.
Choose a filename convention, such as a normalized hostname plus a page label. Avoid using the full URL as a filename: paths can be long or contain characters that are awkward across operating systems.

For consistent manually styled exports, capture each address in Screenshot.rocks, then apply the same frame, background, canvas ratio, dimensions, and file format to each. The editor’s output canvas is the size you set. For example, a 1600 × 900 canvas exports at 1600 × 900 pixels.

3. Capture a small set manually in Screenshot.rocks

Open the website screenshot tool.
Enter one address. Select Mobile if you need the mobile layout; otherwise the tool captures the desktop layout.
Press Capture. The website is rendered on Screenshot.rocks’ server as a first-time visitor, and the first screen opens in the editor.
Set the frame, background, canvas dimensions, and export format you chose for the set.
Export the image, name it according to your convention, and repeat for each URL.
Review the files together at their intended display size. Check for inconsistent framing, blank pages, consent overlays, failed loads, and accidental differences in dimensions.

This path is appropriate for a handful of public pages when you want to use Screenshot.rocks’ editor to frame and style the result. It requires a separate capture and export for every address.

4. Automate a larger list with Python and Playwright

The following is a separate do-it-yourself browser automation workflow, not a Screenshot.rocks bulk feature. It opens each URL in Chromium and saves a first-viewport PNG. It is intended for public pages that your machine can reach; it does not add Screenshot.rocks’ mockup frame or background.

Install and prepare

python -m pip install playwright
python -m playwright install chromium

Create urls.txt with one full URL per line, for example:

https://example.com/
https://www.python.org/
https://developer.mozilla.org/

Save this as `capture_batch.py`

import asyncio
import re
from pathlib import Path
from urllib.parse import urlparse

from playwright.async_api import async_playwright

URL_FILE = Path("urls.txt")
OUTPUT_DIR = Path("thumbnails")
VIEWPORT = {"width": 1440, "height": 900}
DEVICE_SCALE_FACTOR = 1
NAVIGATION_TIMEOUT_MS = 45_000
RETRIES = 2


def load_urls(path: Path) -> list[str]:
    urls = []
    for line in path.read_text(encoding="utf-8").splitlines():
        value = line.strip()
        if not value or value.startswith("#"):
            continue
        if not value.startswith(("https://", "http://")):
            value = "https://" + value
        parsed = urlparse(value)
        if not parsed.netloc:
            print(f"SKIP invalid URL: {value}")
            continue
        urls.append(value)
    # Preserve input order while removing duplicates.
    return list(dict.fromkeys(urls))


def filename_for(url: str, index: int) -> str:
    parsed = urlparse(url)
    label = parsed.netloc + parsed.path
    label = re.sub(r"[^A-Za-z0-9._-]+", "-", label).strip("-._")
    label = (label or "page")[:100]
    return f"{index:04d}-{label}.png"


async def capture_one(page, url: str, destination: Path) -> None:
    last_error = None
    for attempt in range(RETRIES + 1):
        try:
            response = await page.goto(
                url,
                wait_until="domcontentloaded",
                timeout=NAVIGATION_TIMEOUT_MS,
            )
            # Give client-side layouts a short, fixed settling interval.
            await page.wait_for_timeout(1200)
            await page.screenshot(path=str(destination), full_page=False)
            status = response.status if response else "no main response"
            print(f"OK   {status}  {url}  -> {destination}")
            return
        except Exception as exc:
            last_error = exc
            if attempt < RETRIES:
                await page.wait_for_timeout(1000 * (attempt + 1))
    print(f"FAIL {url}: {last_error}")


async def main() -> None:
    if not URL_FILE.exists():
        raise SystemExit("Create urls.txt with one URL per line first.")
    urls = load_urls(URL_FILE)
    if not urls:
        raise SystemExit("No valid URLs found in urls.txt.")

    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
    async with async_playwright() as playwright:
        browser = await playwright.chromium.launch(headless=True)
        context = await browser.new_context(
            viewport=VIEWPORT,
            device_scale_factor=DEVICE_SCALE_FACTOR,
            color_scheme="light",
        )
        page = await context.new_page()
        for index, url in enumerate(urls, start=1):
            await capture_one(page, url, OUTPUT_DIR / filename_for(url, index))
        await browser.close()


if __name__ == "__main__":
    asyncio.run(main())

Run it with:

python capture_batch.py

Images are written to thumbnails/. The script uses a single browser page and handles URLs one after another, which limits simultaneous load on your machine and target sites. It retries navigation and reports failures in the terminal. It does not validate whether the screenshot is visually useful, detect CAPTCHA pages, or retry based on HTTP status; inspect failures and outputs before treating the batch as complete.

Change the capture behavior

Viewport: edit VIEWPORT to set the CSS width and height. To make mobile screenshots, use a phone-sized viewport and consider a device scale factor of 2 or 3; check how the target site responds after changing the viewport.
Full page: change full_page=False to full_page=True to ask Playwright for a scrolling-page capture. Very tall pages can create large files or hit browser limits; capture sections when needed.
Wait behavior: the example waits for domcontentloaded and then a fixed 1.2 seconds. Increase the delay for slow client-rendered pages, or replace it with a site-specific locator wait when a reliable element indicates the page is ready. A fixed delay cannot guarantee that every animation or image has finished.
Theme: set color_scheme to "dark" if you need dark mode. For a mixed batch, decide whether to create one or two output sets.
Parallelism: the example is sequential. For a large list, add bounded concurrency only after checking the target sites’ policies and your machine’s memory and network capacity. Avoid launching an unbounded browser per URL.
Authenticated or private pages: do not put passwords or session tokens in a public URL list. Browser automation can be configured with an authenticated context, but this sample intentionally does not handle credentials. Keep secrets out of source control and output logs.

5. Choose a bulk workflow for a long list

For hundreds or thousands of URLs, compare the workflow against the requirements before starting. A separate screenshot API may offer a multi-URL endpoint, but a batch endpoint alone does not establish its practical limits, reliability, price, retention, or privacy. Verify each item with the provider.

Question	Why it matters
How many URLs fit in one request, and what are the rate and concurrency limits?	Determines batch size, run time, and whether work must be throttled.
Does it capture the first viewport or the full page?	These produce different thumbnail content and file sizes.
Can you set desktop and mobile viewports and pixel density?	Needed for repeatable images across responsive layouts.
Can it reach login-protected, localhost, or private staging pages?	Hosted renderers generally cannot use your browser session or reach your local network without a supported mechanism.
How are failures reported and retried?	You need to distinguish a valid page from a timeout, block page, or empty render.
How are results named, delivered, and stored?	Batch outputs need a stable mapping back to input URLs and a defined retention period.
What are the billing rules and privacy terms?	Check whether failed pages, retries, and cache hits count, and how submitted URLs and images are handled.

The reviewed material describes another, separate screenshot API with a POST batch endpoint. That is not a Screenshot.rocks capability. The available research does not establish that API’s commercial limits, price, retention, or suitability, so verify those details before relying on it.

6. Troubleshooting and edge cases

Symptom	Likely cause	What to try
Screenshot.rocks capture fails	The address may be mistyped, the site may be slow, or it may block automated browsers.	Check the URL and retry. For a page you can open locally, capture it in your own browser and import the image into the editor.
Login page appears instead of the target content	Screenshot.rocks’ online renderer visits as a first-time visitor and cannot see your logged-in session.	Use the Screenshot.rocks browser extension for the visible current tab, or take a screenshot in your browser and bring it into the editor.
Localhost or private staging address is unreachable	The hosted capture server cannot reach your machine’s local address or private environment.	Capture from a browser that can access the page, then edit the resulting image locally in the editor.
Only the top of the page appears	Screenshot.rocks URL capture is first-screen capture.	Use browser-native full-page capture or a browser automation method that supports full-page screenshots, noting that very long pages can exceed browser limits.
Images or content are missing in an automated capture	Lazy loading, delayed JavaScript, network dependencies, or bot protection may prevent content from appearing.	Wait for a meaningful page element, scroll to trigger lazy-loaded assets where appropriate, and check the page manually. Avoid assuming that a successful PNG means the page rendered correctly.
Some output files are absent from the Python run	Navigation timed out or browser rendering raised an error after the configured retries.	Read the printed FAIL lines, check each URL in a normal browser, increase the timeout for known slow pages, and rerun only failures.
Names collide or are hard to map back	Different URLs can normalize to the same filename or share a host and path.	Keep the numeric index prefix, add a stable input ID, or save a manifest mapping each original URL to its output file.
Thumbnails look inconsistent	Viewport, theme, load timing, cookie state, or page content differs.	Fix a common viewport and theme, use a repeatable readiness condition, and record capture time if pages change frequently.

Screenshot.rocks’ privacy description distinguishes the editor from server capture: images edited in the browser are processed there, while entering a website URL sends that URL to the server for rendering. Its product page says the screenshot is not stored on the server. Do not generalize the local-editing statement to the server-rendered URL path. See the privacy details in the editor documentation.

7. Performance, reliability, and cost

Manual capture: the limiting factor is the repeated human capture, styling, export, and file naming for every URL. It works well for a small set where the editor’s framing matters.
Local browser automation: runtime depends on page load time, delays, viewport, image loading, and retries. The sample keeps one page open and processes sequentially, making resource use easier to control at the cost of throughput.
Reliability: websites can change, throttle requests, require interaction, or serve different content to automated browsers. Maintain a failed-URL list and visually review representative outputs and exceptions.
Cost: browser automation uses your own compute and network; a hosted API may charge by plan or successful capture. Read the provider’s billing definition, including how it treats failures, retries, and cache hits, before sending a large batch.
Privacy: a URL can reveal internal project names or identifiers. Do not send private URLs to a hosted service until you have checked its data handling terms. Local automation keeps the render in your environment, though the pages themselves still make network requests from your machine.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. One GET request captures a URL as an image or PDF; its bulk capture supports up to 100 URLs per call. Cookie banners, popups, and chat widgets are removed before the shot, and those cleanup steps can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed; responses include X-Page-Verdict and X-Billed headers. Its MCP server lets AI agents use the take_screenshot, get_page_info, and capture_pdf tools. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Every feature is available on every plan. See the ScreenshotNeo API documentation.

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,
)
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}`);

These snippets show a single URL request. For a batch, use ScreenshotNeo’s documented bulk capture flow; don’t assume the single-shot endpoint accepts a URL list. To get started, sign up for 1,000 free screenshots a month with no card.

Frequently asked questions

Can Screenshot.rocks capture multiple URLs at once?

The public workflow reviewed here documents one URL at a time, with no URL-list upload or batch endpoint. Check with Screenshot.rocks for any newer or private option.

Does Screenshot.rocks make full-page website thumbnails?

Its online URL capture shows the first screen. For a full page, use a browser-native capture method or a separate automation workflow.

No. It renders as a first-time visitor. Its browser extension can capture the visible current tab, including a logged-in page, because it runs in your browser.

Can I use the Screenshot.rocks browser extension for batch capture?

The documented extension captures the visible part of the current tab. The public instructions do not describe a multi-tab or URL-list batch mode.