# Wayback Machine Snapshot Lookup — Archive History & Site Age (`accountable_eel/wayback-snapshot-lookup`) Actor

Look up any domain or URL against the Internet Archive's Wayback Machine. Get the closest archived snapshot, first-ever and most recent capture dates, an estimated site age, and a sample of total captures — all from official archive.org APIs. Charged only when a snapshot exists.

- **URL**: https://apify.com/accountable\_eel/wayback-snapshot-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 domain archive history founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 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:
   ```bash
   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

```json
{
  "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.

```bash
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](https://apify.com/accountable_eel/domain-rdap-lookup) — registration data
  (registrar, creation date, nameservers) for the same domain, from the official RDAP source.
- [Tech Stack Lookup](https://apify.com/accountable_eel/tech-stack-lookup) — what a site is built
  on right now, read live from its HTML and headers.
- [HTTP Status Lookup](https://apify.com/accountable_eel/http-status-lookup) — check a URL's live
  status, redirects, and response headers today, as a companion to this actor's historical view.

# Actor input Schema

## `urls` (type: `array`):

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/. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## `proxyConfiguration` (type: `object`):

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "urls": [
    "example.com",
    "archive.org"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "columns": [
    "hasSnapshots",
    "closestSnapshotDate",
    "closestSnapshotUrl",
    "closestSnapshotTimestamp",
    "firstSnapshotDate",
    "firstSnapshotTimestamp",
    "lastSnapshotDate",
    "estimatedAgeYears",
    "totalSnapshotsSampled"
  ],
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "example.com",
        "archive.org"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/wayback-snapshot-lookup").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "urls": [
        "example.com",
        "archive.org",
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/wayback-snapshot-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "example.com",
    "archive.org"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/wayback-snapshot-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/wayback-snapshot-lookup"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ezL4tjyM07Nk1vLaK/builds/FjSatiXmRubaKuWDi/openapi.json