# Internet Archive Scraper (`dami_studio/internet-archive-scraper`) Actor

Internet Archive scraper for archive.org books, audio, film, software and web items, by keyword or Lucene query. Each row holds the identifier, title, creator, year, media type, download count, subjects, description and link. Uploaders write the metadata, so gaps are common. $2.00 per 1,000 items.

- **URL**: https://apify.com/dami_studio/internet-archive-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Integrations, News, Other
- **Features:** Limited permissions
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.94 / 1,000 items

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

**Search archive.org for books, audio, film, software and more, and get the results as rows**: the
identifier, the title, the creator, the year, the download count, the subject tags, a description
and the link. Filter to one media type, and sort by downloads, by date or by what was added most
recently.

The metadata is written by whoever uploaded the item, so it is uneven. Plenty of items have no
creator, no year and no description, and that is the archive rather than a gap here.

| | |
|---|---|
| **Input** | Search keywords, or an archive.org Lucene query |
| **Output** | One row per archive.org item: identifier, title, creator, year and date, media type, downloads, subjects, description, date added, link |
| **Ceiling** | 10,000 items per run |
| **Account needed** | None, and no API key |
| **Price** | $2.00 per 1,000 items on the Free plan, a little less on paid plans. The free plan's $5 a month covers about 2,500 |

### 🔍 What Internet Archive Scraper does

Plain keywords work. So does the archive's own query syntax, which is worth knowing if you are doing
anything precise: `title:(grateful dead) AND year:[1977 TO 1980]` does what it looks like it does.

Pick a media type to stay inside books, audio, film, software, images, archived web pages, datasets
or collections, or leave it empty and get everything. Sorting is by downloads, by the item's own
date, by when it was added to the archive, or by the archive's relevance ranking.

The run pages a hundred at a time until it has the number of unique items you asked for or the
result set runs out.

### 📋 What data you get from each archive.org item

| What you get | Field |
|---|---|
| The archive's permanent key for the item, and its page | `identifier`, `url` |
| Title and creator | `title`, `creator` |
| The item's own year and date | `year`, `date` |
| What kind of item it is | `mediaType` |
| How often it has been downloaded | `downloads` |
| The uploader's subject tags | `subjects` |
| The start of the uploader's description | `description` |
| When it was added to archive.org | `publicdate` |

### ▶️ How to scrape the Internet Archive

1. Open [Internet Archive Scraper](https://apify.com/dami_studio/internet-archive-scraper) and click
   **Try for free**.
2. Type keywords into **Search query**, or paste an archive.org query if you have one.
3. Pick a **Media type** unless you want everything.
4. Set **Max items**, choose a **Sort by**, then click **Start**.
5. Download the dataset as JSON, CSV or Excel, or read it from the Apify API.

### 💰 How much does it cost to scrape the Internet Archive?

**$2.00 per 1,000 items** on the Free plan. Paid plans pay a little less: $1.98 on Starter, $1.96 on Scale and $1.94 on Business. On the free plan, the $5 Apify
gives you each month covers about 2,500 items.

You pay per item delivered. Items that appear twice across pages are dropped before they are counted,
diagnostic rows are not charged, and a search that matches nothing is not charged. Set a maximum cost
on the run and it stops when it gets there.

### 📥 What you give it

```json
{
  "query": "title:(apollo 11) AND year:[1969 TO 1972]",
  "mediaType": "movies",
  "sort": "downloads",
  "maxItems": 500
}
```

| Field | Default | What it is |
|---|---|---|
| `query` | none, the form starts with `nasa apollo` | Keywords, or an archive.org Lucene query. Required. |
| `mediaType` | any | `texts`, `audio`, `movies`, `software`, `image`, `web`, `data` or `collection`. Empty means any. |
| `sort` | `downloads` | `downloads`, `date` for the item's own date, `publicdate` for recently added, or `relevance`. |
| `maxItems` | `100` | How many unique items to return, up to 10,000. |
| `notionConnector` | none | Optional. Writes each item into your Notion once the run finishes. |
| `notionParentId` | none | Optional. The Notion data source to write into. |
| `proxyConfiguration` | off | Optional network settings. Off by default, and a normal run does not need it. |

**An `OR` covers your whole query.** When you pick a media type, a query with an `OR` in it is
bracketed before the type is added, so `jazz OR blues` with `audio` returns jazz and blues
recordings, all of them audio.

### 📤 What you get back

A real row from a run on 2 October 2026, for `nasa apollo` sorted by downloads, with the description
cut short:

```json
{
  "ok": true,
  "identifier": "Apollo1116mmOnboardFilm",
  "title": "APOLLO 11 16MM ONBOARD FILM",
  "creator": "NASA/Johnson Space Center",
  "year": "1969",
  "date": "1969-01-01T00:00:00Z",
  "mediaType": "movies",
  "downloads": 301031,
  "subjects": ["What -- Apollo 11", "space", "nasa", "Apollo 11", "16MM"],
  "description": "Film taken includes scenes taken out Lunar Module (LM) window documenting lunar surface Extravehicular Activity (EVA) and LM ascent ...",
  "publicdate": "2009-05-30T00:41:55Z",
  "url": "https://archive.org/details/Apollo1116mmOnboardFilm"
}
```

Three of the four rows above it in that same run were collections such as `apolloaudiocollection`,
with `creator`, `year`, `date`, `subjects` and `description` all empty. That is what the archive's
shelves usually look like.

| Field | How to read it |
|---|---|
| `identifier` | The archive's permanent key for the item, and the part of the URL that matters. Use it to dedupe and to fetch the item's files elsewhere. |
| `creator`, `year`, `date` | `null` whenever the uploader left them blank, which is often. `year` is text, as the archive stores it. |
| `mediaType` | Which kind of item it is. `collection` means a container of other items, not a single thing you can play or read. |
| `downloads` | The archive's count, and `0` when the field was missing altogether. |
| `subjects` | The uploader's tags, as an array. Frequently empty. |
| `description` | The first 500 characters as the uploader wrote it, HTML and all, so strip it before displaying it. |
| `publicdate` | When the item was added to archive.org, which is not the same as when it was made. |

### 🧾 Reading the output

Two kinds of row land in your dataset, and `ok` tells them apart.

| Row | How to spot it | Billed |
|---|---|---|
| An item | `ok: true` and an `identifier` | yes |
| A diagnostic | `ok: false` and an `errorCode` | no |

The overview table in the Apify Console shows the item columns only, so a diagnostic row looks blank
there. Switch to the JSON or All fields view to read it.

| Code | What it means |
|---|---|
| `BAD_INPUT` | No query, or a media type that is not one of the listed values. |
| `NO_RESULTS` | The search worked and nothing matched. The `numFound` field on the row shows the archive's own count. |
| `RATE_LIMITED` | archive.org asked for a slower pace than the run could keep. Try a smaller run. |
| `SERVER_ERROR` | archive.org answered with a server error. Usually passes. |
| `NOT_SERVED` | This request was not served this run. Re-run it later. Runs before 13 October 2026 wrote `BLOCKED` here, and runs from 13 to 17 October wrote `NETWORK`. |
| `NETWORK` | archive.org was unreachable, or answered with something that was not the data it promised. The `details` field says which. |
| `TIME_LIMIT` | The run got close to its time limit and stopped on its own. The items delivered before that are complete and charged. Give the run more time, or ask for fewer items, to get the rest. |

A run that ends on one of these rows still finishes as succeeded, including when the time limit
stopped it before any item came back: the `TIME_LIMIT` row and an amber status message say so.

### 💡 What people use it for

- Finding the archived recordings of a band or a broadcaster, sorted by what people actually play.
- Building a reading list of public domain books on a subject, with the identifiers to fetch them.
- Tracking what a collection has gained recently, with `sort` on `publicdate` and a schedule.
- Handing a model a list of source material with links, rather than a page of search results.

### 🚧 What it does not do

- **Metadata and a link, never the files.** No books, audio, video or page captures are downloaded.
- **It does not read Wayback Machine snapshots.** Archived sites appear as items under the `web`
  media type, not as captures of a URL on a given date.
- **Uploader metadata is patchy.** Missing creators, years and descriptions are normal.
- **`downloads` cannot tell you zero from missing.** Both read `0`.
- **Collections are containers.** A `collection` row is a shelf, not an item, and it shows up whenever
  you leave the media type empty.
- **`description` keeps the uploader's HTML** and stops at 500 characters, which can cut mid-tag.
- **10,000 items per run**, and archive.org's own result set can end sooner.
- **No file lists, sizes or formats.** Take the `identifier` to the archive's item page for those.
- It is not an official tool of the Internet Archive. Dami's Studio is independent and is not affiliated with or endorsed by the Internet Archive, or by any other company named on this page.

### 🧭 Which reference scraper do you need?

| If you want | Use |
|---|---|
| Wikipedia search results or article text | [Wikipedia Scraper](https://apify.com/dami_studio/wikipedia-scraper) |
| Wikidata Q-ids, aliases and claims, by name or by ID | [Wikidata Scraper](https://apify.com/dami_studio/wikidata-scraper) |
| Book metadata by keyword, title or ISBN | [Books Scraper](https://apify.com/dami_studio/books-scraper) |
| Goodreads ratings and rating counts from a book search | [Goodreads Books Scraper](https://apify.com/dami_studio/goodreads-books-scraper) |
| Books, audio, film and software held on archive.org | This one |
| Papers with readable abstracts and citation counts | [OpenAlex Scraper](https://apify.com/dami_studio/openalex-scraper) |
| Wikipedia, arXiv and OpenAlex searches as tools for an AI agent | [Research MCP Server](https://apify.com/dami_studio/research-mcp-server) |

### ❓ Questions people ask

#### Do I need an archive.org account?

No. This reads the public search that anyone can use.

#### Can I download the books or the audio?

Not from this actor. Take the `identifier` from each row and fetch the item's files from archive.org
directly.

#### Why do some rows have no creator or year?

Because nobody typed them in when the item was uploaded. The archive accepts what it is given.

#### Can I use the archive's advanced query syntax?

Yes, the query goes through as written. Field searches and date ranges both work.

#### Can I call it from code or connect it to an AI assistant?

The [API tab](https://apify.com/dami_studio/internet-archive-scraper/api/python) has code for Python, JavaScript and
the CLI. MCP clients like Claude and ChatGPT use
`https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/internet-archive-scraper`; coding assistants can load
[our skill
file](https://api.apify.com/v2/key-value-stores/BTBHU3DdiuoF4JOsK/records/apify-open-data-research-SKILL.md). All
three bill your Apify account at the same price.

#### Is scraping the Internet Archive legal?

The search index is public. What you may then do with a
given item depends on that item's own rights, which vary enormously across the archive. Apify's
write-up on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) is a good
starting point, and we are not lawyers.

### 🆘 If something breaks

Open the **Issues** tab on the actor page. Send the run ID and the query you used. The `errorCode` on
the diagnostic row usually names the problem on its own.

# Actor input Schema

## `query` (type: `string`):

Keywords to search the Internet Archive for (e.g. "nasa apollo", "jazz"). Supports Lucene operators used by archive.org, e.g. "title:(grateful dead) AND year:\[1977 TO 1980]". Required.

## `mediaType` (type: `string`):

Restrict results to one media type, or leave empty for any. texts = books/documents, audio = music/recordings, movies = video/film, software, image, web (archived sites), data, collection.

## `sort` (type: `string`):

Order of results. downloads = most-downloaded first, date = newest item date first, publicdate = most recently added to archive.org first, relevance = the archive's default relevance ranking.

## `maxItems` (type: `integer`):

Maximum number of unique items to return. The actor paginates 100 per request until this many items are collected or the result set is exhausted.

## `notionConnector` (type: `string`):

Optional. Write each item as a page into your Notion when the run finishes. Authorize a Notion connector once in Settings → API & Integrations → MCP connectors, then pick it here. Leave empty to skip (default), results are always saved to the dataset regardless.

## `notionParentId` (type: `string`):

Optional. The Notion data source ID of the database to write into (only used if a Notion connector is set). Leave empty to create the pages privately in your workspace instead.

## `proxyConfiguration` (type: `object`):

Optional, and not needed for a normal run.

## Actor input object example

```json
{
  "query": "nasa apollo",
  "mediaType": "",
  "sort": "downloads",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Scraped rows are stored in the default dataset (one row per result). Blocked/empty/error runs return a single uncharged diagnostic row instead.

# 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 = {
    "query": "nasa apollo"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/internet-archive-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 = { "query": "nasa apollo" }

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/internet-archive-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 '{
  "query": "nasa apollo"
}' |
apify call dami_studio/internet-archive-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/internet-archive-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/RWjQIaqyPT6aselA1/builds/2zO6XdorFIyDjB0e3/openapi.json