# Wayback Machine Checker — Archive.org Snapshot Diffs (`taroyamada/wayback-machine-checker`) Actor

Wayback Machine (archive.org) checker: compare snapshots and detect URL changes. No API key / no login. Open Input → leave defaults → Start (1 URL ≈ USD 0.008): https://console.apify.com/actors/fy1UnkQNIzGyy8HIs/input From USD 8/1k.

- **URL**: https://apify.com/taroyamada/wayback-machine-checker.md
- **Developed by:** [naoki anzai](https://apify.com/taroyamada) (community)
- **Categories:** SEO tools, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 19 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$8.00 / 1,000 wayback archive 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

## 📚 Wayback Machine Checker

**What you get:** one row per URL with whether the Internet Archive has it (`available`), the closest snapshot (archive URL, timestamp, HTTP status), and a `status` field, billed at $0.008 per row.

Sample output from a real run (2026-10-18, the JSON below: 1 URL):

| url | available | closestSnapshot.timestamp | closestSnapshot.status | billed |
|---|---|---|---|---|
| https://example.com | true | 20261017144033 | 200 | $0.008 |

**CTA:** Open **Input** (link below) → leave defaults (1 URL) → **Start**. First paid proof ≈ **USD 0.008**.
[Open Input (leave defaults → Start)](https://console.apify.com/actors/fy1UnkQNIzGyy8HIs/input)
Paid first run ≈ **USD 0.008** total (1 URL): 1×USD 0.008 archive row. Open Console Input (deep link above) and run this JSON.

```json
{
  "urls": [
    "https://example.com"
  ],
  "concurrency": 2,
  "dryRun": false
}
```

Instantly check bulk lists of URLs against the Internet Archive to discover cached web pages and extract historical site data. Designed for technical SEO professionals and site administrators, this Wayback Machine checker automates the discovery of archived content at scale. Instead of loading the archive interface for every broken link, simply input your URL list and let the scraper query the underlying API to find exact snapshot matches.

Large-scale website migrations frequently result in orphaned pages and 404 errors. This tool is built to cross-reference your dead URLs with historical web cache data, enabling rapid recovery of lost link equity. Web developers and SEO teams use this scraper to map legacy site structures, audit domain history before acquisitions, and rescue deleted content that Google search previously indexed.

The scraper efficiently processes bulk requests, returning highly structured results for your technical audits. For every requested URL, you will extract the exact timestamp of the most recent snapshot, the direct Wayback Machine URL for the cached HTML, and the HTTP status code of the original capture. Schedule this checker to run alongside your regular broken link crawlers to instantly identify which dead pages can be fully restored from the web archive.

> 📄 **Live sample output**: see [`docs/sample-output.json`](docs/sample-output.json) for a representative dataset captured from a real run of this actor. Use it to validate the schema before subscribing.

### Store Quickstart

Start with the **Quickstart** template to verify 3 archived URLs. For bulk verification, use **Portfolio Archive Check** with up to 500 URLs. For content recovery, use **404 Recovery** after running Broken Link Checker.

### Use with Apify MCP

Exact actor: `taroyamada/wayback-machine-checker`

Sample input JSON:

```json
{
  "urls": [
    "https://example.com"
  ],
  "concurrency": 2,
  "dryRun": false
}
```

### Key Features

- 📚 **Official Internet Archive API** — Uses archive.org/wayback/available endpoint
- 📅 **Closest-snapshot lookup** — Find archived version nearest to any date
- 🔍 **Availability check** — Know if a URL was ever archived
- 📊 **Snapshot count** — Total archived versions per URL
- ⚡ **Bulk processing** — Up to 500 URLs per run
- 🔑 **No API key needed** — Free, open Internet Archive service

### Use Cases

| Who | Why |
|-----|-----|
| **Compliance teams** | Legal evidence preservation for regulated industries |
| **Journalists** | Verify historical versions of web pages that may have been edited |
| **SEO recovery** | Restore content from accidentally deleted pages |
| **Brand protection** | Track archived versions of competitor sites over time |
| **Academic research** | Cite archived web sources in publications |

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| urls | string\[] | (required) | URLs to check in archive (max 500) |
| closest | string |  | Target date in YYYYMMDD format (optional; empty = latest snapshot) |
| concurrency | integer | 3 | Parallel requests (1–5) |
| maxChargeUsd | number | 0.02 | Safety cap for billable rows in this run |

#### Input Example

```json
{
  "urls": ["https://example.com/old-article", "https://deleted-site.com"],
  "closest": "20200101"
}
```

### Input Examples

#### Example: Single URL availability

```json
{
  "urls": [
    "https://example.com"
  ]
}
```

#### Example: Small batch with a cost cap

```json
{
  "urls": [
    "https://example.com",
    "https://www.iana.org/domains/reserved"
  ],
  "concurrency": 2,
  "maxChargeUsd": 0.05
}
```

#### Example: Snapshot closest to a past date

```json
{
  "urls": [
    "https://example.com"
  ],
  "closest": "20150101"
}
```

### Output

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | URL queried |
| `available` | boolean | Whether the Wayback Machine returned a snapshot |
| `closestSnapshot.url` | string | Archive URL of the closest snapshot |
| `closestSnapshot.timestamp` | string | Snapshot time (YYYYMMDDhhmmss) |
| `closestSnapshot.status` | string | HTTP status of the archived capture |
| `status` | string | `success` or an error status |
| `chargedUsd` | number | Charge for this row |

#### Output Example

Real row from the 2026-10-18 run of the JSON at the top (trimmed):

```json
{
  "url": "https://example.com",
  "available": true,
  "closestSnapshot": {
    "url": "http://web.archive.org/web/20261017144033/https://www.example.com/",
    "timestamp": "20261017144033",
    "status": "200"
  },
  "error": null,
  "status": "success",
  "chargedEvent": "apify-default-dataset-item",
  "chargedUsd": 0.008
}
```

### API Usage

Run this actor programmatically using the Apify API. Replace `YOUR_API_TOKEN` with your token from [Apify Console → Settings → Integrations](https://console.apify.com/account/integrations).

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/taroyamada~wayback-machine-checker/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "urls": ["https://example.com/old-article", "https://deleted-site.com"], "closest": "20200101" }'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("taroyamada/wayback-machine-checker").call(run_input={
  "urls": ["https://example.com/old-article", "https://deleted-site.com"],
  "closest": "20200101"
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('taroyamada/wayback-machine-checker').call({
  "urls": ["https://example.com/old-article", "https://deleted-site.com"],
  "closest": "20200101"
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Tips & Limitations

- Use `closest: "20200101"` format (YYYYMMDD) to find a specific historical snapshot.
- Great for verifying when a page was first published or last modified.
- Combine with Broken Link Checker to recover content from dead pages via archive links.
- Wayback Machine is free but rate-limits aggressive callers — keep concurrency low.

### FAQ

**How far back can I check?**

Internet Archive has snapshots back to 1996. Coverage depends on whether a URL was crawled.

**Why is my URL 'not available'?**

Either it was never archived, or Internet Archive excluded it (due to robots.txt or removal request).

**Is this the same as running `curl` to archive.org?**

Yes, but with bulk processing, error handling, and structured output for datasets.

**Can I archive new URLs?**

This actor only reads from the archive. To save NEW pages, use archive.org's /save/ endpoint.

**Why is `archived` false for my URL?**

The Internet Archive may not have crawled that URL yet, or robots.txt blocked it at the time.

**Can I trigger a new snapshot?**

Not via this actor. Use the Wayback Machine 'Save Page Now' feature manually.

### Complete Your Website Health Audit

**Website Health Suite** — Build a comprehensive compliance and trust monitoring workflow:

**1. Link & URL Health**

- [🔗 Broken Link Checker](https://apify.com/taroyamada/broken-link-checker) — Find broken links across your entire site structure
- [🔗 Bulk URL Health Checker](https://apify.com/taroyamada/bulk-url-health-checker) — Validate HTTP status, redirects, SSL, and response times

**2. SEO & Metadata Quality**

- [🏷️ Meta Tag Analyzer](https://apify.com/taroyamada/meta-tag-analyzer) — Audit title tags, Open Graph, Twitter Cards, and hreflang
- [Schema.org Validator](https://apify.com/taroyamada/structured-data-validator) — Validate JSON-LD and Microdata with quality scoring

**3. Security & Email Deliverability**

- [DNS/DMARC Security Checker](https://apify.com/taroyamada/dns-dmarc-security-checker) — Audit SPF, DKIM, DMARC, and MX records

**4. Historical Data & Recovery** (you are here)

- [📚 Wayback Machine Checker](https://apify.com/taroyamada/wayback-machine-checker) — Find archived snapshots for content recovery

**Recommended workflow**: Run Broken Link Checker → Export 404 URLs → Use Wayback Machine Checker to find archived versions → Restore content → Validate with URL Health Checker.

**Other Website Tools:**

- [Sitemap Analyzer](https://apify.com/taroyamada/sitemap-analyzer) — SEO sitemap audit
- [Site Governance Monitor](https://apify.com/taroyamada/site-governance-monitor) — Robots.txt and schema monitoring
- [Domain Trust Monitor](https://apify.com/taroyamada/domain-trust-monitor) — SSL expiry and security headers

### Cost

**Pay Per Event**:

- `actor-start`: $0.01 (flat fee per run)
- `dataset-item`: $0.003 per output item

**Example**: 1,000 items = $0.01 + (1,000 × $0.003) = **$3.01**

No subscription required — you only pay for what you use.

> 💾 **Save it for later**: click the bookmark icon at the top of the Apify Store page if you'd like to come back to it. Bookmarks help other engineers find this actor via Apify's discovery surfaces.

### ⭐ Was Wayback Machine Bulk Checker useful for your URL archive history?

If this actor saved you time, **[please leave a 5★ rating on Apify Store](https://apify.com/taroyamada/wayback-machine-checker/reviews)** — it takes 10 seconds, helps other engineers and analysts discover it, and keeps updates free.

Have a feature request, bug, or sample workflow you'd like to share? **[Open an issue](https://apify.com/taroyamada/wayback-machine-checker/issues)** — we read every one and use them to prioritise the next release.

# Actor input Schema

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

URLs to check in the Wayback Machine (max 500).

## `closest` (type: `string`):

Find snapshot closest to this date (YYYYMMDD format). Leave empty for latest.

## `concurrency` (type: `integer`):

Keep low to respect Internet Archive rate limits.

## `maxChargeUsd` (type: `number`):

Safety cap for this run. Results beyond the cap are kept in output as no-charge limit_reached rows.

## `delivery` (type: `string`):

Where to send results: dataset or webhook

## `webhookUrl` (type: `string`):

Webhook URL to POST results to (if delivery=webhook)

## `dryRun` (type: `boolean`):

Run without saving results (for testing)

## Actor input object example

```json
{
  "urls": [
    "https://example.com"
  ],
  "concurrency": 1,
  "maxChargeUsd": 0.02,
  "delivery": "dataset",
  "dryRun": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all scraped data

# 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://example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("taroyamada/wayback-machine-checker").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://example.com"] }

# Run the Actor and wait for it to finish
run = client.actor("taroyamada/wayback-machine-checker").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://example.com"
  ]
}' |
apify call taroyamada/wayback-machine-checker --silent --output-dataset

```

## MCP server setup

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

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/fy1UnkQNIzGyy8HIs/builds/7UKZ0WumYCc6YCdPs/openapi.json