# Amazon Bestsellers Scraper - Ranks, Prices & Ratings (`webdata_labs/amazon-bestsellers-scraper`) Actor

\[$1.20 / 1K products] Scrape Amazon Best Sellers, New Releases, Most Wished For and Gift Ideas across 15 marketplaces. Full top 100 with prices, star ratings and review counts. No start fee.

- **URL**: https://apify.com/webdata\_labs/amazon-bestsellers-scraper.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** E-commerce, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.96 / 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

## Amazon Bestsellers Scraper — Ranks, Prices & Ratings

Scrape Amazon's ranked lists: **Best Sellers, New Releases, Most Wished For and Gift Ideas**,
across 15 marketplaces. The **full top 100** per category, with price, star rating and review
count on every row that Amazon publishes them for.

**$1.20 per 1,000 products. No start fee.** The cheapest Amazon bestseller Actor on the Store
at the Free tier, and the only one that returns star ratings and review counts alongside the
rank.

***

### What you get

| Group | Fields |
|---|---|
| Rank | `rank` (1-100), `listType`, `categoryName`, `categoryNodeId`, `categoryUrl` |
| Product | `asin`, `title`, `productUrl`, `imageUrl` |
| Money | `price`, `priceText`, `currency` |
| Social proof | `rating` (0-5), `ratingCount` |
| Bookkeeping | `marketplace`, `domain`, `page`, `hasPriceData`, `scrapedAt` |

Prices come back as numbers with the marketplace's own currency code, so `1.234,56 €` is
`price: 1234.56, currency: "EUR"` and sorts correctly next to a US row.

### Three ways to name a category

**1. Paste the URL.** Open the Best Sellers page you want on any Amazon site and paste the
address. The marketplace, the category and the list type all come from the URL.

**2. Marketplace + slug.** Pick `amazon.de` and pass `books`, `computers`, and so on.

**3. Let it walk the tree.** Turn on `includeSubcategories` and each page's own subcategory
list is read off the page and scraped too — that is how you cover a whole department instead
of just its top level. `outputCategories` also returns those subcategories as rows, with their
node IDs, so you can feed them straight back in.

### Why the full 100, and where the prices come from

Amazon serves two different layouts for the same page. A browser gets a grid that lazy-loads,
so only 30 of each 50-item page is in the HTML — but those 30 carry price and star rating.
A self-identifying crawler gets a flat layout with **all 50**, and no prices.

This Actor fetches both and merges them on ASIN: the flat layout supplies the complete 1-100
ranking, the browser layout fills in price and rating over the top. `hasPriceData` tells you
which rows got the extra fields. If you only need the ranking, `includePriceAndRating: false`
halves the requests.

### Pricing

| Event | Free | Bronze | Silver | Gold+ |
|---|---|---|---|---|
| Product | $1.20 / 1K | $1.11 / 1K | $1.03 / 1K | **$0.96 / 1K** |
| Subcategory row | $1.20 / 1K | $1.11 / 1K | $1.03 / 1K | **$0.96 / 1K** |

**No start fee.** Compare: the category leader charges $5.90/1K, and several competitors add a
per-run fee on top of their row price.

### Example output

```json
{
  "itemType": "product",
  "listType": "bestsellers",
  "rank": 1,
  "asin": "B08JHCVHTY",
  "title": "Blink Plus Plan with monthly auto-renewal",
  "productUrl": "https://www.amazon.com/dp/B08JHCVHTY",
  "price": 10.44,
  "currency": "USD",
  "rating": 4.4,
  "ratingCount": 280404,
  "hasPriceData": true,
  "marketplace": "US",
  "categoryName": "Electronics",
  "categoryNodeId": null
}
```

### What people use it for

- **Demand research.** What is actually selling in a category right now, ranked, with the
  price it sells at and how many people reviewed it.
- **New product alerts.** `new-releases` on a schedule, diffed by ASIN, is a feed of every new
  product entering a category.
- **Rank tracking.** Re-run daily and diff `rank` by `asin` to watch products climb or fall.
- **Competitor and supplier sourcing.** Gift Ideas and Most Wished For surface products with
  demand that the Best Sellers list has not caught up with yet.
- **Category mapping.** `outputCategories` gives you Amazon's own browse-node tree with IDs.

### Honest limits

- **Movers & Shakers is not available.** Amazon renders that one list in the browser only —
  the HTML arrives with the grid empty. Rather than ship a column that is silently blank, it
  is left out. The other four lists server-render.
- **Gift Ideas is not published for every category on every marketplace.** Where Amazon has
  no such list, the Actor says so in the log and moves on instead of failing the run.
- **Category slugs are localised.** `electronics` exists on amazon.com but not on amazon.de,
  where the same department is a different word. Amazon answers a wrong slug with a normal
  looking 200 whose page title reads "…the most popular items in **undefined**" — the Actor
  detects exactly that and tells you, rather than returning nothing and calling it success.
  Pasting the URL avoids the problem entirely, and `categoryNodeId` is portable across
  marketplaces where the slug is not.
- **Roughly 60 of every 100 rows carry price and rating**, because that is how many the richer
  layout covers. `hasPriceData` marks them. Rank, ASIN, title and image are there for all 100.
- **Amazon prices in the currency of wherever the request comes from.** On a non-US
  marketplace this Actor routes the price lookup through an exit inside that country, so
  amazon.de returns euros rather than a converted dollar figure. `currency` always records
  what the page actually said.
- Ranks are Amazon's own and refresh hourly on their side, so two runs minutes apart can
  legitimately differ.

### Tips

- Start with one category and `maxProductsPerList: 100` to see the shape, then add lists.
- The node ID in `categoryNodeId` is the portable way to name a category — unlike the slug, it
  means the same thing on every marketplace.
- Combine `new-releases` with a daily schedule for the cheapest early-signal feed on Amazon.

# Actor input Schema

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

Paste Best Sellers, New Releases, Most Wished For or Gift Ideas page URLs straight from Amazon. This is the most reliable way to name a category, because category slugs differ on every marketplace.

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

Which Amazon site to use for the category slugs below. Ignored for pasted URLs, which carry their own marketplace.

## `categorySlugs` (type: `array`):

Category names as they appear in the URL, e.g. electronics, books, toys-and-games. Slugs are localised: "electronics" exists on amazon.com but not on amazon.de. When in doubt paste the URL instead.

## `listTypes` (type: `array`):

Amazon publishes four ranked lists per category. Movers & Shakers is not available: Amazon renders it in the browser only.

## `maxProductsPerList` (type: `integer`):

Amazon publishes a top 100 per category and list type. Lower this to sample.

## `includePriceAndRating` (type: `boolean`):

Amazon serves the complete ranking on one page layout and the prices and star ratings on another, so this fetches both and merges them. Turn it off to halve the requests when you only need the ranking.

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

Reads the subcategory list off each page and scrapes those rankings too. This is how you cover a whole department rather than just its top level.

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

Cap on how many subcategories to follow, so a big department cannot run up a bill.

## `outputCategories` (type: `boolean`):

Adds one row per discovered subcategory, with its node ID, so you can feed them back in later.

## Actor input object example

```json
{
  "categoryUrls": [
    "https://www.amazon.com/gp/bestsellers/electronics/"
  ],
  "marketplace": "US",
  "categorySlugs": [
    "electronics",
    "books"
  ],
  "listTypes": [
    "bestsellers"
  ],
  "maxProductsPerList": 100,
  "includePriceAndRating": true,
  "includeSubcategories": false,
  "maxSubcategories": 10,
  "outputCategories": false
}
```

# Actor output Schema

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

One row per ranked product, with price, rating and review count.

## `categories` (type: `string`):

Subcategories discovered under the categories you asked for.

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

Counts, the lists that ran, and how many requests came back empty.

# 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/gp/bestsellers/electronics/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/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/gp/bestsellers/electronics/"] }

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/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/gp/bestsellers/electronics/"
  ]
}' |
apify call webdata_labs/amazon-bestsellers-scraper --silent --output-dataset

```

## MCP server setup

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