# Amazon Best Sellers Scraper: all 100 ranks, not 60 (`alexmorain/amazon-bestsellers-scraper`) Actor

Scrape all 100 ranks of every Amazon Best Sellers and New Releases list, not the 60 a page-only scraper gets, on amazon.com and amazon.de. Subcategory tree, product page details, entries, rank changes and exits between runs. No browser.

- **URL**: https://apify.com/alexmorain/amazon-bestsellers-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** E-commerce, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 93.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 ranked products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

### What does Amazon Best Sellers Scraper do?

**Amazon Best Sellers Scraper** reads the [Amazon Best Sellers](https://www.amazon.com/gp/bestsellers) and [New Releases](https://www.amazon.com/gp/new-releases) rankings and gives you **all 100 ranks of every category**, as a table or an API. Each row has the rank, ASIN, title, price, rating, review count, image and product URL. It works on amazon.com and amazon.de, walks the whole subcategory tree if you ask, and can tell you what entered, climbed, fell or left a ranking since your last run. It uses plain HTTP: no browser, no Amazon account, no SerpApi key.

It does not read the Movers & Shakers, Most Wished For and Gift Ideas lists, because Amazon serves them empty to anyone who is not signed in (see the FAQ).

### Why use Amazon Best Sellers Scraper?

**Most scrapers return 60 ranks out of 100.** Amazon puts 50 products in each page of a ranking but writes only 30 of them in the page itself (ranks 1 to 30 and 51 to 80). The other 20 of each page load when you scroll. A scraper that reads the page misses ranks 31 to 50 and 81 to 100: 40% of every ranking. This Actor makes the same call as your browser's scroll and returns all of them, in 4 requests per category. We checked it on every run of this build: 60 ranks came from the page, 40 from the deferred load, 100 delivered.

- **All 100 ranks**, with a field (`fromDeferredLoad`) that shows which ones a page-only scraper would have lost.
- **The whole category tree.** Start at a department and go down as many levels as you want. Each category is read once, even when several parents link to it.
- **Watch mode.** Get only new entries, or entries plus rank changes plus exits, between two runs. You pay only for the rows returned.
- **Product page details on demand.** Brand, list price, seller, delivery, specifications, variants, images and Amazon's AI review summary for each rank.
- **Cheap.** About $0.006 of platform usage per 1,000 ranks, no browser. Pricing below.
- **On the Apify platform:** schedule it, call it by API, send the result to Google Sheets, Make, Zapier, n8n or a webhook, and read the logs of every run.

Use it to follow the best sellers of a market, find products that rise before they peak, check which of your competitors' products hold a rank, build a daily feed of new entries for a category, or measure how long a product stays in the top 100.

### What data can Amazon Best Sellers Scraper extract?

One row per rank.

| Field | Type | Description |
|---|---|---|
| `rank` | integer | Rank in the ranking, 1 is the best |
| `asin` | string | Amazon product ID |
| `title` | string | Product title |
| `price`, `priceText`, `currency` | number, string, string | Price as a number, as displayed, and its currency |
| `rating`, `reviewsCount` | number, integer | Average stars and number of ratings |
| `imageUrl`, `productUrl` | string | Image of the ranking and product page |
| `listType` | string | `bestsellers` or `new-releases` |
| `categoryName`, `categoryNodeId`, `department`, `categoryPath`, `categoryUrl` | string, string, string, array, string | The category of the ranking. `categoryNodeId` is empty for a department ranking, whose URL carries the department code in `department` |
| `depth` | integer | 0 for a category you asked for, 1 for its subcategories |
| `marketplace`, `page` | string, integer | `amazon.com` or `amazon.de`, and page 1 (ranks 1 to 50) or 2 (51 to 100) |
| `fromDeferredLoad` | boolean | True for the 20 products per page that Amazon's page does not contain |
| `partial` | boolean | True when Amazon did not serve a product's details after a second try: only ASIN, rank and URL are filled |
| `previousRank`, `rankChange`, `droppedOut` | integer, integer, boolean | Watch mode: rank at the last run, places gained (positive is a climb), and the exit row of a product that left |
| `scrapedAt` | string | When the ranking was read (UTC) |

With **Include product page details**, each row also carries `brand`, `listPrice`, `inStock`, `seller`, `shipsFrom`, `delivery`, `ratingHistogram`, `boughtPastMonth`, `bestSellersRank`, `features`, `description`, `attributes`, `variants`, `images`, `reviewsAiSummary`, `reviewAspects` and more, as the Dataset tab lists them. Some are empty for some products because Amazon does not show them (an AI summary needs enough reviews; `authors` is for books).

### How to scrape Amazon Best Sellers

1. Open the Actor and click **Try for free**.
2. Paste ranking URLs in **Ranking URLs**, for example `https://www.amazon.com/gp/bestsellers/kitchen`, or type a department in **Categories** (`kitchen`, `electronics`, `Kitchen & Dining`, or `All departments`).
3. Pick the **List** (Best Sellers or New Releases) and the **Marketplace** for the categories you typed. A URL carries its own.
4. To go down the tree, turn on **Include subcategories** and set **Max depth** and **Max categories**.
5. Set **Max ranks**, the cap for the whole run, and press **Start**.
6. Download the dataset as JSON, CSV, Excel or HTML, or read it through the API.

A department URL looks like `/gp/bestsellers/kitchen`, a subcategory `/gp/bestsellers/kitchen/289668`. The long form with a slug (`/Best-Sellers-Kitchen-Dining/zgbs/kitchen`) works too. A node ID alone (`289668`) does not open a ranking on Amazon, so write it as `kitchen/289668`.

### How much does it cost to scrape Amazon Best Sellers?

You pay per result, plus a small start fee of $0.002 per GB of memory (the Actor starts with 0.5 GB). The prices by Apify plan:

| Event | Free | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Ranked product (a rank) | $0.60 per 1,000 | $0.50 | $0.40 | $0.30 |
| Detailed ranked product | $1.80 per 1,000 | $1.50 | $1.20 | $0.75 |

So 100 ranks of one category cost $0.05 on the Bronze plan. A whole department with its 12 direct subcategories (about 1,300 ranks) costs $0.65. The 34 top departments (about 3,100 ranks) cost about $1.56.

What you are not charged for: duplicates, **partial rows** (ASIN and rank only), **exit rows** in watch mode, and the rows watch mode skips because nothing changed. A row whose product page Amazon refused is returned without details at the plain price. Set a maximum charge per run in the run options and the Actor stops there.

Measured on the platform on 03/11/2026, a run of 10,386 ranks across 110 categories took 172 seconds, used 89 MB of memory and consumed $0.059 of platform usage (compute and data transfer, no extra proxy fee for datacenter IPs).

### Input

See the Input tab for every option. The ones that need a word:

- **Ranking URLs / Categories.** Use either or both. Duplicates are read once.
- **All departments** reads the ranking of each of the 34 top departments. Amazon has no ranking for the whole store, so this is the way to cover it. Two departments (Digital Music, Digital Educational Resources) have no list of 100 and come back as empty with the reason in the summary.
- **Include subcategories, Max depth, Max categories.** Depth 1 reads the direct subcategories, depth 2 theirs. Max categories counts your own categories too.
- **Max ranks.** Without a limit a deep tree is large: 34 departments with their direct subcategories is about 10,000 ranks. The default is 1,000.
- **Watch.** `New entries only` returns products never returned before. `Entries, rank changes and exits` also returns products whose rank moved (with `previousRank` and `rankChange`) and one `droppedOut` row per product that left. The first run returns everything. The memory lives in your key-value store `amazon-bestsellers-monitor`, one record per ranking, and remembers every rank actually returned (and the date and rank of products still in the ranking, which are never billed again). Exit rows are only computed from a ranking read in full, so a ranking that could not be read completely never reports a false exit.
- **Webhook URL.** A JSON summary is posted at the end of the run when something was returned. The URL is stored encrypted and never logged.
- **Marketplace.** amazon.com and amazon.de. On amazon.de the Actor sets a Berlin delivery postcode, because without one Amazon hides 33 prices out of 100.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
[
  {
    "rank": 1,
    "asin": "B0BZYCJK89",
    "title": "Owala FreeSip Stainless Steel Water Bottle 24 oz Denim",
    "price": 29.99,
    "priceText": "$29.99",
    "currency": "USD",
    "rating": 4.6,
    "reviewsCount": 144526,
    "imageUrl": "https://images-na.ssl-images-amazon.com/images/I/61Gvw0-b0eL._AC_UL300_SR300,200_.jpg",
    "productUrl": "https://www.amazon.com/dp/B0BZYCJK89",
    "listType": "bestsellers",
    "categoryName": "Kitchen & Dining",
    "categoryNodeId": null,
    "department": "kitchen",
    "categoryPath": ["Kitchen & Dining"],
    "categoryUrl": "https://www.amazon.com/gp/bestsellers/kitchen",
    "depth": 0,
    "marketplace": "amazon.com",
    "page": 1,
    "fromDeferredLoad": false,
    "partial": false,
    "previousRank": null,
    "rankChange": null,
    "droppedOut": false,
    "scrapedAt": "2026-11-03T18:40:12Z"
  },
  {
    "rank": 41,
    "asin": "B0DR9NCZCJ",
    "title": "STANLEY Quencher ProTour Flipstraw Tumbler, 40 oz",
    "price": 29.97,
    "rating": 4.7,
    "reviewsCount": 21983,
    "fromDeferredLoad": true,
    "page": 1
  }
]
```

A watch-mode run that finds a product that left the ranking returns a row like this, free of charge:

```json
{"asin": "B0EXAMPLE1", "rank": null, "previousRank": 5, "droppedOut": true, "categoryName": "Kitchen & Dining", "listType": "bestsellers"}
```

A **SUMMARY** record in the key-value store lists, for each category, the requests made, the ranks Amazon listed, the ranks found in the page, the ranks read through the deferred load, the partial ranks and why the category stopped.

#### Run it from code

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("alexmorain/amazon-bestsellers-scraper").call(run_input={
    "categories": ["kitchen"],
    "listType": "bestsellers",
    "includeSubcategories": True,
    "maxDepth": 1,
    "maxItems": 1300,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["rank"], row["asin"], row["title"], row["price"])
```

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('alexmorain/amazon-bestsellers-scraper').call({
    startUrls: ['https://www.amazon.de/gp/new-releases/kitchen'],
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0]);
```

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~amazon-bestsellers-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"categories": ["kitchen"], "maxItems": 100}'
```

### Tips

- **Follow a ranking every day.** Schedule the Actor with `Entries, rank changes and exits` and a **Monitor name**. Most days only a few dozen rows come back, and only those are billed.
- **Keep a run cheap.** Leave **Include product page details** off unless you need it: it opens one product page per rank, which is slower and costs more.
- **Compare markets.** Run the same department on amazon.com and amazon.de. Department codes differ between sites (amazon.de `kitchen` is Küche, Haushalt & Wohnen). Type a name or copy the URL from the site.

### FAQ, disclaimers and support

#### Why only 60 ranks with other Amazon Best Sellers scrapers?

Because Amazon writes only 30 of the 50 products of a page in its HTML. A scraper that reads the HTML gets ranks 1 to 30 and 51 to 80. The others come from a second call that the page makes when you scroll. This Actor makes that call, so you get 100.

#### Does it return the Movers & Shakers, Most Wished For or Gift Ideas lists?

No. Amazon answers "no items available in this category" for these three lists when you are not signed in. We checked kitchen, electronics, toys and games, books and beauty from a home IP, and kitchen from Apify datacenter IPs, on all three lists: always empty. Passing one of these lists returns an input error that says so, instead of billing you for nothing.

#### Does it work on amazon.fr, amazon.co.uk or amazon.co.jp?

No. These sites answer with a JavaScript challenge (AWS WAF) that a plain HTTP client cannot pass. Only amazon.com and amazon.de are offered, each checked by a real run.

#### Why does a category come back empty?

Amazon has no list of 100 for it. Two US departments (Digital Music and Digital Educational Resources) show only a landing page or an empty list. An unknown department code also gives an empty page. The summary names the reason.

#### Why is a rank marked `partial`?

Amazon did not serve the details of that product after two tries. You still get the ASIN and the rank, free of charge, so no rank is missing from your table. This did not happen in about 20,000 ranks read on 03/11/2026.

#### Is it legal to scrape Amazon rankings?

The rankings are public pages shown to any visitor. Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

#### Where do I report a problem?

Open an issue in the Issues tab of the Actor. For programmatic access see the API tab. Amazon changes its pages from time to time: a precise report with the URL you used gets fixed fast.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Amazon Best Sellers Scraper page](https://alexis.morain.fr/en/scrapers/amazon-bestsellers-scraper/) of my site. The [E-commerce family page](https://alexis.morain.fr/en/scrapers/families/ecommerce/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

Amazon ranking pages, one per line: <code>https://www.amazon.com/gp/bestsellers/kitchen</code>, <code>https://www.amazon.com/Best-Sellers-Kitchen-Dining-Bakeware/zgbs/kitchen/289668</code>, <code>https://www.amazon.de/gp/new-releases/kitchen</code>. Best Sellers and New Releases pages on amazon.com and amazon.de. The list type and the marketplace are read from the URL; the page number is ignored (both pages of 50 are always read).

## `categories` (type: `array`):

Optional, instead of or next to the URLs. One per line: a department code as in the URL (<code>kitchen</code>, <code>electronics</code>), a department with a node (<code>kitchen/289668</code>), the name of a top department (<code>Kitchen & Dining</code>) or <code>All departments</code> for the ranking of each of the 34 top departments (Amazon has no ranking for the whole store). They use the <b>List</b> and <b>Marketplace</b> below.

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

Which ranking to read for the categories above. <b>Best Sellers</b>: the best-selling products, updated hourly. <b>New Releases</b>: the best-selling products among those listed recently. URLs carry their own list type.

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

Amazon site for the categories above. URLs carry their own marketplace. On amazon.de the Actor sets a Berlin delivery postcode, without which Amazon hides about a third of the prices. amazon.fr, amazon.co.uk and amazon.co.jp are not offered: they answer with a JavaScript challenge that plain HTTP cannot pass.

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

Also read the ranking of every subcategory listed in the left column of the page, level by level, down to <b>Max depth</b> and up to <b>Max categories</b>. Each category appears once even when several parents link to it.

## `maxDepth` (type: `integer`):

How many levels below your category to read. 1 reads the direct subcategories (Kitchen & Dining gives 12 more rankings), 2 reads theirs too.

## `maxCategories` (type: `integer`):

Most rankings read in the run, your own categories included. Each costs 4 requests and returns up to 100 ranks.

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

Total ranks returned by the run, across all categories. The run stops there.

## `includeProductDetails` (type: `boolean`):

Open the product page of each rank and add brand, list price, seller, delivery, rating histogram, bullet points, description, specifications, variants, images, Amazon's AI review summary and more. Billed at the higher <i>detailed ranked product</i> price for each row whose page was read; a row whose page Amazon refused is returned without details at the plain price.

## `monitorMode` (type: `string`):

Remembers each ranking from one run to the next. <b>New entries only</b> returns the products that were never returned before. <b>Entries, rank changes and exits</b> also returns the products whose rank changed (with <code>previousRank</code> and <code>rankChange</code>, positive when the product climbed) and one <code>droppedOut</code> row for each product that left the ranking. Only the rows returned are billed; exit rows are free. The first run returns everything. Schedule it daily or hourly.

## `monitorName` (type: `string`):

Without a name, the memory belongs to each ranking. With a name, every run using that name shares it. The memory lives in your key-value store <code>amazon-bestsellers-monitor</code>.

## `webhookUrl` (type: `string`):

If set, the Actor POSTs a small JSON summary to this URL at the end of the run, <b>only when at least one rank was returned or a product left a ranking</b>: <code>actor</code>, <code>runId</code>, <code>datasetId</code>, <code>ranks</code>, <code>droppedOut</code>, <code>monitorMode</code> and one line per category. Use the final URL: a redirect is not followed, except a 307 or 308. An unreachable webhook is logged and never fails the run. Stored encrypted.

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

Apify datacenter proxy by default, which is enough for ranking pages. If Amazon refuses datacenter IPs, the Actor falls back to residential IPs at no extra charge to you.

## Actor input object example

```json
{
  "categories": [
    "kitchen"
  ],
  "listType": "bestsellers",
  "marketplace": "com",
  "includeSubcategories": false,
  "maxDepth": 1,
  "maxCategories": 50,
  "maxItems": 100,
  "includeProductDetails": false,
  "monitorMode": "off",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All ranks in the default dataset.

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

For each category: requests, ranks listed by Amazon, ranks found in the page, ranks read through the deferred load, partial ranks, ranks returned, exits and why it stopped.

# 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 = {
    "categories": [
        "kitchen"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/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 = {
    "categories": ["kitchen"],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/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 '{
  "categories": [
    "kitchen"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call alexmorain/amazon-bestsellers-scraper --silent --output-dataset

```

## MCP server setup

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