# Amazon Best Sellers Scraper & API - Top 100 by Category (`rel8ble/amazon-bestsellers-scraper`) Actor

Get the Amazon Best Sellers or New Releases top 100 for any category on any Amazon marketplace (.com, .co.uk, .de, .co.jp, .in...). Input: list URLs or category ids, optional subcategories. One result = one ranked product: rank, ASIN, title, price, rating, ratings count, image, URL. $1.50/1k.

- **URL**: https://apify.com/rel8ble/amazon-bestsellers-scraper.md
- **Developed by:** [Giovanni Rich](https://apify.com/rel8ble) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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/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 Best Sellers Scraper & API - Top 100 Products by Category, New Releases, Any Marketplace

**Amazon Best Sellers Scraper** is an Amazon bestseller list scraper and unofficial Amazon Best Sellers API: give it any Best Sellers or New Releases page from amazon.com, amazon.co.uk, amazon.de, amazon.co.jp, amazon.in or another Amazon marketplace, and get the full top 100 as clean JSON, CSV or Excel: rank, ASIN, title, price, currency, star rating, number of ratings, image and product URL, plus the list name and category path. Turn on `includeSubcategories` to pull every subcategory list in one run.

It reads the data Amazon already sends with the page over plain HTTP, with **no headless browser**, so a 100-product list takes a few seconds and costs very little to run. Amazon shows only the first 30 products of each page and loads the other 20 when you scroll; this scraper fetches those too, so you get all 50 per page and all 100 per list.

### How to use

1. Paste one or more **Amazon list URLs** (Best Sellers or New Releases pages, any marketplace), e.g. `https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/`. Or enter **Category IDs** like `electronics` or `electronics/172541` with a **domain** and **list type**.
2. Set **Max products per list** (1-100). Turn on **Also scrape subcategories** to add each list's child categories (one level down).
3. Click **Start**. Download the results as JSON, CSV, Excel or HTML from the **Output** tab, or pull them through the Apify API, Make, Zapier, n8n or an MCP client.

### What you get

- **Rank and identity**: rank (1-100), ASIN, product URL (`https://www.amazon.<tld>/dp/ASIN`), the highest-resolution image Amazon serves on the list.
- **Price**: numeric `price` and ISO `currency` (USD, GBP, EUR, JPY, INR, CAD, ...), plus the raw `priceText` exactly as shown ("$11.99", "20,46 €", "4 offers from $12.99").
- **Reviews**: star rating (0-5) and number of ratings.
- **Context**: list type (bestsellers / new-releases), list name ("Best Sellers in Electronics"), category id and node id, category path ("Any Department > Electronics"), list URL, marketplace, page number and `scrapedAt` timestamp.
- **Clean and deduplicated**: one row per product per list, ranks in order, no repeats across the two pages.

### Use cases

- **Product research and sourcing**: what sells in a category right now, at which price points and rating levels, on each marketplace.
- **Price and rank tracking**: schedule a daily run per category and build rank histories by ASIN.
- **New-product monitoring**: `new-releases` lists show what just launched or is about to.
- **Competitive intelligence**: see where your products and your competitors' rank, across countries, in one dataset.
- **Datasets for AI agents**: an agent can ask for "top 50 headphones on amazon.de" and get structured rows back through MCP.

### Input example

| Field | Default | Description |
|---|---|---|
| `categoryUrls` | Electronics best sellers (.com) | Best Sellers or New Releases URLs, any marketplace. A plain category URL with `node=` is converted using `listType`. |
| `categoryIds` | - | Alternative to URLs: `electronics`, `books`, `electronics/172541` |
| `domain` | `amazon.com` | Marketplace for `categoryIds` |
| `listType` | `bestsellers` | `bestsellers` or `new-releases`, for `categoryIds` and plain category URLs |
| `maxItemsPerList` | 100 | 1-100 (Amazon shows 100 per list, in two pages of 50) |
| `includeSubcategories` | false | Also scrape each list's child categories (one level) |
| `maxSubcategories` | 50 | Cap on added subcategory lists |
| `proxyConfiguration` | Residential | Apify residential proxies in the marketplace's country (recommended) |

Example: Electronics and Books top 100 on amazon.com, plus New Releases in Electronics on amazon.de:

```json
{
    "categoryUrls": [
        "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
        "https://www.amazon.com/Best-Sellers-Books/zgbs/books/",
        "https://www.amazon.de/gp/new-releases/ce-de/"
    ],
    "maxItemsPerList": 100
}
```

Example: every Electronics subcategory on amazon.co.uk, top 50 each:

```json
{
    "categoryIds": ["electronics"],
    "domain": "amazon.co.uk",
    "listType": "bestsellers",
    "maxItemsPerList": 50,
    "includeSubcategories": true
}
```

### Output example

One dataset item per ranked product. From a real run (Best Sellers in Electronics, amazon.com):

```json
{
    "rank": 1,
    "asin": "B08JHCVHTY",
    "title": "blink plus plan with monthly auto-renewal",
    "price": 11.99,
    "priceText": "$11.99",
    "currency": "USD",
    "rating": 4.4,
    "ratingsCount": 280900,
    "imageUrl": "https://images-na.ssl-images-amazon.com/images/I/31YHGbJsldL._AC_UL900_SR900,600_.png",
    "url": "https://www.amazon.com/dp/B08JHCVHTY",
    "listType": "bestsellers",
    "listName": "Best Sellers in Electronics",
    "categoryId": "electronics",
    "categoryNodeId": "electronics",
    "categoryPath": "Any Department > Electronics",
    "listUrl": "https://www.amazon.com/gp/bestsellers/electronics",
    "marketplace": "amazon.com",
    "page": 1,
    "scrapedAt": "2026-10-08T00:36:48.481Z"
}
```

Fill rates on a 200-product test (amazon.com Best Sellers + amazon.de New Releases, Electronics): rank, ASIN, title, rating, ratings count, image, URL, list name and category path 100%; price 97% (the rest are items Amazon lists without a price, such as subscriptions or out-of-stock products).

### Pricing

Pay per result: **$1.50 per 1,000 results** (one result = one ranked product saved to the dataset).

- One full list (100 products) = $0.15
- 100 lists (10,000 products) = $15

You're never charged for failed requests or duplicates. If you set a maximum cost per run, the scraper stops cleanly when it reaches it. Apify's free plan includes $5 of monthly platform credit, enough for thousands of products. Residential proxy traffic is billed separately by Apify (about 0.5 MB per list page).

### Integrations

- **Make, Zapier and n8n**: start runs and send new rankings to Sheets, Slack, Airtable or your database.
- **Google Sheets**: export the dataset straight into a spreadsheet, or refresh it on a schedule.
- **Apify API**: run the actor and fetch results over REST, or with the official JavaScript and Python clients.
- **Webhooks**: get notified when a run finishes and process the data right away.
- **Schedules**: run the same lists daily or hourly to track rank and price over time.
- **MCP for AI agents**: through the Apify MCP server (https://mcp.apify.com), Claude, ChatGPT, Cursor and other agents can call this Amazon Best Sellers API directly and read the results.

### Limits (read before large runs)

- **100 products per list.** That's all Amazon publishes (two pages of 50). To get more, use subcategories: Electronics alone has about 18 direct subcategories, each with its own top 100.
- **Best Sellers and New Releases only.** Amazon's Movers & Shakers, Most Wished For and Most Gifted pages render without a product grid at the moment; URLs of that kind are accepted but usually return no products, and the run summary says so.
- **List prices are what Amazon shows on the list page**: the default offer, in the marketplace's currency. Some items (subscriptions, out-of-stock products, some media) show no price and get `price: null`.
- **Rankings change hourly.** Two runs minutes apart can differ. Use `scrapedAt` and `rank` to build time series.
- **Residential proxies are the default** because Amazon blocks most datacenter IP ranges. Switching to datacenter proxies works but means more retries and occasional failed lists.
- **No product details** (bullet points, descriptions, variations, seller, BSR in other categories). This actor covers the ranked lists; pair it with a product-detail scraper when you need the full page.

### FAQ

**Is it legal to scrape Amazon Best Sellers?**
This actor collects only publicly available product listing data, not personal data. You're responsible for using it in line with Amazon's terms of service and applicable law. This is not legal advice: if you're unsure, check with a lawyer.

**How does it avoid blocks?**
Requests go through Apify Proxy (residential by default, in the marketplace's country) with realistic Chrome headers and a session pool. When Amazon returns a captcha, a 503 or an error page, that session is retired and the page is retried on a fresh IP, up to 8 times by default. Other errors are retried with exponential backoff.

**Why do I get 50 products when Amazon's page shows 30?**
Amazon renders 30 cards and loads the remaining 20 when you scroll. The scraper makes that same background call, so each page yields all 50 products.

**Which marketplaces work?**
Any `amazon.*` domain: .com, .co.uk, .de, .fr, .it, .es, .nl, .se, .pl, .be, .ca, .com.mx, .com.br, .com.au, .co.jp, .in, .sg, .ae, .sa, .eg, .com.tr. Prices are parsed in each locale's format (`20,46 €` and `$1,234.56` both work) and `currency` is set per marketplace.

**Can I get rank history?**
Run on a schedule and keep the datasets; each row has `asin`, `rank`, `listUrl` and `scrapedAt`.

**Does it need a browser, cookies or a login?**
No. Plain HTTPS requests only, which is why it's fast and cheap.

### How it works (for developers)

An Amazon list page embeds all 50 ASINs of the page with their ranks in a `data-client-recs-list` attribute and renders the first 30 product cards server-side. The remaining 20 cards come from a `nextPage` call to the same component endpoint the page's own script uses, sent with the page's `x-amz-acp-params` token on the same session. The scraper parses the cards with Cheerio, merges both halves, sorts by rank and reads the left-hand navigation for parent and child categories. Prices, ratings and counts are parsed per locale. Every field is read defensively: a malformed card just has fewer fields.

Run it locally:

```bash
npm install
npm test                                  # parser tests on saved fixtures
APIFY_LOCAL_STORAGE_DIR=./storage node src/main.js   # input in storage/key_value_stores/default/INPUT.json
```

# Actor input Schema

## `categoryUrls` (type: `array`):

Provide these or categoryIds. Amazon Best Sellers or New Releases URLs, one per line, from any Amazon marketplace, e.g. https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/ or https://www.amazon.de/gp/new-releases/ce-de/. A plain category page URL with a node id (…/b?node=172541) is converted to the chosen listType. Each list has up to 100 products (two pages of 50).

## `categoryIds` (type: `array`):

Optional. Amazon category ids as they appear in list URLs, one per line: a department slug like "electronics", "books", "beauty", or department/node like "electronics/172541". Combined with domain and listType. Leave empty when using categoryUrls.

## `domain` (type: `string`):

Optional. Amazon marketplace used with categoryIds, e.g. "amazon.com", "amazon.co.uk", "amazon.de", "amazon.co.jp", "amazon.in". Default "amazon.com". URLs in categoryUrls carry their own marketplace.

## `listType` (type: `string`):

Optional. Which ranked list to read when the input is a category id or a plain category page: "bestsellers" (default, top 100 by sales) or "new-releases" (top 100 new and upcoming). Full list URLs keep their own type.

## `maxItemsPerList` (type: `integer`):

Optional. Products to save per list, integer 1-100. Amazon shows at most 100 per list (two pages of 50). Default 100. Use 30 for a quick, single-request answer.

## `includeSubcategories` (type: `boolean`):

Optional boolean. true = also scrape the ranked list of every subcategory shown in the left menu of each input list (one level down), each with up to maxItemsPerList products. Default false.

## `maxSubcategories` (type: `integer`):

Optional. Cap on subcategory lists added when includeSubcategories is on, integer >= 0. Default 50. Electronics alone has about 18 direct subcategories.

## `maxConcurrency` (type: `integer`):

Optional, advanced. Parallel requests, integer 1-10. Default 3. Keep it low; Amazon rate-limits aggressively.

## `maxRequestRetries` (type: `integer`):

Optional, advanced. Retries per blocked or failed request, integer 0-20; each retry uses a new proxy session. Default 8.

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

Optional, advanced. Apify Proxy settings object. Default: Apify residential proxies in the marketplace's country, which Amazon rarely blocks and which return local prices. Datacenter proxies ({"useApifyProxy": true}) work but see more captchas and retries.

## Actor input object example

```json
{
  "categoryUrls": [
    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
  ],
  "domain": "amazon.com",
  "listType": "bestsellers",
  "maxItemsPerList": 30,
  "includeSubcategories": false,
  "maxSubcategories": 50,
  "maxConcurrency": 3,
  "maxRequestRetries": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `products` (type: `string`):

All ranked products found: rank, ASIN, title, price, rating, review count, image, URL and the list/category they came from.

## `summary` (type: `string`):

Per-list counts, pages read and stop reasons.

# 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 = {
    "categoryUrls": [
        "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
    ],
    "maxItemsPerList": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rel8ble/amazon-bestsellers-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 = {
    "categoryUrls": ["https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"],
    "maxItemsPerList": 30,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rel8ble/amazon-bestsellers-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 '{
  "categoryUrls": [
    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
  ],
  "maxItemsPerList": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call rel8ble/amazon-bestsellers-scraper --silent --output-dataset

```

## MCP server setup

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