How do I archive a web page with an API?

POST { "url": "...", "fullPage": true, "format": "png" } to https://api.apiscreenshot.com/v1/screenshot with your API key. You get a full-page image back in one synchronous call — store it with a timestamp in your own bucket and you have a record of exactly how the page looked that day.

Why use a screenshot instead of saving the URL?

A live URL can be edited or removed, so it is no evidence of how the page looked when it mattered. A captured image is frozen at the moment of capture, so a timestamped snapshot stays a faithful record even after the live page changes.

Does it capture the whole page for the record?

Yes. Set fullPage: true and the renderer captures the complete page, header to footer, so nothing below the fold is missing from the archive. Use format: "png" for a lossless, faithful record.

Where are the archived images stored?

In your own systems. APIScreenshot streams the image bytes back and stores nothing on our side, so you write each snapshot to your bucket or records system under your own retention and access controls.

Can I build a dated history of a page over time?

Yes. Run the same capture on a schedule — from cron or a serverless cron — and store each image keyed by date, so the archive accrues a history. Pair it with visual monitoring to be alerted when a page changes.

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 — the archive lives entirely in your storage.

Keep proof of how a page looked

website archiving API

Capture a full-page PNG of the URL and store it with a timestamp, and you have a record fixed to that day — frozen even after the live page is edited or removed. POST { url, fullPage: true } to the screenshot API, write the image to your own storage, and run it on a schedule to build a dated history for compliance, audits or disputes.

Start free — no credit card Read 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/terms",
    "fullPage": true,
    "format": "png",
    "viewport": { "width": 1440, "height": 900 },
    "waitUntil": "networkidle2"
  }' \
  -o "archive/terms-$(date +%Y%m%d).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.

Running a headless browser to snapshot pages and proving the captures are faithful.
Saving only the live URL, which changes or disappears the moment you need the evidence.
Capturing the full page reliably so nothing below the fold is missing from the record.
Maintaining the scroll-and-stitch capture pipeline as the pages you archive evolve.

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.

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

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

Full-page, faithful records. Capture with fullPage: true and PNG so the archived image shows the whole page top to bottom, exactly as it rendered — not just the part above the fold.
Frozen the moment you capture. The snapshot is an image, so it does not change when the live page is edited or taken down. Store it with a timestamp and you have a record fixed to that date.
You own the archive. Nothing is stored on our side — the bytes are streamed back and you write them to your own bucket or records system, where your retention and access rules apply.

curl https://api.apiscreenshot.com/v1/screenshot \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/terms",
    "fullPage": true,
    "format": "png",
    "viewport": { "width": 1440, "height": 900 },
    "waitUntil": "networkidle2"
  }' \
  -o "archive/terms-$(date +%Y%m%d).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.

Full-page, faithful records

fullPage: true with PNG captures the whole page top to bottom exactly as it rendered, so nothing below the fold is missing from the record.

Frozen the moment you capture

The snapshot is an image, so it does not change when the live page is edited or taken down — store it with a timestamp and it stays a record fixed to that date.

You own the archive

Nothing is stored on our side; the bytes stream back and you write them to your own bucket or records system, under your own retention and access rules.

All features →Documentation →Pricing →

Same API, more jobs

The one call behind website archiving powers these too.

Browse all use cases →

FAQ

Website archiving — common questions

How do I archive a web page with an API?: POST { "url": "...", "fullPage": true, "format": "png" } to https://api.apiscreenshot.com/v1/screenshot with your API key. You get a full-page image back in one synchronous call — store it with a timestamp in your own bucket and you have a record of exactly how the page looked that day.
Why use a screenshot instead of saving the URL?: A live URL can be edited or removed, so it is no evidence of how the page looked when it mattered. A captured image is frozen at the moment of capture, so a timestamped snapshot stays a faithful record even after the live page changes.
Does it capture the whole page for the record?: Yes. Set fullPage: true and the renderer captures the complete page, header to footer, so nothing below the fold is missing from the archive. Use format: "png" for a lossless, faithful record.
Where are the archived images stored?: In your own systems. APIScreenshot streams the image bytes back and stores nothing on our side, so you write each snapshot to your bucket or records system under your own retention and access controls.
Can I build a dated history of a page over time?: Yes. Run the same capture on a schedule — from cron or a serverless cron — and store each image keyed by date, so the archive accrues a history. Pair it with visual monitoring to be alerted when a page changes.
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 — the archive lives entirely in your storage.

Archive pages for my records

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

Start free — no credit card See pricing

Cancel anytime · no long-term contract

Keep proof of how a page looked

Building this yourself means…

One request, the asset back

Send the request

It renders

Get the asset