# Amazon Books Intelligence: Authors, Series & Kindle Deals (`xyrelith-data/amazon-books-scraper`) Actor

Read Amazon book search, detail pages, complete author catalogues, series reading order and Kindle/book deals across 21 marketplaces.

- **URL**: https://apify.com/xyrelith-data/amazon-books-scraper.md
- **Developed by:** [Xyrelith Data](https://apify.com/xyrelith-data) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Amazon Books Intelligence: Authors, Series & Kindle Deals

Amazon's book catalogue is bigger than a keyword search box. This actor reads the book-specific surfaces that generic product scrapers skip:

- **Search** the Books, Kindle and Audible catalogues and get clean, filterable rows.
- **Read an author's complete catalogue** from an author store, including books that never surface in a keyword search, with the author bio, photo and total catalogue size.
- **Follow a series** in reading order with positions, publication dates, contributors and Goodreads ratings.
- **Collect Kindle and book deals** with the deal price, list price, discount and deal badge.
- **Enrich any row** with its detail page for publisher, publication date, page count, ISBN, file size, best-seller rank and full description.

Everything is public and cookieless. No Amazon login, cookie, API key or proxy setup is needed.

### Modes

| Mode | What it returns | Required input |
|---|---|---|
| `search` | One row per book from Amazon Books / Kindle / Audible search results | `searchQueries` |
| `details` | One row per ASIN with the full detail page fields | `asins` or `bookUrls` |
| `author` | Every book in an author's catalogue, newest first or by any sort | `authorIds` |
| `series` | Every book in a series, in reading order | `asins` or `bookUrls` (series ASINs) |
| `deals` | Today's Kindle and book deals, one row per deal | none |

### Input examples

#### Search books

```json
{
  "mode": "search",
  "searchQueries": ["cozy fantasy", "brandon sanderson"],
  "marketplace": "amazon.com",
  "format": "kindle",
  "searchSort": "review",
  "minRating": 4,
  "maxItems": 50
}
```

#### Author catalogue

```json
{
  "mode": "author",
  "authorIds": ["B001IGFHW6"],
  "authorSort": "newest",
  "authorLanguage": "English",
  "maxItems": 200
}
```

#### Series reading order

```json
{
  "mode": "series",
  "asins": ["B0F11YD12X"],
  "maxItems": 50
}
```

#### Book details with enrichment

```json
{
  "mode": "details",
  "asins": ["B0BPNB19CL", "059035342X"],
  "bookUrls": ["https://www.amazon.com/dp/1408856778"],
  "includeDetails": true
}
```

#### Kindle and book deals

```json
{
  "mode": "deals",
  "format": "kindle",
  "minDiscountPercent": 50,
  "maxItems": 100
}
```

### What each row contains

Every row includes:

- `recordType`: `bookSearch`, `bookDetail`, `authorBook`, `seriesBook` or `bookDeal`
- `asin`, `title`, `sourceUrl`, `marketplace`, `currency`, `scrapedAt`
- `authors`, `primaryAuthor`, `contributors` with roles and profile links
- `format`, `formatGroup`, `formats` (when the page lists other bindings)
- `price`, `listPrice` as `{value, currency, display}` objects
- `rating`, `reviewCount`, `savingsPercent`, `savingsAmount`
- `seriesTitle`, `seriesPosition`, `seriesTotal`, `seriesUrl`
- `coverImageUrl`, `imageUrls`
- `sponsored`, `bestSeller`, `editorsPick`, `amazonsChoice`, `kindleUnlimited`
- `page`, `positionOnPage` for search results

Detail-enriched rows add:

- `publisher`, `publicationDate`, `publicationDateText`, `language`
- `pageCount`, `isbn10`, `isbn13`, `fileSize`, `dimensions`, `readingAge`
- `bestSellersRanks` (all ranks shown) and `bestSellersRankPrimary`
- `description`, `availability`

Author rows add:

- `author`: `{authorId, authorName, authorBio, authorPhotoUrl, authorBookCount, authorUrl}`

Deal rows add:

- `dealCollection`, `dealRefTag`, `dealBadge`, `dealMessage`

Empty fields are omitted. A missing field never becomes `null`, `""` or a sentinel value.

### How it works

1. Opens a fresh Amazon session with a mobile browser profile and seeds the requested display currency.
2. Reads the requested surface: the mobile search endpoint, a product page, an author store and its product-grid API, the series `seriesAsinList` endpoint, or the book-deals page.
3. Parses the embedded JSON first and falls back to the rendered HTML.
4. Rotates the session, backs off and retries when Amazon returns a bot-check or a 429/5xx page.
5. Pushes one clean record per book and stops at `maxItems`.

The author mode reads the complete catalogue through Amazon's own paginated product grid, not just the first visible shelf. Series mode walks every `seriesAsinList` page until no new ASINs arrive.

### Input reference

| Field | Type | Notes |
|---|---|---|
| `mode` | select | `search`, `details`, `author`, `series`, `deals` |
| `searchQueries` | string list | Search mode queries |
| `asins` | string list | Book ASINs (details) or series ASINs (series) |
| `bookUrls` | string list | Full Amazon URLs; ASINs are extracted |
| `authorIds` | string list | Author IDs or author-store URLs |
| `marketplace` | select | 21 Amazon marketplaces |
| `currency` | select | Display currency; `auto` follows the marketplace |
| `deliveryCountry` | select | Ship-to country for price/availability |
| `deliveryPostalCode` | text | Optional postal/ZIP code for the delivery country |
| `searchSort` | select | relevance, price, review, newest, bestseller |
| `authorSort` | select | popularity, price, review, newest, most reviews |
| `format` | select | all, kindle, paperback, hardcover, audiobook, mass market, board book |
| `authorLanguage` | select | Author-catalogue language filter |
| `minPrice` / `maxPrice` | number | Price bounds |
| `minRating` / `maxRating` | number | Rating bounds |
| `minDiscountPercent` | number | Deal discount floor |
| `publishedAfter` / `publishedBefore` | date | ISO date bounds; unknown dates pass |
| `titleContains` | text | Substring filter |
| `excludeKeywords` | text | Comma-separated title exclusions |
| `includeSponsored` | boolean | Keep sponsored search placements |
| `includeDetails` | boolean | Fetch every book's detail page |
| `maxItems` | integer | 1-1000, default 50 |
| `maxPages` | integer | 1-50, default 10 |
| `proxyConfiguration` | object | Optional Apify Proxy override |

### Defaults

| Field | Default |
|---|---|
| `mode` | `search` |
| `marketplace` | `amazon.com` |
| `currency` | `auto` |
| `deliveryCountry` | `auto` |
| `searchSort` | `relevance` |
| `authorSort` | `popularity` |
| `format` | `all` |
| `authorLanguage` | `All Languages` |
| `includeSponsored` | `true` |
| `includeDetails` | `false` |
| `maxItems` | `50` (prefill `3`) |
| `maxPages` | `10` (prefill `1`) |

### Limits and notes

- Amazon shows different prices by delivery location. Set `deliveryCountry` (and optionally `deliveryPostalCode`) when you need a specific store's price. The actor still returns data without it.
- Search result cards do not expose every detail field. Turn on `includeDetails` when you need publisher, page count, ISBN, BSR or the full description.
- A few books have no public price (pre-orders, third-party-only listings, unavailable titles). The `price` field is omitted rather than invented.
- Author catalogues can contain hundreds of editions. `maxItems` and `maxPages` keep a run bounded; raise them for a full bibliography.
- Series pages are Kindle series pages. Books that Amazon does not link into the series page cannot be discovered from that page.
- Amazon's markup varies by marketplace and over time. The actor prefers embedded JSON and retries fresh sessions before falling back, but no scraper can guarantee every field on every page forever.
- Data is public Amazon catalogue information. Use it for research, price monitoring, catalogue enrichment and similar lawful purposes.

### FAQ

**Do I need a proxy or cookies?** No. The actor works with no proxy and no Amazon account. An optional proxy override is available for users who already have one.

**Can I get every book by an author?** Yes, author mode pages through the author store's complete catalogue. Use `maxItems` to cap the run.

**Can I filter Kindle deals only?** Yes. Set `format` to `kindle` in deals mode.

**Why is a price missing on some rows?** Amazon did not show a public price for that listing. The field is omitted instead of returning zero.

**How do I get BSR and page count on search results?** Turn on `includeDetails`. It costs one extra request per book.

**Does it work outside the US?** Yes. Pick any of the 21 supported marketplaces and a delivery country.

# Actor input Schema

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

What to collect.

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

One or more Amazon Books search queries, e.g. `harry potter`, `brandon sanderson`, `cozy fantasy`.

## `asins` (type: `array`):

Amazon ASINs. In details mode each ASIN is a book; in series mode each ASIN is a series page ASIN. Bare ASINs or full Amazon URLs are accepted.

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

Full Amazon book or series URLs. ASINs are extracted automatically.

## `authorIds` (type: `array`):

Amazon author IDs (e.g. `B001IGFHW6`) or author-store URLs such as `https://www.amazon.com/stores/author/B001IGFHW6`.

## `marketplace` (type: `string`):

Amazon site to read. Prices and availability follow the site plus the delivery setting.

## `currency` (type: `string`):

Currency Amazon shows on the page. `Auto` uses the marketplace currency.

## `deliveryCountry` (type: `string`):

Ship-to country used for prices and availability. `Auto` leaves Amazon's detected location unchanged.

## `deliveryPostalCode` (type: `string`):

Optional ZIP/postal code for the delivery country. Leave empty to use a representative local code.

## `searchSort` (type: `string`):

Result order for keyword search.

## `authorSort` (type: `string`):

Catalogue order for author mode.

## `format` (type: `string`):

Filter by binding. Search mode uses the Kindle/Audible storefronts for those formats and filters the rest on the result card.

## `authorLanguage` (type: `string`):

Language filter on the author catalogue. Only the languages Amazon exposes for author pages are listed.

## `minPrice` (type: `number`):

Drop records priced below this amount.

## `maxPrice` (type: `number`):

Drop records priced above this amount.

## `minRating` (type: `number`):

Drop records rated below this value (1-5).

## `maxRating` (type: `number`):

Drop records rated above this value (1-5).

## `minDiscountPercent` (type: `number`):

Keep only deals at or above this discount.

## `publishedAfter` (type: `string`):

ISO date `YYYY-MM-DD`. Records without a publication date pass through.

## `publishedBefore` (type: `string`):

ISO date `YYYY-MM-DD`. Records without a publication date pass through.

## `titleContains` (type: `string`):

Case-insensitive substring filter on the book title.

## `excludeKeywords` (type: `string`):

Comma-separated words; records whose title contains any of them are dropped.

## `includeSponsored` (type: `boolean`):

Keep Amazon sponsored search placements in search mode.

## `includeDetails` (type: `boolean`):

Fetch each book's detail page for publisher, page count, ISBN, BSR and description. Slower and uses more requests.

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

Hard cap on emitted records.

## `maxPages` (type: `integer`):

Maximum result/catalogue pages to read per query or author.

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

Optional Apify Proxy override. The actor works without a proxy and selects its own retry strategy automatically.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "harry potter"
  ],
  "asins": [],
  "bookUrls": [],
  "authorIds": [],
  "marketplace": "amazon.com",
  "currency": "auto",
  "deliveryCountry": "auto",
  "searchSort": "relevance",
  "authorSort": "popularity",
  "format": "all",
  "authorLanguage": "All Languages",
  "includeSponsored": true,
  "includeDetails": false,
  "maxItems": 3,
  "maxPages": 1
}
```

# Actor output Schema

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

Dataset containing search results, book details, author catalogue rows, series books or deals.

# 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",
    "searchQueries": [
        "harry potter"
    ],
    "asins": [],
    "bookUrls": [],
    "authorIds": [],
    "marketplace": "amazon.com",
    "currency": "auto",
    "deliveryCountry": "auto",
    "searchSort": "relevance",
    "authorSort": "popularity",
    "format": "all",
    "authorLanguage": "All Languages",
    "includeSponsored": true,
    "includeDetails": false,
    "maxItems": 3,
    "maxPages": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("xyrelith-data/amazon-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 = {
    "mode": "search",
    "searchQueries": ["harry potter"],
    "asins": [],
    "bookUrls": [],
    "authorIds": [],
    "marketplace": "amazon.com",
    "currency": "auto",
    "deliveryCountry": "auto",
    "searchSort": "relevance",
    "authorSort": "popularity",
    "format": "all",
    "authorLanguage": "All Languages",
    "includeSponsored": True,
    "includeDetails": False,
    "maxItems": 3,
    "maxPages": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("xyrelith-data/amazon-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 '{
  "mode": "search",
  "searchQueries": [
    "harry potter"
  ],
  "asins": [],
  "bookUrls": [],
  "authorIds": [],
  "marketplace": "amazon.com",
  "currency": "auto",
  "deliveryCountry": "auto",
  "searchSort": "relevance",
  "authorSort": "popularity",
  "format": "all",
  "authorLanguage": "All Languages",
  "includeSponsored": true,
  "includeDetails": false,
  "maxItems": 3,
  "maxPages": 1
}' |
apify call xyrelith-data/amazon-books-scraper --silent --output-dataset

```

## MCP server setup

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