Full-page screenshot
Get an entire web page in one tall image, from the header to the footer: the page is scrolled to its full height, so images that load on the way down and sections below the fold all appear. Good for dated records. You pay per use, with no subscription.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
A viewport capture stops at the fold; this one keeps going until the page runs out of content, stitching every section into a single tall image. It's the difference between proving a page loaded and proving it actually rendered end to end.
Why a normal screenshot misses most of the page
Most screenshot tools capture only what fits in a browser window. That is fine for a banner, but useless for checking a long landing page, a lengthy article or a product page with reviews stacked below the buy button. Modern pages rarely draw everything on load either: endless scrolling, images that load only when you reach them and sticky headers all break a simple snapshot. This tool loads the page in a real browser and scrolls it to its full height, which triggers those late images and scroll effects, then stitches everything into one continuous image.
Records people keep with a full-page capture
Quality teams capture the full length of key pages before and after each release, to catch layout problems a single screen would miss. Legal teams archive the complete text of a terms of service page exactly as it appeared on a given date. Marketing teams keep a competitor's entire pricing page, including the sections that only appear further down, for internal review, and editors share one tall image of a long article so others can approve it before publishing. The finished image waits behind a secure link for 24 hours, and a capture that fails is not charged.
Why full-page capture is harder than it sounds
Modern web pages rarely render fully on load — infinite scroll, lazy-loaded images and sticky headers that reflow content all make a naive 'take a picture' approach produce broken or incomplete results. The task accounts for that by scrolling through the page rather than just resizing the viewport, which is the only reliable way to capture content that's designed to appear only once a user reaches it.
What you can do with it
Pre/post-deploy visual records
A QA pipeline captures the full length of key pages before and after each release to catch layout regressions a viewport shot would miss.
Dated compliance records
A legal team archives the complete content of a terms-of-service page exactly as it appeared on a given date.
Competitive landing page research
A marketing team captures a competitor's entire pricing page, including sections revealed only after scrolling, for internal review.
Long-form content previews
An editorial team generates a single scrollable image of a long article for stakeholders to approve before publishing.
FAQ
Does it handle lazy-loaded images?
Yes, the task scrolls through the page to trigger lazy-loaded content and scroll-based animations before capturing, rather than just resizing the viewport.
Is there a free tier?
There's no free tier — free tiers get abused and slow everyone down. No subscription, no tokens, no invented credits, and a failed task is never charged.
Can I capture many URLs in bulk?
Yes, each URL is a separate async request billed independently, which suits scheduled crawls across large sets of pages.
What happens if the page fails to load?
The task retries automatically up to three times; if it still fails you receive a clear error and are never charged.
How is this different from an ordinary screenshot?
An ordinary screenshot stops at the edge of the screen. This one scrolls through the page until the content runs out and joins every section into one tall image, so reviews below the buy button or the end of a long article are included.
Related tools
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, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/web/screenshot-full \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"url":"https://example.com"}'const res = await fetch("https://api.kit.forhosting.com/web/screenshot-full", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"url": "https://example.com"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/screenshot-full",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"url": "https://example.com"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/screenshot-full", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"url":"https://example.com"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"url":"https://example.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/screenshot-full", 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://example.com"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.screenshot_full",
"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. |
Technical notes
The fold was never the whole page
Most screenshot tools default to capturing only what fits in a browser window, which is fine for a hero banner but useless for verifying a long landing page, a lengthy article, or an e-commerce product page with reviews stacked below the buy button.
How the capture is built
Send POST /web/screenshot-full with a URL and the task loads the page in a real browser environment, scrolls it to its full rendered height (triggering lazy-loaded images and scroll-based animations along the way), and stitches the result into one continuous image. It's asynchronous by design: you receive a task_id immediately, and the finished image arrives by signed webhook or through a signed link valid for 24 hours, since full-page images of long pages can be large.
Where teams actually use it
QA teams archiving what a marketing page looked like before and after a deploy, legal and compliance teams recording the full content of a page for a dated record, competitive research tools capturing an entire competitor landing page for review, and content teams generating visual previews of long-form articles for internal approval.
Slotting into automation
Because it's billed only on success — three retries before a clear error, never charged on failure — it fits cleanly into a CI pipeline that screenshots every staging deploy, or a monitoring job that checks a set of pages on a schedule without manual babysitting. Pricing is a $0.040 base per request plus $0.001 per URL, which makes it straightforward to budget a nightly crawl across hundreds of pages.
Technical questions
What does a full page screenshot API actually capture?
The entire rendered height of a page, not just what's visible in a browser window, stitched into one continuous image.
How is pricing structured?
A $0.040 base per request plus $0.001 per URL, published and predictable for budgeting large capture jobs.
What image format do I get back?
A single stitched image representing the full scroll length of the page, delivered via webhook or signed link.
How do I retrieve the screenshot?
Through a signed webhook when the task completes, or a signed link that stays valid for 24 hours.