Wayback Machine

Look up Internet Archive snapshot availability and closest cache URLs for up to 500 known URLs

Wayback Machine Bulk Checker queries the Internet Archive Wayback Machine available endpoint for URL lists you already have (maximum 500 per run). It reports whether a URL was archived and, when present, the closest snapshot URL and timestamp. It is a read-only archive lookup — not live HTTP status QA, not nested sitemap XML discovery, and not a tool that saves new snapshots.

Try Input: 1 URL = $0.008 if one lookup row is delivered. Store Quickstart 3 URLs can be $0.024. $8.00 / 1,000 results. No Actor Start.

Try the cheapest first paid Wayback lookup on Apify Input

Open taroyamada/wayback-machine-checker on the Apify Store · 404 recovery first paid path

Archive availability lookups, not live HTTP status and not sitemap XML

Use this page when you already have URLs and need to know whether the Internet Archive cached them. Use Bulk URL Status Checker when you need live HTTP status, redirect chains, and timing on a known list. Use Sitemap Scraper & Analyzer when the job is to parse nested sitemap.xml files and invent URL lists. Use Website Content Extractor to clean live docs, pricing, policy, or product pages. Use Article Content Extractor to clean live news, blog, or press pages.

Wayback Machine Bulk Checker Bulk URL Status Checker Sitemap Scraper & Analyzer
Intent Verify Internet Archive cache availability and closest snapshots HTTP status, redirect-chain, timing, and broken-URL QA on a known list Discover URLs from nested XML sitemaps; optional HEAD 200 / indexability check
Input Known URLs in urls (max 500) Known page URLs in urls (max 1000) Required sitemapUrls (sitemap.xml or a domain that auto-discovers /sitemap.xml)
What it reads Wayback Machine archive.org/wayback/available endpoint Live HTTP(S) responses for those URLs; it does not crawl pages Sitemap XML and sitemap index files; optional HEAD on discovered URLs when checkStatus is true
Primary output Availability plus closest snapshot URL and timestamp when present Status code, final URL, redirect chain, response time, severity URL inventory plus structure and freshness analysis; optional HTTP 200 sampling
Not this job Live HTTP status, sitemap XML discovery, live HTML extraction, creating snapshots Internet Archive availability; discovering URLs from sitemap XML Historical cache lookup; status QA of a URL list you already have

No Internet Archive API key is required. The published README positions the Actor as a bulk alternative to loading the archive UI for every broken link. The live Store description is: Check bulk lists of URLs against the Internet Archive database to instantly verify cache availability. Automate historical web page discovery for large sites.

Use cases

The published README also positions the Actor for technical SEO and site administration: cross-reference dead, 404, or orphaned URLs with historical cache data, map legacy site structures, audit domain history before acquisitions, and rescue deleted content that Google search previously indexed. Store templates named in the README are Quickstart (verify 3 archived URLs), Portfolio Archive Check (bulk verification, up to 500 URLs), and 404 Recovery after a broken-link crawl.

How is Wayback Machine Bulk Checker different from Bulk URL Status Checker and Sitemap Scraper & Analyzer?

This Actor queries the Internet Archive Wayback Machine available endpoint for a list of URLs you already have (urls, maximum 500). It reports whether a URL was archived and, when present, the snapshot closest to a target date. Bulk URL Status Checker checks a known URL list (urls, maximum 1000) for live HTTP status, redirect chains, response timing, and broken-URL findings; it does not query the archive. Sitemap Scraper & Analyzer reads sitemap.xml and nested sitemap indexes (sitemapUrls) to discover URL inventories, with optional HEAD checks for HTTP 200; it does not look up historical cache availability. Use this Actor for read-only archive availability. Use Bulk URL Status Checker for live HTTP QA. Use Sitemap Scraper & Analyzer to discover URLs from nested XML sitemaps.

What input is required for Wayback Machine Bulk Checker?

urls is required: URLs to check in the Wayback Machine (maximum 500). Schema editor is stringList. Schema prefill is https://example.com and https://google.com. Optional live schema fields are closest (YYYYMMDD; leave empty for the latest snapshot), concurrency (integer, default 3, minimum 1, maximum 5), maxChargeUsd (number, default 1, minimum 0, maximum 100), delivery (dataset or webhook, default dataset), webhookUrl (when delivery is webhook), and dryRun (boolean, default false). additionalProperties is false. The live schema description for urls is: URLs to check in the Wayback Machine (max 500). The live schema description for closest is: Find snapshot closest to this date (YYYYMMDD format). Leave empty for latest.

Field Type Default Notes
urls string[] required URLs to check in the Wayback Machine (max 500). Schema prefill is https://example.com, https://google.com.
closest string empty = latest Find the snapshot closest to this date. Format is YYYYMMDD (for example 20200101).
concurrency integer 3 Keep low to respect Internet Archive rate limits; minimum 1, maximum 5
maxChargeUsd number 1 Safety cap for this run; minimum 0, maximum 100. Results beyond the cap are kept as no-charge limit_reached rows.
delivery string dataset dataset or webhook
webhookUrl string — POST target when delivery is webhook
dryRun boolean false Run without saving results (for testing)

Published input example (matches the schema):

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

Published README single-URL availability example:

{
  "urls": ["https://example.com/old-page"]
}

Closest-snapshot lookup (schema format):

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

Start with the Store Quickstart to verify a few archived URLs. Use Portfolio Archive Check for bulk verification (up to 500 URLs). Keep concurrency low. Use dryRun: true before larger runs.

Cheapest first paid input: one URL (README single-URL availability example). The Store Quickstart verifies 3 archived URLs.

{
  "urls": ["https://example.com"],
  "delivery": "dataset",
  "dryRun": false
}

If one lookup row is delivered, documented PPE is $0.008. There is no Actor Start. If the 3-URL Quickstart delivers three rows, 3 × $0.008 = $0.024 at the same rate. Then raise the list after the snapshot URL is useful. For 404 recovery, see Find Wayback snapshots for broken URLs.

Run this 1-URL input on Apify

Which README Wayback input examples are not live schema fields?

The README Input table lists closest as YYYY-MM-DD and includes checkAvailability (boolean, default true). README examples labeled Bulk archived snapshot history and Domain change-detection digest send includeCdx, maxSnapshotsPerUrl, and compareToLatestLive. Those names are not in the live input schema. additionalProperties is false, so do not send them. Use closest in YYYYMMDD form (for example 20200101), not YYYY-MM-DD. Schema-valid published inputs use urls plus optional closest, concurrency, maxChargeUsd, delivery, webhookUrl, and dryRun. The README single-URL availability example (urls only) matches the schema.

What does a Wayback lookup result row contain?

The published README output table lists url, archived, closestSnapshotUrl, closestSnapshotDate (YYYYMMDDhhmmss), totalSnapshots, firstSnapshotDate, and lastSnapshotDate. The published README output example uses url, available, closestSnapshot (archive url and timestamp), and archivedVersions. README prose also describes the timestamp of the most recent snapshot, the direct Wayback Machine URL for cached HTML, and the HTTP status of the original capture. There is no published output_schema.json on the Store page. The sample is an illustration, not a live coverage guarantee. Treat snapshot counts, first/last capture dates, and original HTTP status as README-claimed columns, not as a published dataset schema.

Published README sample:

{
  "url": "https://example.com/old-article",
  "available": true,
  "closestSnapshot": {
    "url": "https://web.archive.org/web/20200115000000/https://example.com/old-article",
    "timestamp": "20200115000000"
  },
  "archivedVersions": 23
}

Field names differ between the README table and the example. The sample is the published README illustration, not a live coverage guarantee.

How do Wayback dataset delivery, dry-run, and the charge cap work?

delivery defaults to dataset. Set delivery to webhook and provide webhookUrl to POST results. dryRun true runs without saving results (for testing). maxChargeUsd defaults to 1 as a safety cap; results beyond the cap are kept in output as no-charge limit_reached rows. Store templates named in the README are Quickstart (verify 3 archived URLs), Portfolio Archive Check (bulk verification, up to 500 URLs), and 404 Recovery after a broken-link crawl. 404 Recovery names Broken Link Checker as a README Store path, not an extra landing on this site.

Does this Actor return cached HTML or a CDX full-history dump?

No. This Actor queries the Wayback Machine available endpoint. It returns structured lookup rows for availability and the closest snapshot metadata when present. It does not fetch live page HTML, does not extract article bodies, and does not dump CDX full history. The published schema does not include includeCdx, maxSnapshotsPerUrl, or compareToLatestLive. Website Content Extractor cleans live docs, pricing, policy, and product pages. Article Content Extractor cleans live news, blog, and press pages. Use this Actor when the job is historical cache availability, not live page text and not a CDX timeline.

How far back can I check?

Internet Archive has snapshots back to 1996. Coverage depends on whether a URL was crawled. Snapshots exist only where the Archive crawled the page; availability is not guaranteed per URL.

Why is a URL not available?

Either it was never archived, or Internet Archive excluded it (due to robots.txt or a removal request). The README also notes that archived can be false when the URL was not crawled yet, or robots.txt blocked it at the time.

Can I archive new URLs or trigger a snapshot?

No. This Actor only reads the archive. To save new pages, the README points to archive.org’s /save/ endpoint. To trigger a new snapshot, use the Wayback Machine Save Page Now feature manually. This Actor cannot create snapshots.

Is an Internet Archive API key required?

No. The published README positions the Actor as using the official Internet Archive available endpoint (archive.org/wayback/available) with no API key needed. The README compares a single lookup to curl against archive.org, with bulk processing, error handling, and structured dataset output as the difference.

How is Wayback Machine Bulk Checker priced?

Billing is pay per event. The published Store card is $8.00 / 1,000 wayback archive results. Live Store events list only Wayback archive result at $0.008 (charged only for one successfully delivered Wayback Machine lookup row; event key apify-default-dataset-item). Current PPE lists only that event (no Actor Start). The cheapest first paid path is one urls item: $0.008 if one lookup row is delivered. The Store Quickstart verifies 3 archived URLs (3 × $0.008 = $0.024 if all three are delivered). Platform usage is listed as Included on the pricing page. The README Cost section still quotes actor-start $0.01 plus dataset-item $0.003 ($3.01 for 1,000 items); those figures are not the live Store rates. maxChargeUsd is a safety cap; results beyond the cap are kept as no-charge limit_reached rows. No subscription is required.

Try Input: 1 URL = $0.008 if one lookup row is delivered. $8.00 / 1,000 results. No Actor Start.

See Wayback Machine Bulk Checker pricing on Apify

Limits to keep in mind

Try Input: 1 URL on Apify

Related pages