# Literal.club Books & Reviews Scraper (`thescrapelab/literal-club-book-reviews-scraper`) Actor

Extract public Literal.club book metadata, visible review text, authors, ratings, and profiles from book names, ISBNs, URLs, authors, or profile handles. No API or login.

- **URL**: https://apify.com/thescrapelab/literal-club-book-reviews-scraper.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** Developer tools, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Literal.club Books & Reviews Scraper

Extract public book metadata and visible public review text from Literal.club. Enter book names, ISBNs, author names, Literal.club URLs, or profile handles and get normalized records for books, reviews, authors, and profiles.

This Actor does **not** use Literal.club's API, does **not** log in, and does **not** collect private data.

### What You Can Scrape

- Public book metadata: title, subtitle, description, cover, ISBNs, publisher, page count, language, ratings, review counts, and authors
- Public review text rendered on book pages
- Public reviews rendered on profile review pages
- Public author and profile details when available
- Source URLs and timestamps for traceability

### Common Use Cases

- Build book review datasets from public Literal.club pages
- Monitor public review snippets for selected books
- Enrich ISBN or title lists with public book metadata
- Collect public reviews from known Literal.club profiles
- Compare public book ratings, review counts, and metadata across a small catalog

### Input Examples

Search by book name:

```json
{
  "searchQueries": ["Sapiens"],
  "includeReviews": true,
  "maxReviews": 5
}
````

Search by ISBN:

```json
{
  "isbns": ["9780062316110"],
  "includeReviews": false
}
```

Use a direct Literal.club book URL:

```json
{
  "startUrls": ["https://literal.club/book/sapiens-bp7kc"],
  "includeReviews": true,
  "maxReviews": 10
}
```

Fast daily smoke-test input:

```json
{
  "startUrls": ["https://literal.club/book/sapiens-bp7kc"],
  "includeReviews": true,
  "maxReviews": 1
}
```

Collect public reviews from a profile:

```json
{
  "profileHandles": ["piet"],
  "includeReviews": true,
  "maxReviews": 25
}
```

### Input Fields

- `searchQueries`: book names or search terms
- `isbns`: ISBN-10 or ISBN-13 values
- `authorNames`: author names to search
- `startUrls`: public Literal.club book, search, author, profile, or profile review URLs
- `profileHandles`: public Literal.club profile handles
- `includeReviews`: toggle public review scraping on or off
- `maxReviews`: maximum review records for the whole run

The Actor keeps advanced settings hidden and uses conservative defaults for concurrency, request delay, memory, and timeouts.

### Output

The dataset is normalized. Each saved item has an `entityType`:

- `book`
- `review`
- `author`
- `profile`

The Apify Console dataset view includes review text, reviewed book title, reviewer handle, ratings, source URL, and scrape timestamp.

Book item:

```json
{
  "entityType": "book",
  "source": "literal.club",
  "sourceBookId": "ckpptxpp01226151givfzdstoh7",
  "slug": "sapiens-bp7kc",
  "title": "Sapiens",
  "subtitle": "A Brief History of Humankind",
  "coverUrl": "https://assets.literal.club/2/ckpptxpp01226151givfzdstoh7.jpg",
  "isbn10": "0062316117",
  "isbn13": "9780062316110",
  "language": "en",
  "pageCount": 464,
  "publisher": "Harper Perennial",
  "averageRating": 4.34,
  "reviewCount": 1304,
  "authors": [{ "id": "AUTHOR_ID", "name": "Yuval Noah Harari", "slug": "yuval-noah-harari-2guoz" }],
  "bookLevelReviewDiscoveryStatus": "available_in_public_page_and_collected",
  "sourceUrl": "https://literal.club/book/sapiens-bp7kc",
  "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

Review item:

```json
{
  "entityType": "review",
  "source": "literal.club",
  "sourceReviewId": "REVIEW_ID",
  "rating": 4,
  "reviewText": "Fascinating read, well written and engaging.",
  "reviewerProfileId": "PROFILE_ID",
  "reviewerHandle": "reader",
  "reviewerName": "Reader Name",
  "bookId": "BOOK_ID",
  "bookSlug": "sapiens-bp7kc",
  "bookTitle": "Sapiens",
  "sourceUrl": "https://literal.club/book/sapiens-bp7kc",
  "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

### Reviews Coverage

Reviews are returned only when they are visible on public Literal.club pages. The Actor can collect:

- review previews rendered on public book pages
- reviews rendered on public profile review pages

The Actor does not log in and does not call private or public APIs to force complete review pagination. `maxReviews` is an output cap, not a guarantee that every book has that many public reviews available.

### Pricing

Recommended launch pricing: **$0.001 per result**.

A result is one saved dataset item, such as a book, review, author, or profile. This keeps pricing simple for clients and fits Apify's price-per-dataset-item model.

### API Usage

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("thescrapelab/literal-club-book-reviews-scraper").call(
    run_input={
        "startUrls": ["https://literal.club/book/sapiens-bp7kc"],
        "includeReviews": True,
        "maxReviews": 1,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Limitations

- No API calls, login, bearer token, or authenticated data are used.
- Only data visible in public rendered pages or public page HTML is collected.
- Book-name search depends on public search/discovery pages. For best precision, use ISBNs or direct Literal.club book URLs.
- Some books expose metadata but no public review text.
- Public profile review pages depend on profile visibility and page rendering.

### Polite Scraping

The Actor uses low concurrency, request delays, bounded retries, and cost-aware memory/timeouts. It does not bypass Cloudflare, login walls, private pages, or anti-bot systems.

### Troubleshooting

- Empty results: try a direct Literal.club book URL or ISBN.
- No reviews returned: enable `includeReviews`, increase `maxReviews`, or provide a public profile handle with visible reviews.
- Wrong edition: use the exact ISBN or direct Literal.club book URL.
- Slow runs: use direct URLs, reduce the number of book names, or lower `maxReviews`.

# Actor input Schema

## `searchQueries` (type: `array`):

Book titles or search terms to look up on public Literal.club pages. Start here for the simplest run.

## `isbns` (type: `array`):

Optional ISBN-10 or ISBN-13 values. Spaces and hyphens are removed automatically.

## `authorNames` (type: `array`):

Optional author names to search for related public Literal.club book pages.

## `startUrls` (type: `array`):

Optional public Literal.club book, search, author, profile, or profile review URLs. Direct book URLs are fastest and most precise.

## `profileHandles` (type: `array`):

Optional public Literal.club profile handles. When reviews are enabled, the Actor scrapes that user's public reviews page.

## `includeReviews` (type: `boolean`):

Collect public review text rendered on book pages and profile review pages.

## `maxReviews` (type: `integer`):

Maximum number of review records to save for the whole run. This is a cap, not a guarantee that reviews exist publicly.

## Actor input object example

```json
{
  "searchQueries": [
    "Sapiens"
  ],
  "isbns": [],
  "authorNames": [],
  "startUrls": [
    "https://literal.club/book/sapiens-bp7kc"
  ],
  "profileHandles": [],
  "includeReviews": false,
  "maxReviews": 20
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All normalized output records saved to the default dataset, including books, reviews, authors, and profiles.

## `reviewsView` (type: `string`):

Default dataset with the review-focused view selected. Review records expose reviewText, bookTitle, reviewerHandle, rating, and sourceUrl when available.

## `booksView` (type: `string`):

Default dataset with the book-focused view selected. Book records expose title, ISBNs, ratings, review counts, publisher, sourceUrl, and review discovery status when available.

## `profilesView` (type: `string`):

Default dataset with the profile-focused view selected. Profile records expose handles, names, bios, public counts, and source URLs when available.

## `runStats` (type: `string`):

JSON summary written to the default key-value store under RUN-STATS, including entity counts, warnings, errors, and unavailable capability notes.

# 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 = {
    "searchQueries": [
        "Sapiens"
    ],
    "isbns": [],
    "authorNames": [],
    "startUrls": [
        "https://literal.club/book/sapiens-bp7kc"
    ],
    "profileHandles": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/literal-club-book-reviews-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 = {
    "searchQueries": ["Sapiens"],
    "isbns": [],
    "authorNames": [],
    "startUrls": ["https://literal.club/book/sapiens-bp7kc"],
    "profileHandles": [],
}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/literal-club-book-reviews-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 '{
  "searchQueries": [
    "Sapiens"
  ],
  "isbns": [],
  "authorNames": [],
  "startUrls": [
    "https://literal.club/book/sapiens-bp7kc"
  ],
  "profileHandles": []
}' |
apify call thescrapelab/literal-club-book-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Literal.club Books & Reviews Scraper",
        "description": "Extract public Literal.club book metadata, visible review text, authors, ratings, and profiles from book names, ISBNs, URLs, authors, or profile handles. No API or login.",
        "version": "0.2",
        "x-build-id": "n42ndQn8gPXHyKTa5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thescrapelab~literal-club-book-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thescrapelab-literal-club-book-reviews-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/thescrapelab~literal-club-book-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thescrapelab-literal-club-book-reviews-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/thescrapelab~literal-club-book-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thescrapelab-literal-club-book-reviews-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",
                "properties": {
                    "searchQueries": {
                        "title": "Book names",
                        "type": "array",
                        "description": "Book titles or search terms to look up on public Literal.club pages. Start here for the simplest run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "isbns": {
                        "title": "ISBNs",
                        "type": "array",
                        "description": "Optional ISBN-10 or ISBN-13 values. Spaces and hyphens are removed automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "authorNames": {
                        "title": "Author names",
                        "type": "array",
                        "description": "Optional author names to search for related public Literal.club book pages.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Literal URLs",
                        "type": "array",
                        "description": "Optional public Literal.club book, search, author, profile, or profile review URLs. Direct book URLs are fastest and most precise.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "profileHandles": {
                        "title": "Profile handles",
                        "type": "array",
                        "description": "Optional public Literal.club profile handles. When reviews are enabled, the Actor scrapes that user's public reviews page.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeReviews": {
                        "title": "Scrape reviews",
                        "type": "boolean",
                        "description": "Collect public review text rendered on book pages and profile review pages.",
                        "default": false
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of review records to save for the whole run. This is a cap, not a guarantee that reviews exist publicly.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```