# Internet Archive Snapshot Finder (`daddyd-prints/internet-archive-snapshot-finder`) Actor

Lists the Internet Archive captures of any URL, path or domain: date, status code, type and a link to each archived copy. Newest first for a single page, with date, status and duplicate filters. Pay per snapshot found.

- **URL**: https://apify.com/daddyd-prints/internet-archive-snapshot-finder.md
- **Developed by:** [Derek Derringer](https://apify.com/daddyd-prints) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Internet Archive Snapshot Finder

### What it does

This Actor lists the captures the Internet Archive holds for a web address. Give it one address or a list. For each capture you get the date and time, the HTTP status the page answered with, the content type, a content fingerprint and a direct link to the archived copy.

It searches one exact address, every page under a path, every page on a host, or a whole domain with its subdomains. You can keep only working pages (2xx), only redirects or only errors, limit the dates, keep one capture per day, month or year, drop captures whose content did not change, or keep one capture per address.

Common uses:

- **Find a live copy of a dead page.** Exact address, newest first, status 2xx, maximum 1.
- **List the pages a site had.** Domain search, one per URL, web pages only. Raise **Maximum snapshots per URL** from its default of 100 (up to 10,000 addresses per line).
- **See how often a page changed.** Exact address, unique content only.

It reads only the archive's public capture index. It never downloads the archived pages, never logs in and contacts no other site.

### How to use it

1. Open the Actor in Apify Console.
2. Put one address or domain per line in **URLs or domains**, for example `example.com` or `https://example.com/old-page`.
3. Choose a **Match type**, and any filters you want.
4. Click **Start**.
5. When the run ends, open the **Output** tab. The **Snapshots** view shows each capture with a link to the archived copy. Export as CSV, JSON or Excel.

A line ending in `/*` is searched as a prefix, and a line starting with `*.` as a whole domain, whatever **Match type** says.

### Input

| Field | What it does | Default | Limits |
| --- | --- | --- | --- |
| URLs or domains (`urls`) | The addresses to search, one per line. | None. Prefilled with `https://apify.com/` | http and https addresses or bare domain names. Up to 1,000 lines. Lines the archive treats as the same search are searched once |
| Match type (`matchType`) | `exact`: that one address. `prefix`: every page under the path. `host`: every page on the host. `domain`: the domain and its subdomains. | `exact` | |
| Order (`order`) | `newest` or `oldest` first, for exact addresses. | `newest` | See the note below |
| Maximum snapshots per URL (`maxSnapshotsPerUrl`) | The most snapshots saved for each line. | 100 | 1 to 10,000 |
| From date (`fromDate`) | Only captures on or after this date: `2019`, `2019-06` or `2019-06-30`. | None | |
| To date (`toDate`) | Only captures on or before this date. A year or month includes all of it. | None | |
| Status code (`statusFilter`) | `any`, `2xx`, `3xx`, `4xx` or `5xx`. | `any` | |
| Web pages only (`htmlOnly`) | Keep only text/html captures. | false | |
| Collapse (`collapse`) | `none`, `day`, `month`, `year` (first capture of each period), `content` (drop unchanged captures) or `url` (one capture per address). | `none` | |

**About order.** The archive's index is sorted by address, then by time. For an exact address, newest first gives the most recent captures. Prefix, host and domain searches always come back in the archive's own order: address by address, oldest first within each address. To get recent captures of a whole site, set **From date**. Collapse works on captures that sit next to each other in that order.

**About duplicate lines.** The archive treats http and https, a leading `www.`, upper and lower case, and a trailing slash on an exact address as the same address. Lines that differ only in those ways are searched once; the others are listed in SKIPPED as `duplicate`. Lines that overlap without being the same, such as a prefix inside a domain, are separate searches, so a capture can appear once for each of them, and each is charged.

A date that cannot be read (including a day that does not exist), or a From date after the To date, stops the run before any search, so nothing is charged for results you did not ask for.

### Output

One dataset item per snapshot:

| Field | What it holds |
| --- | --- |
| `inputUrl`, `matchType` | The line from your input, as it was searched, and how it was matched |
| `originalUrl` | The address the archive captured. In prefix, host and domain searches, the page found |
| `archiveUrl` | Link to the archived copy |
| `timestamp`, `capturedAt` | The capture time as the archive writes it (14 digits, UTC) and in ISO 8601 |
| `statusCode` | The HTTP status the page answered with when captured. Empty when the archive did not record one |
| `mimeType` | The content type. `warc/revisit` means the content was the same as an earlier capture |
| `contentDigest` | The archive's fingerprint of the content. Same digest, same content |
| `recordLengthBytes` | Size of the compressed archive record, not of the page itself |
| `urlKey` | The archive's sort key for the address |

Example row from a test run, the newest working capture of a page:

```json
{"inputUrl": "https://www.python.org/about/", "matchType": "exact", "originalUrl": "https://www.python.org/about/", "archiveUrl": "https://web.archive.org/web/20261012134310/https://www.python.org/about/", "timestamp": "20261012134310", "capturedAt": "2026-10-12T13:43:10Z", "statusCode": 200, "mimeType": "text/html", "contentDigest": "22GOVU7B7QLGERIRMN4E6TVIGC67CIHA", "recordLengthBytes": 9995, "urlKey": "org,python)/about"}
```

### Pricing

This Actor is priced per event, with two charges:

- **Actor start:** Apify's automatic start event, $0.0001 per start (one event per GB of run memory, minimum one; this Actor runs at 256 MB, so one per run).
- **Snapshot:** one charge for each snapshot written to the dataset.

**Price per snapshot: $2.00 per 1,000, which is $0.002 each.**

These are never charged: lines with no captures, lines the archive could not answer, lines not searched, exact duplicate index rows, rows without a usable time or address, and the REPORT and SKIPPED records.

Each search asks the archive for no more rows than the run's remaining budget can pay for. If you set a maximum cost for the run and it is reached, the Actor stops, lists the rest in SKIPPED as `spending_limit_reached`, and ends the run without an error.

### Records

| Record | What it holds |
| --- | --- |
| REPORT | Why the run stopped, the settings used, snapshots saved per line, whether more may exist, duplicates dropped, requests made, retries and waits |
| SKIPPED | Every line that gave no snapshots, was not searched, or was cut short, with the reason: `no_snapshots`, `invalid_url`, `duplicate`, `archive_error`, `archive_unavailable`, `rate_limited`, `spending_limit_reached` and others. Only the snapshots in the dataset are charged; a line cut short keeps the snapshots it already saved |

### How it treats the archive

- The archive's robots.txt is read first and obeyed. If it cannot be read, nothing is searched.
- One request at a time, at least one second apart.
- If the archive answers 429 or a server error, the Actor waits (as long as the archive asks, up to five minutes) and tries again, up to three times. If the archive keeps answering 429, or asks for a wait longer than five minutes, the run stops asking and lists the remaining lines in SKIPPED. After three lines in a row the archive could not answer, or answered with something unreadable, the run stops.
- No cookie, login or proxy. The user agent starts with `internet-archive-snapshot-finder/0.1`.

### Your responsibility

This Actor is not affiliated with or endorsed by the Internet Archive. The Internet Archive's Terms of Use say access to its collections is for scholarship and research purposes. You are responsible for following those terms and the law in how you use the results and the archived pages they link to.

### Limits

| Limit | Value |
| --- | --- |
| Lines per run | 1 to 1,000 |
| Snapshots per line | 1 to 10,000 |
| Search time | Exact addresses usually take 1 to 5 seconds. Prefix, host and domain searches can take 10 seconds to 2 minutes each, longer when the archive is busy |
| Memory | 256 MB |

# Actor input Schema

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

One web address or domain per line, for example example.com or https://example.com/old-page. A line ending in /\* is searched as a prefix (every page under that path), and a line starting with \*. is searched as a whole domain with its subdomains, whatever Match type says. Up to 1,000 lines.

## `matchType` (type: `string`):

Exact: captures of that one address. Prefix: every page under that path. Host: every page on that host. Domain: every page on that domain and its subdomains. Prefix, host and domain searches can take 10 seconds to 2 minutes each, longer when the archive is busy.

## `order` (type: `string`):

For an exact address: newest first gives the most recent captures, which is what you want for finding a live copy of a dead page; oldest first starts at the first capture. Prefix, host and domain searches always come back in the archive's own order, address by address and oldest first within each address. To get recent captures of a whole site, set From date.

## `maxSnapshotsPerUrl` (type: `integer`):

The most snapshots saved for each line of the list. Each saved snapshot is one charged result.

## `fromDate` (type: `string`):

Only captures on or after this date. Write a year (2019), a month (2019-06) or a day (2019-06-30). Leave empty for no start date.

## `toDate` (type: `string`):

Only captures on or before this date, in the same form as From date. A year or month includes the whole year or month. Leave empty for no end date.

## `statusFilter` (type: `string`):

Keep only captures whose archived answer had this status. 2xx finds working copies; 3xx finds redirects; 4xx and 5xx find error pages the archive recorded.

## `htmlOnly` (type: `boolean`):

Keep only captures whose type is text/html, so images, scripts and other files are left out.

## `collapse` (type: `string`):

Thin out captures that sit next to each other in the archive's index. One per day, month or year keeps the first of each period. Unique content drops captures whose content did not change. One per URL keeps one capture of each address, useful with prefix or domain searches.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com/"
  ],
  "matchType": "exact",
  "order": "newest",
  "maxSnapshotsPerUrl": 100,
  "statusFilter": "any",
  "htmlOnly": false,
  "collapse": "none"
}
```

# Actor output Schema

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

No description

## `report` (type: `string`):

No description

## `skipped` (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": [
        "https://apify.com/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("daddyd-prints/internet-archive-snapshot-finder").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": ["https://apify.com/"] }

# Run the Actor and wait for it to finish
run = client.actor("daddyd-prints/internet-archive-snapshot-finder").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": [
    "https://apify.com/"
  ]
}' |
apify call daddyd-prints/internet-archive-snapshot-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,daddyd-prints/internet-archive-snapshot-finder"
        }
    }
}
```

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/v0T1TJd3z8QGycqTh/builds/3LQ7RSFGXWRsrgsNu/openapi.json