Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →For bulk captures, use ScreenshotMachine’s HTTP API and build a small shell script or other orchestrator around it. ScreenshotMachine documents an API request and a curl example, but the official pages reviewed do not establish a separate vendor-supported CLI or a batch endpoint. A script can read URLs, save files, detect failures, and control concurrency; confirm throughput limits with ScreenshotMachine before a high-volume run.
Is ScreenshotMachine a CLI or an API?
ScreenshotMachine documents its screenshot service as an HTTP GET API. Its bash example calls that API with curl; that makes a shell-driven workflow possible, but it is not evidence of a separate ScreenshotMachine CLI product. The maintained Python example also sends one URL per options object and saves the result locally. ScreenshotMachine’s API documentation and official Python example show these API-based workflows.
The reviewed request documentation describes one url parameter per request and does not document a batch endpoint. For a URL list, your own script must make multiple requests unless ScreenshotMachine confirms another supported option. This conclusion is limited to the cited public documentation; it does not rule out a private or newer feature.
Choose the workflow that fits the job
| Approach | When it fits | What you manage |
|---|---|---|
| Direct API request | One-off screenshots, app integrations, or systems that already manage jobs and files. | Constructing requests, handling responses and errors, and storing captures. |
| Shell script calling the API | Repeatable URL lists, CI jobs, local output folders, or simple scheduled captures. | Input parsing, unique filenames, error detection, retries, and concurrency. This is a CLI-style workflow you build around curl, not a confirmed ScreenshotMachine CLI. |
Decide based on the size and shape of the workload, how much script maintenance is acceptable, how you will handle retries and output, and whether a cached screenshot is acceptable. For larger production runs, throughput limits, concurrency ceilings, and bulk completion guarantees are not stated in the reviewed official pages; ask the vendor rather than assuming a safe request rate.
#1 Best Overall
Make a ScreenshotMachine API request
You need a customer API key and a webpage URL. The documented request is an HTTP GET, and the vendor’s example uses curl -G to pass query parameters and save the response. Keep the key in an environment variable or another server-side secret store, not in public client-side code.
export SCREENSHOTMACHINE_KEY='YOUR_API_KEY'
curl -G 'https://api.screenshotmachine.com/'
--data-urlencode "key=$SCREENSHOTMACHINE_KEY"
--data-urlencode 'url=https://example.com'
--data-urlencode 'dimension=1024xfull'
--data-urlencode 'format=png'
-o example.pngScreenshotMachine’s documentation says API calls start with https://api.screenshotmachine.com/? followed by query parameters. The example above requests a full-page PNG; use a unique output name for each URL in a batch. Check the current API documentation for exact parameter names and supported values before adapting the request.
Build a cautious bulk workflow
A basic bulk capture script should make one request per URL, use deterministic filenames, and stop treating every saved response as a valid image. The following Bash pattern illustrates the orchestration; add your real API key and input file, and verify your chosen parameters against the vendor documentation.
Rank #2
![Free Fling File Transfer Software for Windows [PC Download]](https://m.media-amazon.com/images/I/41Vq6ZqHfjL._SL160_.jpg)
- Intuitive interface of a conventional FTP client
- Easy and Reliable FTP Site Maintenance.
- FTP Automation and Synchronization
#!/usr/bin/env bash
set -u
: "${SCREENSHOTMACHINE_KEY:?Set SCREENSHOTMACHINE_KEY first}"
input="${1:?Usage: ./capture.sh urls.txt}"
outdir="captures"
mkdir -p "$outdir"
while IFS= read -r url || [[ -n "$url" ]]; do
[[ -z "$url" || "$url" == #* ]] && continue
name=$(printf '%s' "$url" | sha256sum | cut -d' ' -f1)
target="$outdir/$name.png"
headers=$(mktemp)
if curl --fail --silent --show-error -G 'https://api.screenshotmachine.com/'
-D "$headers"
--data-urlencode "key=$SCREENSHOTMACHINE_KEY"
--data-urlencode "url=$url"
--data-urlencode 'dimension=1024xfull'
--data-urlencode 'format=png'
-o "$target"; then
if grep -qi '^X-Screenshotmachine-Response:' "$headers"; then
echo "API reported an error for $url; inspect $headers" >&2
rm -f "$target"
else
echo "Saved $url as $target"
fi
else
echo "Request failed for $url" >&2
rm -f "$target"
fi
rm -f "$headers"
done < "$input"The response documentation identifies X-Screenshotmachine-Response as the header carrying a specific error code. Inspect its value and handle it according to the documented codes; the example detects the header so an API error is not silently accepted as a successful image. For a durable production job, log the URL, HTTP result, API error code, attempt count, and output path. Add retries only for failures you determine are transient, with a finite retry limit and delay. Do not retry invalid keys, URLs, selectors, or other request errors unchanged.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Keep concurrency deliberate
The public materials reviewed do not state a rate limit or concurrency ceiling. Begin conservatively, measure failure rates and completion time, and raise parallelism only after confirming acceptable limits with ScreenshotMachine. Unbounded parallel requests can make failures harder to diagnose and may not finish faster if the service throttles or queues them.
Capture options that matter for bulk jobs
The API documentation lists options that can be set per request. Use only the settings needed for your capture, and validate the exact parameter spelling and allowed values in the official docs.
| Need | Documented behavior | Bulk consideration |
|---|---|---|
| Page dimensions | Width 100–1920 pixels; height 100–9999 pixels, or full. |
Full-page captures can be larger and slower than viewport captures. |
| Device | desktop, phone, or tablet. |
Include device choice in filenames or metadata if capturing multiple variants of a URL. |
| Image format | JPG, PNG, or GIF. | Use an extension and downstream processing appropriate to the requested format. |
| Cache | Cache age can be configured from 0 to 14 days; cacheLimit=0 requests a fresh capture. |
Choose whether a repeat URL should reuse a cached result or consume a fresh screenshot allowance. |
| Delay | Listed delay values run from 0 through 10,000 milliseconds in set increments. | Long pages with images or animations may need more delay; longer waits increase run time. |
| Page interaction and targeting | Click a CSS selector, select a DOM element, crop, or set zoom. | Invalid selectors or crop values can fail; test the settings on representative pages first. |
| Request context | Cookies, language, and user-agent headers are supported. | Protect sensitive cookie values and avoid putting credentials in logs. |
For full-page capture, set the height to full, for example 1024xfull. ScreenshotMachine advises allowing more delay on long pages with images or animations. The documented option ranges and behaviors are in the API reference.
Fresh screenshot allowances, cache, and cost
ScreenshotMachine’s public pricing page, accessed in 2026, distinguishes fresh screenshot allowances from cached requests. The following are the figures listed on that page at access; check the live page before purchasing because pricing and terms can change.
| Plan | Fresh screenshots per month | Listed monthly price | Additional screenshot rate |
|---|---|---|---|
| Free | 100 | not stated on the cited pricing page | not stated |
| Basic | 2,500 | 9 EUR/month | 0.004 EUR |
| Pro | 20,000 | 59 EUR/month | 0.003 EUR |
| Enterprise | 50,000 | 99 EUR/month | 0.002 EUR |
The same page says additional screenshots are counted in groups of 1,000 rounded down, and that cached screenshots are not charged as fresh captures; it describes a 14-day cache. Confirm how those terms apply to your account and workload on the current pricing page. In a bulk script, decide whether cache reuse meets the freshness requirement before setting cache behavior.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Secure the key and diagnose failures
An API key is an account credential. ScreenshotMachine recommends a hash parameter when requests are made directly from public HTML and says requests without a correct hash are ignored when a secret phrase is configured. For automation, keep the key server-side or load it from an environment-based secret; never commit it to a script repository or expose it in browser code.
The API documentation lists these error categories and says the X-Screenshotmachine-Response header contains a specific error code:
- Invalid or missing key: check the account key and parameter construction; avoid printing the key in diagnostic logs.
- Invalid or missing URL: validate each input line, URL encoding, and the URL parameter name.
- Exhausted credits: check fresh screenshot usage and plan allowance before rerunning the remaining queue.
- Invalid selector: verify that the requested CSS selector exists on the target page at capture time.
- Invalid crop: correct the crop values and test on a single URL before resuming the batch.
- Generic system error: record the response code and URL, retry cautiously only if appropriate, and contact the vendor if it persists.
Do not treat the existence of an output file as proof of success. Check the HTTP result and API error header, preserve a failure log, and rerun only the URLs that did not produce valid captures.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsBest Value
Or skip the browser setup
If you prefer a screenshot API with a one-call request, ScreenshotNeo is an alternative to try first: it removes cookie banners, popups, and chat widgets before capture, bills only clean shots, supports MCP tools for AI agents, and includes 1,000 free screenshots per month without a card; paid plans start at $5 for 3,000. Its API also supports bulk capture, with up to 100 URLs per call.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webpSee the ScreenshotNeo API documentation for request options. Failed loads, bot checks, blank pages, and cache hits are not billed, and the response identifies the page verdict and billing status in headers. Sign up for ScreenshotNeo’s free plan: 1,000 screenshots a month, no card required.
Conclusion
For ScreenshotMachine, the documented choice is API request versus your own shell orchestration—not a documented standalone CLI versus batch API. Use direct calls when another system already manages jobs; use a script for URL lists when you need repeatable naming, logging, retry handling, and controlled concurrency. Validate pricing, cache behavior, and throughput with the current vendor documentation before scaling.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Free tools Windows power users keep installed
One-click scans. No signup required.
