ScreenshotMachine CLI Alternatives for Full-Page Website Screenshots

Direct answer: Screenshot Machine documents a hosted screenshot API that you can call from a terminal with curl; its reviewed official documentation does not describe a standalone Screenshot Machine CLI executable. For local full-page screenshots, the most relevant command-line alternatives are Playwright CLI, capture-website-cli, and shot-scraper. Playwright and Puppeteer APIs are better fits when a script needs browser control or post-processing.

Choose based on whether you want a hosted browser or your own local browser, how much setup and browser maintenance you can take on, and your required automation. The cited documentation does not establish a speed, image-quality, or reliability winner. Validate any choice against the pages you actually capture.

What Screenshot Machine provides from the command line

The Screenshot Machine API accepts HTTP GET parameters, and its official API guide includes a Bash curl example. That makes it usable from a terminal or shell script, but a documented HTTP request is not evidence of a dedicated vendor CLI binary. Its full-length capture uses a dimension value with a width and full height, such as 1024xfull. For long pages with images or animations, its guide recommends a larger delay; the documented values range from 0 to 10,000 milliseconds in specified increments. See the Screenshot Machine API documentation for current parameters and syntax.

curl --get 'https://api.screenshotmachine.com' \
  --data-urlencode 'key=YOUR_API_KEY' \
  --data-urlencode 'url=https://example.com' \
  --data-urlencode 'dimension=1024xfull' \
  --data-urlencode 'delay=2000' \
  --output screenshot.png

Use the endpoint and parameter names from the vendor’s current documentation for your account. The sample shows the documented command-line API pattern and full-height setting; it does not imply that Screenshot Machine publishes a separate CLI package.

Alternatives at a glance

Tool	Execution model	Documented full-page path	Consider it when
ScreenshotNeo	Hosted screenshot API and MCP server	One GET request; full-page capture is an available option	You want a hosted capture without maintaining a browser, clean shots, and billing status in response headers.
Playwright CLI	Local browser via CLI	`screenshot --full-page`	You want a direct terminal command that can fit into an existing Playwright workflow.
`capture-website-cli`	Local browser via CLI utility	`--full-page`	You need a command-line utility for one-off or scripted captures.
`shot-scraper`	Local browser via CLI, built on Playwright	Automated screenshot CLI workflow	You want a CLI built on Playwright and are comfortable with its setup.
Playwright API	Local browser controlled by code	`page.screenshot({ path, fullPage: true })`	You need navigation, waits, page interaction, or image processing in a program.
Puppeteer	Local browser controlled by code	`Page.screenshot()` supports `fullPage`	Your application already uses Puppeteer or needs its browser automation APIs.

Feature descriptions come from each project’s documentation: Playwright screenshots, Playwright CLI, Puppeteer screenshot API, capture-website-cli, and shot-scraper. Confirm current installation steps and options in those docs before adopting a tool.

Local full-page capture with Playwright CLI

Playwright’s screenshot command accepts --full-page to capture the full scrollable page. Install Playwright and its browser as documented for your environment, then run:

npx playwright install chromium
npx playwright screenshot --full-page --viewport-size="1365,768" \
  https://example.com full-page.png

Use the output filename you need, such as full-page.jpg, when the installed version supports that output format. For a repeatable capture, pin the Playwright version in your project and install the matching browser during environment setup. The browser binary and its system dependencies are part of the local runtime.

Other CLI options

capture-website-cli

The project documents a --full-page option. Install it using the current package instructions, then use the CLI’s help output to confirm its URL and output arguments for the installed release. A typical invocation pattern is:

npx capture-website-cli --help
npx capture-website-cli https://example.com --full-page

Because CLI argument details can change by version, treat --help as authoritative for the package version you install and specify an output path using that version’s documented option.

shot-scraper

shot-scraper is documented as a command-line utility for automated website screenshots built on Playwright. Follow its versioned installation and command documentation, then use the documented full-page capture option for the installed version:

shot-scraper --help

Its Playwright foundation means local browser installation and runtime compatibility matter. It can suit shell automation while retaining the broader ecosystem of Playwright-based capture.

Use an API when the capture is part of a program

Playwright’s API sets fullPage: true. The following Node.js example creates a browser, navigates to a page, captures the full scrollable page, and closes the browser even if capture fails. Install the package and Chromium using Playwright’s documented setup for your project.

import { chromium } from 'playwright';

const browser = await chromium.launch();
try {
  const page = await browser.newPage({ viewport: { width: 1365, height: 768 } });
  await page.goto('https://example.com', { waitUntil: 'networkidle', timeout: 60000 });
  await page.screenshot({ path: 'full-page.png', fullPage: true });
} finally {
  await browser.close();
}

For pages that keep network connections open, networkidle may never be the right readiness signal. Wait for a known content selector or use a bounded delay after navigation instead. Playwright can return screenshot bytes for further processing by omitting the path option and storing the returned buffer.

Puppeteer offers a similar API-based approach. Its screenshot API documents the fullPage option and element screenshots. Confirm the required browser/runtime setup for your environment in the Puppeteer API reference.

How to choose

Question	Prefer a local CLI or browser API	Prefer a hosted API
Where should the browser run?	When you need the capture environment under your control or inside an existing job.	When you want to make an HTTP request instead of managing browser processes.
How much interaction is needed?	When the workflow needs custom code, page interaction, or image processing.	When the provider’s documented capture options cover the workflow.
What does setup cost?	Account for browser installation, runtime dependencies, upgrades, and operational ownership.	Account for service pricing, quotas, and the provider’s current terms.
How will you know what happened?	Design your own logging, retries, and failure classification.	Check the service’s response and status metadata, plus its documented failure behavior.

For dynamic, very long, authenticated, or interaction-heavy pages, verify actual behavior on representative URLs. The cited feature documentation does not establish that any option succeeds on every site. It also does not support a comparative performance benchmark.

Full-page capture edge cases

Lazy-loaded content: Some pages load images or sections only as the viewport approaches them. A full-page flag alone may not trigger every site’s lazy-loading behavior. Check whether images and lower sections appear; use the tool’s documented scrolling or wait controls where available.
Long or animated pages: Content may still be moving when capture starts. Screenshot Machine recommends a larger delay for long pages with images or animations. For local tools, wait for a meaningful selector or a bounded settling delay.
Sticky headers and footers: Full-page stitching can show repeated sticky elements or unusual positioning. Inspect the output at different scroll positions and consider hiding a selector when the tool supports it.
Single-page applications: Navigation can finish before client-rendered content is ready. Wait for the actual page content, not only the initial document response.
Authentication: A local browser can be configured with a session or authentication flow. For a hosted API, confirm the documented support for cookies or authorization headers before sending credentials.
Very tall output: Huge pages consume more memory and produce larger files. Capture only the needed page or element when possible, or resize after capture if the tool supports it.
Bot checks and consent dialogs: These can replace or obscure the target page. Determine whether the selected tool can handle the site state safely and whether the resulting image is useful.

Performance, reliability, and cost

For local capture, the main operational costs are browser setup, browser and package updates, compute and memory for tall pages, and the engineering time to manage retries and failures. Reusing a browser process in a controlled worker can avoid repeated startup overhead, but isolate jobs and close pages reliably. Set navigation and job timeouts, limit concurrent captures to available memory, and record the URL, browser version, and failure reason for debugging.

Hosted capture trades local browser maintenance for service quotas, network dependency, and per-plan economics. Screenshot Machine’s pricing page, checked October 3, 2026, listed Starter free with 100 fresh screenshots monthly, Basic at €9/month for 2,500, Pro at €59/month for 20,000, and Enterprise at €99/month for 50,000. It also described extra screenshot charges, possible VAT for non-business EU customers under applicable tax rules, and 14-day cached screenshots for which repeated cached requests were not charged as fresh captures. These are vendor terms that can change; check the current Screenshot Machine pricing page before estimating cost.

ScreenshotNeo offers a different hosted option. Its plans are Free for 1,000 shots/month with no card, Starter $5 for 3,000, Growth $15 for 15,000, Pro $39 for 60,000, Scale $99 for 250,000, and Business $249 for 1,000,000; yearly billing gives two months free. Every feature is on every plan. Compare the plan that fits your expected volume and verify current terms on ScreenshotNeo.

Or skip the browser setup

ScreenshotNeo is a hosted website screenshot API and MCP server. One GET request returns a PNG, JPEG, WebP, or PDF. Full-page capture is one of its available options. See the ScreenshotNeo API documentation for request options.

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

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)

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(`Screenshot request failed: ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());
await (await import('node:fs/promises')).writeFile('shot.webp', bytes);

Cookie banners are accepted like a visitor and removed along with 60+ known consent platforms, newsletter popups, and chat widgets before the shot; each cleanup step can be turned off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and each response includes X-Page-Verdict and X-Billed headers. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients. The free plan includes 1,000 screenshots per month with no card, and paid plans start at $5 for 3,000.

Create a free ScreenshotNeo account for 1,000 screenshots a month with no card.

Troubleshooting

Symptom	Likely cause	What to do
The image stops at the viewport	The full-page option was omitted or unsupported by the command/version.	Use Playwright CLI’s `--full-page`, the API’s `fullPage: true`, or the selected tool’s documented full-page option; check its help output.
Images or lower sections are missing	Lazy loading or client rendering had not completed.	Wait for a content selector, scroll through the page if supported, or add a bounded delay. Inspect a representative URL after each change.
Navigation times out on a page that appears loaded	Persistent requests can prevent a network-idle condition.	Wait for a specific selector or use a different documented readiness condition with an explicit timeout.
CLI reports command not found	The package is not installed, its executable is not on `PATH`, or a different package command is expected.	Follow the project’s install instructions, invoke through its package runner if documented, and check `--help`.
Browser executable or shared-library error	The browser or system dependencies are missing or do not match the installed automation package.	Install the browser version and dependencies using the tool’s official setup steps; keep package and browser versions aligned.
Screenshot is blank or shows a challenge page	The site returned an interstitial, bot check, or empty response to the capture environment.	Confirm the page is accessible in the intended environment and inspect the returned image before treating it as a successful capture.
Output is unexpectedly huge or capture runs out of memory	The page is exceptionally tall, has large assets, or too many captures run concurrently.	Reduce concurrency, capture a specific element or viewport, and resize or convert the output after capture if appropriate.
Repeated service requests cost more than expected	Requests may differ in URL or options, bypass cache, or count under current service terms.	Review provider pricing and caching rules, normalize requests where appropriate, and track response status and billing metadata.

Frequently asked questions

Does Screenshot Machine have an official CLI?

The reviewed official documentation describes its HTTP API and provides a curl sample. It does not document a standalone CLI executable.

What does full-page mean in Playwright?

Playwright describes it as capturing the full scrollable page as if it fit on a very tall screen. See its screenshot documentation.

Which alternative is fastest?

The cited documentation contains no controlled comparison. Measure your own representative pages under the same runtime, network, readiness condition, and output format.

It depends on how the chosen tool supplies and maintains the authenticated session. Verify the tool’s documented cookie, header, or browser-state support and test against the intended page.