# Amazon Book Scraper — Books Data & Metadata Extractor (`scrapepilot/amazon-book-scraper----books-data-metadata-extractor`) Actor

Scrape Amazon books data from any keyword, URL, or ASIN list. Get full book metadata — title, author, rating, reviews, price, publisher, pages, language, and cover image. Supports 7 Amazon marketplaces. No login. $8.99/month. 2-hour free trial.

- **URL**: https://apify.com/scrapepilot/amazon-book-scraper----books-data-metadata-extractor.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$8.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

## 📚 Amazon Book Scraper — Books Data & Metadata Extractor

> **The most complete Amazon Book Scraper on Apify.** Extract full Amazon books data from any keyword search, direct book URL, or bulk ASIN list — title, author, rating, reviews, price, description, publisher, publication date, page count, language, availability status, and high-resolution cover image. Supports 7 Amazon marketplaces. No login. No API key. Instant structured output.

---

### 📌 Table of Contents

- [What Is This Actor?](#what-is-this-actor)
- [Why Use This Amazon Book Scraper?](#why-use-this-amazon-book-scraper)
- [Supported Marketplaces](#supported-marketplaces)
- [Use Cases](#use-cases)
- [Input Parameters](#input-parameters)
- [Output Fields](#output-fields)
- [Example Input & Output](#example-input--output)
- [Pricing & Free Trial](#pricing--free-trial)
- [Performance & Limits](#performance--limits)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Terms of Use](#legal--terms-of-use)

---

### 🔍 What Is This Actor?

**Amazon Book Scraper** is a production-ready Apify actor that extracts complete **Amazon books data** and **Amazon book metadata** from any keyword search, direct Amazon book URL, or bulk list of ASINs — across 7 Amazon marketplaces.

Provide a search keyword like `"machine learning"` or `"Stephen King"`, paste a direct Amazon book URL, or supply a list of ASINs — and receive back a clean, structured dataset for every book found: title, author, star rating, review count, price, full description, publisher, publication date, page count, language, availability status, and cover image URL.

This **Amazon book scraper** handles keyword search with sort options, pagination across multiple result pages, direct detail page extraction with automatic fallback URL formats, and partial record recovery when full data is unavailable — making it the most reliable Amazon books data tool on Apify.

---

### 🚀 Why Use This Amazon Book Scraper?

| Feature | This Actor | Manual Research | Amazon API | Other Scrapers |
|---|---|---|---|---|
| **Keyword search → bulk books data** | ✅ Paginated | ❌ Slow | ⚠️ Limited | ⚠️ |
| **Direct URL + ASIN bulk input** | ✅ Both modes | ❌ | ✅ | ⚠️ |
| **Full Amazon book metadata** | ✅ 15 fields | ❌ | ⚠️ Partial | ⚠️ |
| **Publisher, pub date, pages, language** | ✅ | ❌ | ❌ | ⚠️ |
| **Price & availability status** | ✅ | ✅ Manual | ⚠️ | ⚠️ |
| **High-resolution cover image** | ✅ | ❌ | ⚠️ | ⚠️ |
| **7 Amazon marketplaces** | ✅ | ❌ | ⚠️ | ❌ |
| **Sort by bestseller, new, reviews** | ✅ Built-in | ❌ | ❌ | ❌ |
| **No login or API key** | ✅ | N/A | ❌ Required | ✅ |
| **Export to CSV / Excel** | ✅ Via Apify | ❌ | ❌ | ❌ |

> **Bottom line:** This **Amazon book scraper** is the only actor that combines keyword search with sort options, direct ASIN lookup, multi-marketplace support, and a complete 15-field **Amazon book metadata** record — all in one tool with no credentials needed.

---

### 🌍 Supported Marketplaces

| Code | Marketplace | Domain |
|---|---|---|
| `us` | United States | amazon.com |
| `uk` | United Kingdom | amazon.co.uk |
| `de` | Germany | amazon.de |
| `in` | India | amazon.in |
| `ca` | Canada | amazon.ca |
| `au` | Australia | amazon.com.au |
| `jp` | Japan | amazon.co.jp |

> Simply set the `country` input to the marketplace code. The actor automatically targets the correct Amazon domain and currency for that market.

---

### 🎯 Use Cases

#### 📊 Book Market Research & Publishing Intelligence
- Scrape **Amazon books data** for any genre or topic to analyze pricing trends, rating distributions, and review volumes
- Identify bestselling books in a category with full metadata for competitive publishing research
- Track new releases, publication dates, and publisher activity across Amazon marketplaces

#### 🛒 Price Monitoring & Comparison
- Monitor Amazon book prices across multiple marketplaces (US, UK, DE, IN) for arbitrage or pricing strategy
- Track price changes on a watchlist of ASINs by scheduling regular scraper runs
- Compare paperback, hardcover, and Kindle pricing using the same ASIN list

#### 🤖 AI & Recommendation Systems
- Build book recommendation datasets by scraping **Amazon book metadata** — title, author, genre, description, ratings
- Collect training data for NLP models using book descriptions, titles, and category tags
- Extract cover images and metadata for visual book recommendation interfaces

#### 🏪 E-Commerce & Affiliate Integrations
- Populate a book directory, affiliate site, or comparison platform with structured **Amazon books data**
- Automate product catalog updates by re-scraping ASINs on a schedule
- Build structured book listings with prices, ratings, and descriptions for content sites

#### 🎓 Academic & Library Research
- Collect publication metadata (publisher, date, pages, language) for academic bibliographic research
- Build structured datasets of books in specific fields for literature review automation
- Study Amazon review and rating patterns across genres for consumer behavior research

#### 📰 Content Creation & Journalism
- Research book topics, authors, and publication histories at scale for editorial content
- Gather structured book metadata for book review sites, newsletters, or media platforms
- Track Amazon bestseller rankings and new releases for publishing industry reporting

---

### ⚙️ Input Parameters

```json
{
  "keyword":     "machine learning",
  "url":         "",
  "urls":        [],
  "country":     "us",
  "sort_by":     "bestseller",
  "max_results": 20,
  "proxyConfiguration": {
    "useApifyProxy":    true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `keyword` | string | `""` | Search keyword — any book title, author name, topic, or ISBN (e.g. `"python programming"`, `"Stephen King"`) |
| `url` | string | `""` | Single Amazon book URL or ASIN — processed as a direct detail page lookup |
| `urls` | array or string | `[]` | Multiple Amazon book URLs or bare ASINs for bulk extraction — newline-separated string also accepted |
| `country` | string | `"us"` | Target Amazon marketplace — `"us"`, `"uk"`, `"de"`, `"in"`, `"ca"`, `"au"`, `"jp"` |
| `sort_by` | string | `"relevance"` | Search result sort order — `"relevance"`, `"bestseller"`, `"new"`, `"avg_review"` |
| `max_results` | integer | `20` | Maximum books to return across all input modes |
| `proxyConfiguration` | object | Residential | Apify proxy config — residential proxy strongly recommended for Amazon |

> **Tip:** You can combine `keyword` and `urls` in the same run. Keyword search results are processed first, then direct URLs and ASINs are scraped individually. All results are merged into a single output dataset.

***

### 📋 Output Fields

Every record from this **Amazon book scraper** includes complete **Amazon book metadata**:

| Field | Type | Description | Example |
|---|---|---|---|
| `url` | string | Full Amazon book page URL | `"https://www.amazon.com/dp/B08XY..."` |
| `asin` | string | Amazon Standard Identification Number | `"B08XY12345"` |
| `title` | string | Full book title (max 500 chars) | `"Deep Learning with Python"` |
| `author` | string | Author name(s) | `"François Chollet"` |
| `rating` | float | Average star rating | `4.6` |
| `reviews_count` | integer | Total customer review count | `2841` |
| `price` | string | Listed price with currency symbol | `"$39.99"` |
| `description` | string | Full book description (max 2000 chars) | `"The definitive guide to..."` |
| `image` | string | High-resolution cover image URL | `"https://images-na.ssl-images-amazon.com/..."` |
| `publisher` | string | Publisher name | `"Manning Publications"` |
| `pub_date` | string | Publication date | `"October 14, 2021"` |
| `pages_count` | integer | Total page count | `504` |
| `language` | string | Book language | `"English"` |
| `status` | string | Availability status | `"available"`, `"out_of_stock"`, `"unavailable"` |
| `scraped_at` | string | Extraction timestamp (ISO 8601 UTC) | `"2024-03-15T10:30:00Z"` |

***

### 📦 Example Input & Output

**Input — keyword search:**

```json
{
  "keyword":     "deep learning",
  "country":     "us",
  "sort_by":     "bestseller",
  "max_results": 3
}
```

**Output (one record):**

```json
{
  "url":           "https://www.amazon.com/dp/B08XY12345/",
  "asin":          "B08XY12345",
  "title":         "Deep Learning with Python, Second Edition",
  "author":        "François Chollet",
  "rating":        4.6,
  "reviews_count": 2841,
  "price":         "$39.99",
  "description":   "The definitive guide to deep learning using Python and Keras. Revised and updated to cover the latest deep learning techniques...",
  "image":         "https://images-na.ssl-images-amazon.com/images/I/81abc123.jpg",
  "publisher":     "Manning Publications",
  "pub_date":      "October 14, 2021",
  "pages_count":   504,
  "language":      "English",
  "status":        "available",
  "attempt":       1,
  "scraped_at":    "2024-03-15T10:30:00Z"
}
```

***

### 💰 Pricing & Free Trial

| Plan | Price | Includes |
|---|---|---|
| **Free Trial** | $0 | 2 hours full access — no credit card required |
| **Monthly** | $8.99 / month | Unlimited runs, all input modes, all 7 marketplaces |

#### Everything included in every plan:

- ✅ Keyword search with pagination and sort options
- ✅ Direct URL and bulk ASIN extraction
- ✅ Complete Amazon book metadata — 15 fields per book
- ✅ 7 Amazon marketplaces (US, UK, DE, IN, CA, AU, JP)
- ✅ Sort by relevance, bestseller, newest, or average review
- ✅ Availability status per book
- ✅ High-resolution cover image URL
- ✅ JSON + CSV + Excel export from Apify dataset
- ✅ Scheduled runs for automated price and metadata monitoring

> **Start your 2-hour free trial now** — no credit card needed. Click **Try for free** at the top of this page.

***

### ⚡ Performance & Limits

| Mode | Count | Estimated Time |
|---|---|---|
| Single book URL or ASIN | 1 | ~8–20 seconds |
| Keyword search | 20 books | ~3–6 minutes |
| Bulk ASINs | 20 books | ~4–8 minutes |
| Keyword search (paginated) | 50 books | ~12–20 minutes |

- Results are pushed to the Apify dataset in real time as each book is processed
- Partial records are saved for books where full detail page extraction is blocked
- Per-URL retry logic with automatic alternate URL format fallback
- Residential proxy strongly recommended for reliable Amazon access at any volume

***

### ❓ FAQ

**Q: Can I scrape books from multiple Amazon marketplaces in one run?**
A: Each run targets one marketplace via the `country` input. For multi-marketplace scraping, run the actor multiple times with different `country` values, or use Apify's task scheduling to run them in parallel.

**Q: Can I input bare ASINs without a full URL?**
A: Yes. The `urls` field accepts bare 10-character ASINs (e.g. `B08XY12345`) directly — the actor automatically builds the correct Amazon URL for the selected marketplace.

**Q: What does `status: "partial_search_only"` mean?**
A: When a book detail page cannot be fetched (blocked or slow), the actor saves a partial record using the data available from the search results page — title, author, rating, reviews, price, and image — rather than losing the record entirely.

**Q: Why is `price` null for some books?**
A: Some Amazon book listings do not display a public price — this is common for books sold exclusively through third-party sellers, pre-order titles, or marketplace-only listings. The field returns `null` when no price is present on the page.

**Q: Can I sort search results by bestseller or newest release?**
A: Yes. Use the `sort_by` parameter: `"bestseller"` for Amazon bestseller rank order, `"new"` for newest releases first, `"avg_review"` for highest rated, or `"relevance"` for default search relevance.

**Q: Is residential proxy required?**
A: Amazon actively blocks datacenter IP addresses. A residential proxy makes requests appear to come from regular home internet connections, which significantly improves reliability — especially for keyword searches and high-volume ASIN lookups. It is strongly recommended.

**Q: Can I export results to Excel or CSV?**
A: Yes. All results are pushed to the Apify dataset, which can be exported to JSON, CSV, Excel, and more directly from the Apify Console after each run completes.

**Q: What happens if Amazon blocks a specific book page?**
A: The actor automatically retries with alternate URL formats, rotates browser fingerprints, and applies backoff delays. If all attempts fail, a partial record with available data is saved and the run continues with the remaining books.

***

### 📜 Changelog

#### v2.0.0 (Current)

- ✅ Three input modes: keyword search, direct URL, and bulk ASIN list
- ✅ Full Amazon book metadata — 15 fields per record
- ✅ Publisher, publication date, page count, and language extraction
- ✅ Availability status detection per book
- ✅ High-resolution cover image URL
- ✅ 7 Amazon marketplace support (US, UK, DE, IN, CA, AU, JP)
- ✅ Sort options: relevance, bestseller, newest, average review
- ✅ Automatic pagination across multiple search result pages
- ✅ Alternate URL format fallback for 404 and blocked pages
- ✅ Partial record recovery from search results when detail page fails
- ✅ Proxy rotation support for high-volume runs
- ✅ Real-time dataset push as each book is processed

#### v1.0.0

- Initial release with basic keyword search and core field extraction

***

### 🏷️ Tags

`amazon book scraper` `amazon books data` `amazon book metadata` `amazon scraper` `book data extractor` `amazon asin scraper` `book price tracker` `amazon search scraper` `book metadata` `amazon product scraper` `book research tool` `amazon bestseller scraper`

***

### ⚖️ Legal & Terms of Use

This actor accesses publicly visible Amazon book listing pages in the same way a regular user browses the Amazon website.

**Please note:**

- Use extracted **Amazon books data** only for **lawful purposes** — research, price monitoring, content creation, affiliate marketing, and academic use are common legitimate applications
- Do not use this **Amazon book scraper** to systematically copy Amazon's catalog for redistribution or to build a competing retail platform
- Respect Amazon's Terms of Service — do not use this tool at volumes designed to overload or disrupt Amazon's infrastructure
- Book descriptions, cover images, and metadata are Amazon's intellectual property — always credit the source appropriately in your application
- The actor developer is not responsible for how extracted **Amazon book metadata** is used

***

### 🤝 Support & Feedback

- **Bug report?** Contact us via the Apify actor page
- **Feature request?** Post in the Apify Community forum
- **Loving it?** Please leave a ⭐ review — it helps other users find this actor!

***

<p align="center">
  <strong>Built with ❤️ on Apify</strong><br/>
  <em>The most complete Amazon Book Scraper — full metadata, 7 marketplaces, keyword search & bulk ASIN</em><br/><br/>
  <strong>💰 $8.99/month · 🆓 2-hour free trial · No credit card required</strong>
</p>

# Actor input Schema

## `keyword` (type: `string`):

Search Amazon Books by keyword, title, or author.

Examples:
python programming
J.K. Rowling
machine learning beginners

💡 If you provide both keyword and url, both will be scraped.

## `url` (type: `string`):

Single Amazon book URL or bare ASIN (10-character ID).

✅ Accepted:
https://www.amazon.com/dp/1593279280
https://www.amazon.com/dp/0134685997
1593279280

💡 For bulk, use 'Multiple URLs' below.

## `urls` (type: `string`):

One URL or ASIN per line — scrape multiple books at once.

Example:
https://www.amazon.com/dp/1593279280
0134685997
https://www.amazon.com/dp/1491954361

## `max_results` (type: `integer`):

Maximum number of books to return per keyword search.

## `country` (type: `string`):

Which Amazon marketplace to scrape from.

## `sort_by` (type: `string`):

How to sort keyword search results.

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

RESIDENTIAL proxy strongly recommended for Amazon.
Amazon blocks datacenter IPs aggressively.

✅ Keep RESIDENTIAL enabled for reliable results.

## Actor input object example

```json
{
  "keyword": "python programming",
  "max_results": 20,
  "country": "us",
  "sort_by": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "keyword": "python programming",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/amazon-book-scraper----books-data-metadata-extractor").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 = {
    "keyword": "python programming",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/amazon-book-scraper----books-data-metadata-extractor").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 '{
  "keyword": "python programming",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapepilot/amazon-book-scraper----books-data-metadata-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Book Scraper — Books Data & Metadata Extractor",
        "description": "Scrape Amazon books data from any keyword, URL, or ASIN list. Get full book metadata — title, author, rating, reviews, price, publisher, pages, language, and cover image. Supports 7 Amazon marketplaces. No login. $8.99/month. 2-hour free trial.",
        "version": "0.0",
        "x-build-id": "YMkBzHnag1czMwWEM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~amazon-book-scraper----books-data-metadata-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-amazon-book-scraper----books-data-metadata-extractor",
                "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/scrapepilot~amazon-book-scraper----books-data-metadata-extractor/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-amazon-book-scraper----books-data-metadata-extractor",
                "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/scrapepilot~amazon-book-scraper----books-data-metadata-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-amazon-book-scraper----books-data-metadata-extractor",
                "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": {
                    "keyword": {
                        "title": "🔍 Search Keyword",
                        "type": "string",
                        "description": "Search Amazon Books by keyword, title, or author.\n\nExamples:\n  python programming\n  J.K. Rowling\n  machine learning beginners\n\n💡 If you provide both keyword and url, both will be scraped."
                    },
                    "url": {
                        "title": "🔗 Single Book URL or ASIN",
                        "type": "string",
                        "description": "Single Amazon book URL or bare ASIN (10-character ID).\n\n✅ Accepted:\nhttps://www.amazon.com/dp/1593279280\nhttps://www.amazon.com/dp/0134685997\n1593279280\n\n💡 For bulk, use 'Multiple URLs' below."
                    },
                    "urls": {
                        "title": "📋 Multiple URLs / ASINs (Bulk)",
                        "type": "string",
                        "description": "One URL or ASIN per line — scrape multiple books at once.\n\nExample:\nhttps://www.amazon.com/dp/1593279280\n0134685997\nhttps://www.amazon.com/dp/1491954361"
                    },
                    "max_results": {
                        "title": "📦 Max Results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of books to return per keyword search.",
                        "default": 20
                    },
                    "country": {
                        "title": "🌍 Amazon Country",
                        "enum": [
                            "us",
                            "uk",
                            "de",
                            "in",
                            "ca",
                            "au",
                            "jp"
                        ],
                        "type": "string",
                        "description": "Which Amazon marketplace to scrape from.",
                        "default": "us"
                    },
                    "sort_by": {
                        "title": "📊 Sort Results By",
                        "enum": [
                            "relevance",
                            "bestseller",
                            "new",
                            "avg_review",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "How to sort keyword search results.",
                        "default": "relevance"
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy (RESIDENTIAL Recommended)",
                        "type": "object",
                        "description": "RESIDENTIAL proxy strongly recommended for Amazon.\nAmazon blocks datacenter IPs aggressively.\n\n✅ Keep RESIDENTIAL enabled for reliable results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
