Scheduled screenshots
Some pages need watching, not just capturing — a pricing table, a competitor's homepage, a dashboard that only you can see. This scheduled screenshot API takes the capture off your cron server: tell it a URL and a cadence, and it fires the shot on time, every time, delivered wherever your webhook lives.
Why a one-off screenshot isn't enough
A single capture tells you what a page looked like once. Teams tracking a pricing page, a job listing, a status banner or a regulator's notice board need the same shot taken on the same schedule, so any two captures are directly comparable. Building that yourself means running a server that never sleeps, handling retries, and remembering time zones — the actual job you wanted to outsource in the first place.
How the schedule works
You register a URL with a daily or weekly cadence and an optional time window; from then on each run behaves exactly like a normal capture — a real browser loads the page, waits for it to settle, and renders it to JPEG or PNG. Every run gets its own task_id and its own webhook delivery, so your system can treat each screenshot as an independent event rather than polling a dashboard to see if something changed.
What arrives, and when
Results are never emailed or stored in a UI you have to check — each scheduled run posts its result to your signed webhook, or leaves a signed link valid for 24 hours if you'd rather pull it. That keeps the capture pipeline entirely event-driven: no polling loop, no login, just a payload landing when the run completes.
A short history of watching pages
Before APIs like this existed, 'monitoring a page' usually meant a browser extension polling every few minutes on someone's laptop, or a fragile Selenium script glued to a cron job. Headless browser rendering made server-side capture reliable enough to run unattended; scheduling turns that reliability into a standing job instead of a one-time favor.
Where it fits in a pipeline
Pair scheduled captures with a diff step downstream — your own or another task in this API — and you get change detection without writing a scraper. Feed the same schedule into an archive, and you get a visual paper trail: what the page said, and when, indefinitely reconstructible from timestamped images rather than memory.
What you can do with it
Competitor price watch
Capture a competitor's pricing page every morning and keep a dated image archive without anyone opening a browser.
Uptime and layout sanity checks
Schedule a daily shot of a critical landing page to catch a broken deploy or a missing hero image before customers do.
Compliance and audit trails
Take a weekly capture of a public disclosure or terms page so you can prove what it said on any given date.
Internal dashboard snapshots
Schedule captures of a metrics dashboard for a daily digest, without exposing the dashboard itself to more logins.
FAQ
How do I set up a scheduled screenshot?
Call POST /web/screenshot-scheduled with the URL, a daily or weekly cadence, and your webhook; each run afterward is billed and delivered independently.
Is there a free tier?
There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.
What happens if a run fails?
The task retries automatically up to three times; if it still fails you get a clear error and are not charged for that run.
Can I change the cadence later?
Yes, update the schedule's cadence or target URL at any time; future runs use the new settings, past runs are unaffected.
How is it priced?
$0.040 per request plus $0.001 per URL, published and predictable — the same rate whether the run is scheduled or triggered manually.
Do I need to poll for results?
No. Each scheduled run delivers its own webhook payload, or a signed link valid 24 hours if you prefer to fetch it yourself.
What image formats are supported?
JPEG for smaller files or PNG for lossless capture, the same options available on a one-off screenshot.
How long is old data kept?
Captured images are deleted after the retention period and are never used for training — treat each delivery as the record of that moment.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/web/screenshot-scheduled \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"url":"https://ejemplo.com"}'const res = await fetch("https://api.kit.forhosting.com/web/screenshot-scheduled", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"url": "https://ejemplo.com"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/screenshot-scheduled",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"url": "https://ejemplo.com"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/screenshot-scheduled", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"url":"https://ejemplo.com"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"url":"https://ejemplo.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/screenshot-scheduled", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"url": "https://ejemplo.com"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.screenshot_scheduled",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
timeout_sec | 30 |
max_crawl_pages | 25 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |