# Hardcover Book Data Scraper (`crawlerbros/hardcover-book-data-scraper`) Actor

Scrape Hardcover.app - search books by title/author, browse by genre, reader-tagged mood, or series, and get rich book detail: ratings, mood/content-warning tags, series reading order, author profiles, and full bibliographic metadata.

- **URL**: https://apify.com/crawlerbros/hardcover-book-data-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Hardcover Book Data Scraper

Scrape [Hardcover.app](https://hardcover.app) — a modern, fast-growing Goodreads-alternative for tracking and discovering books. Search by title, author, or ISBN; browse by genre or reader-tagged mood; or look up specific books by URL. Every book comes back with ratings, reader-tagged moods and content warnings, series info, and full bibliographic metadata. No login, no cookies, no proxy required — all data scraped is publicly viewable.

### What this actor does

- **Seven modes:** `search`, `byGenre`, `byMood`, `byAuthor`, `byBookSlugs`, `bySeries`, `authorProfile`
- **14 reader-tagged moods** (adventurous, dark, hopeful, tense, etc.) and dozens of community genre tags as ready-made filters
- **Reader-consensus data:** average rating, rating count, review count, how many readers have the book on their shelf, how many marked it read, and how many community reading-prompt discussions mention it
- **Content warnings** as submitted by the reading community, with a one-click exclude filter for the most common ones
- **Full bibliographic metadata:** series (with reading-order position), page count, release year, ISBNs, alternate/translated titles, audiobook/ebook availability
- **Author profiles:** bio-style records (books count, top books, alternate pen names) fetched straight from Hardcover's author index — not just author-attributed book listings
- Empty fields are omitted — every record only contains data that was actually found

### Output per book

- `bookId`, `slug`, `title`, `subtitle`, `alternativeTitles[]`
- `authors[]`, `primaryAuthor`, `authorSlugs[]`, `primaryAuthorUrl`, `contributionTypes[]` (Author, Illustrator, Narrator, Translator, etc.)
- `seriesNames[]`, `primarySeriesName`, `seriesPosition`, `seriesSlug`, `seriesUrl`, `seriesBooksCount`, `seriesPrimaryBooksCount`
- `coverImageUrl`, `coverColor`, `description`
- `pageCount`, `releaseYear`, `releaseDate`, `isbns[]`
- `genres[]` — community-voted genre tags
- `moods[]` — reader-tagged moods (adventurous, dark, hopeful, tense, etc.)
- `tags[]` — additional reader-submitted tags (pacing, character-driven vs. plot-driven, etc.)
- `contentWarnings[]`
- `averageRating`, `ratingsCount`, `reviewsCount`, `usersCount`, `usersReadCount`, `listsCount`, `activitiesCount`, `promptsCount`
- `hasAudiobook`, `hasEbook`, `isCompilation`
- `sourceUrl`, `recordType: "book"`, `scrapedAt`

### Output per author (mode=authorProfile)

- `authorId`, `name`, `slug`, `imageUrl`
- `booksCount`, `topBooks[]`, `alternateNames[]` (pen names / name variants)
- `sourceUrl`, `recordType: "author"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byGenre` / `byMood` / `byAuthor` / `byBookSlugs` / `bySeries` / `authorProfile` |
| `searchQuery` | string | `fourth wing` | Free-text query (mode=search) — matches title, author, ISBN, or series |
| `genre` | string | – | Genre tag to browse (mode=byGenre) |
| `mood` | string | – | Mood to browse (mode=byMood) |
| `authorName` | string | – | Exact author name (mode=byAuthor), or name/URL/slug (mode=authorProfile) |
| `seriesName` | string | – | Exact series name to browse (mode=bySeries) |
| `bookUrls` | array | – | Hardcover book URLs or slugs (mode=byBookSlugs) |
| `sortBy` | string | `relevance` | `relevance` / `popularity` / `rating` / `newest` / `mostReviewed` / `longest` / `shortest` / `mostActivity` / `mostRead` / `mostDiscussed` / `seriesOrder` |
| `minAverageRating` | number | – | Drop books rated below this (0-5) |
| `releaseYearMin` / `releaseYearMax` | int | – | Restrict to a release-year range |
| `minPageCount` / `maxPageCount` | int | – | Restrict to a page-count range |
| `excludeContentWarnings` | array | – | Drop books tagged with any selected content warning |
| `hasAudiobookOnly` / `hasEbookOnly` | bool | `false` | Only include books with that edition format |
| `excludeCompilations` | bool | `false` | Drop multi-book compilations/boxsets |
| `maxItems` | int | `30` | Hard cap on emitted records (1-500) |

#### Example: browse a series in reading order

```json
{
  "mode": "bySeries",
  "seriesName": "The Empyrean",
  "sortBy": "seriesOrder",
  "excludeCompilations": true
}
````

#### Example: author profile lookup

```json
{
  "mode": "authorProfile",
  "authorName": "Rebecca Yarros"
}
```

#### Example: shorter books, no graphic content

```json
{
  "mode": "byGenre",
  "genre": "Fantasy",
  "maxPageCount": 350,
  "excludeContentWarnings": ["Sexual content", "Violence", "Gore"],
  "sortBy": "rating"
}
```

#### Example: highly-rated dark fantasy

```json
{
  "mode": "byGenre",
  "genre": "Fantasy",
  "mood": "dark",
  "minAverageRating": 4,
  "sortBy": "rating",
  "maxItems": 25
}
```

#### Example: everything by an author

```json
{
  "mode": "byAuthor",
  "authorName": "Rebecca Yarros",
  "maxItems": 50
}
```

#### Example: look up specific books

```json
{
  "mode": "byBookSlugs",
  "bookUrls": [
    "https://hardcover.app/books/project-hail-mary",
    "fourth-wing"
  ]
}
```

### Use cases

- **Reading-app integrations** — pull mood tags to power a "books like this, but lighter" recommender
- **Content warning research** — surface sensitive-content flags before recommending a book, or exclude sensitive titles entirely
- **Book-club curation** — filter by genre + mood + rating + page count to build a themed reading list
- **Publishing intelligence** — track how readers tag a title's mood/genre against marketing copy
- **Backlist discovery** — pull an author's full bibliography with community engagement stats in one run
- **Series tracking** — pull a whole series in reading order to power a "what to read next" feature
- **Author research** — fetch an author's profile (books count, alternate pen names) without scraping their whole catalog

### FAQ

**What's Hardcover?** A modern social book-tracking and discovery platform positioned as a faster, ad-free alternative to Goodreads, with StoryGraph-style mood tagging layered on top of genres and reviews.

**What are "moods"?** Reader-submitted tags describing how a book *feels* to read (e.g. "dark", "hopeful", "funny", "tense") — the same taxonomy popularized by StoryGraph.

**Do I need a Hardcover account?** No — search and book pages are public; the actor never logs in.

**Why do some books have very few genres/moods/tags?** Tagging is community-driven, so newer or less-popular titles may have sparse metadata. Popular titles usually have rich genre/mood/tag coverage.

**Can I combine genre and mood filters?** `byGenre` and `byMood` are separate modes (server-side filtered by the primary axis), but `minAverageRating`, `releaseYearMin`/`Max`, `hasAudiobookOnly`/`hasEbookOnly`, and `excludeCompilations` all apply as additional filters on top of any mode.

**What's the difference between `genres` and `tags`?** `genres` are category-style labels (Fantasy, Romance, Nonfiction); `tags` capture other reader-submitted descriptors (pacing, character-driven vs. plot-driven, diversity of cast, etc.). Tags are too free-form/long-tail to offer as a filter, so they stay output-only — `genres` and `moods` cover the bounded, filterable taxonomy.

**What's the difference between `byAuthor` and `authorProfile`?** `byAuthor` returns every *book* written by an author (recordType `book`). `authorProfile` returns a single bio-style *author* record (recordType `author`) — books count, top books, alternate pen names, profile photo — without listing the full bibliography. `authorProfile` also accepts a partial name for fuzzy author search, or a Hardcover author URL/slug for an exact lookup.

**How does `bySeries` order the books?** Set `sortBy` to `seriesOrder` to get books in official reading-order position. Series data on Hardcover includes boxsets/omnibus editions tagged to the same series, so also enable `excludeCompilations` for the cleanest single-book-per-slot list.

**How current is this data?** Ratings, review counts, and tags update continuously as the Hardcover community reads, rates, and tags books.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `searchQuery` (type: `string`):

Free-text query — matches title, author, ISBN, or series name.

## `genre` (type: `string`):

Community genre tag to browse. Hardcover genres are free-form; pick a common one or type your own.

## `mood` (type: `string`):

Reader-tagged mood to browse (same taxonomy popularized by StoryGraph).

## `authorName` (type: `string`):

Exact author name as it appears on Hardcover (e.g. `Rebecca Yarros`), or — for mode=authorProfile only — a Hardcover author URL/slug (e.g. `https://hardcover.app/authors/rebecca-yarros`) or a partial name to search.

## `seriesName` (type: `string`):

Exact series name as it appears on Hardcover, e.g. `The Empyrean`. Returns every book in the series; use sortBy=`seriesOrder` for reading order, and enable `excludeCompilations` to drop boxset/omnibus duplicates for the cleanest list.

## `bookUrls` (type: `array`):

Hardcover book URLs or bare slugs, e.g. `https://hardcover.app/books/fourth-wing` or `fourth-wing`.

## `sortBy` (type: `string`):

How to order results. Not used for mode=authorProfile (always ranked by name match). Note on `newest`: Hardcover's search index only exposes a year-granularity `release_year` field as sortable (confirmed via direct API test — the full `release_date` field exists on each record but is not configured as sortable in the search schema), so ordering is exact between different years but not fully chronological for multiple books released in the same year — use the returned `releaseDate` field to sort further client-side if day-level precision matters.

## `minAverageRating` (type: `number`):

Drop books with a community average rating below this (0-5, decimals allowed e.g. 3.5).

## `releaseYearMin` (type: `integer`):

Drop books released before this year.

## `releaseYearMax` (type: `integer`):

Drop books released after this year.

## `minPageCount` (type: `integer`):

Drop books shorter than this many pages.

## `maxPageCount` (type: `integer`):

Drop books longer than this many pages.

## `excludeContentWarnings` (type: `array`):

Drop any book tagged by readers with any of the selected content warnings.

## `hasAudiobookOnly` (type: `boolean`):

Only include books with an available audiobook edition.

## `hasEbookOnly` (type: `boolean`):

Only include books with an available ebook edition.

## `excludeCompilations` (type: `boolean`):

Drop multi-book compilations and boxsets from results.

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

Hard cap on emitted records (books, or author profiles for mode=authorProfile).

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "fourth wing",
  "bookUrls": [],
  "sortBy": "relevance",
  "excludeContentWarnings": [],
  "hasAudiobookOnly": false,
  "hasEbookOnly": false,
  "excludeCompilations": false,
  "maxItems": 30
}
```

# Actor output Schema

## `books` (type: `string`):

Dataset containing all scraped Hardcover records (books, or author profiles for mode=authorProfile).

# 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 = {
    "mode": "search",
    "searchQuery": "fourth wing",
    "bookUrls": [],
    "sortBy": "relevance",
    "excludeContentWarnings": [],
    "hasAudiobookOnly": false,
    "hasEbookOnly": false,
    "excludeCompilations": false,
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/hardcover-book-data-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 = {
    "mode": "search",
    "searchQuery": "fourth wing",
    "bookUrls": [],
    "sortBy": "relevance",
    "excludeContentWarnings": [],
    "hasAudiobookOnly": False,
    "hasEbookOnly": False,
    "excludeCompilations": False,
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/hardcover-book-data-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "searchQuery": "fourth wing",
  "bookUrls": [],
  "sortBy": "relevance",
  "excludeContentWarnings": [],
  "hasAudiobookOnly": false,
  "hasEbookOnly": false,
  "excludeCompilations": false,
  "maxItems": 30
}' |
apify call crawlerbros/hardcover-book-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/hardcover-book-data-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hardcover Book Data Scraper",
        "description": "Scrape Hardcover.app - search books by title/author, browse by genre, reader-tagged mood, or series, and get rich book detail: ratings, mood/content-warning tags, series reading order, author profiles, and full bibliographic metadata.",
        "version": "1.0",
        "x-build-id": "5ZbfzbZyRHN4amkdw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~hardcover-book-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-hardcover-book-data-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~hardcover-book-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-hardcover-book-data-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~hardcover-book-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-hardcover-book-data-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byGenre",
                            "byMood",
                            "byAuthor",
                            "byBookSlugs",
                            "bySeries",
                            "authorProfile"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text query — matches title, author, ISBN, or series name.",
                        "default": "fourth wing"
                    },
                    "genre": {
                        "title": "Genre (mode=byGenre)",
                        "enum": [
                            "Fantasy",
                            "Science Fiction",
                            "Romance",
                            "Mystery",
                            "Thriller",
                            "Horror",
                            "Young Adult",
                            "Middle Grade",
                            "Childrens",
                            "Classics",
                            "Historical Fiction",
                            "Literary Fiction",
                            "Contemporary",
                            "Biography",
                            "Memoir",
                            "Autobiography",
                            "Self Help",
                            "Poetry",
                            "Graphic Novels",
                            "Comics",
                            "Nonfiction",
                            "History",
                            "Science",
                            "Philosophy",
                            "Psychology",
                            "Business",
                            "True Crime",
                            "Humor",
                            "Adventure",
                            "Dystopian",
                            "Paranormal",
                            "Short Stories",
                            "Essays",
                            "Cookbooks",
                            "Travel",
                            "Religion",
                            "Sports",
                            "Music",
                            "Art",
                            "LGBT"
                        ],
                        "type": "string",
                        "description": "Community genre tag to browse. Hardcover genres are free-form; pick a common one or type your own."
                    },
                    "mood": {
                        "title": "Mood (mode=byMood)",
                        "enum": [
                            "adventurous",
                            "challenging",
                            "dark",
                            "emotional",
                            "funny",
                            "hopeful",
                            "informative",
                            "inspiring",
                            "lighthearted",
                            "mysterious",
                            "reflective",
                            "relaxing",
                            "sad",
                            "tense"
                        ],
                        "type": "string",
                        "description": "Reader-tagged mood to browse (same taxonomy popularized by StoryGraph)."
                    },
                    "authorName": {
                        "title": "Author name (mode=byAuthor / authorProfile)",
                        "type": "string",
                        "description": "Exact author name as it appears on Hardcover (e.g. `Rebecca Yarros`), or — for mode=authorProfile only — a Hardcover author URL/slug (e.g. `https://hardcover.app/authors/rebecca-yarros`) or a partial name to search."
                    },
                    "seriesName": {
                        "title": "Series name (mode=bySeries)",
                        "type": "string",
                        "description": "Exact series name as it appears on Hardcover, e.g. `The Empyrean`. Returns every book in the series; use sortBy=`seriesOrder` for reading order, and enable `excludeCompilations` to drop boxset/omnibus duplicates for the cleanest list."
                    },
                    "bookUrls": {
                        "title": "Book URLs or slugs (mode=byBookSlugs)",
                        "type": "array",
                        "description": "Hardcover book URLs or bare slugs, e.g. `https://hardcover.app/books/fourth-wing` or `fourth-wing`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "popularity",
                            "rating",
                            "newest",
                            "mostReviewed",
                            "longest",
                            "shortest",
                            "mostActivity",
                            "mostRead",
                            "mostDiscussed",
                            "seriesOrder"
                        ],
                        "type": "string",
                        "description": "How to order results. Not used for mode=authorProfile (always ranked by name match). Note on `newest`: Hardcover's search index only exposes a year-granularity `release_year` field as sortable (confirmed via direct API test — the full `release_date` field exists on each record but is not configured as sortable in the search schema), so ordering is exact between different years but not fully chronological for multiple books released in the same year — use the returned `releaseDate` field to sort further client-side if day-level precision matters.",
                        "default": "relevance"
                    },
                    "minAverageRating": {
                        "title": "Min average rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Drop books with a community average rating below this (0-5, decimals allowed e.g. 3.5)."
                    },
                    "releaseYearMin": {
                        "title": "Release year (min)",
                        "minimum": 0,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop books released before this year."
                    },
                    "releaseYearMax": {
                        "title": "Release year (max)",
                        "minimum": 0,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop books released after this year."
                    },
                    "minPageCount": {
                        "title": "Min page count",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Drop books shorter than this many pages."
                    },
                    "maxPageCount": {
                        "title": "Max page count",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Drop books longer than this many pages."
                    },
                    "excludeContentWarnings": {
                        "title": "Exclude books with these content warnings",
                        "type": "array",
                        "description": "Drop any book tagged by readers with any of the selected content warnings.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Sexual content",
                                "Violence",
                                "Death",
                                "Death of parent",
                                "Blood",
                                "Murder",
                                "Rape",
                                "Sexual assault",
                                "Grief",
                                "Child death",
                                "Suicide",
                                "Racism",
                                "Emotional abuse",
                                "Gore",
                                "Injury/Injury detail",
                                "Animal death",
                                "Child abuse",
                                "Misogyny",
                                "Mental illness",
                                "Gun violence",
                                "Bullying",
                                "Homophobia",
                                "Domestic abuse",
                                "Toxic relationship",
                                "Confinement",
                                "Medical content",
                                "Body horror",
                                "Torture",
                                "Alcohol",
                                "Drug use",
                                "Physical abuse",
                                "Alcoholism",
                                "Infidelity",
                                "Kidnapping",
                                "Suicidal thoughts",
                                "War",
                                "Sexism",
                                "Sexual violence",
                                "Addiction",
                                "Panic attacks/disorders",
                                "Animal cruelty",
                                "Drug abuse",
                                "Abandonment",
                                "Pregnancy",
                                "Ableism",
                                "Slavery",
                                "Self harm",
                                "Fire/Fire injury",
                                "Suicide attempt",
                                "Adult/minor relationship"
                            ]
                        },
                        "default": []
                    },
                    "hasAudiobookOnly": {
                        "title": "Has audiobook edition only",
                        "type": "boolean",
                        "description": "Only include books with an available audiobook edition.",
                        "default": false
                    },
                    "hasEbookOnly": {
                        "title": "Has ebook edition only",
                        "type": "boolean",
                        "description": "Only include books with an available ebook edition.",
                        "default": false
                    },
                    "excludeCompilations": {
                        "title": "Exclude compilations/boxsets",
                        "type": "boolean",
                        "description": "Drop multi-book compilations and boxsets from results.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records (books, or author profiles for mode=authorProfile).",
                        "default": 30
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
