Skip to content
AAPIScreenshot
FeaturesUse casesDocsPricingBlogContact
Sign inGet started

Capture a whole page, top to bottom

full page screenshot API

Add fullPage: true to the request and the screenshot API measures the full scroll height, scrolls so lazy content loads, and returns the entire page, header to footer, as one tall image. The viewport width fixes the column while the height grows to fit. No scroll-and-stitch script of your own to build or maintain.

Start free — no credit cardRead the docs

No credit card · 100 free screenshots to start

curl https://api.apiscreenshot.com/v1/screenshot \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/pricing",
    "fullPage": true,
    "format": "png",
    "viewport": { "width": 1440, "height": 900 },
    "waitUntil": "networkidle2"
  }' \
  -o full-page.png

BUY VS BUILD

Building this yourself means…

Doing it in-house is owning a browser fleet and every edge case around it. Here is the work you skip.

  • Scripting a headless browser to scroll the page and stitch the slices into one image.
  • Triggering lazy-loaded images and content that only appear as the page scrolls.
  • Capturing a long page reliably without the bottom half rendering blank.
  • Maintaining the whole scroll-and-stitch pipeline as pages and frameworks change.

HOW IT WORKS

One request, the asset back

Same shape every time: send the request, it renders on a managed browser engine, you get the image back to store or serve.

  1. 01

    Send the request

    POST your payload to /v1/screenshot with your API key — a URL or your own HTML, plus the options this job needs.

  2. 02

    It renders

    A managed browser engine loads the page, waits for it to settle, and captures it — no headless browser of your own to run or scale.

  3. 03

    Get the asset

    The response body is the image bytes, synchronously — write them to a file, push them to your bucket, or hand them to a diff. No queue to poll.

THE CALL

The exact request for full-page capture

The parameters this job needs, ready to paste. Full reference in the docs.

  • The whole page in one image. Set fullPage: true and the renderer captures the full scroll height — header to footer — as a single tall image instead of just the viewport.
  • Lazy content settles first. Use waitUntil: "networkidle2" (the default) so the page finishes loading before capture, and waitForSelector to block on a specific element appearing.
  • Set the capture width. The viewport width fixes how wide the page renders; with fullPage on, the height grows to whatever the page needs, so you control the column without guessing the length.
curl https://api.apiscreenshot.com/v1/screenshot \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/pricing",
    "fullPage": true,
    "format": "png",
    "viewport": { "width": 1440, "height": 900 },
    "waitUntil": "networkidle2"
  }' \
  -o full-page.png

WHY IT HOLDS UP

What actually makes this work

The concrete parts: the formats, the edge cases it handles, the way it scales. Nothing here is a number we can't show you.

The whole page in one image

fullPage: true captures the complete scroll height as a single tall image, so nothing below the fold is cut off — not just the viewport slice.

Lazy content settles first

The renderer scrolls the page so deferred images load, and waitUntil: "networkidle2" holds until the network goes quiet; waitForSelector blocks on a specific late element.

PNG or JPEG, your choice

Take a lossless PNG or a smaller JPEG with a quality value — the response is the image bytes either way, ready to write straight to disk or a bucket.

All features →Documentation →Pricing →

RELATED

Same API, more jobs

The one call behind full-page capture powers these too.

Turn any URL into a preview thumbnail

Turn any URL into a clean preview thumbnail in a single call.

View use case

Keep proof of how a page looked

Snapshot a page exactly as it appeared, for compliance and records.

View use case

Catch visual changes before users do

Re-capture a page on a schedule and spot visual changes or regressions.

View use case

Browse all use cases →

FAQ

Full-page capture — common questions

How do I capture a full-page screenshot via API?
POST { "url": "...", "fullPage": true } to https://api.apiscreenshot.com/v1/screenshot with your API key. The renderer measures the full scroll height, captures the entire page, and returns the image bytes straight back — no scroll-and-stitch script of your own.
How is a full-page capture different from a normal screenshot?
A normal capture returns only the viewport — the above-the-fold frame. With fullPage: true the renderer captures the complete page height, header to footer, as one tall image, so nothing below the fold is cut off.
Does it capture lazy-loaded images and content below the fold?
Yes. The renderer scrolls the full page so deferred content loads, and waitUntil: "networkidle2" (the default) holds until the network settles. Add waitForSelector to block until a specific late-loading element appears before capture.
Can I control how wide the captured page is?
Yes. Set viewport.width to fix the render column (for example 1440). With fullPage on, the width stays fixed and the height grows to whatever the page needs, so you get a consistent column without guessing the length.
Can I save a full page as PNG or JPEG?
Both. Set format to "png" for a lossless capture or "jpeg" with a quality value for a smaller file. The response is the image bytes either way — write them straight to disk or a bucket.
Are the captured pages stored on your servers?
No. Each page is rendered to produce the image, the bytes are streamed back in the response, and nothing of the page or capture is persisted on our side.

Capture full pages in my app

One endpoint, the asset back in one call. 100 free screenshots to start, no credit card to begin.

Start free — no credit cardSee pricing

Cancel anytime · no long-term contract