Wayback Machine API

The Wayback Machine API lists the archived captures the Internet Archive holds for a URL — or, with one flag, for an entire domain. It reads the Archive's CDX server and returns one row per snapshot: the capture timestamp raw and as ISO, the original URL, the MIME type, the HTTP status at capture, the content digest, the byte length and the playback link.

The input field is target — a single page, or a domain when you set match_prefix — and you can bound it to a date range with from and to. Near-identical captures are collapsed by their content digest, so a page archived nightly but rarely changed does not drown the result in duplicates. It returns the index of what was captured, with a snapshot_url to open the archived copy; it does not return the archived page's contents. Every lookup rides our TLS tier through a rotating residential exit. Its OSINT companion is the certificate transparency API.

$0.0003 per delivered snapshot, up to 1,000 snapshots per run. Nothing delivered means nothing charged.

How the Wayback Machine API works

You post a target and the collector queries the CDX server, then flattens the response into a table ordered oldest-first. No browser is involved — CDX is a plain index service.

Runs up to 100 snapshots return inline; larger sweeps, up to the 1,000-snapshot ceiling, are queued and delivered on completion.

Inputs

target is the only required input — a page URL, or a domain when match_prefix is set; from and to bound the capture dates and max_results caps the run at up to 1,000 snapshots.

What one snapshot looks like

Each capture is one row: timestamp and ISO captured_at, the original_url, mimetype, status_code, content digest, byte length and the snapshot_url that plays the archived copy back.

What the Wayback Machine API costs

$0.0003 per delivered snapshot ($0.30 per 1,000). Nothing delivered means nothing charged, and the $2 monthly free credit covers roughly 6,666 snapshots here. Volume tiers take up to 30% off.

$0.0003 per delivered snapshot — 30 cents per 1,000 rows. Mapping a single page's revision history is a fraction of a cent; enumerating a large domain's entire archived footprint across two decades is still well under a dollar.

A target the Archive has never captured simply returns no rows, and nothing you are not delivered is billed.

vs the CDX server directly

The Internet Archive's CDX API is free and open, and for a one-off you can query it directly. Its quirks are the reason a wrapper earns its keep: the response is space-separated CDX lines, not JSON; collapsing duplicates by digest is a parameter you have to know to add; timestamps come in the Archive's own yyyymmddhhmmss format; and the endpoint gets slow and rate-sensitive on large prefix queries.

This returns typed JSON rows with the ISO timestamp already computed and digests already collapsed, fetched through rotating exits so a heavy prefix sweep is not your single IP waiting on a throttled endpoint. The Archive is a nonprofit — running big jobs politely through distributed exits is also just good manners.

vs scripting CDX yourself

A CDX script is easy until the domain is big. Then you meet the real work: paging through very large result sets, parsing the plain-text format, remembering the collapse flag, converting timestamps, and backing off when the endpoint slows under load. It is all doable and all ongoing.

Handing it over gives you a stable row schema and a bill that only counts delivered snapshots. If you would rather keep your own fetcher and just want clean, rotating exits beneath it, that is what our residential proxies are.

What people build with it

Reconstruct a page's history

List every distinct capture of one URL to see when it changed, what MIME type it served and what status it returned — the timeline behind a single page.

Map a domain's archived footprint

Set match_prefix and enumerate every archived path under a domain, a fast way to find old pages, retired sections and URLs that no longer resolve live.

OSINT and due diligence

Pull the capture record for a target domain over a date range to establish what it published and when, with a playback link for each snapshot.

Limits and honesty

This returns the index of captures and a playback URL for each; it does not return the archived HTML itself — you follow snapshot_url for that. Coverage is whatever the Internet Archive actually captured, which is uneven: some pages are archived nightly, others never, and the collector cannot show a snapshot that was never taken. The digest-collapse means you see distinct versions, not raw crawl frequency.

One run caps at 1,000 snapshots; larger domains are more runs against narrower date windows. Archived material remains subject to its original copyright — the Archive holding a copy does not change who owns it.

FAQ

Is the Wayback Machine API free?

The Internet Archive's CDX server is free to query. Here small usage falls under the $2-a-month free allowance — around 6,600 snapshots at $0.0003 each — then pay-as-you-go with no subscription.

Do I need a Wayback Machine API key?

No. The CDX server is keyless, and you authenticate only with your QuantumProxies key. There is no Internet Archive account or token to obtain.

What is the input — a URL or a domain?

The field is target. Pass a single page URL for that page's captures, or a bare domain with match_prefix set to true to enumerate every archived path under it.

Does it return the archived page content?

No. It returns the capture index — timestamps, status, MIME type, digest, length — and a snapshot_url for each. To read an archived page, follow its snapshot_url; this collector finds the snapshots rather than downloading them.

Related scrapers