# Project Gutenberg Books Scraper — Titles, Authors & Downloads (`hipersoft/gutenberg-books-scraper`) Actor

Search and export Project Gutenberg's public-domain book catalog in bulk: title, authors with birth/death years, subjects, bookshelves, languages, download count and download links for plain-text and EPUB. Clean structured JSON, CSV or Excel.

- **URL**: https://apify.com/hipersoft/gutenberg-books-scraper.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Other, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0005 / book scraped

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

## Project Gutenberg Books Scraper — Titles, Authors & Downloads

Search and export **Project Gutenberg's** public-domain book catalog as clean, structured **JSON, CSV or Excel**: **title, authors** (with birth/death years), **subjects, bookshelves, languages, download count** and ready-to-use **download links** for **plain-text** and **EPUB**. Search by keyword, filter by topic, language and author era, and pull one tidy record per book — thousands of free classics in a single run.

### What does Project Gutenberg Books Scraper do?

This Project Gutenberg scraper turns the world's largest library of free, public-domain ebooks into a structured dataset. Give it a search query (like `sherlock holmes`), or browse the whole catalog and narrow it down by **topic**, **language** and **author era**, then choose how the results are ordered — most popular first, or by catalog ID. For every matching book you get the headline metadata plus direct download links, so you can build reading lists, feed text-analysis pipelines, or archive classics in bulk.

### What data can you scrape from Project Gutenberg?

| Data point | Description |
| --- | --- |
| `id` | Project Gutenberg book ID. |
| `title` | Book title. |
| `authors` | Author list — each with `name`, `birthYear` and `deathYear`. |
| `translators` | Translators, when credited (same shape as authors). |
| `subjects` | Library-of-Congress style subject headings. |
| `bookshelves` | Curated Project Gutenberg bookshelf categories. |
| `languages` | Two-letter language codes the book is available in. |
| `copyright` | Whether the book is under copyright (usually `false`). |
| `mediaType` | Media type (e.g. `Text`). |
| `downloadCount` | How many times the book has been downloaded. |
| `formats` | Map of MIME type → download URL (HTML, EPUB, Kindle, plain-text and more). |
| `textUrl` | Direct plain-text download link, when available. |
| `epubUrl` | Direct EPUB download link, when available. |
| `url` | Project Gutenberg reading page for the book. |

### Use cases

- **Reading & research datasets** — assemble a themed corpus of classics for analysis or search.
- **Text mining & NLP** — feed full-text book links into notebooks, models or RAG apps.
- **Digital libraries** — build or enrich a catalog with titles, authors, subjects and covers.
- **Bulk downloads** — grab plain-text and EPUB links for offline reading collections.
- **Discovery** — surface the most popular public-domain books by topic, language or author era.

### How to scrape Project Gutenberg data

1. Add **Project Gutenberg Books Scraper** to your Apify account and open its input.
2. Enter a **search** query (e.g. `sherlock holmes`), or leave it empty to browse everything.
3. Optionally set a **topic** (e.g. `children`), one or more **languages** (e.g. `["en"]`), and an **author era** with **authorYearStart** / **authorYearEnd**.
4. Choose the **sort** order and a **maxItems** cap (or `0` for every match).
5. Click **Run**, then export the results as JSON, CSV or Excel — or fetch them through the Apify API.

### Input

```json
{
  "search": "sherlock holmes",
  "topic": "",
  "languages": ["en"],
  "sort": "popular",
  "maxItems": 100
}
```

| Field | Description |
| --- | --- |
| `search` | Keywords matched against titles and author names. |
| `topic` | Single subject/bookshelf keyword filter (e.g. `children`, `history`). |
| `languages` | Keep only books in these two-letter language codes. |
| `authorYearStart` | Keep books with an author alive during/after this year. |
| `authorYearEnd` | Keep books with an author alive during/before this year. |
| `sort` | `popular`, `ascending` or `descending`. |
| `maxItems` | Maximum books to collect (`0` = no limit). |

### What you get

One flat JSON record per book, ready to export to CSV, Excel, JSON or XML:

```json
{
  "id": 1661,
  "title": "The Adventures of Sherlock Holmes",
  "authors": [
    { "name": "Doyle, Arthur Conan", "birthYear": 1859, "deathYear": 1930 }
  ],
  "translators": [],
  "subjects": [
    "Detective and mystery stories, English",
    "Private investigators -- England -- Fiction"
  ],
  "bookshelves": ["Category: Crime, Thrillers and Mystery"],
  "languages": ["en"],
  "copyright": false,
  "mediaType": "Text",
  "downloadCount": 96543,
  "formats": {
    "text/plain; charset=us-ascii": "https://www.gutenberg.org/ebooks/1661.txt.utf-8",
    "application/epub+zip": "https://www.gutenberg.org/ebooks/1661.epub3.images"
  },
  "textUrl": "https://www.gutenberg.org/ebooks/1661.txt.utf-8",
  "epubUrl": "https://www.gutenberg.org/ebooks/1661.epub3.images",
  "url": "https://www.gutenberg.org/ebooks/1661"
}
```

### Related Actors

Building a broader books or research dataset? Pair this with:

- [OpenLibrary Book Scraper](https://apify.com/hipersoft/openlibrary-scraper) — millions of books by title, author, subject or ISBN.
- [arXiv Scraper](https://apify.com/hipersoft/arxiv-scraper) — research papers with metadata and abstracts.
- [Wikipedia Scraper](https://apify.com/hipersoft/wikipedia-scraper) — articles and structured page data.
- [Website Content Crawler](https://apify.com/hipersoft/website-content-crawler) — crawl any site into clean text for LLM/RAG.

### FAQ

**What is Project Gutenberg?**
Project Gutenberg is a volunteer library of over 70,000 free ebooks, mostly older works whose copyright has expired. This Actor makes that catalog searchable and exportable as structured data.

**Can I download the actual book text?**
Yes. Each record includes a `formats` map plus `textUrl` and `epubUrl` shortcuts pointing to the plain-text and EPUB downloads hosted by Project Gutenberg.

**How do the filters work together?**
All filters combine — `search`, `topic`, `languages` and the author-era range are applied together, so you can, for example, find popular English children's books by authors alive in the 1800s.

**How many books can I scrape per run?**
There's no fixed cap. `maxItems` limits how many books are collected (`0` = every match). Larger runs simply take longer.

**Is scraping Project Gutenberg data legal?**
The Actor collects only publicly available catalog data for public-domain works. You are responsible for using it in line with Project Gutenberg's terms and applicable laws.

**What's the output format?**
A structured dataset with one item per book. Export as JSON, CSV or Excel from the Apify Console or API.

**Can I use this with n8n, Make or Zapier?**
Yes. Run it from [n8n](https://n8n.io) via the Apify node, or connect it to [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), [Google Drive](https://docs.apify.com/platform/integrations/drive) and [many more](https://apify.com/integrations), plus the [Apify API](https://docs.apify.com/api/v2), JavaScript/Python clients, MCP and [webhooks](https://docs.apify.com/platform/integrations/webhooks).

### Notes

Original clean-room implementation. Returns only public, public-domain catalog data; you are responsible for compliance with Project Gutenberg's terms. Not affiliated with Project Gutenberg.

# Actor input Schema

## `search` (type: `string`):

Keywords matched against book titles and author names. Multiple words must all match (e.g. "sherlock holmes" or "dickens london"). Leave empty to browse the whole catalog and filter with the options below.

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

Filter by a single subject or bookshelf keyword, e.g. "children", "science fiction", "history" or "poetry". Matched against each book's subjects and bookshelves.

## `languages` (type: `array`):

Keep only books available in these two-letter language codes, e.g. \["en"] for English or \["en", "fr"] for English and French. Leave empty for all languages.

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

Keep only books with at least one author alive during or after this year. Negative values mean BCE, e.g. -500. Leave empty for no lower bound.

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

Keep only books with at least one author alive during or before this year. Negative values mean BCE. Leave empty for no upper bound.

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

Order of results: most popular (by download count), or by ascending / descending Project Gutenberg ID.

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

Maximum number of books to collect across all pages. Use 0 for no limit (collect every matching book).

## Actor input object example

```json
{
  "search": "sherlock holmes",
  "topic": "children",
  "languages": [
    "en"
  ],
  "sort": "popular",
  "maxItems": 100
}
```

# Actor output Schema

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

The results as dataset items.

# 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 = {
    "search": "sherlock holmes"
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/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 = { "search": "sherlock holmes" }

# Run the Actor and wait for it to finish
run = client.actor("hipersoft/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 '{
  "search": "sherlock holmes"
}' |
apify call hipersoft/gutenberg-books-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hipersoft/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/bGoqeRE1QfSmNboqc/builds/FHoqfhbeHlIqqwXTf/openapi.json