# Wayback Archive History - Capture Metadata & Changes (`maydit/wayback-archive-history-monitor`) Actor

Find archived URL captures with timestamps, original URLs, HTTP status, content digests and replay links. Track newly observed captures in bounded watchlists; no API key.

- **URL**: https://apify.com/maydit/wayback-archive-history-monitor.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 saved observations

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?

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 Archive History - Capture Metadata & Changes

Find historical evidence without downloading whole websites. Give this Actor an exact URL and receive a small, structured window of Wayback capture metadata: capture date, original URL, HTTP status, MIME type, content digest, archive record length and a replay link.

### Useful for

- SEO and migration teams investigating historical URL coverage.
- Due-diligence analysts collecting dated source references.
- AI research workflows that need capture timestamps and provenance before retrieving content.

### Start in one minute

1. Paste up to five exact public URLs.
2. Choose a capture window and optional date range.
3. Run, then inspect the Dataset and readable Run report. Export JSON or CSV.

### Copy an input

#### Latest example.com captures

Inspect up to three recent indexed captures of one exact URL.

```json
{
  "urls": [
    "https://example.com/"
  ],
  "capturesPerUrl": 3,
  "maxResults": 3
}
```

#### Two-domain archive check

Get one recent capture for each of two exact URLs.

```json
{
  "urls": [
    "https://example.com/",
    "https://example.net/"
  ],
  "capturesPerUrl": 1,
  "maxResults": 2
}
```

#### Historical 2020 window

Inspect a bounded historical capture window, independent of current live content.

```json
{
  "urls": [
    "https://example.com/"
  ],
  "fromDate": "2020-01-01",
  "toDate": "2020-12-31",
  "capturesPerUrl": 3,
  "maxResults": 3
}
```

### What the results mean

`capturedAt` is the archive timestamp. `observedAt` is when this tool queried the index. `digest` is the source CDX digest, not a newly verified page hash. `archiveLength` is the CDX archive-record length, not the size of a live page. `replayUrl` is a constructed source link; this tool does not fetch it or guarantee replay availability.

Only HTTP200 captures are selected. Exact URL means the CDX canonical match: the archive can group scheme, www, path letter case and query-parameter order variants. Original URLs are preserved verbatim, and nondefault ports or unrelated hosts/paths are rejected. The CDX API uses fast latest lookup. It may return fewer than the requested captures. `SUMMARY.sourceCoverage` records returned and saved counts. Empty matching windows are valid; blocked, malformed and timed-out responses are failures rather than empty results.

### Track new observations

Set `comparePrevious: true` and reuse `snapshotName`. A complete first run saves a baseline; later output reports `new`, `changed` or `unchanged` with changed fields and prior values. `onlyChanges: true` suppresses unchanged rows. URL list, date filters, capture limit and snapshot name define the scope. Incomplete output, source errors, time limits and charge limits do not advance history. Avoid simultaneous writers to one snapshot; conflict detection prevents overwriting a changed baseline. Missing captures are never labelled removed.

### Pricing and limits

Base pricing: $0.002 per saved capture, plus $0.00005 Actor start; platform tier discounts are shown in the Store. Three captures cost $0.00605 before any platform-specific adjustments. You pay for observations saved, including unchanged rows unless `onlyChanges` is enabled. Maximum five URLs, twenty captures per URL, one hundred saved rows and a 120-second source budget.

### Deliberate scope

No page-text extraction, full-site archive crawling, wildcard/domain enumeration, historical completeness guarantee or live-website availability check. This independent tool is not affiliated with the Internet Archive. Access restrictions and source delays are reported honestly. No API key required.

### API and automation

Use the Apify API, saved Tasks, schedules or the Apify MCP integration with the same JSON input. Export the Dataset to your spreadsheet or pipeline; use SUMMARY to decide whether a run is complete.

[Official Wayback documentation](https://archive.org/help/wayback_api.php) · [CDX API reference](https://github.com/internetarchive/wayback/tree/master/wayback-cdx-server) · [Mayd It data tools](https://mayd-it.com/data-tools/)

Questions or a source-format change? Open an issue on this Actor with a public URL and run ID. Never post credentials.

# Actor input Schema

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

Up to five public HTTP(S) URLs. Empty uses example.com. Exact URL queries only; no wildcards, credentials or private network addresses.

## `capturesPerUrl` (type: `integer`):

Fast latest CDX metadata, up to this many captures. The source can return fewer; this is not exhaustive archive enumeration.

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

Optional real YYYY-MM-DD UTC date, inclusive.

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

Optional real YYYY-MM-DD UTC date, inclusive.

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

Maximum rows across URLs. A cap that leaves selected observations unread prevents history updates.

## `comparePrevious` (type: `boolean`):

Compare capture metadata with the last complete run for this exact URL/date/window scope. Missing captures are not removals.

## `onlyChanges` (type: `boolean`):

Save only newly observed or changed capture metadata. Enables comparison; a successful unchanged run may save zero rows.

## `snapshotName` (type: `string`):

1–80 letters, numbers, underscores or hyphens. Reuse for the same watchlist; choose a new name for independent history.

## `maxRunSeconds` (type: `integer`):

Shared deadline for all source requests. Stops safely within this budget or the platform timeout, whichever is earlier.

## Actor input object example

```json
{
  "urls": [
    "https://example.com/"
  ],
  "capturesPerUrl": 3,
  "maxResults": 15,
  "comparePrevious": false,
  "onlyChanges": false,
  "snapshotName": "default",
  "maxRunSeconds": 90
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/wayback-archive-history-monitor").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("maydit/wayback-archive-history-monitor").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 maydit/wayback-archive-history-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maydit/wayback-archive-history-monitor"
        }
    }
}
```

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/yhUpMEztVXJOZ9lN4/builds/ZzI7OXEyZmyUs8oso/openapi.json