Wayback Machine Snapshot Lookup — Archive History & Site Age

You give this actor a list of domains or URLs. For each one, it queries the Internet Archive's official, free Wayback Machine APIs — no scraping, no third-party lookup service — and tells you whether the page has ever been archived, the closest archived snapshot to right now, when it was first ever captured, when it was most recently captured, and roughly how old the site is. It's the "how old is this site, what did it look like" question, answered in one row per URL.

Who it's for

The accountable_eel catalogue sells company intelligence columns for outbound and diligence work. Each actor takes a list of domains or identifiers and returns one flat, stably-named row per input — firmographics, registry IDs, tech stack, archive history — the shape a Clay table, an n8n workflow, or an AI agent can consume without post-processing. Pricing is pay-per-event and per-domain: a fraction of a cent for a row that was actually found, and nothing for a miss, so a list that doesn't resolve costs you next to nothing. This one answers "does the Wayback Machine have this site, and how far back does its history go" — useful for domain due diligence (was this a parked domain last year, or a real business?), competitive research (what did a competitor's pricing page say two years ago), and content/SEO audits (how long has this URL existed).

Why this one

• Two official archive.org APIs, not one. The /wayback/available endpoint answers "what's the closest snapshot to now" but can't tell you how old a site is. This actor also queries the CDX index — the same system that powers web.archive.org's own capture calendar — to find the OLDEST capture on record, which is what "how old is this site" actually needs.
• Honest about sampling. The CDX hop is capped at 1,000 captures per lookup for speed. For the vast majority of sites that's every capture there is; for a handful of very heavily-archived domains it's a sample, and totalSnapshotsSampled is labelled and documented as exactly that — never presented as a true lifetime total.
• Never charged for a miss. A URL that has never been archived comes back with found: false and costs nothing. A URL that HAS at least one snapshot is charged once, regardless of how much the CDX hop was able to add.
• Fail-soft second hop. If the CDX index is slow or unreachable, the closest-snapshot result (the thing you're actually paying for) is unaffected — only the first-seen/last-seen/age fields come back empty, with a log line explaining why.
• No proxies, no headless browser, no auth. Both archive.org endpoints are free, public, and undefended — this is a plain HTTP fetch through Apify's default proxy.

What you get

Field	Type	Description
query	text	The domain or URL you submitted, echoed back
found	boolean	true if the Wayback Machine has at least one archived snapshot for this URL
status	text	OK on a hit; NOT_FOUND on a miss
message	text	Plain-English reason for a miss — only present when found is false
scrapedAt	ISO 8601 datetime	When the lookup ran
hasSnapshots	boolean	Always true on a found row (present for schema stability alongside found)
closestSnapshotDate	text (ISO date)	The archived snapshot closest to right now
closestSnapshotUrl	text	Direct web.archive.org URL for that closest snapshot
closestSnapshotTimestamp	text	The raw 14-digit Wayback timestamp behind closestSnapshotDate
firstSnapshotDate	text (ISO date)	The OLDEST capture on record — "how old is this site"
firstSnapshotTimestamp	text	The raw 14-digit Wayback timestamp behind firstSnapshotDate
lastSnapshotDate	text (ISO date)	The most recent capture in the sampled set
estimatedAgeYears	number	Years between firstSnapshotDate and today, one decimal place
totalSnapshotsSampled	number	Captures counted from the CDX index, capped at 1,000 — a sample, not a guaranteed true total on very heavily-archived sites

Deselect any field in the Input tab's column picker to drop it from every row — query, found, status, message, and scrapedAt always stay. The firstSnapshotDate/lastSnapshotDate/ estimatedAgeYears/totalSnapshotsSampled fields come back empty (not an error) on the rare run where the CDX hop itself fails — the closest-snapshot fields are unaffected either way.

Price

$3 per 1,000 domains or URLs, plus a $0.00005 start fee. Misses (found:false) are never charged.

How to use

1. In the Apify Console. Open the actor page and click Start — the urls field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. Via the API. Call it directly with a POST request — no Console needed once you have an API token:

   curl "https://api.apify.com/v2/acts/accountable_eel~wayback-snapshot-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"urls":["example.com","archive.org"]}'
   

3. On a schedule. Save this actor as an Apify Task with the input you want, then add a Schedule (hourly, daily, weekly) so it runs on its own — no server of your own required.

Typical uses: checking whether a domain someone is pitching you was a live business a year ago or a freshly-registered parked page, pulling up how a competitor's homepage or pricing page looked at a specific point in the past, or auditing your own site's archive coverage before a migration.

Input

{
  "urls": [
    "example.com",
    "archive.org"
  ]
}

One domain or URL per line, e.g. "example.com" or "https://example.com/about". Accepted formats: example.com, https://example.com/about, https://web.archive.org/web/20200101000000/https://example.com/.

Sample output

query	found	status	hasSnapshots	closestSnapshotDate	closestSnapshotUrl	closestSnapshotTimestamp	firstSnapshotDate	firstSnapshotTimestamp	lastSnapshotDate	estimatedAgeYears	totalSnapshotsSampled	scrapedAt
example.com	true	OK	true	2026-08-31T04:23:57Z	http://web.archive.org/web/20260831042357/https://example.com/	20260831042357						2026-08-31T06:30:26.423Z

A URL the Wayback Machine has never archived comes back as a row with found: false and a NOT_FOUND status, and is never charged.

Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

curl "https://api.apify.com/v2/acts/accountable_eel~wayback-snapshot-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"urls":["example.com","archive.org"]}'

n8n. Add an HTTP Request node: Method POST, URL https://api.apify.com/v2/acts/accountable_eel~wayback-snapshot-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>, Body Content Type JSON, JSON Body {"urls":["example.com","archive.org"]} (swap in an expression from an earlier node for a real value).

Clay. Add an "HTTP API" column: Method POST, URL https://api.apify.com/v2/acts/accountable_eel~wayback-snapshot-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>, Body {"urls":["{{domain or URL}}"]}, mapping the row's domain or URL into the urls array.

MCP. In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Wayback Machine Snapshot Lookup | Apify" — the agent will find and run this actor.

Tips

• Paste a bare domain when you want the site's overall archive history; paste a specific page URL (e.g. example.com/pricing) when you want that exact page's history — the two can have very different first-seen dates.
• A web.archive.org/web/... URL copied straight out of your browser's address bar is accepted — it's unwrapped back to the underlying URL before the lookup runs.
• totalSnapshotsSampled hitting exactly 1,000 is a sign the real capture count is higher — read it as "at least this many", not "exactly this many", for a heavily-archived domain.
• estimatedAgeYears is based on the OLDEST capture the Wayback Machine happens to have, not the domain's real registration date — a site can be older than its earliest snapshot if the Wayback Machine simply started crawling it later.

vs. alternatives

	What it costs	What you get	Trade-off
This actor (wayback-snapshot-lookup)	A fraction of a cent per found row, nothing for a miss	Closest snapshot, first-seen and last-seen capture dates, estimated site age, and a sampled capture count, straight from archive.org's own APIs	CDX is capped at 1,000 captures per lookup for speed — a true total on very heavily-archived sites is a floor, not an exact count
web.archive.org, by hand	Free	The same underlying data, one URL at a time in a browser	No batching, no structured output, no way to run it over a list programmatically
ryanclinton's Wayback Machine actor	Unrated, ~21 users/30 days	Wayback lookups via the same public API family	Thin usage and no rating to judge reliability against; this actor adds the CDX first-seen/age layer on top of the closest-snapshot lookup
Doing it yourself	Your time + handling the CDX pagination/format and the empty-response no-snapshot case	The same data	The 14-digit timestamp parsing, the empty-archived_snapshots miss case, and the fail-soft second hop are the maintenance burden this actor absorbs

Prices and user counts for third-party tools are approximate as of August 2026 and are not tracked here — check the vendor before relying on the comparison.

FAQ

Why is a row empty, or why does found say false? The Wayback Machine has never archived that exact URL. Try the bare domain instead of a specific page path — a page's own history can start later than the site's.

Am I charged for a miss? No. Actor.charge() only fires when /wayback/available returns at least one closest snapshot. A URL with zero archived history produces a found: false row and costs nothing.

Is totalSnapshotsSampled the real total number of captures? Not necessarily. It's capped at 1,000 for speed and cost. For most sites that's every capture there is; for a small number of very heavily-crawled domains (major news sites, for example) the real total is higher. Treat a value of exactly 1,000 as "at least 1,000".

What if the CDX hop fails but the closest-snapshot lookup succeeds? The row still comes back found: true with the closest-snapshot fields filled in — only firstSnapshotDate, lastSnapshotDate, estimatedAgeYears, and totalSnapshotsSampled come back empty. The closest-snapshot result is what's billed, and a slow or failed second hop never turns that into a miss.

Is this a live check or a stored database? Live. Every run queries archive.org's own APIs directly — there's no cached snapshot behind it.

Do I need to configure proxies? No. Both archive.org endpoints are free, public, and unauthenticated; the actor uses Apify's default proxy configuration out of the box.

Is this GDPR-relevant? No personal data is involved — this reads publicly archived page metadata (capture timestamps and URLs) from the Internet Archive's own public index.

Can I schedule this to re-check the same list on a cadence? Yes — set up an Apify Task with a schedule and point it at this actor with a saved input. Each run queries archive.org fresh, so a scheduled task will pick up new captures as they're archived.

Can an AI agent call this directly? Yes. It's registered on the Apify MCP server — an agent in Claude, Cursor, or another MCP client can find and run it by name ("Wayback Machine Snapshot Lookup | Apify"), or you can call the REST endpoint shown above from any script or workflow tool.

Related actors

• Domain RDAP Lookup — registration data (registrar, creation date, nameservers) for the same domain, from the official RDAP source.
• Tech Stack Lookup — what a site is built on right now, read live from its HTML and headers.
• HTTP Status Lookup — check a URL's live status, redirects, and response headers today, as a companion to this actor's historical view.