Best Free Full-Page Screenshot API for Scheduled Website Captures

Short answer: If you want a hosted API with an ongoing free quota and can run it from your own scheduler, ScreenshotOne is the clearest documented fit in the sources reviewed: its pricing page lists 100 screenshots per month, and its options documentation describes full-page capture. Those sources do not establish that recurring schedules are included in its free tier, so plan to trigger the API with cron or another scheduler unless the vendor confirms otherwise. ScreenshotNeo is the first alternative to consider if you want clean captures, usage-based billing rules that do not charge for failed or blocked pages, and an API you can call from a schedule you control.

“Scheduled screenshot API” can mean two different things: an API you call repeatedly from your own scheduler, or a managed service that runs recurring jobs for you. A continuing free API allowance does not imply the service manages the schedule. The comparison below keeps those cases separate.

1. The options at a glance

Service	Free or trial terms in reviewed sources	Full-page evidence	Scheduling evidence	Important qualification
ScreenshotNeo	Free plan: 1,000 shots per month, no card.	Full-page capture with lazy images loaded.	The API can be called from an external scheduler. Native recurring schedules were not part of the supplied product facts.	Only clean shots are billed; failed loads, bot checks, blank pages, timeouts, and cache hits cost nothing. All listed features are on every plan.
ScreenshotOne	Pricing page lists 100 free screenshots per month.	Full-page option is documented; full-page mode scrolls to trigger lazy-loaded images by default.	The reviewed pages do not establish native recurring schedules on the free tier. Use an external scheduler unless the vendor confirms otherwise.	Good fit for recurring API calls you manage, if 100 monthly screenshots are enough.
Urlbox Capturedeck	Paid plans; the cited page describes a seven-day trial without a credit card.	The cited plan page focuses on bulk capture and recurrence; verify capture details against your needs.	Basic and Standard list daily, weekly, and monthly schedules; Pro lists schedules as often as every five minutes.	Native schedules are documented, but the reviewed page does not establish a permanent free tier.
Screenshotlayer	Pricing page lists 100 snapshots per month on the free plan.	Product overview documents full-height capture.	Native recurring scheduling was not established in the reviewed pages.	The free tier is labeled non-commercial. Commercial users should check the current paid terms.

These are document-based comparisons, not results from a hands-on benchmark. Provider quotas, plan terms, and features can change; check the linked provider pages before choosing.

2. Which option should you choose?

Choose ScreenshotNeo for clean captures and a larger free allowance

ScreenshotNeo is the first option to evaluate when you need an API that can be called on a schedule and want cookie or consent banners, newsletter popups, and chat widgets removed before capture. It offers 1,000 free shots per month without a card. Its API responses identify the page verdict and billing status in X-Page-Verdict and X-Billed headers. That makes it possible to distinguish a usable capture from a bot check, blank page, timeout, failed load, or cache hit in your job logs.

ScreenshotNeo also has an MCP server with take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. Plans are Free (1,000 shots/month), 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. See the ScreenshotNeo API documentation for parameters and setup.

Choose ScreenshotOne when a managed schedule is unnecessary

ScreenshotOne is the strongest fit in the reviewed evidence when you need a recurring free API allowance and already have a scheduler. Its official pages list 100 screenshots per month and document full-page capture. The reviewed sources do not show that the free plan includes a native recurring-job scheduler. Confirm current terms and schedule capabilities in its pricing and options documentation.

Choose Capturedeck when native recurrence matters more than a permanent free plan

Urlbox’s Capturedeck page explicitly lists daily, weekly, and monthly schedules on Basic and Standard, and intervals as frequent as five minutes on Pro. The cited page describes a seven-day trial, not a permanent free tier. Compare the current plan’s capacity and price with the number of pages and captures your job needs. See Capturedeck pricing.

Consider Screenshotlayer for eligible non-commercial use

Screenshotlayer’s official pages list 100 monthly snapshots on its free plan and document full-height capture. Its free tier is explicitly non-commercial, and the reviewed documentation did not establish native recurring schedules. Check its pricing terms and product overview before using it.

3. Plan the capture workload before you pick a quota

Calculate your expected monthly output before signing up:

monthly screenshots = URLs per run × runs per day × active days

For example, 10 URLs captured once each weekday require about 220 screenshots in a 22-workday month. That is above a 100-screenshot monthly allowance. A five-minute interval across 10 URLs would require 2,880 captures per day if run continuously, before retries. This is why both frequency and page count matter more than the headline quota alone.

Count each URL and each intended output. If you save desktop and mobile versions, budget for two captures per URL per run.
Decide whether the job should run on weekdays, continuously, or only during a monitored window.
Allow for retries carefully. A retry policy that repeats every failure indefinitely can consume quota or overload your own workers.
Check whether commercial use is allowed on the plan you intend to use.
Decide where images will be stored and how long to keep them. The cited vendor pages do not establish a common retention or export policy, so verify this for each service.

4. DIY: run full-page captures from an external schedule

With an API that accepts a URL and returns an image, the basic pattern is: store the API key in a secret, call the endpoint from a script, save the returned bytes, then have cron or another scheduler invoke the script. The examples below show the general workflow with ScreenshotNeo’s documented endpoint and supplied request format. For ScreenshotOne or another provider, use its own endpoint, authentication, and full-page parameter names from its documentation; do not assume these are interchangeable.

cURL

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

See the ScreenshotNeo API documentation for the full-page option and other request parameters. This example writes the response body to a file; production jobs should also record the HTTP status and response headers so they can classify failures and billing outcomes.

Python: save a capture and invoke it on a schedule

import os
from pathlib import Path
import requests

API_KEY = os.environ["SCREENSHOTNEO_API_KEY"]
URL = "https://stripe.com"

response = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={
        "access_key": API_KEY,
        "url": URL,
        "format": "webp",
        # Add the provider's documented full-page parameter here.
    },
    timeout=90,
)
response.raise_for_status()

Path("captures").mkdir(exist_ok=True)
Path("captures/stripe.webp").write_bytes(response.content)
print("HTTP", response.status_code)
print("Page verdict:", response.headers.get("X-Page-Verdict"))
print("Billed:", response.headers.get("X-Billed"))

Install the dependency with python -m pip install requests, then set SCREENSHOTNEO_API_KEY in the job environment. Add the provider’s documented full-page parameter before relying on the result as a full-page capture. Avoid putting secrets directly in a crontab command or source file.

Node.js

const fs = require('node:fs/promises');

const q = new URLSearchParams({
  access_key: process.env.SCREENSHOTNEO_API_KEY,
  url: 'https://stripe.com',
  format: 'webp',
  // Add the provider's documented full-page parameter here.
});

const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`, {
  signal: AbortSignal.timeout(90000),
});
if (!res.ok) {
  throw new Error(`Screenshot request failed: HTTP ${res.status}`);
}
await fs.mkdir('captures', { recursive: true });
await fs.writeFile('captures/stripe.webp', Buffer.from(await res.arrayBuffer()));
console.log('Page verdict:', res.headers.get('x-page-verdict'));
console.log('Billed:', res.headers.get('x-billed'));

Run on a Node.js release that supports built-in fetch and AbortSignal.timeout. Keep the API key in an environment variable managed by your scheduler or secret store.

Schedule with cron

For a daily run at 06:15 UTC, a crontab entry can invoke a saved script:

15 6 * * * /usr/bin/python3 /opt/capture/capture.py >> /var/log/capture.log 2>&1

Set the key in the job runner’s environment, not in a publicly readable script. Cron uses the machine’s timezone unless configured otherwise, and its environment is sparse: use absolute paths, set a working directory in the script, and confirm the schedule’s timezone. For managed platforms, use their scheduler and secret-management features. The same approach works with GitHub Actions, cloud schedulers, or an internal queue, but the exact setup depends on that platform.

5. Make the scheduled job reliable

Keep an explicit URL list. Validate each URL and decide how redirects and authentication should be handled.
Use bounded concurrency. Start with a small number of simultaneous captures and increase only if the provider’s limits and your workload permit it.
Set a timeout and bounded retries. Retry transient network errors and selected server errors with exponential backoff and jitter. Do not retry every client error, CAPTCHA, or persistent bot check as if it were temporary.
Write files atomically. Save to a temporary path, verify the response, then rename it into place. This prevents downstream consumers from reading a partial file.
Record useful metadata. Log the URL, scheduled time, HTTP status, duration, output size, page verdict, and billing header when available. Never log API keys or sensitive page content.
Make reruns safe. Include a timestamp or stable job identifier in filenames. If the same scheduled run can be delivered twice, decide whether to overwrite, deduplicate, or retain both images.
Alert on missing output. A successful process exit is not enough if the body is empty or not an image. Check response type and file size before marking the capture complete.

6. Full-page capture edge cases

Lazy-loaded images: Some pages load images only when scrolled into view. Use a provider that documents full-page scrolling or lazy-image handling, and check that the page is not too long for the capture timeout.
Infinite scroll: A page that keeps adding content may never reach a stable bottom. Prefer a documented maximum-height or wait strategy where supported; otherwise capture a defined viewport or target element.
Animations and rotating content: A scheduled capture can differ from run to run even when the site has not changed. If the API supports it, disable animation or wait for a stable selector. Capture at a consistent time.
Consent banners and overlays: These can obscure content. Check whether the tool can accept or remove them, or whether your own CSS or interaction is allowed by the provider and the site.
Authentication and access controls: A public API may not see the same page as your signed-in browser. Use documented headers or cookies only for pages you are authorized to access, and protect resulting files.
Very long pages: Full-page output can be large and slow to transfer. Consider element capture, image resizing, or a PDF if the goal is review rather than pixel comparison.
Time-sensitive pages: Weather, dashboards, and storefronts can change between the schedule trigger and the moment the page finishes loading. Record capture time and any relevant time zone.

7. Performance, reliability, and cost

Full-page rendering takes longer and returns more data than a viewport capture. The main factors are page size, client-side scripts, lazy loading, network response, and the provider’s wait settings. Set a realistic timeout, avoid unnecessary high-frequency schedules, and capture only the pages and dimensions you need. The reviewed sources provide no independent performance benchmarks, so compare candidates using your own representative URLs before committing a production workflow.

For reliability, distinguish request failure from a completed capture of an unexpected page. ScreenshotNeo exposes X-Page-Verdict and X-Billed response headers; use them in accounting and alerts. Other vendors may expose different status signals; check their documentation rather than assuming identical behavior.

Estimate recurring cost as captures per run × runs per month × price per plan unit, plus storage and scheduler costs if applicable. Include retries, multiple viewport sizes, and test runs. ScreenshotOne’s documented 100 free monthly screenshots can be exhausted quickly: 10 URLs on weekdays already need about 220 outputs in a 22-day month. Screenshotlayer also lists 100 monthly snapshots, with its free tier labeled non-commercial. Capturedeck’s reviewed pricing describes a trial and paid scheduled plans. ScreenshotNeo offers 1,000 free shots per month with no card, then plans from $5 for 3,000 shots; see its site for the current plan details.

8. Troubleshooting

Symptom	Likely cause	What to do
Capture is clipped at the viewport	The request used the default viewport mode or omitted the provider’s full-page option.	Set the documented full-page parameter and verify the resulting image dimensions.
Lower-page images are missing	Images load lazily or the page did not finish scrolling/loading before capture.	Use documented lazy-load behavior, allow sufficient wait time, or capture after the relevant content appears.
HTML or JSON appears instead of an image	The API returned an error response, authentication failure, or usage message.	Check HTTP status, content type, and response body before saving. Do not treat every response body as an image.
Blank page or bot-check screen	The target site blocked automated access or failed to render in the capture environment.	Check the verdict or provider error details. Do not loop retries indefinitely; confirm that automated capture is permitted by the site.
Scheduled job works interactively but not in cron	Cron has a different working directory, PATH, timezone, or environment.	Use absolute paths, configure secrets in the scheduler, set the timezone deliberately, and inspect redirected logs.
Quota runs out earlier than expected	Each URL, viewport, retry, or repeated run consumes output allowance.	Recalculate monthly captures, reduce frequency, avoid duplicate work, and review the provider’s current quota definition.
Capture times out on long pages	Slow scripts, infinite scrolling, or large assets prevent completion within the request timeout.	Use a supported wait condition, bound the page height if available, capture a smaller target, or increase timeout within provider limits.
Files are zero bytes or incomplete	The script saved an error body or was interrupted during writing.	Validate status, content type, and minimum file size; write to a temporary path and rename only after validation.

9. Or skip the browser setup

ScreenshotNeo is a hosted screenshot API, so a scheduled job can call one endpoint instead of maintaining a browser installation. The call below follows its documented request pattern; use the API docs for full-page and other parameters.

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

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)

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

Cookie banners, popups, and chat widgets are removed before the shot.
Bot checks, blank pages, timeouts, failed loads, and cache hits are never billed.
An MCP server lets AI agents take screenshots with tools for screenshots, page info, and PDF capture.
1,000 screenshots a month are free with no card; paid plans start at $5 for 3,000.

Start with 1,000 free screenshots per month, with no card required.

10. Frequently asked questions

Is an API with a free quota the same as a free scheduled screenshot service?

No. A quota lets you make requests within its limits. Unless native scheduling is documented, you need a separate scheduler to make those requests recur.

Can I use Screenshotlayer’s free plan for a business site?

The reviewed pricing page labels its free tier non-commercial. Check its current paid terms for business use.

How often should I capture a site?

Choose the slowest interval that catches the changes you care about. Calculate its monthly output first, then include every URL, viewport, and planned retry.

Does full-page capture guarantee every element will appear?

No. Lazy loading, infinite scroll, authentication, bot protection, and dynamic content can affect the result. Test representative pages and use documented wait or interaction options where available.