# Wayback Machine

> Read the web's past from the Internet Archive's Wayback Machine: check whether a page is archived, list every copy of it, find the captures where it actually changed, and read or download any of them. Audit a list of links for dead ones, watch a competitor's pricing page for changes, recover a document a site has taken down, or map every page a site had before it disappeared. Free and public: no account, no API key, and nothing to pay for.

App · Research & Academia · 20 actions. Web page: https://docs.lodol.com/docs/integrations/wayback-machine

## Actions

### Check if a page is archived

Ask the Wayback Machine whether it has a copy of a page, and get a link to the nearest one. Point it at a date to ask for the copy closest to that moment instead of the most recent. This is the quickest check to run before following a link that may be dead, or to decide whether the rest of a workflow has anything to work with. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page to look for in the archive. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- Closest to (`target_time`, date and time): Return the copy captured nearest this moment. Leave it blank for the most recent copy.

**Outputs**

- `archived_url` (text): The URL exactly as it was crawled.
- `calendar_url` (text): The Wayback Machine's own calendar page for this URL.
- `captured_at` (text): The same instant as an ISO 8601 UTC time.
- `is_archived` (true/false): Whether the archive has a copy it can serve. Branch on this rather than on the link being present.
- `raw_url` (text): The link that serves the capture's original bytes, with no Wayback banner added.
- `snapshot_url` (text): The Wayback link that replays this capture.
- `status_code` (number): The HTTP status the page returned when it was captured.
- `target_time` (text): The moment that was asked about, or null when the most recent copy was wanted.
- `timestamp` (text): The capture's Wayback timestamp, fourteen digits of YYYYMMDDhhmmss.
- `url` (text): The URL that was checked.

**Example output**

```json
{
  "archived_url": "https://www.example.com/",
  "calendar_url": "https://web.archive.org/web/*/example.com",
  "captured_at": "2020-01-01T21:37:28Z",
  "is_archived": true,
  "raw_url": "https://web.archive.org/web/20200101213728id_/https://www.example.com/",
  "snapshot_url": "https://web.archive.org/web/20200101213728/https://www.example.com/",
  "status_code": 200,
  "target_time": "2020-01-01T00:00:00Z",
  "timestamp": "20200101213728",
  "url": "example.com"
}
```

### Check several pages at once

Run the same archived-or-not check over a list of URLs and get one row per link, with a Wayback link for the ones that have a copy. Built for auditing the links in a page, a document or a spreadsheet: a URL the archive cannot answer for is reported as unarchived rather than failing the step. Up to 50 URLs. No API key required.

**Inputs**

- URLs (`urls`, list, required): The pages to check, one per line. Up to 50 at a time.
- Closest to (`target_time`, date and time): Return the copy of each page captured nearest this moment. Leave it blank for the most recent copy.

**Outputs**

- `archived_count` (number): How many of them the archive has a copy of.
- `count` (number): How many URLs were checked.
- `missing_count` (number): How many it has nothing for.
- `results` (list): One row per URL, in the order given.
- `target_time` (text): The moment that was asked about, or null when the most recent copy was wanted.

**Example output**

```json
{
  "archived_count": 1,
  "count": 2,
  "missing_count": 1,
  "results": [
    {
      "archived_url": "http://www.iana.org/",
      "calendar_url": "https://web.archive.org/web/*/iana.org",
      "captured_at": "2026-08-25T20:32:25Z",
      "is_archived": true,
      "raw_url": "https://web.archive.org/web/20260825203225id_/http://www.iana.org/",
      "snapshot_url": "https://web.archive.org/web/20260825203225/http://www.iana.org/",
      "status_code": 200,
      "target_time": null,
      "timestamp": "20260825203225",
      "url": "iana.org"
    },
    {
      "archived_url": null,
      "calendar_url": "https://web.archive.org/web/*/zzz-nope-9999.example",
      "captured_at": null,
      "is_archived": false,
      "raw_url": null,
      "snapshot_url": null,
      "status_code": null,
      "target_time": null,
      "timestamp": null,
      "url": "zzz-nope-9999.example"
    }
  ],
  "target_time": null
}
```

### Compare two snapshots

Compare a page as it was at two moments and get back what was added and what was removed, in the words a reader would have seen rather than as a diff of markup. The archive's own content fingerprints are checked first, so a page that did not change at all is reported as identical outright. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page to compare with itself. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- Compare from (`first_time`, date and time, required): The earlier of the two moments to compare.
- Compare to (`second_time`, date and time, required): The later of the two moments to compare.
- Maximum changes to list (`max_changes`, number): How many added and removed passages to list. The counts are always complete. From 1 to 500. Default: `50`.

**Outputs**

- `added_count` (number): How many passages the later capture added.
- `added_lines` (list): The added passages, up to the limit asked for.
- `after` (object): The later capture.
- `before` (object): The earlier capture.
- `character_change` (number): How much longer or shorter the page's text became.
- `is_identical` (true/false): True when nothing a reader would notice changed.
- `removed_count` (number): How many the earlier capture had and the later did not.
- `removed_lines` (list): The removed passages, up to the limit asked for.
- `same_stored_content` (true/false): True when the archive stored byte-identical content for both captures.
- `truncated` (true/false): True when there were more changes than were listed.
- `url` (text): The page that was compared.

**Example output**

```json
{
  "added_count": 11,
  "added_lines": [
    "The global coordination of the DNS Root, IP addressing, and other Internet protocol resources is performed as the Internet Assigned Numbers Authority (IANA) functions."
  ],
  "after": {
    "captured_at": "2024-05-31T23:26:18Z",
    "characters": 1319,
    "digest": "BY6BQOTX34GXMJIKNUNLXFKQCFNR7AIO",
    "snapshot_url": "https://web.archive.org/web/20240531232618/https://www.iana.org/",
    "timestamp": "20240531232618"
  },
  "before": {
    "captured_at": "2010-05-29T12:04:41Z",
    "characters": 1124,
    "digest": "IXML4B7BOWPMNLWCDAHO3DI7EYQACFPS",
    "snapshot_url": "https://web.archive.org/web/20100529120441/http://www.iana.org:80/",
    "timestamp": "20100529120441"
  },
  "character_change": 195,
  "is_identical": false,
  "removed_count": 6,
  "removed_lines": [
    "The Internet Assigned Numbers Authority (IANA) is responsible for the global coordination of the DNS Root, IP addressing, and other Internet protocol resources."
  ],
  "same_stored_content": false,
  "truncated": true,
  "url": "iana.org"
}
```

### Count captures day by day

How many times a page was captured on each day of a year, or of one month. This is the calendar the Wayback Machine draws, and the cheap way to find the days worth looking at before asking for the captures themselves. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page whose calendar you want. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- Year (`year`, text, required): The year to count. The list holds the years this page was actually captured in.
- Month (`month`, text): Narrow the count to one month of that year. Every month by default. One of: `any` (Every month), `01` (January), `02` (February), `03` (March), `04` (April), `05` (May), `06` (June), `07` (July), `08` (August), `09` (September), and 3 more. Default: `any`.

**Outputs**

- `busiest_day` (text): The day with the most captures.
- `calendar_url` (text): The Wayback Machine's own calendar page for this URL.
- `days` (list): One entry per day with captures, oldest first.
- `days_with_captures` (number): How many days hold at least one capture.
- `month` (number): The month that was counted, or null when the whole year was.
- `total_captures` (number): How many captures those days hold in total.
- `url` (text): The URL that was asked about.
- `year` (number): The year that was counted.

**Example output**

```json
{
  "busiest_day": "2024-03-01",
  "calendar_url": "https://web.archive.org/web/*/iana.org",
  "days": [
    {
      "calendar_url": "https://web.archive.org/web/20240301*/iana.org",
      "captures": 7,
      "date": "2024-03-01",
      "status_code": 200
    }
  ],
  "days_with_captures": 31,
  "month": 3,
  "total_captures": 103,
  "url": "iana.org",
  "year": 2024
}
```

### Download an archived file

Download an archived file as it was captured, so a later step can attach it to an email, post it to a chat or put it in storage. Anything the archive holds comes back this way: a PDF a site has taken down, an image, a data file, a page. No API key required.

**Inputs**

- File URL (`url`, text, required): The file or page to download. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- As it was on (`target_time`, date and time): Download the copy captured nearest this moment. Leave it blank for the most recent copy.

**Outputs**

- `archived_url` (text): The URL exactly as it was crawled.
- `byte_size` (number): The file's size in bytes.
- `captured_at` (text): The same instant as an ISO 8601 UTC time.
- `content_type` (text): The file's media type.
- `document_ref` (text): The stored file's reference, repeated for convenience.
- `documents` (list): The stored file, in the shape every Lodol action that produces one returns, so a later step can attach or upload it.
- `source_url` (text): The Wayback link the bytes came from.
- `timestamp` (text): The capture's Wayback timestamp, fourteen digits of YYYYMMDDhhmmss.
- `url` (text): A link the app can serve the stored file from.

**Example output**

```json
{
  "archived_url": "http://www.iana.org/about/informational-booklet.pdf",
  "byte_size": 2209338,
  "captured_at": "2015-09-06T19:20:24Z",
  "content_type": "application/pdf",
  "document_ref": "doc_9c1f0a2b6d7e4f80",
  "documents": [
    {
      "content_type": "application/pdf",
      "document_ref": "doc_9c1f0a2b6d7e4f80",
      "filename": "www.iana.org-about-informational-booklet-20150906192024.pdf",
      "size_bytes": 2209338,
      "url": "/actions/core/serve-document/doc_9c1f0a2b6d7e4f80?teamId=64b0000000000000000000aa"
    }
  ],
  "source_url": "https://web.archive.org/web/20150906192024id_/http://www.iana.org/about/informational-booklet.pdf",
  "timestamp": "20150906192024",
  "url": "/actions/core/serve-document/doc_9c1f0a2b6d7e4f80?teamId=64b0000000000000000000aa"
}
```

### Export snapshots as CSV

Write a capture list out as a CSV file instead of into the workflow, so tens of thousands of rows can be attached to an email, put in storage or handed to a spreadsheet. Takes the same filters as the listing actions, with a much higher ceiling. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page or site whose captures you want. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- How much of the site to cover (`scope`, text): Whether the URL above means one page, everything under its path, the whole host, or the site and all of its subdomains. One of: `page` (Just this exact page), `path` (This page and everything under it), `host` (The whole host (www.example.com)), `site` (The site and all of its subdomains). Default: `page`.
- Captured on or after (`captured_from`, date): Keep only captures captured on or after this date. Optional.
- Captured on or before (`captured_to`, date): Keep only captures captured on or before this date. Optional.
- Response when captured (`status`, text): Keep only the captures where the server answered this way. One of: `any` (Any response), `ok` (Only captures that loaded (200)), `redirect` (Only redirects (3xx)), `not_found` (Only pages that were missing (404)), `client_error` (Only client errors (4xx)), `server_error` (Only server errors (5xx)), `broken` (Only errors (4xx and 5xx)). Default: `any`.
- File type (`content_type`, text): Keep only captures of this kind of file. One of: `any` (Any file type), `html` (Web pages (HTML)), `pdf` (PDFs), `image` (Images), `video`, `audio`, `css` (Stylesheets (CSS)), `javascript` (Scripts (JavaScript)), `json`, `xml` (XML and feeds), `plain_text` (Plain text), `office` (Office documents (Word, Excel, PowerPoint)). Default: `any`.
- Thin the list to (`one_capture_per`, text): A busy page is captured many times a day. Keep one capture per hour, day, month or year instead of all of them. One of: `all` (Every capture), `hour` (One capture per hour), `day` (One capture per day), `month` (One capture per month), `year` (One capture per year). Default: `all`.
- How many to return (`limit`, number): The most rows to return, from 1 to 50,000. From 1 to 50000. Default: `1000`.

**Outputs**

- `archived_url` (text): The URL the export was made for.
- `byte_size` (number): The file's size in bytes.
- `content_type` (text): The file's media type.
- `document_ref` (text): The stored file's reference, repeated for convenience.
- `documents` (list): The stored file, in the shape every Lodol action that produces one returns, so a later step can attach or upload it.
- `source_url` (text): The Wayback calendar page for that URL.
- `url` (text): A link the app can serve the stored file from.

**Example output**

```json
{
  "archived_url": "iana.org",
  "byte_size": 1035,
  "content_type": "text/csv",
  "document_ref": "doc_9c1f0a2b6d7e4f80",
  "documents": [
    {
      "content_type": "text/csv",
      "document_ref": "doc_9c1f0a2b6d7e4f80",
      "filename": "wayback-iana.org-20260827.csv",
      "size_bytes": 1035,
      "url": "/actions/core/serve-document/doc_9c1f0a2b6d7e4f80?teamId=64b0000000000000000000aa"
    }
  ],
  "source_url": "https://web.archive.org/web/*/iana.org",
  "url": "/actions/core/serve-document/doc_9c1f0a2b6d7e4f80?teamId=64b0000000000000000000aa"
}
```

### Get a link to a page as it was

Turn a URL and a date into a link to that page as it looked then, so a message, a document or a citation can point at the archived copy rather than at a page that has since changed. The archive picks the capture nearest the date and says which one it chose. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page to link to. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- As it was on (`target_time`, date and time): The moment the link should point at. Leave it blank for the page as it is archived now.

**Outputs**

- `archived_url` (text): The URL exactly as it was crawled.
- `calendar_url` (text): The Wayback Machine's own calendar page for this URL.
- `captured_at` (text): The same instant as an ISO 8601 UTC time.
- `raw_url` (text): The link that serves the capture's original bytes, with no Wayback banner added.
- `requested_time` (text): The moment the link was wanted for.
- `snapshot_url` (text): The Wayback link that replays this capture.
- `timestamp` (text): The capture's Wayback timestamp, fourteen digits of YYYYMMDDhhmmss.
- `url` (text): The URL that was asked about.

**Example output**

```json
{
  "archived_url": "http://example.com/",
  "calendar_url": "https://web.archive.org/web/*/https://example.com/",
  "captured_at": "2019-03-15T12:09:52Z",
  "raw_url": "https://web.archive.org/web/20190315120952id_/http://example.com/",
  "requested_time": "2019-03-15T12:00:00Z",
  "snapshot_url": "https://web.archive.org/web/20190315120952/http://example.com/",
  "timestamp": "20190315120952",
  "url": "https://example.com/"
}
```

### Get a page's capture history

How often a page has been captured, year by year and month by month, with its first and last capture. This is the shape of a page's life in the archive: whether it is watched closely, was captured once and forgotten, or stopped being captured at some point. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page whose history you want. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.

**Outputs**

- `calendar_url` (text): The Wayback Machine's own calendar page for this URL.
- `first_captured_at` (text): When the page was first captured, in UTC.
- `first_snapshot_url` (text): A link to that first capture.
- `first_timestamp` (text): The capture's Wayback timestamp, fourteen digits of YYYYMMDDhhmmss.
- `is_archived` (true/false): Whether the archive holds anything at all.
- `last_captured_at` (text): When it was most recently captured, in UTC.
- `last_snapshot_url` (text): A link to that most recent capture.
- `last_timestamp` (text): The capture's Wayback timestamp, fourteen digits of YYYYMMDDhhmmss.
- `total_captures` (number): How many captures it holds in total.
- `url` (text): The URL that was asked about.
- `years` (list): One entry per year, oldest first.
- `years_covered` (number): How many calendar years hold captures.

**Example output**

```json
{
  "calendar_url": "https://web.archive.org/web/*/iana.org",
  "first_captured_at": "1998-02-11T06:55:37Z",
  "first_snapshot_url": "https://web.archive.org/web/19980211065537/iana.org",
  "first_timestamp": "19980211065537",
  "is_archived": true,
  "last_captured_at": "2026-08-25T20:32:25Z",
  "last_snapshot_url": "https://web.archive.org/web/20260825203225/iana.org",
  "last_timestamp": "20260825203225",
  "total_captures": 10755,
  "url": "iana.org",
  "years": [
    {
      "captures": 3,
      "months": [
        {
          "captures": 0,
          "month": 1,
          "name": "January"
        },
        {
          "captures": 1,
          "month": 2,
          "name": "February"
        }
      ],
      "year": 1998
    }
  ],
  "years_covered": 29
}
```

### Get a page's Memento timemap

A page's history in the Memento format defined by RFC 7089: the original URL, the gateway that resolves a date to a copy, and the first, last and intermediate copies with their dates. Use it when the history has to be handed to another Memento-aware tool rather than read here. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page whose timemap you want. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- How many to return (`limit`, number): The most mementos to return, from 1 to 1,000. From 1 to 1000. Default: `25`.

**Outputs**

- `count` (number): How many of them this step returned.
- `first_memento` (object): The earliest copy the archive holds.
- `has_more` (true/false): True when the timemap lists more than were returned.
- `last_memento` (object): The most recent copy the archive holds.
- `limit` (number): The number that was asked for.
- `memento_count` (number): How many copies the timemap lists in total.
- `mementos` (list): The most recent copies, oldest of them first.
- `original_url` (text): The live URL the archive holds copies of, as the timemap names it.
- `timegate_url` (text): The gateway that redirects a date to the copy nearest it.
- `timemap_url` (text): The timemap itself, for another tool to read.
- `url` (text): The URL that was asked about.

**Example output**

```json
{
  "count": 1,
  "first_memento": {
    "captured_at": "1998-02-11T06:55:37Z",
    "relations": [
      "first",
      "memento"
    ],
    "snapshot_url": "https://web.archive.org/web/19980211065537/http://www.iana.org:80/",
    "timestamp": "19980211065537"
  },
  "has_more": true,
  "last_memento": {
    "captured_at": "2026-08-25T20:32:25Z",
    "relations": [
      "memento"
    ],
    "snapshot_url": "https://web.archive.org/web/20260825203225/http://www.iana.org/",
    "timestamp": "20260825203225"
  },
  "limit": 25,
  "memento_count": 10755,
  "mementos": [
    {
      "captured_at": "2026-08-25T20:32:25Z",
      "relations": [
        "memento"
      ],
      "snapshot_url": "https://web.archive.org/web/20260825203225/http://www.iana.org/",
      "timestamp": "20260825203225"
    }
  ],
  "original_url": "http://www.iana.org:80/",
  "timegate_url": "https://web.archive.org/web/iana.org",
  "timemap_url": "https://web.archive.org/web/timemap/link/iana.org",
  "url": "iana.org"
}
```

### Get a snapshot's details

Everything the archive's index records about one capture: when it was taken, what the server said, what kind of file it was, how much was stored, and the content fingerprint that says whether two captures hold the same bytes. Ask for the first capture, the most recent one, or the one closest to a date. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page to look up. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- Which capture (`which`, text): Which of the page's captures to describe. One of: `closest` (The capture closest to a date), `latest` (The most recent capture), `first` (The very first capture). Default: `latest`.
- Closest to (`target_time`, date and time): The moment to look near. Required only when you asked for the capture closest to a date.
- Only captures that loaded (`only_successful`, true/false): On by default, so an error page or a redirect the crawler happened to catch is skipped. Turn it off to include every capture. Default: `true`.

**Outputs**

- `calendar_url` (text): The Wayback Machine's own calendar page for this URL.
- `captured_at` (text): The same instant as an ISO 8601 UTC time.
- `digest` (text): A fingerprint of the captured content. Two captures with the same digest hold identical bytes.
- `length_bytes` (number): How much was stored for this capture, in bytes.
- `mime_type` (text): The file type the server declared when captured.
- `raw_url` (text): The link that serves the capture's original bytes, with no Wayback banner added.
- `requested_url` (text): The URL that was asked about.
- `snapshot_url` (text): The Wayback link that replays this capture.
- `status_code` (number): The HTTP status the server returned, or null where the archive did not record one.
- `timestamp` (text): The capture's Wayback timestamp, fourteen digits of YYYYMMDDhhmmss.
- `unchanged_since_previous` (true/false): True when the archive stored this capture as unchanged from an earlier one. It still replays; only the bytes were not stored again.
- `url` (text): The URL exactly as it was crawled, which can differ from the one asked about (http vs https, a www that was or was not there).

**Example output**

```json
{
  "calendar_url": "https://web.archive.org/web/*/iana.org",
  "captured_at": "2024-12-31T00:36:28Z",
  "digest": "BY6BQOTX34GXMJIKNUNLXFKQCFNR7AIO",
  "length_bytes": 2289,
  "mime_type": "text/html",
  "raw_url": "https://web.archive.org/web/20241231003628id_/https://www.iana.org/",
  "requested_url": "iana.org",
  "snapshot_url": "https://web.archive.org/web/20241231003628/https://www.iana.org/",
  "status_code": 200,
  "timestamp": "20241231003628",
  "unchanged_since_previous": false,
  "url": "https://www.iana.org/"
}
```

### List a page's content changes

Only the captures where a page actually changed, with the thousands of identical captures in between left out. This is how you find when a policy was rewritten, when a price moved or when a claim disappeared, without reading every crawl. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page whose changes you want. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- Captured on or after (`captured_from`, date): Keep only changes captured on or after this date. Optional.
- Captured on or before (`captured_to`, date): Keep only changes captured on or before this date. Optional.
- Newest first (`newest_first`, true/false): On by default. Turn it off to start from the oldest capture instead. Default: `true`.
- How many to return (`limit`, number): The most changes to return, from 1 to 1,000. From 1 to 1000. Default: `25`.

**Outputs**

- `calendar_url` (text): The Wayback Machine's own calendar page for this URL.
- `count` (number): How many captures where the content differed from the one before this step returned.
- `has_more` (true/false): True when the answer filled the requested size, so the archive holds more than were returned.
- `limit` (number): The size that was asked for.
- `snapshots` (list): The captures where the content differed from the one before.
- `url` (text): The URL that was asked about.

**Example output**

```json
{
  "calendar_url": "https://web.archive.org/web/*/iana.org",
  "count": 1,
  "has_more": true,
  "limit": 25,
  "snapshots": [
    {
      "captured_at": "2024-12-31T00:36:28Z",
      "digest": "BY6BQOTX34GXMJIKNUNLXFKQCFNR7AIO",
      "length_bytes": 2289,
      "mime_type": "text/html",
      "raw_url": "https://web.archive.org/web/20241231003628id_/https://www.iana.org/",
      "snapshot_url": "https://web.archive.org/web/20241231003628/https://www.iana.org/",
      "status_code": 200,
      "timestamp": "20241231003628",
      "unchanged_since_previous": false,
      "url": "https://www.iana.org/"
    }
  ],
  "url": "iana.org"
}
```

### List a page's snapshots

Every capture of one page, newest first, narrowed to the dates, the kind of response and the kind of file you care about. A busy page is captured many times a day, so thin the list to one capture per day, month or year when you want a timeline rather than every crawl. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page whose captures you want. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- Captured on or after (`captured_from`, date): Keep only captures captured on or after this date. Optional.
- Captured on or before (`captured_to`, date): Keep only captures captured on or before this date. Optional.
- Response when captured (`status`, text): Keep only the captures where the server answered this way. One of: `any` (Any response), `ok` (Only captures that loaded (200)), `redirect` (Only redirects (3xx)), `not_found` (Only pages that were missing (404)), `client_error` (Only client errors (4xx)), `server_error` (Only server errors (5xx)), `broken` (Only errors (4xx and 5xx)). Default: `any`.
- File type (`content_type`, text): Keep only captures of this kind of file. One of: `any` (Any file type), `html` (Web pages (HTML)), `pdf` (PDFs), `image` (Images), `video`, `audio`, `css` (Stylesheets (CSS)), `javascript` (Scripts (JavaScript)), `json`, `xml` (XML and feeds), `plain_text` (Plain text), `office` (Office documents (Word, Excel, PowerPoint)). Default: `any`.
- Thin the list to (`one_capture_per`, text): A busy page is captured many times a day. Keep one capture per hour, day, month or year instead of all of them. One of: `all` (Every capture), `hour` (One capture per hour), `day` (One capture per day), `month` (One capture per month), `year` (One capture per year). Default: `all`.
- Newest first (`newest_first`, true/false): On by default. Turn it off to start from the oldest capture instead. Default: `true`.
- How many to return (`limit`, number): The most captures to return, from 1 to 1,000. From 1 to 1000. Default: `25`.

**Outputs**

- `calendar_url` (text): The Wayback Machine's own calendar page for this URL.
- `count` (number): How many captures this step returned.
- `has_more` (true/false): True when the answer filled the requested size, so the archive holds more than were returned.
- `limit` (number): The size that was asked for.
- `snapshots` (list): The captures.
- `url` (text): The URL that was asked about.

**Example output**

```json
{
  "calendar_url": "https://web.archive.org/web/*/iana.org",
  "count": 1,
  "has_more": true,
  "limit": 25,
  "snapshots": [
    {
      "captured_at": "2024-12-31T00:36:28Z",
      "digest": "BY6BQOTX34GXMJIKNUNLXFKQCFNR7AIO",
      "length_bytes": 2289,
      "mime_type": "text/html",
      "raw_url": "https://web.archive.org/web/20241231003628id_/https://www.iana.org/",
      "snapshot_url": "https://web.archive.org/web/20241231003628/https://www.iana.org/",
      "status_code": 200,
      "timestamp": "20241231003628",
      "unchanged_since_previous": false,
      "url": "https://www.iana.org/"
    }
  ],
  "url": "iana.org"
}
```

### List a site's archived files

The files of one kind the archive holds under a site: the PDFs a regulator published and later withdrew, the images a brand used, the feeds a blog served. One row per file, each with a link that serves the original bytes. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The site whose files you want. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- File type (`content_type`, text): Which kind of file to list. PDFs by default; there is no 'any' here, because listing every file is what List a site's archived pages is for. One of: `html` (Web pages (HTML)), `pdf` (PDFs), `image` (Images), `video`, `audio`, `css` (Stylesheets (CSS)), `javascript` (Scripts (JavaScript)), `json`, `xml` (XML and feeds), `plain_text` (Plain text), `office` (Office documents (Word, Excel, PowerPoint)). Default: `pdf`.
- How much of the site to cover (`scope`, text): Whether the URL above means one page, everything under its path, the whole host, or the site and all of its subdomains. One of: `page` (Just this exact page), `path` (This page and everything under it), `host` (The whole host (www.example.com)), `site` (The site and all of its subdomains). Default: `host`.
- Captured on or after (`captured_from`, date): Keep only files captured on or after this date. Optional.
- Captured on or before (`captured_to`, date): Keep only files captured on or before this date. Optional.
- How many to return (`limit`, number): The most files to return, from 1 to 5,000. From 1 to 5000. Default: `50`.

**Outputs**

- `content_type` (text): The kind of file that was listed.
- `count` (number): How many archived files this step returned.
- `files` (list): The archived files.
- `has_more` (true/false): True when the answer filled the requested size, so the archive holds more than were returned.
- `limit` (number): The size that was asked for.
- `scope` (text): How much of the site was covered.
- `snapshots` (list): The same rows as files, under the name every other capture listing uses.
- `url` (text): The URL that was asked about.

**Example output**

```json
{
  "content_type": "pdf",
  "count": 1,
  "files": [
    {
      "captured_at": "2015-09-06T19:20:24Z",
      "digest": "DMFRBBAHWAJCU7YJKJA4Z4MIW2AWI5QE",
      "length_bytes": 2209338,
      "mime_type": "application/pdf",
      "raw_url": "https://web.archive.org/web/20150906192024id_/http://www.iana.org/about/informational-booklet.pdf",
      "snapshot_url": "https://web.archive.org/web/20150906192024/http://www.iana.org/about/informational-booklet.pdf",
      "status_code": 200,
      "timestamp": "20150906192024",
      "unchanged_since_previous": false,
      "url": "http://www.iana.org/about/informational-booklet.pdf"
    }
  ],
  "has_more": true,
  "limit": 50,
  "scope": "site",
  "snapshots": [
    {
      "captured_at": "2015-09-06T19:20:24Z",
      "digest": "DMFRBBAHWAJCU7YJKJA4Z4MIW2AWI5QE",
      "length_bytes": 2209338,
      "mime_type": "application/pdf",
      "raw_url": "https://web.archive.org/web/20150906192024id_/http://www.iana.org/about/informational-booklet.pdf",
      "snapshot_url": "https://web.archive.org/web/20150906192024/http://www.iana.org/about/informational-booklet.pdf",
      "status_code": 200,
      "timestamp": "20150906192024",
      "unchanged_since_previous": false,
      "url": "http://www.iana.org/about/informational-booklet.pdf"
    }
  ],
  "url": "iana.org"
}
```

### List a site's archived pages

The distinct pages the archive holds under a site, one row per page rather than per capture of it. This is the site map of a site that no longer exists, or the list to run the rest of a workflow over. Cover a path, a host, or the site and all of its subdomains. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The site whose pages you want. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- How much of the site to cover (`scope`, text): Whether the URL above means one page, everything under its path, the whole host, or the site and all of its subdomains. One of: `path` (This page and everything under it), `host` (The whole host (www.example.com)), `site` (The site and all of its subdomains). Default: `host`.
- Captured on or after (`captured_from`, date): Keep only pages captured on or after this date. Optional.
- Captured on or before (`captured_to`, date): Keep only pages captured on or before this date. Optional.
- File type (`content_type`, text): Which kind of file counts as a page. Web pages by default. One of: `any` (Any file type), `html` (Web pages (HTML)), `pdf` (PDFs), `image` (Images), `video`, `audio`, `css` (Stylesheets (CSS)), `javascript` (Scripts (JavaScript)), `json`, `xml` (XML and feeds), `plain_text` (Plain text), `office` (Office documents (Word, Excel, PowerPoint)). Default: `html`.
- How many to return (`limit`, number): The most pages to return, from 1 to 5,000. From 1 to 5000. Default: `50`.

**Outputs**

- `calendar_url` (text): The Wayback Machine's own calendar page for this URL.
- `count` (number): How many archived pages, with the first capture of each this step returned.
- `has_more` (true/false): True when the answer filled the requested size, so the archive holds more than were returned.
- `limit` (number): The size that was asked for.
- `pages` (list): The archived pages, with the first capture of each.
- `scope` (text): How much of the site was covered.
- `snapshots` (list): The same rows as pages, under the name every other capture listing uses.
- `url` (text): The URL that was asked about.

**Example output**

```json
{
  "calendar_url": "https://web.archive.org/web/*/iana.org",
  "count": 1,
  "has_more": true,
  "limit": 50,
  "pages": [
    {
      "captured_at": "2024-12-31T00:36:28Z",
      "digest": "BY6BQOTX34GXMJIKNUNLXFKQCFNR7AIO",
      "length_bytes": 2289,
      "mime_type": "text/html",
      "raw_url": "https://web.archive.org/web/20241231003628id_/https://www.iana.org/",
      "snapshot_url": "https://web.archive.org/web/20241231003628/https://www.iana.org/",
      "status_code": 200,
      "timestamp": "20241231003628",
      "unchanged_since_previous": false,
      "url": "https://www.iana.org/"
    }
  ],
  "scope": "host",
  "snapshots": [
    {
      "captured_at": "2024-12-31T00:36:28Z",
      "digest": "BY6BQOTX34GXMJIKNUNLXFKQCFNR7AIO",
      "length_bytes": 2289,
      "mime_type": "text/html",
      "raw_url": "https://web.archive.org/web/20241231003628id_/https://www.iana.org/",
      "snapshot_url": "https://web.archive.org/web/20241231003628/https://www.iana.org/",
      "status_code": 200,
      "timestamp": "20241231003628",
      "unchanged_since_previous": false,
      "url": "https://www.iana.org/"
    }
  ],
  "url": "iana.org"
}
```

### List a site's broken pages

The pages under a site that a crawler found broken: 404s, server errors and redirects, as they were when the archive reached them. Run it after a migration to find what the redirects missed, or over a competitor's site to see what they took down. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The site to look for broken pages on. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- Response when captured (`status`, text): Which kind of failure to look for. One of: `broken` (Only errors (4xx and 5xx)), `not_found` (Only pages that were missing (404)), `client_error` (Only client errors (4xx)), `server_error` (Only server errors (5xx)), `redirect` (Only redirects (3xx)). Default: `broken`.
- How much of the site to cover (`scope`, text): Whether the URL above means one page, everything under its path, the whole host, or the site and all of its subdomains. One of: `page` (Just this exact page), `path` (This page and everything under it), `host` (The whole host (www.example.com)), `site` (The site and all of its subdomains). Default: `host`.
- Captured on or after (`captured_from`, date): Keep only captures captured on or after this date. Optional.
- Captured on or before (`captured_to`, date): Keep only captures captured on or before this date. Optional.
- How many to return (`limit`, number): The most pages to return, from 1 to 5,000. From 1 to 5000. Default: `50`.

**Outputs**

- `count` (number): How many captures that returned an error or a redirect this step returned.
- `has_more` (true/false): True when the answer filled the requested size, so the archive holds more than were returned.
- `limit` (number): The size that was asked for.
- `scope` (text): How much of the site was covered.
- `snapshots` (list): The captures that returned an error or a redirect.
- `status_filter` (text): The kind of failure that was looked for.
- `url` (text): The URL that was asked about.

**Example output**

```json
{
  "count": 1,
  "has_more": true,
  "limit": 50,
  "scope": "host",
  "snapshots": [
    {
      "captured_at": "2024-04-23T22:12:30Z",
      "digest": "5NZPVVGL37B7BUZEJGMREP5PNNSWFPEX",
      "length_bytes": 1330,
      "mime_type": "text/html",
      "raw_url": "https://web.archive.org/web/20240423221230id_/https://www.iana.org/!161",
      "snapshot_url": "https://web.archive.org/web/20240423221230/https://www.iana.org/!161",
      "status_code": 404,
      "timestamp": "20240423221230",
      "unchanged_since_previous": false,
      "url": "https://www.iana.org/!161"
    }
  ],
  "status_filter": "not_found",
  "url": "iana.org"
}
```

### List captures on one day

Every capture of a page on one day, with the crawl behind each one. The archive is filled by many projects at once, and this is the only view that says which: the live-web crawler, a focused crawl, an Archive-It partner's collection, or someone clicking Save Page Now. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page whose captures you want. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- Day (`day`, date, required): The day to list captures for.

**Outputs**

- `calendar_url` (text): The Wayback Machine's own calendar page for this URL.
- `captures` (list): The day's captures, earliest first.
- `count` (number): How many captures that day holds.
- `crawl_count` (number): How many distinct crawls contributed to them.
- `crawls` (list): The names of those crawls.
- `date` (text): The day that was listed, as YYYY-MM-DD.
- `url` (text): The URL that was asked about.

**Example output**

```json
{
  "calendar_url": "https://web.archive.org/web/*/iana.org",
  "captures": [
    {
      "captured_at": "2024-03-15T00:53:05Z",
      "crawls": [
        "archiveteam",
        "archiveteam_urls"
      ],
      "raw_url": "https://web.archive.org/web/20240315005305id_/iana.org",
      "snapshot_url": "https://web.archive.org/web/20240315005305/iana.org",
      "status_code": 200,
      "timestamp": "20240315005305"
    }
  ],
  "count": 1,
  "crawl_count": 2,
  "crawls": [
    "archiveteam",
    "archiveteam_urls"
  ],
  "date": "2024-03-15",
  "url": "iana.org"
}
```

### Read an archived page

Read a page as it was, so a later step can summarise it, search it or answer questions about it. The text comes back with the markup stripped and none of the Wayback banner in it, or as the original source if that is what you need. Leave the date blank for the most recent copy. No API key required.

**Inputs**

- Page or site URL (`url`, text, required): The page to read. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.
- As it was on (`target_time`, date and time): Read the copy captured nearest this moment. Leave it blank for the most recent copy.
- Return (`output`, text): Whether to return readable text or the raw source. One of: `text` (Readable text, with the markup stripped), `html` (The original source exactly as it was captured). Default: `text`.
- Maximum characters (`max_characters`, number): Stop after this many characters. The result says whether it was cut short. From 100 to 500000. Default: `20000`.

**Outputs**

- `byte_size` (number): How many bytes the capture holds.
- `captured_at` (text): The same instant as an ISO 8601 UTC time.
- `characters` (number): How many characters came back.
- `content` (text): The archived page, as text or as source.
- `content_type` (text): The media type the capture was served as.
- `digest` (text): A fingerprint of the captured content. Two captures with the same digest hold identical bytes.
- `format` (text): Which of the two was returned.
- `length_bytes` (number): How much was stored for this capture, in bytes.
- `mime_type` (text): The file type the server declared when captured.
- `raw_url` (text): The link that serves the capture's original bytes, with no Wayback banner added.
- `requested_url` (text): The URL that was asked about.
- `snapshot_url` (text): The Wayback link that replays this capture.
- `status_code` (number): The HTTP status the server returned, or null where the archive did not record one.
- `timestamp` (text): The capture's Wayback timestamp, fourteen digits of YYYYMMDDhhmmss.
- `total_characters` (number): How long the whole page is.
- `truncated` (true/false): True when the page was longer than the limit.
- `unchanged_since_previous` (true/false): True when the archive stored this capture as unchanged from an earlier one. It still replays; only the bytes were not stored again.
- `url` (text): The URL exactly as it was crawled, which can differ from the one asked about (http vs https, a www that was or was not there).

**Example output**

```json
{
  "byte_size": 6392,
  "captured_at": "2015-06-02T14:40:27Z",
  "characters": 199,
  "content": "Internet Assigned Numbers Authority The Internet Assigned Numbers Authority (IANA) is responsible for the global coordination of the DNS Root, IP addressing, and other Internet protocol resources.",
  "content_type": "text/html; charset=UTF-8",
  "digest": "OYXFV54XQL2A6V4RALRAFTBGDJZAOQTD",
  "format": "text",
  "length_bytes": 2288,
  "mime_type": "text/html",
  "raw_url": "https://web.archive.org/web/20150602144027id_/http://www.iana.org/",
  "requested_url": "iana.org",
  "snapshot_url": "https://web.archive.org/web/20150602144027/http://www.iana.org/",
  "status_code": 200,
  "timestamp": "20150602144027",
  "total_characters": 1285,
  "truncated": true,
  "unchanged_since_previous": false,
  "url": "http://www.iana.org/"
}
```

### Search archived sites

Search the archive for sites by name or by what they are about, and get back how many captures each has and the years they run between. Use it to find the site to point the rest of a workflow at when you do not already know the address. No API key required.

**Inputs**

- Search (`query`, text, required): A name, a word or part of an address to search for.
- How many to return (`limit`, number): The most sites to return, from 1 to 100. From 1 to 100. Default: `10`.

**Outputs**

- `count` (number): How many sites came back.
- `has_more` (true/false): True when the archive matched more than were returned.
- `limit` (number): The number that was asked for.
- `query` (text): What was searched for.
- `sites` (list): The matching sites, best match first.

**Example output**

```json
{
  "count": 1,
  "has_more": true,
  "limit": 10,
  "query": "nasa",
  "sites": [
    {
      "audio_captures": 2866,
      "calendar_url": "https://web.archive.org/web/*/www.nasa.gov",
      "description": "nasa",
      "first_year": 1996,
      "host": "www.nasa.gov",
      "image_captures": 404230,
      "last_year": 2016,
      "page_captures": 335514,
      "total_captures": 9247928,
      "url": "http://nasa.gov/",
      "video_captures": 5477
    }
  ]
}
```

### Suggest archived hosts

Complete a partly typed address into hosts the archive actually holds, subdomains and all: 'nasa' becomes www.nasa.gov, science1.nasa.gov and the rest. Run it before a site-wide query so the query is spent on a host that exists. No API key required.

**Inputs**

- Address (`query`, text, required): A host name, or the start of one.
- How many to return (`limit`, number): The most hosts to return, from 1 to 100. From 1 to 100. Default: `10`.

**Outputs**

- `count` (number): How many hosts came back.
- `has_more` (true/false): True when the archive matched more than were returned.
- `hosts` (list): The matching hosts, best match first.
- `limit` (number): The number that was asked for.
- `looks_like_a_url` (true/false): Whether the archive read the query as an address rather than as a word to search for.
- `query` (text): What was typed.

**Example output**

```json
{
  "count": 1,
  "has_more": true,
  "hosts": [
    {
      "calendar_url": "https://web.archive.org/web/*/www.nasa.gov",
      "host": "www.nasa.gov",
      "url": "http://www.nasa.gov/"
    }
  ],
  "limit": 10,
  "looks_like_a_url": true,
  "query": "nasa.gov"
}
```

### Summarize what is archived for a site

How much of a whole site the archive holds, year by year: how many captures it made, how many distinct pages those covered, how many pages it saw for the first time, and the breakdown by file type. Run it before a deeper crawl of the archive to know what is there. No API key required.

**Inputs**

- Site (`url`, text, required): The site to summarize. Any path is dropped: the summary covers the whole host. Paste an address with or without https://, or paste a Wayback link and the original URL is read out of it.

**Outputs**

- `calendar_url` (text): The Wayback Machine's own calendar page for this URL.
- `file_types` (list): Every year's captures by file type, commonest first.
- `first_year` (number): The first year with captures.
- `host` (text): The host that was summarized.
- `is_archived` (true/false): Whether the archive holds anything for it.
- `last_year` (number): The most recent year with captures.
- `summarized_at` (text): When the archive last rebuilt this summary, in UTC.
- `total_captures` (number): How many captures it holds in total.
- `total_urls` (number): How many distinct pages those captures cover.
- `years` (list): One entry per year, oldest first.

**Example output**

```json
{
  "calendar_url": "https://web.archive.org/web/*/www.iana.org",
  "file_types": [
    {
      "captures": 1268403,
      "mime_type": "text/html"
    }
  ],
  "first_year": 1998,
  "host": "www.iana.org",
  "is_archived": true,
  "last_year": 2026,
  "summarized_at": "2026-02-12T20:47:50Z",
  "total_captures": 1576963,
  "total_urls": 59429,
  "years": [
    {
      "captures": 206,
      "file_types": [
        {
          "captures": 206,
          "mime_type": "text/html"
        }
      ],
      "new_urls": 203,
      "urls": 203,
      "year": 1998
    }
  ]
}
```