# Amazon Best Sellers Scraper — Category Rankings (`logiover/amazon-bestsellers-scraper`) Actor

Scrape Amazon Best Sellers, New Releases, Movers & Shakers, Most Wished For and Gift Ideas charts for any category. Returns rank, ASIN, title, price, rating and review count across 19 marketplaces. No API key.

- **URL**: https://apify.com/logiover/amazon-bestsellers-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** E-commerce, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Best Sellers Scraper — Category Rankings & ASIN Data

Scrape Amazon's ranked charts for any category and export them to CSV, JSON or Excel: **Best Sellers, New Releases, Movers & Shakers, Most Wished For and Gift Ideas** — with rank, ASIN, title, price, star rating and review count, across **19 Amazon marketplaces**.

No Amazon API key. No login.

***

### Search results tell you what Amazon shows. Charts tell you what sells.

A keyword search returns whatever the ranking algorithm decides to surface for that query, sponsored placements included. A Best Sellers chart is ordered by actual sales rank.

The five charts answer different questions:

| Chart | What it reveals |
|---|---|
| **Best Sellers** | What is selling right now, ranked 1–100 |
| **New Releases** | Recent launches already gaining traction |
| **Movers & Shakers** | Biggest *rank gains* in 24 hours — products taking off before they are established |
| **Most Wished For** | Demand that has not converted yet — a leading indicator |
| **Gift Ideas** | What is actually being bought for others, which peaks seasonally |

**Movers & Shakers** is the sharpest of the five for spotting a trend early: it ranks by change, not by position.

***

### What this Actor extracts

| Field | Type | Description |
|---|---|---|
| `rank` | integer | Position in the chart, read from the badge Amazon prints on the card |
| `asin` | string | Amazon's product identifier |
| `title` | string | Product title |
| `url` | string | Product detail page |
| `price` | number | Price as a number |
| `priceText` | string | Price as Amazon renders it |
| `currency` | string | Currency of the marketplace |
| `rating` | number | Average star rating out of 5 |
| `reviewCount` | integer | Number of ratings |
| `imageUrl` | string | Product thumbnail |
| `category` | string | Chart category slug |
| `listType` | string | Which of the five charts |
| `marketplace` | string | Amazon storefront |
| `page` | integer | Chart page (1 or 2) |
| `scrapedAt` | string | UTC timestamp of extraction |

`rank` is read from the printed badge rather than inferred from grid order, so the number stays correct even when the layout reflows or a card is missing.

***

### Input

```json
{
  "categories": ["electronics", "kitchen", "toys-and-games", "pet-supplies"],
  "listType": "bestsellers",
  "marketplace": "US",
  "maxResults": 2000
}
```

| Input | Default | Notes |
|---|---|---|
| `categories` | one default category | Slugs as they appear in a Best Sellers URL. A full chart URL works too. |
| `listType` | `bestsellers` | `bestsellers`, `newReleases`, `moversAndShakers`, `mostWishedFor`, `giftIdeas`. |
| `marketplace` | `US` | One of 19 storefronts. |
| `maxPagesPerCategory` | 2 | Amazon caps each chart at 100 products over two pages. |
| `maxResults` | 500 | Global cap. `0` = unlimited. |

**Nothing is required.** Run it with empty input (`{}`) and it scrapes a default busy category so you can see the output shape first.

#### Common category slugs

`electronics` · `books` · `kitchen` · `toys-and-games` · `sporting-goods` · `beauty` · `pet-supplies` · `office-products` · `home-garden` · `automotive` · `videogames` · `baby-products` · `tools` · `appliances` · `musical-instruments` · `arts-crafts` · `industrial` · `fashion`

***

### Output sample

```json
{
  "rank": 2,
  "asin": "B0DCH8VDXF",
  "title": "Apple EarPods Headphones with USB-C Plug",
  "url": "https://www.amazon.com/dp/B0DCH8VDXF",
  "price": 19,
  "priceText": "$19.00",
  "currency": "USD",
  "rating": 4.6,
  "reviewCount": 16321,
  "category": "electronics",
  "listType": "bestsellers",
  "marketplace": "US",
  "scrapedAt": "2026-08-06T18:25:00.000Z"
}
```

***

### Use cases

#### Product sourcing for private label

Scan many categories at once and look for charts where the top ranks are cheap and lightly reviewed. High rank with few reviews means demand exists and no incumbent has locked it in.

#### Trend detection

Run **Movers & Shakers** daily against a set of categories and diff the results. A product appearing near the top two days running is a trend forming, not noise.

#### Competitive rank tracking

Track your own ASINs' `rank` over time per category and marketplace. Because `rank` is read from the page, the series is directly comparable across runs.

#### Seasonal planning

**Gift Ideas** and **Most Wished For** move ahead of the buying season. Scraping them through Q4 shows demand building before it shows up in Best Sellers.

#### Cross-market expansion research

The same category ranks differently in each of the 19 storefronts. Comparing `electronics` in `US`, `DE` and `JP` tells you where a product has room before you commit inventory.

***

### Integrating the results

**HTTP**

```bash
curl "https://api.apify.com/v2/acts/logiover~amazon-bestsellers-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"categories":["electronics"],"listType":"moversAndShakers"}'
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover/amazon-bestsellers-scraper").call(
    run_input={
        "categories": ["electronics", "kitchen", "pet-supplies"],
        "listType": "moversAndShakers",
        "maxResults": 1000,
    }
)
for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(p["rank"], p["title"], p["price"], p["rating"])
```

Schedule it daily in Apify and push the output to Google Sheets, Airtable or a database through the built-in integrations, or read it from an AI agent over MCP.

***

### Frequently asked questions

#### How many products can one run return?

A single test run returned **1,140 products across twenty categories**, with rank and price on 100% of rows and ratings on 99%. Each chart is capped by Amazon at 100 products, so scale comes from scraping more categories and more marketplaces rather than deeper pagination.

#### Why is `maxPagesPerCategory` limited to 2?

Because Amazon publishes only 100 products per chart, split across two pages of 50. Asking for more pages would return nothing.

#### What is the difference between Best Sellers and Movers & Shakers?

Best Sellers ranks by current sales volume, so it is dominated by established products. Movers & Shakers ranks by *change* in sales rank over 24 hours, which surfaces products accelerating right now — the useful signal if you are hunting trends rather than confirming them.

#### Can I get full product details for the ASINs in a chart?

Yes. Take the `asin` values and feed them into the **Amazon Product Detail Scraper** for specs, description, seller, Best Sellers Rank and full-size images.

#### Is scraping Amazon legal?

This Actor reads publicly available chart pages, does not log in, and collects no personal data. How you use the output is your responsibility; review Amazon's terms and your local rules before redistributing data commercially.

***

### Related Actors

- **Amazon Product Detail Scraper** — full record for any ASIN in the chart.
- **Amazon Scraper (Product Search)** — keyword-level search rather than category charts, with sponsored-placement flags.

A natural pipeline: **charts here → take the ASINs → enrich with the detail Actor → compare against keyword search rank.**

***

### Pricing

Pay per result — one charge per ranked product returned, plus a negligible flat fee when a run starts. No subscription, no minimum.

***

*This Actor uses publicly available data. Amazon is a trademark of Amazon.com, Inc. This is an independent tool and is not affiliated with, endorsed by, or sponsored by Amazon.*

# Actor input Schema

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

Category slugs as they appear in a Best Sellers URL, e.g. 'electronics', 'books', 'kitchen', 'toys-and-games'. A full chart URL works too. Leave EMPTY to scrape a default busy category.

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

Which Amazon chart to read. 'Movers & Shakers' is the one that surfaces products gaining rank fastest.

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

Which Amazon storefront to read the chart from.

## `maxPagesPerCategory` (type: `integer`):

Amazon caps each chart at 100 products over two pages of 50.

## `maxResults` (type: `integer`):

Global cap for the run. 0 = unlimited.

## Actor input object example

```json
{
  "categories": [
    "electronics"
  ],
  "listType": "bestsellers",
  "marketplace": "US",
  "maxPagesPerCategory": 2,
  "maxResults": 500
}
```

# Actor output Schema

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

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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": [
        "electronics"
    ],
    "listType": "bestsellers",
    "marketplace": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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": ["electronics"],
    "listType": "bestsellers",
    "marketplace": "US",
}

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

```

## MCP server setup

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