ForHosting KIT · Web Scraping & Monitoring

Full-page screenshot

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.

● StablePer request + per URL$0.040

Run — $0.040 + $0.001/URL How it works & API

Use it from WebAPIEmailApp soonTelegram soon

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.

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. A full-page capture matters whenever the thing you actually need to check — a footer, a pricing table three sections down, a broken widget near the bottom — lives outside that first screenful.

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.

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.

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

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. 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.

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

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.

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. 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.

How is pricing structured?

A $0.040 base per request plus $0.001 per URL, published and predictable for budgeting large capture jobs.

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 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.

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.

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

POSThttps://api.kit.forhosting.com/web/screenshot-full

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-full \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"url":"https://ejemplo.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://ejemplo.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[&#39;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-full", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"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-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://ejemplo.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

Per request$0.040

Per URL$0.001

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.

Read the full KIT documentation →