ScreenshotMachine CLI Alternatives for Agencies Capturing Client Websites

Screenshot Machine’s documented integration is a hosted HTTP API, with an official Node.js example—not a dedicated first-party CLI. Agencies can use it through HTTP requests, or choose a hosted CLI/API or a self-managed browser tool such as Playwright, capture-website-cli, or shot-scraper. The right fit depends on whether you want the provider or your team to operate the browser, which capture controls you need, and how jobs fit into your batch and review process.

ScreenshotNeo is the first alternative to consider when you want hosted capture without managing a browser: cookie banners, popups, and chat widgets are removed before the shot, and only clean shots are billed.

What Screenshot Machine provides

Screenshot Machine’s API accepts a URL and customer key in an HTTP GET request. Its documented controls include width and height, full-page output, device type, output format, and cache age. The documentation lists width values from 100 to 1920 pixels and height values from 100 to 9999 pixels; it also accepts full for a full-length page and identifies desktop, phone, and tablet modes. Check the current API documentation for exact parameter names, allowed values, authentication details, and plan limits before integrating.

The vendor advises allowing more delay for long pages that may load images or animations, giving delay=2000 or more as an example. That is a starting point, not a guarantee that every page has finished rendering. Source: Screenshot Machine API documentation.

Its official Node.js sample writes the returned output to a local file. The documented integration is an API request and sample code; do not assume a separate official CLI exists. Source: Screenshot Machine’s Node.js example.

Alternatives at a glance

Option	Operating model	Documented strengths	Agency considerations
ScreenshotNeo	Hosted screenshot API and MCP server	One-call capture; full-page and element captures; browser settings and cleanup controls; only clean shots billed	Check the options and limits that match your client workflow in the API docs. The MCP server supports AI-agent workflows.
Screenshot Machine	Hosted API	Dimensions, full-page capture, device selection, formats, cache age, code samples	Evaluate current limits, costs, authentication, and bulk workflow needs.
Screenshot Scout	Hosted service with CLI	`capture` requests, locally composed capture URLs, options files, output redirection, environment-based credentials	Generated URLs include an access key; treat them as sensitive and account for quota use.
ScreenshotAPI.net	Hosted API	The provider advertises bulk processing, scheduling, PDF/video/data extraction, and customer-cloud storage	These are provider claims. Verify current availability, limits, destinations, and security fit.
Playwright CLI	Self-managed browser workflow	Viewport, element, full-page, PNG/JPEG/WebP, custom filenames, device-pixel screenshots	Your team provisions the browser and owns CI resources, browser versions, state, and job orchestration.
capture-website-cli	Self-managed Node.js/Puppeteer CLI	URL, local file, or stdin; output, viewport/device options, waits, selectors, cookies, headers, PDF; shell-loop example	The documented URL-list workflow is a serial shell loop, not a managed bulk service.
shot-scraper	Self-managed Python CLI around Playwright	Screenshots, video demos, JavaScript scraping, documented GitHub Actions usage	Confirm browser installation and account for maintaining the pipeline.

Provider feature pages describe what vendors say their products do; they are not independent performance or fidelity benchmarks. Compare current documentation and run your own representative captures before committing to a workflow.

Choose by operating model and workflow

Choose a hosted API or CLI when

You prefer not to install and maintain browser binaries and runtime dependencies in agency infrastructure.
You need an HTTP integration or a provider-operated capture service that can fit into existing scripts.
You need scheduling or bulk features: verify the exact batch size, retry behavior, output handling, and plan limits rather than relying on a feature headline.
Your team has a clear policy for client URLs, authentication credentials, generated links, storage, and retention.

Choose a self-managed CLI when

Captures belong in an existing browser automation or CI environment.
You need to control browser setup, session state, headers, cookies, waits, or local inputs.
Your team can maintain browser installation, version consistency, job retries, storage, and runtime capacity.

Playwright CLI documents viewport, element, and full-page screenshots. Its documentation distinguishes screenshots for visual inspection from accessibility snapshots for understanding page structure and reading text. A screenshot is a rendered image; it is not a substitute for a structured accessibility snapshot. See Playwright’s screenshot and PDF documentation.

For capture-website-cli, see the project documentation. For shot-scraper, see its stable documentation, which describes CLI installation and browser installation as separate setup steps. For Screenshot Scout, see its CLI documentation. ScreenshotAPI.net’s bulk and scheduling statements are on its provider page; confirm the current product and plan details directly.

Set up a repeatable agency capture workflow

Define the capture matrix. Record each client URL, viewport or device mode, full-page or element scope, image format, authentication needs, and expected output name.
Choose a wait strategy. Account for client pages with lazy images, animations, consent banners, or delayed content. A fixed delay may help but does not prove that all page content is ready.
Keep captures comparable. Use the same viewport, device mode, wait strategy, format, and naming rules for screenshots reviewed side by side.
Handle secrets deliberately. Store API keys and session credentials in your secret manager or environment, not in source control, logs, or publicly shared URLs. Screenshot Scout specifically notes credentials from environment variables; generated URLs contain the key and should be treated as sensitive.
Plan batch behavior. Decide how the workflow records success and failure, retries transient errors, avoids accidental duplicate work, and stores output. Check whether the chosen service supports the batch size and scheduling you actually need.
Test representative pages. Include long pages, lazy-loaded images, animations, responsive breakpoints, cookie banners, and authenticated pages. This is a recommended validation checklist, not a claim that any listed provider was independently tested.

Runnable examples

The examples below show the different integration shapes. Screenshot Machine and the hosted alternatives take a URL through a service; the local tools run under your own browser environment. Check each provider’s current documentation for required keys, parameter syntax, installation, and output behavior before using these snippets in production.

Screenshot Machine: cURL

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

This illustrates a GET request and local output. Confirm the current endpoint, parameter names, format, and credentials in Screenshot Machine’s API documentation before running it; the documentation is the authority for its supported values.

Screenshot Machine: Python

import os
import requests

params = {
    "key": os.environ["SCREENSHOTMACHINE_KEY"],
    "url": "https://example.com",
    "dimension": "1024x768",
}
response = requests.get(
    "https://api.screenshotmachine.com",
    params=params,
    timeout=90,
)
response.raise_for_status()
with open("screenshot.png", "wb") as image_file:
    image_file.write(response.content)

Screenshot Machine: Node.js

const params = new URLSearchParams({
  key: process.env.SCREENSHOTMACHINE_KEY,
  url: 'https://example.com',
  dimension: '1024x768',
});

const response = await fetch(`https://api.screenshotmachine.com/?${params}`);
if (!response.ok) {
  throw new Error(`Screenshot request failed: ${response.status}`);
}
const image = Buffer.from(await response.arrayBuffer());
await import('node:fs/promises').then(({ writeFile }) =>
  writeFile('screenshot.png', image)
);

Screenshot Machine’s official Node.js repository contains its own integration example: screenshotmachine-nodejs. Treat the snippets here as request-shape examples and verify exact API parameters against the live documentation.

Playwright CLI

Install the Playwright CLI and browser according to the current official documentation. A typical documented screenshot command takes a URL and output path; consult the CLI reference for exact flags available in your installed version. The following illustrates the capture modes to configure, not a replacement for the version-specific command reference:

# Capture a page at a chosen viewport, or use the CLI's full-page option.
playwright screenshot --viewport-size="1280,900" https://example.com page.png

For an agency pipeline, pin the CLI/browser version in the environment and use the documented element or full-page controls where needed. Avoid copying flags across versions without checking the official reference.

capture-website-cli

Install and use the options documented by capture-website-cli. Its documentation covers URL or local-file input, output control, viewport/device options, waits, selectors, cookies, headers, and PDF output. For a small URL list, the documented shell-loop approach is straightforward:

while IFS= read -r url; do
  [ -z "$url" ] && continue
  capture-website "$url" --output="captures/$(date +%s).png"
done < urls.txt

Use stable, collision-resistant filenames in a real pipeline; the timestamp illustration above is not a naming scheme for parallel jobs.

shot-scraper

Install the CLI and its browser as described in the shot-scraper documentation. Its documented quick start treats those as separate setup steps. Then use the installed command’s documented screenshot options for your target URL, viewport, and output. Review its GitHub Actions guidance if captures belong in CI. Keep the installed CLI and browser setup reproducible in the agency pipeline.

Screenshot Scout CLI

Follow the current Screenshot Scout CLI documentation for its capture and capture-url commands, options file, and output redirection. Load credentials from environment variables as its docs describe. Treat generated capture URLs as secrets because they include an access key and may consume quota.

Or skip the browser setup

ScreenshotNeo provides a hosted screenshot API and an MCP server for AI agents. One GET request can return PNG, JPEG, WebP, or PDF output. Its browser accepts cookie and consent banners like a visitor and removes 60+ known consent platforms, newsletter popups, and chat widgets before capture; each cleanup step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and responses identify the page verdict and billing status in headers. AI agents can use its MCP tools: take_screenshot, get_page_info, and capture_pdf.

For example, save a WebP capture with cURL:

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

Or use 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)

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

See the ScreenshotNeo API documentation for the available capture options. It supports full-page capture with lazy images loaded, CSS element capture, device presets and custom viewports, dark mode, retina scale, PDFs, HTML/CSS rendering, custom CSS and JavaScript, click and hide selectors, selector/delay/network-idle waits, request blocking, custom headers/cookies/user agent/authorization, timezone and geolocation, transparent backgrounds, resizing, chosen cache TTL, signed public image links, async jobs with signed webhooks, bulk capture of 100 URLs per call, a usage API, and an OpenAPI spec. Parameter names used by other screenshot APIs also work to simplify switching.

There are 1,000 screenshots per month free with no card. Paid plans start at $5 for 3,000 screenshots; higher listed plans are Growth at $15 for 15,000, Pro at $39 for 60,000, Scale at $99 for 250,000, and Business at $249 for 1,000,000. Yearly billing gives two months free, and every feature is on every plan. Start with 1,000 free screenshots a month, no card required.

Performance, reliability, and cost

Performance

Capture time depends on the target page, browser work, wait condition, and output. The reviewed source material does not establish comparative timing or performance guarantees. Screenshot Machine recommends increasing delay for some long pages; validate waits on the pages your clients actually use. For self-managed tools, include browser startup, page load, and file handling in the time and CI capacity your workflow needs.

Reliability

Make each capture job observable: retain the requested URL and configuration, output location, completion state, and error details without logging secrets. Decide which failures are safe to retry and cap retries so an inaccessible page does not tie up a batch indefinitely. For self-managed browsers, keep browser versions and dependencies consistent across local and CI runs. For hosted providers, confirm their documented error behavior, limits, and service terms; no availability guarantee is established by the sources in this guide.

Cost

Estimate volume as client URLs multiplied by viewport or device variants and capture frequency. Include retries and test captures in the estimate, and compare that volume with current plan limits and billing rules. Hosted services trade infrastructure work for provider pricing and service constraints; self-managed tools avoid a hosted capture charge but still use staff time and compute resources. Confirm current vendor pricing before purchase: the research sources do not provide a verified, comparable price table.

Troubleshooting common capture problems

Symptom	Likely cause	What to do
Blank or incomplete page	The page is still rendering, a request failed, or the target returned a bot check/CAPTCHA.	Check the page in a browser, inspect the provider’s response and headers, and adjust the documented wait behavior. Do not assume a longer delay resolves a bot challenge.
Missing images lower on a long page	Images load lazily as the page is scrolled or rendered.	Use a documented full-page mode and a suitable wait strategy. Screenshot Machine advises more delay for some long pages; verify the result visually.
Capture differs between runs	Viewport, device scale, wait timing, animation, content, or browser version changed.	Fix the viewport, device mode, format, and wait strategy; stabilize the self-managed browser version and consider page-specific CSS or JavaScript controls where supported.
Wrong responsive layout	Viewport or device mode does not match the review target.	Specify the same viewport/device preset on every run and record it alongside the output.
Authentication page appears	Session cookies, headers, or authorization were not supplied or expired.	Use the chosen tool’s documented credential/session mechanism, check expiry, and keep secrets out of logs and shared links.
Request rejected or unauthorized	Missing, invalid, expired, or incorrectly encoded credentials; unsupported parameters may also be rejected.	Check the current API/CLI documentation, key scope and encoding, and whether parameter names and values are valid.
CLI command or browser executable not found	The package or browser is absent from the environment or PATH.	Install the CLI and its browser using that tool’s official setup instructions, then verify the CI image and local environment match.
Batch has duplicate or missing files	Parallel jobs reused filenames, shell input was malformed, or failures were not recorded.	Use deterministic unique names, validate each input line, and record per-URL completion and errors.

Frequently asked questions

Does Screenshot Machine have an official CLI?

The reviewed official material documents an HTTP API and a Node.js example. It does not establish a dedicated first-party CLI.

Which alternative fits an agency already using CI?

Playwright CLI, capture-website-cli, and shot-scraper are self-managed options that can be incorporated into a team-run environment. Choose based on your existing language/runtime and the capture controls you need.

Which option has documented scheduled or bulk capture?

ScreenshotAPI.net advertises bulk processing and scheduling on its provider page. Verify current limits and behavior with the provider before designing around them.

Can a screenshot tell me the page’s accessible structure?

No. A screenshot represents visual rendering. Playwright’s documentation describes accessibility snapshots separately for understanding structure and text.