# Project Gutenberg Books Scraper (`parseforge/project-gutenberg-books-scraper`) Actor

Scrapes Project Gutenberg book metadata via the Gutendex API. Returns title, authors, subjects, download count, copyright status, and direct links to ebook formats for each book.

- **URL**: https://apify.com/parseforge/project-gutenberg-books-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Automation, Other
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $13.00 / 1,000 result 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Project Gutenberg Books Scraper

**Scrape Project Gutenberg books by search term, language, topic, or author era, up to a million per run.** Every book comes with its title, authors, download count, subjects, and direct links to EPUB, MOBI, TXT, and HTML formats. No API key required. Export to CSV, JSON, Excel, or XML.

Project Gutenberg's own site is built for reading, not for bulk research. This Actor queries the public Gutendex API so you can pull thousands of book records in one go, filtered exactly how you need them. Search by keyword, restrict to a language like 'fr' for French, narrow by topic, or target authors born in a specific century. Each result lands in a flat, predictable row ready for analysis.

| Who uses it | What they scrape Project Gutenberg for |
|---|---|
| Digital humanities researchers | Build a corpus of 19th-century English novels for text analysis. |
| Librarians and archivists | Audit available public-domain titles on a specific subject heading. |
| Language learning app developers | Gather a list of free French or Spanish texts with direct ebook links. |
| Data journalists | Analyze publication trends by author birth year and topic over time. |

### What it does

This Actor collects Project Gutenberg book metadata by search query, language, topic, and author birth year, and returns each book as a flat row with download links.

- 🔍 **Search-driven collection:** Feed it a keyword like 'tolkien' or leave it empty to pull the most popular books on Gutenberg.
- 🌐 **Language filter:** Restrict results to one or more ISO 639-1 codes, such as 'en' for English, 'es' for Spanish, or 'de,fr' for German and French.
- 📚 **Topic and subject filter:** Narrow by Library of Congress subject heading with a substring match, e.g. 'Science fiction' or 'History'.
- 📅 **Author era filter:** Set a birth-year range to target authors from a specific period, like 1800 to 1900.
- ©️ **Copyright status:** Choose to see only public-domain works, only copyrighted ones, or all.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Project Gutenberg data

**📖 Build a reading list for a language course.**

A Spanish teacher filters by language 'es' and topic 'Readers' to collect graded public-domain texts with direct download links for students.

**📊 Analyze literary history by author birth year.**

A researcher sets author birth years from 1800 to 1900 and topic 'English literature' to chart the rise of the novel across the 19th century.

**🔎 Audit a niche subject collection.**

A librarian searches for 'cookery' and filters to public-domain only to see what free historical recipe books are available for digitization.

**📱 Populate a free ebook app with direct links.**

A developer pulls the top 10,000 English books by download count and uses the format URLs to offer in-app EPUB and HTML reading.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key or registration** | The Gutendex API is open. You set the filters and the Actor handles pagination and rate limits. |
| **Direct ebook links** | Every record includes URLs for EPUB, MOBI, TXT, and HTML formats so you can download the full text. |
| **Rich metadata** | Get title, authors, languages, download count, subjects, bookshelves, and copyright status in one row. |
| **Scalable collection** | Pull up to a million books per run, far beyond what a manual browser session can do. |

### How it compares

Three other actors scrape Project Gutenberg via the same Gutendex API. This one adds author birth-year range filtering and a copyright status toggle alongside the standard search, language, and topic filters.

| Feature | ParseForge | Project Gutenberg Books Scraper | Gutendex Books Scraper - Gutenberg Metadata | Gutenberg Scraper · Books, Authors, Subjects & Downloads |
|---|---|---|---|---|
| Search by keyword | Yes | Yes | Yes | Yes |
| Filter by language (ISO 639-1) | Yes | Yes | Yes | Yes |
| Filter by topic/subject | Yes | Yes | Yes | Yes |
| Filter by author birth-year range | Yes | Not listed | Not listed | Not listed |
| Filter by copyright status | Yes | Not listed | Not listed | Not listed |
| Direct ebook download links (EPUB, MOBI, TXT, HTML) | Yes | Yes | Yes | Yes |

### Configure the run

Drive the Actor with a search term, and optionally filter by language, topic, author birth-year range, and copyright status. Filters are applied as each book is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10,
 "query": "tolkien"
}
```

A larger pull:

```json
{
 "maxItems": 200,
 "query": "tolkien"
}
```

### Pricing

Pay-per-result: **$0.01733 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.73 |
| 1,000 results | $17.33 |
| 10,000 results | $173.30 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Project Gutenberg Books Scraper](https://apify.com/parseforge/project-gutenberg-books-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Project Gutenberg through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/project-gutenberg-books-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your filters are not too restrictive. Try removing the topic or author year range, or broaden your search term. An empty search with no filters returns the most popular books.

**Why are some download links missing?**

Not every format is available for every book. Project Gutenberg generates formats based on the source text. A missing MOBI link means that format was not produced for that title.

**The language filter is not working as I expected.**

Use ISO 639-1 two-letter codes like 'en', 'fr', 'de'. Check for typos and ensure codes are comma-separated without spaces. The filter matches the language metadata in the Gutenberg catalog.

**I am getting fewer results than my maxItems setting.**

The Actor stops when it has collected your requested number of books or when no more books match your filters, whichever comes first. Broaden your filters to get more results.

**The run is taking a long time.**

Large requests with high maxItems values will paginate through many pages. The Gutendex API has rate limits, and the Actor respects them. Reduce maxItems or narrow your filters for faster runs.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Project Gutenberg account or API key? | No. This Actor uses the open Gutendex API, which requires no registration, no key, and no authentication. |
| What formats can I get download links for? | Each book record includes direct links to EPUB, MOBI, TXT, and HTML formats when they are available on Project Gutenberg. |
| How do I search for books by a specific author? | Put the author's name in the search term field. The query matches against title and author name, so 'Austen' will return Jane Austen's works. |
| Can I filter by multiple languages at once? | Yes. Enter comma-separated ISO 639-1 codes in the language field, like 'en,fr,de' to get books in English, French, and German. |
| What does the topic filter match against? | It does a substring match against the Library of Congress subject headings. 'Science' will match 'Science fiction', 'Political science', and 'Science -- History'. |
| How do I get only public-domain books? | Set the Copyright filter to 'Public domain'. This excludes the small number of copyrighted works that Gutenberg hosts with permission. |
| What is the maximum number of books I can scrape in one run? | You can set the maximum up to 1,000,000 books. The Actor will paginate through results until it hits your limit or runs out of matches. |
| Does this Actor download the full book text? | No. It collects metadata and direct links to the ebook files. You can use those links in a separate process to download the full texts. |
| Can I leave the search field empty? | Yes. An empty search returns all books, ranked by popularity on Project Gutenberg. Combine it with other filters to narrow the set. |
| How are author birth years used? | Set a start year and an end year to include only authors born in that range. This is useful for period studies, like targeting Victorian-era writers. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Project Gutenberg Literary Archive Foundation. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

Maximum number of books to collect per run.

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

Search terms (matches title, author name, etc.). Empty = all books, ranked by popularity.

## `language` (type: `string`):

Filter by language code(s) — e.g. 'en' for English, 'es' for Spanish, 'fr' for French. Multiple: 'en,fr'.

## `topic` (type: `string`):

Filter by Library of Congress subject heading (substring match).

## `authorYearStart` (type: `integer`):

Filter by author birth year >= this.

## `authorYearEnd` (type: `integer`):

Filter by author birth year <= this.

## `copyrightStatus` (type: `string`):

Filter by copyright status.

## Actor input object example

```json
{
  "maxItems": 10,
  "query": "tolkien",
  "copyrightStatus": ""
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "query": "tolkien",
    "language": "",
    "topic": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/project-gutenberg-books-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 = {
    "maxItems": 10,
    "query": "tolkien",
    "language": "",
    "topic": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/project-gutenberg-books-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 '{
  "maxItems": 10,
  "query": "tolkien",
  "language": "",
  "topic": ""
}' |
apify call parseforge/project-gutenberg-books-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/project-gutenberg-books-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/jYmo6AhN5ES7agVkM/builds/brYrqg5fNR1JaGdNV/openapi.json