ScreenshotMachine CLI Pricing for Bulk Screenshot Jobs

Short answer: ScreenshotMachine’s documented “CLI” workflow uses curl to call its HTTP screenshot API. Its published pricing is for API subscriptions, not a separately priced CLI product. The reviewed documentation does not establish a batch endpoint, concurrency ceiling, throughput limit, or job-level bulk interface. For bulk jobs, you orchestrate individual API requests from your own script or shell workflow, accounting for monthly fresh-screenshot allowances, cache hits, and overage rules.

Prices and plan details below are from ScreenshotMachine’s official pages reviewed on October 3, 2026. Confirm current terms on the ScreenshotMachine pricing page before budgeting.

1. ScreenshotMachine pricing for bulk jobs

Plan	Monthly price	Included fresh screenshots	Additional screenshot rate
Starter	Free	100	Not listed
Basic	€9/month	2,500	€0.004
Pro	€59/month	20,000	€0.003
Enterprise	€99/month	50,000	€0.002

These are API plans measured in fresh screenshots. The pricing page says only new, fresh screenshots are charged; cached screenshots are not billed and are cached for 14 days. It also says overages are counted at the end of the billing period and billed in groups of 1,000, rounded down. So, under that rule, 999 additional screenshots do not add a charge, while 1,999 are billed as 1,000. EU non-business customers may have VAT added according to their country’s tax rules.

Estimate the bill carefully

Start with expected fresh captures, then subtract the included allowance. Apply the plan’s additional-capture rate to the overage blocks as described by the pricing page. Do not estimate by multiplying every requested URL by the overage rate: some calls may be served from cache and are not billed, and the rounding rule affects the overage count. The reviewed source does not give enough detail to infer how every request pattern maps to a fresh capture, so use your account’s usage records and confirm terms with ScreenshotMachine for a production forecast.

Compare more than the headline rate: allowance, overage rate, 1,000-unit rounding, 14-day cache treatment, and any support or SLA terms that matter to your workload. Verify exact support and SLA terms on the current pricing page.

2. What “CLI pricing” means

The API guide shows Bash using curl -G to send an HTTP GET request, supply capture parameters, and save the response as an image. That is a command-line way to use the API; it does not establish a separately priced CLI package or license. The listed commercial plans are API subscriptions.

The guide documents options such as dimensions, output format, cache age, delay, zoom, and CSS selector clicks. A bulk workflow can call the API repeatedly and save each result, but the reviewed docs do not specify a batch endpoint, concurrency allowance, throughput guarantee, or bulk job management interface. Design your own queue and pacing rather than assuming parallel requests are supported at a particular rate.

3. Run a small curl capture

First validate one URL and your key. This example follows the documented shell pattern; check the official API guide for current parameter names, bounds, and response behavior.

curl -G "https://api.screenshotmachine.com" \
  --data-urlencode "key=YOUR_SCREENSHOTMACHINE_KEY" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "dimension=1024x768" \
  --data-urlencode "format=png" \
  --data-urlencode "cacheLimit=14" \
  --output example.png

The API guide identifies options including dimensions, format, cache age, capture delay, zoom, and clicking a CSS selector. Use the guide’s accepted values and bounds; do not assume the sample values fit every account or capture. Treat the API key as a secret and avoid committing it to source control or printing it in shared logs.

4. Orchestrate a bulk job

Keep the URL list in a file, validate it before sending requests, and record one result per input URL. A simple serial shell loop is a conservative starting point because the reviewed documentation does not state a concurrency ceiling. It gives you an easy place to add retry policy and inspect failures.

#!/usr/bin/env bash
set -u

: "${SCREENSHOTMACHINE_KEY:?Set SCREENSHOTMACHINE_KEY first}"
input="urls.txt"
out="screenshots"
mkdir -p "$out"

index=0
while IFS= read -r url || [[ -n "$url" ]]; do
  [[ -z "$url" ]] && continue
  index=$((index + 1))
  file=$(printf '%s/%05d.png' "$out" "$index")

  if curl --fail --silent --show-error -G "https://api.screenshotmachine.com" \
      --data-urlencode "key=$SCREENSHOTMACHINE_KEY" \
      --data-urlencode "url=$url" \
      --data-urlencode "dimension=1024x768" \
      --data-urlencode "format=png" \
      --output "$file"; then
    printf 'ok\t%s\t%s\n' "$index" "$url" >> "$out/results.tsv"
  else
    rm -f "$file"
    printf 'error\t%s\t%s\n' "$index" "$url" >> "$out/results.tsv"
  fi
done < "$input"

Set the key in the environment before running, for example with your normal secret manager. This loop is intentionally basic: it does not claim an API-specific retry schedule or rate limit. For large lists, use a durable queue, cap concurrency conservatively, back off after transient network or service errors, and preserve a manifest so interrupted jobs can resume without losing which URLs succeeded.

Python example

import csv
import os
import time
from pathlib import Path

import requests

key = os.environ["SCREENSHOTMACHINE_KEY"]
output = Path("screenshots")
output.mkdir(exist_ok=True)

with open("urls.txt", encoding="utf-8") as source, \
     open(output / "results.csv", "w", newline="", encoding="utf-8") as report:
    writer = csv.writer(report)
    writer.writerow(["url", "status", "file"])

    for index, line in enumerate(source, start=1):
        url = line.strip()
        if not url:
            continue
        path = output / f"{index:05d}.png"
        try:
            response = requests.get(
                "https://api.screenshotmachine.com",
                params={
                    "key": key,
                    "url": url,
                    "dimension": "1024x768",
                    "format": "png",
                },
                timeout=(10, 90),
            )
            response.raise_for_status()
            path.write_bytes(response.content)
            writer.writerow([url, "ok", path.name])
        except requests.RequestException as exc:
            writer.writerow([url, f"error: {exc}", ""])
        time.sleep(0.2)  # local pacing only; not an API limit

The timeout and short pause are client-side examples, not ScreenshotMachine service guarantees or published limits. Adjust them to your workload, and do not treat a timeout as proof that the service did not receive or process a request.

Node.js example

import { mkdir, writeFile, appendFile } from 'node:fs/promises';
import { readFile } from 'node:fs/promises';

const key = process.env.SCREENSHOTMACHINE_KEY;
if (!key) throw new Error('Set SCREENSHOTMACHINE_KEY');
const urls = (await readFile('urls.txt', 'utf8')).split(/\r?\n/).filter(Boolean);
await mkdir('screenshots', { recursive: true });

for (let i = 0; i < urls.length; i++) {
  const url = urls[i];
  const query = new URLSearchParams({
    key,
    url,
    dimension: '1024x768',
    format: 'png',
  });
  try {
    const response = await fetch(`https://api.screenshotmachine.com?${query}`, {
      signal: AbortSignal.timeout(90000),
    });
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    const file = `${String(i + 1).padStart(5, '0')}.png`;
    await writeFile(`screenshots/${file}`, Buffer.from(await response.arrayBuffer()));
    await appendFile('screenshots/results.tsv', `ok\t${url}\t${file}\n`);
  } catch (error) {
    await appendFile('screenshots/results.tsv', `error\t${url}\t${error.message}\n`);
  }
}

This uses Node’s built-in fetch and an abort timeout. As with the other examples, it runs sequentially and does not imply a provider concurrency or throughput policy.

5. Bulk-job design checklist

• Estimate volume: count expected new captures per billing month, then compare each plan’s allowance and overage rate.
• Account for cache: the pricing page states cached screenshots are held for 14 days and are not billed. Repeated captures within that window may affect fresh usage; verify behavior for your exact parameters and URL changes.
• Persist a manifest: track source URL, output path, attempt count, completion status, and error so a stopped job can resume.
• Validate inputs: reject empty or malformed URLs, assign stable filenames, and consider duplicate URLs explicitly.
• Control request volume: the reviewed docs do not publish a bulk endpoint or concurrency ceiling. Begin conservatively and contact the provider if you need a confirmed operating limit.
• Separate failure classes: network errors, HTTP errors, and a valid response that cannot be opened as an image need different handling.
• Protect credentials: keep keys in environment-based secret storage, restrict access to job logs, and rotate credentials if exposed.
• Reconcile usage: compare the job manifest with account usage and the billing period’s fresh/overage accounting.

6. Troubleshooting

Symptom	Likely cause	What to do
Authentication or key error	Missing, invalid, or incorrectly encoded key.	Check the account key, ensure the query parameter is named as in the current API guide, and URL encode values. Keep the key out of logs.
Request fails for one URL	The target URL may be malformed or inaccessible to the capture service, or a capture parameter may be invalid.	Try the URL in a single request, verify the URL and documented parameter bounds, and inspect the returned status/body before retrying.
Output is not a usable image	An error response may have been saved with an image extension, or the capture may not match the desired viewport or format.	Use HTTP failure handling, inspect response headers/body on errors, and verify format and dimensions against the official guide.
Repeated URLs consume more than expected	A request may produce a fresh capture rather than a cache hit; cache treatment depends on the service’s rules and capture inputs.	Review the 14-day cache terms, avoid changing capture parameters unnecessarily, and reconcile actual usage with the provider.
Job stalls or stops partway	Transient network failure, client timeout, process termination, or an unhandled response.	Write results incrementally, preserve completed files and a manifest, and resume only failed entries with bounded retries and backoff.
Unexpected invoice amount	Fresh captures exceeded allowance, overage blocks were applied, or VAT applies to the account.	Compare fresh usage with the plan allowance, apply the 1,000-screenshot rounding-down rule, and check account tax status and current terms.

7. Performance, reliability, and cost

Performance: capture duration depends on target pages and request settings; the reviewed sources provide no benchmark or throughput limit. Serial execution is simple and predictable but may take longer on a large list. If you add parallelism, increase it cautiously and ask ScreenshotMachine for supported limits instead of assuming a particular safe rate.

Reliability: bulk work should be restartable. Save each successful output atomically where practical, record errors as they happen, use bounded retries with exponential backoff for transient failures, and avoid retrying permanent input or authentication errors unchanged. A client timeout does not necessarily prove that the remote operation was not processed, so account for possible repeat requests when reconciling usage.

Cost: plan around fresh screenshots, not raw URL count. Starter provides 100 per month; Basic, Pro, and Enterprise provide 2,500, 20,000, and 50,000. Additional fresh captures are listed at €0.004, €0.003, and €0.002 respectively, with the stated 1,000-unit rounding-down rule. Cached captures are described as unbilled for 14 days. VAT may apply to EU non-business customers. Confirm the current pricing and cache conditions before committing to a high-volume workflow.

8. Or skip the browser setup

For a managed screenshot API, ScreenshotNeo is an alternative to try first: it removes cookie banners, popups, and chat widgets before the shot, and only clean shots are billed. Bot checks, blank pages, and failed loads are never billed, and response headers say the page verdict and billing status. It offers an MCP server so AI agents can take screenshots. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000. Every feature is on every plan.

Example API call (replace the URL and key):

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

See the ScreenshotNeo API documentation for request options. To try it, sign up for 1,000 free screenshots a month with no card.

9. FAQ

Is there a ScreenshotMachine CLI subscription?

The reviewed official documentation shows curl calling the HTTP API, and the pricing page lists API plans. It does not document a separately priced CLI subscription.

Can I submit a whole list of URLs in one batch request?

The reviewed documentation does not establish a batch endpoint. The examples above orchestrate individual requests from a local script.

Which plan fits a particular monthly volume?

Compare your expected fresh captures with the included allowance, then account for cache behavior, overage rounding, and any applicable VAT. For operational or support requirements, confirm current terms with ScreenshotMachine.