ScreenshotMachine CLI vs ScreenshotOne for HTML to Image Conversion

For converting raw HTML to an image from the command line, ScreenshotOne has the clearer documented route in the sources reviewed: its API accepts HTML, and its vendor-announced CLI includes an HTML-to-PNG Docker example. ScreenshotMachine’s official documentation shows a curl request to its hosted screenshot API for capturing a URL; it does not establish a separate first-party executable called “ScreenshotMachine CLI” or raw-HTML input on that API page.

That distinction matters. If you need to render an HTML string directly, start with ScreenshotOne’s documented HTML input. If you need a short shell command that captures a publicly reachable URL, ScreenshotMachine’s API example may be enough. The reviewed documentation does not establish whether ScreenshotOne’s CLI renders locally or calls a hosted service, and it does not establish that ScreenshotMachine lacks raw-HTML support through another product or endpoint. Verify the exact tool and rendering location if either is a requirement.

This is a documentation-based comparison, not a hands-on test. There are no controlled measurements here for speed, image quality, or reliability.

1. What “ScreenshotMachine CLI” means in the documentation

ScreenshotMachine’s official website screenshot API documentation provides a shell example using curl. Its GitHub organization also has Bash, Node.js, and Python examples described as API-calling examples. The sources reviewed do not identify a distinct first-party ScreenshotMachine CLI binary. So, unless you have a particular third-party wrapper or repository in mind, it is more precise to call this the ScreenshotMachine shell/API workflow.

The documented API captures a URL and returns an image. Its page lists options such as dimensions, image format, device, cache, and delay. That is not the same as passing an arbitrary HTML document directly to a renderer. The cited page does not establish direct raw-HTML input; check the vendor’s current documentation for other endpoints before concluding that no such feature exists.

ScreenshotOne announced a dedicated CLI on December 8, 2025. Its CLI announcement describes command-line screenshots, PDF generation from HTML or URLs, scrolling screenshots and videos, and Docker use. Its Docker listing shows an HTML-to-PNG command example. Separately, ScreenshotOne’s API documentation expressly supports HTML, Markdown, and URL input.

2. Quick comparison

Question	ScreenshotMachine shell/API workflow	ScreenshotOne CLI/API
Is there a documented standalone CLI?	The reviewed official sources show a curl API example and language examples, not a distinct executable.	A dedicated CLI was announced, with GitHub and Docker distribution described by the vendor.
Can I submit raw HTML?	The cited screenshot API page documents URL capture. It does not establish raw-HTML input on that page.	Yes. The API documents HTML input; the Docker listing shows an HTML-to-PNG example.
Can I capture a URL?	Yes, using the hosted screenshot API and its URL parameter.	Yes, through the API; the CLI announcement also describes website screenshots.
Does the CLI run offline?	The documented curl call sends a request to a hosted API.	The reviewed CLI announcement does not establish that rendering is local or offline. Check before relying on that behavior.
What formats are documented?	The API page lists JPG, PNG, and GIF among supported formats; check its current documentation for the complete list.	The options documentation lists PNG, JPEG/JPG, WebP, GIF, JP2, TIFF, AVIF, HEIF, PDF, HTML, and Markdown response formats.
What cost can be compared?	No ScreenshotMachine price was captured in the research for this article.	The pricing snapshot below is vendor-published and dated. Recheck current plan terms before choosing.

Sources: ScreenshotMachine Website Screenshot API, ScreenshotMachine GitHub organization, ScreenshotOne Getting Started, ScreenshotOne Screenshot Options, ScreenshotOne CLI announcement, and the ScreenshotOne Docker CLI listing.

3. Convert raw HTML with ScreenshotOne

For an HTML string, use ScreenshotOne’s documented HTML input. For larger HTML or Markdown payloads, its docs recommend a JSON POST body rather than putting the content in the URL; the documented maximum request body is 100 MiB. Supply your access key as documented, use HTTPS, and keep credentials out of public client-side code.

Docker CLI example

The Docker listing demonstrates the CLI’s --html option and PNG output. Check the listing for the current image version and full invocation requirements before using this example in a build script:

docker run --rm screenshotone/cli --html '<h1>Hello, world!</h1>' --output image.png

CLI flags and image distribution can change; consult the current Docker CLI listing for authentication syntax and supported options. Do not put a real access key in a committed shell command or Dockerfile.

API request shape for HTML

For a small payload, the API accepts HTML input; use the current options documentation to confirm parameter encoding and the response format you want. A URL-encoded request is convenient for a short snippet, while JSON POST is the appropriate documented approach for larger HTML:

curl -X POST "https://api.screenshotone.com/take" \
  -H "Content-Type: application/json" \
  -d '{"access_key":"YOUR_ACCESS_KEY","html":"<h1>Hello, world!</h1>","format":"png"}' \
  -o image.png

Confirm the endpoint and exact option names against Getting Started and Screenshot Options for your account and current API version. Large request bodies have a documented 100 MiB maximum.

4. Capture a URL with ScreenshotMachine’s documented shell workflow

The official ScreenshotMachine example is a hosted API call made with curl. The exact key and option names should be taken from the vendor’s current API documentation; this illustrates the request pattern for a page URL and saves the response to a file:

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

ScreenshotMachine’s API reference documents its endpoint and parameters. Check the current page for required account parameters, allowed formats, dimensions, device options, delay behavior, and cache settings. This URL-based example does not demonstrate direct HTML submission.

Python: call the hosted ScreenshotMachine API

The official ScreenshotMachine Python repository is an API example. This minimal standard-library version makes the same kind of URL request and writes the returned bytes. Adapt parameter names to the vendor’s current docs:

from urllib.parse import urlencode
from urllib.request import urlopen

params = urlencode({
    "key": "YOUR_API_KEY",
    "url": "https://example.com",
    "dimension": "1024x768",
    "format": "png",
})

with urlopen(f"https://api.screenshotmachine.com?{params}", timeout=90) as response:
    image = response.read()

with open("screenshot.png", "wb") as output:
    output.write(image)

For ScreenshotOne, use the API’s documented HTML field and POST JSON for large content. The following Python example shows the transport pattern; verify the current endpoint and parameter names in its docs:

import requests

payload = {
    "access_key": "YOUR_ACCESS_KEY",
    "html": "<h1>Hello, world!</h1>",
    "format": "png",
}
response = requests.post(
    "https://api.screenshotone.com/take",
    json=payload,
    timeout=90,
)
response.raise_for_status()
with open("image.png", "wb") as output:
    output.write(response.content)

5. Node.js examples

ScreenshotMachine’s official Node repository is an API example. This plain Node.js example sends a URL request and stores the image. Confirm endpoint and parameter names against the current API page:

import { writeFile } from 'node:fs/promises';

const params = new URLSearchParams({
  key: 'YOUR_API_KEY',
  url: 'https://example.com',
  dimension: '1024x768',
  format: 'png',
});

const response = await fetch(`https://api.screenshotmachine.com?${params}`);
if (!response.ok) {
  throw new Error(`ScreenshotMachine returned HTTP ${response.status}`);
}
await writeFile('screenshot.png', Buffer.from(await response.arrayBuffer()));

For ScreenshotOne’s HTML API, send JSON and save the binary response. Keep the key on a server or in a secret manager, and verify the endpoint and request fields with the current docs:

import { writeFile } from 'node:fs/promises';

const response = await fetch('https://api.screenshotone.com/take', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    access_key: process.env.SCREENSHOTONE_ACCESS_KEY,
    html: '<h1>Hello, world!</h1>',
    format: 'png',
  }),
});
if (!response.ok) {
  throw new Error(`ScreenshotOne returned HTTP ${response.status}`);
}
await writeFile('image.png', Buffer.from(await response.arrayBuffer()));

ScreenshotOne supports placing the access key in a header, body, or query according to its documentation. HTTPS is recommended. Avoid exposing a secret in browser JavaScript, a public repository, logs, or a URL that may be recorded.

6. Choose input, output, and rendering controls

Start by separating the source document from the desired artifact. Raw HTML means the renderer receives markup; URL capture means it loads a page from a web address. Those can involve different authentication, assets, and rendering behavior.

Requirement	What to check
Raw HTML rather than a URL	ScreenshotOne documents HTML and Markdown input. ScreenshotMachine’s cited page documents URL capture; verify other endpoints if considering it for raw markup.
External CSS, fonts, or images	Ensure the HTML references assets reachable by the renderer, or inline what the workflow requires. A relative asset path may not resolve without a base URL.
Large HTML	Use ScreenshotOne JSON POST as its docs advise; its documented maximum request body is 100 MiB.
Image format	Choose from the current format list and check whether your downstream system accepts it. ScreenshotMachine’s cited page lists JPG, PNG, and GIF; ScreenshotOne documents a broader list including PNG, JPEG, WebP, GIF, and others.
Viewport and dimensions	Set dimensions explicitly for repeatable output. ScreenshotMachine’s API page lists dimension and device controls; inspect ScreenshotOne’s options for its current viewport controls.
Timing and dynamic content	Check documented delay or wait options. Pages that render data asynchronously may need a wait condition or sufficient delay where supported.
Reuse and caching	ScreenshotMachine’s API docs list cache controls; ScreenshotOne’s options docs describe caching and storage options. Verify TTL and response behavior for the current plan.
Credentials	Use HTTPS and server-side secrets. ScreenshotOne supports key placement in a header, body, or query; its docs advise HTTPS. ScreenshotMachine documents a hash/secret-phrase mechanism for calls from public HTML pages.

Sources: ScreenshotOne options, ScreenshotOne Getting Started, and ScreenshotMachine API documentation.

7. Cost, performance, and reliability

Published pricing snapshot

ScreenshotOne’s official pricing page, checked October 3, 2026, listed 100 free screenshots per month; Basic at $17/month for 2,000; Growth at $79/month for 10,000; and Scale at $259/month for 50,000. The page says prices exclude VAT. These are vendor-published quota and price figures, not independent measurements. Plan rules, overages, cache treatment, included features, and prices can change, so verify the live page before committing.

No comparable ScreenshotMachine price was captured for this article, so there is no substantiated price winner. Compare the current plan’s billable request definition, quota, overage policy, and whether cache hits consume quota against your own expected volume.

Performance and repeatability

The available sources provide no controlled benchmark for latency or image accuracy, so do not choose on assumed speed. Measure your actual documents if those properties matter: use the same HTML or URL, viewport, output format, and wait conditions; record response time and failures over repeated runs. Keep test conditions fixed and distinguish cold requests from cache hits.

For a repeatable pipeline, pin the CLI or Docker image version where possible, set viewport and output format explicitly, and keep representative input fixtures. Dynamic fonts, external assets, asynchronous content, and animation can change the resulting image. If a CLI’s local-versus-hosted behavior affects data residency, network access, or latency, confirm it with the vendor instead of inferring it from the word “CLI.”

Reliability and operational cost

• Set request timeouts and handle non-success HTTP responses before treating the body as an image.
• Retry transient network failures with a small bounded retry policy; avoid retrying invalid requests or authentication failures unchanged.
• Write to a temporary file and rename only after a successful response if downstream jobs must never see partial output.
• For large HTML, use POST rather than a long query string, and stay within ScreenshotOne’s documented 100 MiB body maximum.
• Account for the full pipeline cost: API quota or subscription, build and storage time, retries, and any downstream image processing.

8. Troubleshooting

Symptom	Likely cause	What to do
“ScreenshotMachine CLI” command cannot be found	The instructions may refer to the hosted API’s curl example rather than a separately installed first-party binary.	Check the exact repository or executable named by the instructions. The official sources reviewed document a curl/API workflow and language examples.
Raw HTML is rejected or treated as a URL	The chosen ScreenshotMachine page documents URL capture, not raw-HTML submission.	Use ScreenshotOne’s documented HTML input, or verify whether another current ScreenshotMachine endpoint supports your required input.
CLI option or Docker command fails	CLI syntax, image tags, or required authentication flags may differ from an older example.	Follow the current Docker listing and CLI announcement; inspect the current help output.
Request returns an error instead of an image	Incorrect key, endpoint, parameter, or unsupported option.	Check the response status and body, confirm the account key and current parameter names, and do not save an error response with an image extension.
Large HTML request fails	Putting a large document in a query string can exceed URL or intermediary limits; body size may also exceed the documented cap.	Send JSON POST as ScreenshotOne advises and keep the body at or below the documented 100 MiB maximum.
Image is blank or missing styles and assets	Relative URLs may lack a base, external assets may be unreachable, or content may not have loaded before capture.	Use resolvable absolute asset URLs or inline required resources; check network accessibility and use supported timing controls.
Output file is not a valid image	The request may have returned JSON or an error page, or the selected format may not match the filename.	Check HTTP status, content type, and response body before writing; align the requested format and file extension.
API key appears in logs or source control	A secret was put in a public command, client bundle, or logged query string.	Move it to a server-side environment secret, rotate exposed credentials, and use the vendor’s supported secure key placement over HTTPS.

9. Which one should you choose?

For a documented direct-HTML path, ScreenshotOne is the clearer fit in the sources reviewed: its API accepts HTML and its announced CLI has a Docker HTML-to-PNG example. For a simple shell request that captures a URL through a hosted API, ScreenshotMachine’s official curl workflow may be sufficient. If you require local or offline rendering, neither product’s behavior is established by the reviewed sources; confirm where rendering occurs before deciding.

Compare the exact input mode, output format, viewport controls, wait behavior, authentication approach, monthly quota, and total cost for your expected volume. Do not infer comparative speed, quality, or reliability from these docs.

10. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server for developers. It can return a PNG, JPEG, WebP, or PDF from one GET request. Its clean-shot flow accepts cookie or consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers identify the page verdict and whether the request was billed. Its MCP server gives Claude, Cursor, and other MCP clients screenshot, page-info, and PDF tools.

For a URL screenshot, the request is:

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 output and capture options. Cookie banners, popups, and chat widgets are removed before the shot; bot checks, blank pages, and failed loads are never billed. An 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.

Create a free ScreenshotNeo account to get started.

11. FAQ

Can I convert raw HTML to PNG from the command line?

ScreenshotOne’s Docker CLI listing shows an HTML-to-PNG command example, and its API documents HTML input. The ScreenshotMachine page reviewed documents URL capture rather than raw HTML.

Is ScreenshotMachine CLI a separate program or a curl example?

The first-party material reviewed establishes a curl/API example and language client examples, but not a separately documented ScreenshotMachine CLI executable. The title may refer to a wrapper not covered by those sources.

Does ScreenshotOne CLI render locally?

The CLI announcement and Docker listing establish a CLI distribution and use cases, but the sources reviewed do not establish whether rendering happens locally or through a hosted service. Confirm this if offline operation or data location matters.

What is ScreenshotOne’s listed price?

The pricing snapshot checked October 3, 2026 listed 100 free monthly screenshots and paid plans at $17 for 2,000, $79 for 10,000, and $259 for 50,000 per month, excluding VAT. Check the current pricing page before purchase.

Sources

• ScreenshotMachine Website Screenshot API
• ScreenshotMachine GitHub organization, including its Bash example, Node.js example, and Python example
• ScreenshotOne Getting Started and Screenshot Options
• ScreenshotOne CLI announcement and Docker CLI listing
• ScreenshotOne Pricing (snapshot checked October 3, 2026)