# Wayback Machine Scraper — Snapshots · No Login · Cheap (`gio21/wayback-machine-scraper`) Actor

List Internet Archive Wayback Machine snapshots for any URL: timestamp, snapshot URL, status code, MIME type and size. No login. Flat $0.001 per snapshot, cheaper than the Store leader.

- **URL**: https://apify.com/gio21/wayback-machine-scraper.md
- **Developed by:** [Gio](https://apify.com/gio21) (community)
- **Categories:** E-commerce, Developer tools, AI
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 snapshot scrapeds

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

## Wayback Machine Scraper — Snapshots · No Login · Cheap

List every snapshot the Internet Archive's Wayback Machine holds for one or more URLs: timestamp, snapshot URL, HTTP status code, MIME type, content length and digest. No login, no API key from the Internet Archive, and no browser automation needed on your side.

### Why use this scraper

The Wayback Machine's own CDX API is public but returns raw, undocumented rows that need parsing and date-range logic before they're usable, and most teams that need this data (OSINT researchers, brand monitors, legal and compliance teams checking what a site said on a given date) just want a clean list of snapshots per URL, not a CDX query language to learn.

This actor wraps that lookup: give it one or more URLs and, optionally, a date range, and get back one structured JSON record per archived snapshot, ready to filter, sort or join with your own data.

### Overview

Input is one or more URLs plus optional `from`/`to` date filters and a cap on snapshots per URL. The actor queries the Wayback Machine for each URL and returns one JSON record per archived snapshot: the input URL, the snapshot's timestamp, its full `web.archive.org` snapshot URL, the original URL at that point in time, HTTP status code, MIME type, content length and digest (useful for spotting when a page's content actually changed versus when it was merely re-crawled). A lookup of two URLs with 50 snapshots each typically finishes in a few seconds.

### Supported inputs

- **URLs (`urls`)** — one or more URLs to look up, e.g. `apify.com` or `https://www.example.com/page`.
- **Date range (`from`/`to`)** — optional start and end dates in `YYYY` or `YYYYMMDD` format to filter snapshots to a window; leave blank to get the full archive history.
- **Max snapshots per URL (`maxSnapshotsPerUrl`)** — caps how many snapshots are listed per URL (default 50, up to 1,000), so a long-lived domain with thousands of captures doesn't run away on its own.
- **Debug logs** — optional verbose logging for troubleshooting a run.

### Use cases

- **OSINT and investigative research** — reconstruct what a website said at a specific point in time, and track exactly when its content changed using the `digest` field.
- **Brand and competitor monitoring** — check how often and when a competitor's site, pricing page or terms page has changed over months or years.
- **Legal and compliance teams** — pull a date-stamped snapshot list as evidence of what a page published and when, ahead of a dispute or audit.
- **Content recovery** — find an old snapshot of a page that has since been taken down or redesigned, to recover text, structure or historical claims.
- **SEO and content history audits** — see how many times a page has been crawled and archived over its lifetime as a rough proxy for how actively it changed.

### How it works

The actor queries the Wayback Machine's own public snapshot index for each input URL and returns the matching capture records, respecting the optional date range and per-URL cap. Because this reads the Internet Archive's own public lookup rather than scraping rendered pages, there is no target-site anti-bot system to work around, and no login or API key from the Internet Archive is required.

### Input configuration

**Single URL, default range:**

```json
{
  "urls": ["apify.com"],
  "maxSnapshotsPerUrl": 50
}
```

**Multiple URLs with a date range:**

```json
{
  "urls": ["apify.com", "google.com"],
  "from": "2020",
  "to": "2023",
  "maxSnapshotsPerUrl": 100
}
```

**Full history, high cap for a long-lived domain:**

```json
{
  "urls": ["wikipedia.org"],
  "maxSnapshotsPerUrl": 500,
  "debug": false
}
```

### Output sample

Real output from a live run:

```json
[
  {
    "url": "apify.com",
    "timestamp": "20070531101538",
    "snapshotUrl": "https://web.archive.org/web/20070531101538/http://www.apify.com:80/",
    "originalUrl": "http://www.apify.com:80/",
    "statusCode": "200",
    "mimeType": "text/html",
    "digest": "EE6FCHP3MKBC3EV5D5Q4WQJNZNVUTNU6",
    "length": 1013
  },
  {
    "url": "apify.com",
    "timestamp": "20110210025321",
    "snapshotUrl": "https://web.archive.org/web/20110210025321/http://apify.com/",
    "originalUrl": "http://apify.com/",
    "statusCode": "200",
    "mimeType": "text/html",
    "digest": "YW37QD7ORZTIPSZS3TXWLLEG5APRIPB3",
    "length": 2801
  }
]
```

### Key output fields

| Field | Type | Description |
|---|---|---|
| `url` | string | The input URL this snapshot belongs to |
| `timestamp` | string | Capture timestamp in `YYYYMMDDhhmmss` format |
| `snapshotUrl` | string | Direct `web.archive.org` URL to view this exact snapshot |
| `originalUrl` | string | The original URL as captured at that point in time (protocol and `www` can vary across captures) |
| `statusCode` | string | HTTP status code the Wayback Machine recorded for the capture |
| `mimeType` | string | MIME type of the captured resource |
| `digest` | string | Content hash of the capture; identical digests across captures mean the content did not change between those crawls |
| `length` | number | Content length in bytes of the captured resource |

### Pricing

Pay-per-event, charged only for snapshots actually returned:

| Event | Price |
|---|---|
| Actor start | $0.00005 (one-time per run, scales with memory) |
| Snapshot scraped | $0.001 per snapshot |

At $0.001/snapshot, 1,000 snapshots cost about $1.00 plus the one-time start fee. Errors and empty lookups are not charged.

### What makes this richer than the competition

`ryanclinton/wayback-machine-search`, the highest-traffic Wayback Machine actor on the Store, charges $0.0035 per snapshot on its Free tier, nearly 3.5 times this actor's flat $0.001, dropping only to $0.00063 at its top Diamond tier; a Free or Bronze-tier buyer, which is most buyers trying the category, pays substantially more there than this actor's single flat rate regardless of plan. `andok/wayback-machine-scraper`, the other established actor in the category, does not publish a fixed per-event number in its listing, which makes this actor's transparent $0.001/snapshot easier to budget against up front.

### Notes & limitations

- The Wayback Machine itself sometimes records the exact same timestamp more than once for a URL (seen in the sample above for `google.com`); this is the Internet Archive's own index, not duplication introduced by the actor.
- `statusCode` reflects what the Wayback Machine recorded at crawl time; a page that returned an error when the Internet Archive's crawler visited it will show that error code here, not a successful one.
- Very old captures (pre-2000) can have minimal `length` and sparse metadata because the Internet Archive's own crawling and indexing were less thorough in its early years; this is a limitation of the source archive, not the actor.
- The actor lists snapshot metadata only; it does not download or render the archived page's HTML content itself. Use the `snapshotUrl` to open or separately fetch the archived page if you need its content.
- A URL with no snapshots in the Wayback Machine (never crawled, or blocked by the site's historical `robots.txt`) returns zero records for that URL; this reflects the archive's own coverage, not an actor failure.
- `from`/`to` date filters narrow by the Wayback Machine's own index granularity; a filter narrower than any available snapshot simply returns no results for that URL.

### FAQ

**Does this need a Wayback Machine or Internet Archive account?**
No. The actor queries the Internet Archive's public snapshot index, which requires no account or API key.

**Can I get the full HTML content of a snapshot, not just its metadata?**
Not directly from this actor; use the returned `snapshotUrl` to open or fetch the archived page separately.

**Why do I see two records with the exact same timestamp?**
The Wayback Machine's own index occasionally lists the same capture twice; this is the source archive's behavior, not an actor artifact.

**Can I look up more than one URL in the same run?**
Yes, list as many URLs as you need in the `urls` array; each is queried and returned separately.

**What date format does `from`/`to` expect?**
Either a 4-digit year (`"2023"`) or a full date (`"20230115"`); leave both blank for the complete archive history.

**Does the price change based on my Apify plan?**
No. This actor charges a flat $0.001 per snapshot regardless of your Apify plan tier, unlike the category leader whose price depends heavily on plan tier.

**Can I schedule this to run automatically?**
Yes, use Apify's built-in Scheduler to re-check a set of URLs periodically and track when new snapshots appear.

### For AI Agents & LLM Apps

This actor is available over the Apify MCP server (`mcp.apify.com`) for direct use from Claude, Cursor or any MCP-compatible agent, and over the plain REST API for scripted pipelines.

Synchronous call that returns dataset items directly, no polling required:

```bash
curl "https://api.apify.com/v2/acts/gio21~wayback-machine-scraper/run-sync-get-dataset-items?token=<APIFY_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"urls": ["apify.com"], "maxSnapshotsPerUrl": 50}'
```

A single URL with the default `maxSnapshotsPerUrl` of 50 is the sweet spot for a quick history check; raise it for a domain you know has thousands of captures.

### Disclaimer

This actor is an independent tool that reads publicly available Internet Archive Wayback Machine data. It is not affiliated with, endorsed by or sponsored by the Internet Archive. "Wayback Machine" is a trademark of the Internet Archive. Use it in line with the Internet Archive's own terms and any applicable data protection law in your jurisdiction.

### SEO Keywords

Wayback Machine scraper, Internet Archive API, website history scraper, snapshot lookup tool, OSINT Wayback Machine, no-login Wayback Machine API.

# Actor input Schema

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

URLs to look up in the Internet Archive Wayback Machine.

## `from` (type: `string`):

Optional start date to filter snapshots.

## `to` (type: `string`):

Optional end date to filter snapshots.

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

Max snapshots to list per input URL.

## `debug` (type: `boolean`):

Enable verbose logging.

## Actor input object example

```json
{
  "urls": [
    "apify.com",
    "google.com"
  ],
  "from": "",
  "to": "",
  "maxSnapshotsPerUrl": 50,
  "debug": false
}
```

# Actor output Schema

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

One snapshot record per archived capture: url, timestamp, snapshotUrl, statusCode, mimeType, length, digest.

# 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": [
        "apify.com",
        "google.com"
    ],
    "from": "",
    "to": "",
    "maxSnapshotsPerUrl": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("gio21/wayback-machine-scraper").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": [
        "apify.com",
        "google.com",
    ],
    "from": "",
    "to": "",
    "maxSnapshotsPerUrl": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("gio21/wayback-machine-scraper").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": [
    "apify.com",
    "google.com"
  ],
  "from": "",
  "to": "",
  "maxSnapshotsPerUrl": 50
}' |
apify call gio21/wayback-machine-scraper --silent --output-dataset

```

## MCP server setup

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

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/kRb43SzdoNOy1rQPR/builds/3AczJBTVbJcVqTFVX/openapi.json