# Amazon Best Sellers Scraper - New Releases, Movers & Ranks (`topapi/amazon-bestsellers-scraper`) Actor

Scrape Amazon Best Sellers, New Releases, Movers & Shakers, Most Wished For and Gift Ideas by list link or category, subcategories included, on 22 Amazon sites: rank, ASIN, title, price, rating, reviews, image, category path. Rank-change monitor. $0.31 per 1,000 products, no start fee.

- **URL**: https://apify.com/topapi/amazon-bestsellers-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** E-commerce, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.31 / 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.

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 Amazon's ranking lists - **Best Sellers, New Releases, Movers & Shakers, Most Wished For and Gift Ideas** - and returns one row per ranked product: rank, ASIN, title, price, stars, number of ratings, image, author or brand line, format, and the full category path. Give it list links or category names, choose how deep to go into subcategories, and it reads the **top 100 of every list** on 22 Amazon marketplaces.

Also known as: Amazon bestsellers API, Amazon top 100 scraper, Amazon BSR list scraper, Amazon new releases scraper, Amazon rank tracker.

- 🏆 **All five Amazon lists**, any category and subcategory, ranks 1-100 (Amazon's own limit per list).
- 🌍 **22 marketplaces**: .com, .co.uk, .de, .fr, .it, .es, .nl, .se, .pl, .com.be, .ie, .com.tr, .ca, .com.mx, .com.br, .co.jp, .in, .com.au, .sg, .ae, .sa, .eg - prices in the local currency.
- 🌳 **Whole category trees**: subcategory depth 1-10, or every department of a marketplace with one switch.
- 🔁 **Rank tracker**: monitor mode compares each list with its previous run - previous rank, rank change, new entries, drop-outs, days on chart.
- 📦 **Product page add-on**: brand, list price, availability, "bought in past month", every Best Sellers Rank, description, images, variant ASINs.
- 💸 **$0.31 per 1,000 products**, no start fee. Empty lists, filtered products and unread ranks are never charged.
- 🔓 **No Amazon account, no login, no cookies, no browser.**

### What data can you get from Amazon Best Sellers lists?

| | | |
|---|---|---|
| 🥇 Rank `position` | 🆔 ASIN `asin` | 🏷️ Title `name` |
| 💲 Price `price` + `currency` | 🧾 Price as shown `priceText` | 🛒 Offers `numberOfOffers` |
| ⭐ Stars `stars` | 💬 Ratings `reviewsCount` | ✍️ Author / brand `byline` |
| 📚 Format `format` | 📖 Formats available `formatsAvailable` | 🖼️ Image `imageUrl` + `thumbnailUrl` |
| 🗂️ Category `categoryName` | 🧭 Path `categoryPath` | 🔢 Node id `categoryId` |
| 📋 List type `listType` | 🔗 List link `categoryUrl` | 🌿 Subcategories `subcategories` |
| 📈 Previous rank `previousRank` | ↕️ Change `rankChange` / `movement` | 📅 Days on chart `daysOnChart` |
| 🏭 Brand `brand` | 🏷️ List price `listPrice` | 🔥 Bought last month `monthlyPurchaseVolume` |

### How to scrape Amazon Best Sellers with Amazon Best Sellers Scraper

1. [Sign up for a free Apify account](https://console.apify.com/sign-up) - it comes with free monthly credit.
2. Open **Amazon Best Sellers Scraper** and paste one or more list links, e.g. `https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics`, or type a category name such as `electronics` or `Home & Kitchen`.
3. Pick the list types (Best Sellers, New Releases, ...) and the subcategory depth.
4. Optionally switch on product details or monitor mode.
5. Click **Start**. The prefilled run (two lists, 50 products each) finishes in seconds.
6. Download the rows as JSON, CSV, Excel or HTML, or read them through the API.

### ⬇️ Input

| Parameter | Type | Description |
|---|---|---|
| `categoryUrls` | array | List links (any of the five list types, any marketplace), category slugs (`electronics`, `electronics/172541`) or department names (`Kindle Store`). A link keeps its own marketplace. |
| `listTypes` | array | `bestsellers`, `new-releases`, `movers-and-shakers`, `most-wished-for`, `gift-ideas`. Empty = the list in each link (Best Sellers for names). |
| `marketplace` | string | Amazon site for names and All departments. Default `amazon.com`. |
| `allDepartments` | boolean | Every top-level department of the marketplace. Default `false`. |
| `depthOfCrawl` | integer | 1 = only the lists given, 2 = also their subcategories, up to 10. Default `1`. |
| `maxCategories` | integer | Most lists one run reads. Default `100`. |
| `language` | string | `auto` (the marketplace's language) or e.g. `en`, `de`, `ja`. Default `auto`. |
| `minRating`, `minReviews`, `minPrice`, `maxPrice` | number | Filters applied before a row is delivered or charged. |
| `dedupeAsins` | boolean | A product ranked in several lists is delivered once. Default `false`. |
| `detailedInformation` | boolean | Product page fields on every row, $0.001 per row that gets them. Default `false`. |
| `monitorMode` | boolean | Compare with the previous run of each list. Default `false`. |
| `monitorOutput` | string | `new` (products not delivered before), `changes` (new + moved) or `all`. Default `new`. |
| `includeDroppedOut` | boolean | One row per product that left a list since the last run. Default `false`. |
| `monitorStoreName` | string | Named key-value store that keeps the lists. Default `amazon-bestsellers-monitor`. |
| `maxItemsPerStartUrl` | integer | Top N per list, 1-100. Default `100`. |
| `maxItems` | integer | Most rows in the run, `0` = no limit. Default `0`. |
| `compact` | boolean | Core fields only, for AI/MCP pipelines. Default `false`. |
| `proxyConfiguration` | object | Last step of the connection ladder (direct, then Apify datacenter, then this proxy). Default Apify RESIDENTIAL. |
| `maxConcurrency` | integer | Lists fetched in parallel, 1-10. Default `4`. |

None of the fields is required: an empty input runs the two sample lists (Electronics and Books Best Sellers on amazon.com, 50 products each).

#### Input JSON

```json
{
  "categoryUrls": [
    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics",
    "https://www.amazon.de/gp/new-releases/kitchen"
  ],
  "listTypes": ["bestsellers", "new-releases"],
  "depthOfCrawl": 2,
  "maxCategories": 40,
  "maxItemsPerStartUrl": 100
}
```

#### Give a list link or a category name

Any of these works in `categoryUrls`: a Best Sellers link (`/zgbs/...` or `/gp/bestsellers/...`), a New Releases, Movers & Shakers, Most Wished For or Gift Ideas link (`/gp/new-releases/...`, `/gp/movers-and-shakers/...`, `/gp/most-wished-for/...`, `/gp/most-gifted/...`), a slug (`books`), a slug with a node id (`electronics/172541`), or a department name as Amazon shows it in the left menu (`Toys & Games`). Product links (`/dp/...`) are not lists and are skipped with a message.

#### Use list types to read several lists of one category

With `listTypes` set, every link and name is read once per list type: one Electronics link with `["bestsellers", "new-releases"]` reads both lists.

#### Depth multiplies the number of lists

Amazon has about 40 departments on amazon.com and each has 10-40 subcategories. Depth 2 on one department reads 20-40 lists; `allDepartments` at depth 2 reads several hundred. `maxCategories` stops the run at a number you choose.

### ⬆️ Output

A real row from the prefilled run (amazon.com Electronics, 2026-10-28; `subcategories` shortened):

```json
{
  "position": 1,
  "asin": "B08JHCVHTY",
  "name": "blink plus plan with monthly auto-renewal",
  "url": "https://www.amazon.com/Blink-Plus-Plan-monthly-auto-renewal/dp/B08JHCVHTY",
  "price": 11.99,
  "priceText": "$11.99",
  "currency": "USD",
  "numberOfOffers": null,
  "stars": 4.4,
  "reviewsCount": 281506,
  "byline": null,
  "format": null,
  "thumbnailUrl": "https://images-na.ssl-images-amazon.com/images/I/31YHGbJsldL._AC_UL300_SR300,200_.png",
  "imageUrl": "https://images-na.ssl-images-amazon.com/images/I/31YHGbJsldL.png",
  "listType": "bestsellers",
  "categoryName": "Electronics",
  "categoryFullName": "Best Sellers in Electronics",
  "categoryPath": ["Electronics"],
  "categoryId": "electronics",
  "categoryUrl": "https://www.amazon.com/gp/bestsellers/electronics",
  "subcategories": [{ "categoryName": "Headphones", "categoryUrl": "https://www.amazon.com/gp/bestsellers/electronics/172541" }],
  "page": 1,
  "marketplace": "amazon.com"
}
```

A book row adds the author and format: `"byline": "Sarah J. Maas"`, `"bylineUrl": "https://www.amazon.com/Sarah-J-Maas/e/B0070291GK"`, `"format": "Hardcover"`, `"formatsAvailable": 5`. A card that says "8 offers from $29.95" gives `"price": 29.95, "numberOfOffers": 8`.

With **monitor mode** a row also carries `previousRank`, `rankChange` (positive = moved up), `movement` (`new`, `up`, `down`, `same`, `dropped`), `isNewEntry`, `firstSeenAt` and `daysOnChart`.

With **product details** a row also carries `brand`, `listPrice`, `availability`, `inStock`, `monthlyPurchaseVolume` ("6K+ bought in past month"), `bestSellersRank` (`[{"rank": 1, "category": "Clothing, Shoes & Jewelry"}, {"rank": 2, "category": "Men's Sweatshirts"}]`), `dateFirstAvailable`, `features`, `description`, `images` and `variantAsins`.

#### Fields and how often they are filled

Measured on 1,729 ranked products from 18 lists on 13 marketplaces (2026-10-28) and 18 product pages:

| Field | Filled | Note |
|---|---|---|
| `position`, `asin`, `name`, `url`, `imageUrl`, `categoryName`, `categoryPath` | 100% | |
| `price`, `currency`, `priceText` | 99% | Amazon shows no price for some subscriptions and unavailable items |
| `stars`, `reviewsCount` | 97% | new titles have no ratings yet |
| `byline` | 51% | books, music, games, some brands |
| `format` | 51% | books (Hardcover, Kindle Edition...), games (platform) |
| `numberOfOffers` | 1% | only on "N offers from" cards |
| `brand`, `bestSellersRank`, `images` (details) | 100% | |
| `listPrice` (details) | 83% | only when Amazon shows a struck-through price |
| `monthlyPurchaseVolume` (details) | 67% | only when Amazon shows "bought in past month" |
| `features`, `dateFirstAvailable`, `variantAsins` (details) | 61-67% | books have no bullets; single products have no variants |

### Use cases

- 📊 **Product research for sellers**: which products and brands hold the top 100 of a niche, at what price and rating.
- 🚀 **Trend spotting**: new entries and fast climbers per category with monitor mode on a daily schedule.
- 📚 **Publishing and KDP**: Kindle Store and Books lists with authors, formats and ratings per genre.
- 🏷️ **Pricing teams**: the price and offer count of the category leaders, every day.
- 🧠 **Market intelligence and AI agents**: a compact, structured feed of what sells on 22 Amazon sites.
- 🛍️ **Affiliate and deal sites**: fresh top lists with images and links.

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

**$0.31 per 1,000 ranked products**, no start fee. The product details add-on is **$0.001 per row** that gets them.

Measured on Apify on 2026-10-28:

| Run | Lists | Products | Time | Price |
|---|---:|---:|---:|---:|
| Prefilled run (Electronics + Books, top 50 each) | 2 | 100 | 4 s | $0.031 |
| Electronics and its subcategories, Best Sellers + New Releases, top 100 | 15 | 1,500 | 14 s | $0.465 |
| Every amazon.com department, top 100 | 39 | 3,620 | 58 s | $1.12 |
| 6 lists on 6 marketplaces, top 100 | 6 | 500 | 10 s | $0.155 |
| 2 lists, top 8, with product details | 2 | 16 | 10 s | $0.005 + $0.016 |

The empty Movers & Shakers list in the 6-marketplace run (amazon.fr) was not charged. Empty lists, products removed by your filters, ranks Amazon did not serve and monitor rows not delivered are never charged, and a run stops cleanly at the maximum charge you set (measured: a $0.003 cap delivered and charged 9 products).

### Integrations, API, scheduling & MCP

- ⏰ **Schedules**: run the same input daily with monitor mode on; each run delivers only what changed. Create one under **Schedules** in Apify Console.
- 🔔 **Webhooks**: get a call when a run finishes and fetch the dataset.
- 🔌 **Make, Zapier, n8n, Google Sheets, Slack**: through Apify's integrations.
- 🧑‍💻 **API**: start runs and read rows with the [Python](https://docs.apify.com/api/client/python) or [JavaScript](https://docs.apify.com/api/client/js) client, or plain HTTP.
- 🤖 **MCP**: AI agents call it through the Apify MCP server.

Run it on a schedule through the API:

```bash
curl -X POST "https://api.apify.com/v2/acts/TopApi~amazon-bestsellers-scraper/runs?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"categoryUrls":["electronics","books"],"monitorMode":true,"monitorOutput":"changes","monitorStoreName":"daily-top100"}'
```

### More Amazon scrapers

- 🔎 **Amazon Product Scraper** - search results and product pages by keyword or ASIN.
- ⭐ **Amazon Reviews Scraper** - review text, ratings histogram and "customers say".
- 🏪 **Amazon Seller Leads Scraper** - seller business names, addresses and contacts.

### Limits & empty runs

- **100 products per list** is Amazon's own limit; more products come from more subcategories (`depthOfCrawl`).
- **Movers & Shakers, Most Wished For and Gift Ideas**: on 2026-10-28 Amazon showed these lists empty ("Sorry, there are no movers and shakers available in this category") in every category we tried on amazon.com, .de, .co.uk and .co.jp. The actor reads them whenever Amazon fills them (then rows also carry Amazon's `salesRank`, `previousSalesRank` and `salesRankChangePercent`), names an empty list in the run status and charges nothing for it. Monitor mode gives you rank movement on the Best Sellers lists in the meantime.
- **A run that returns nothing** says why in its status: the list is empty on Amazon, the filters removed every product, monitor mode found nothing new, or the input is not a ranking list. Nothing is charged.
- **A run Amazon refuses completely** ends FAILED with the request counts, and nothing is charged.
- Prices follow the marketplace's delivery location (the actor sets it the way a signed-out shopper does: 10001 for amazon.com, 10115 for amazon.de...).
- The run summary (`RUN_SUMMARY` in the key-value store) lists every list read, empty or not read, the filtered counts and the field fill of the run.

### ❓ FAQ

#### How much does Amazon Best Sellers Scraper cost?

$0.31 per 1,000 ranked products, no start fee; product page details $0.001 per row that gets them. A top-100 list costs $0.031.

#### How many products can Amazon Best Sellers Scraper return?

100 per list. With subcategories and all departments one run reads thousands of lists; `maxCategories` and `maxItems` cap it.

#### Can Amazon Best Sellers Scraper track rank changes over time?

Yes. Switch on monitor mode and schedule the run: each list is compared with its previous run (previous rank, rank change, new entries, drop-outs, days on chart), and `monitorOutput` decides whether you get only new products, new + moved, or everything.

#### Does Amazon Best Sellers Scraper read Movers & Shakers?

Yes, with Amazon's own sales rank and % change when Amazon fills that list. Amazon currently shows it empty in most categories; empty lists are named in the status and never charged.

#### Which Amazon marketplaces does Amazon Best Sellers Scraper support?

22: United States, United Kingdom, Germany, France, Italy, Spain, Netherlands, Sweden, Poland, Belgium, Ireland, Turkey, Canada, Mexico, Brazil, Japan, India, Australia, Singapore, United Arab Emirates, Saudi Arabia and Egypt.

#### Do I need an Amazon account or API key for Amazon Best Sellers Scraper?

No. It reads the public lists like a signed-out shopper. No login, no cookies.

#### Can I use Amazon Best Sellers Scraper through the Apify API?

Yes - start runs and fetch rows with the Python or JavaScript client or plain HTTP, and connect it to Make, Zapier, n8n or Google Sheets.

#### Can AI agents use Amazon Best Sellers Scraper through MCP?

Yes, through the Apify MCP server. Switch on `compact` for shorter rows.

#### Why did my Amazon Best Sellers Scraper run return no products?

The status says which: the list is empty on Amazon right now, the filters removed every product, monitor mode found nothing new, or the input was not a ranking list. None of these is charged.

#### Your feedback

Something missing or wrong? Open an issue on the **Issues** tab - we read every one.

# Actor input Schema

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

A ranking list link (e.g. https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics), a category slug or slug/node ("electronics", "electronics/172541") or a department name ("Home & Kitchen"). A link keeps its own marketplace.

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

Lists to read for every category. Empty = the list in each link (Best Sellers for names). Amazon currently shows Movers & Shakers, Most Wished For and Gift Ideas empty in most categories; empty lists are never charged.

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

Amazon site for category names and "All departments". Links always use their own site.

## `allDepartments` (type: `boolean`):

Read the list of every top-level department of the marketplace (about 40 on amazon.com), on top of any links given.

## `depthOfCrawl` (type: `integer`):

1 = only the lists you give. 2 = also their direct subcategories, 3 = two levels down, up to 10 (every level). Each subcategory has its own top 100.

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

Most lists (categories x list types) one run reads. A department at depth 2 is ~20-40 lists; all of amazon.com at depth 3 is several thousand.

## `language` (type: `string`):

Language of titles and category names. Auto = the marketplace's own (German on amazon.de). Amazon falls back to its default when a site lacks the language.

## `minRating` (type: `number`):

Keep products rated at least this many stars (0-5). Products with no rating are dropped when set.

## `minReviews` (type: `integer`):

Keep products with at least this many ratings, e.g. 100.

## `minPrice` (type: `number`):

Keep products priced at or above this, in the marketplace currency.

## `maxPrice` (type: `number`):

Keep products priced at or below this, in the marketplace currency.

## `dedupeAsins` (type: `boolean`):

A product ranked in several lists (a department and its subcategory) is delivered once, from the first list read.

## `detailedInformation` (type: `boolean`):

Open each product page: brand, list price, availability, bought in past month, every Best Sellers Rank, date first available, bullets, description, images, variant ASINs. $0.001 per row that gets them.

## `monitorMode` (type: `boolean`):

Remember each list between runs and add previousRank, rankChange, movement (new/up/down/same/dropped), firstSeenAt and daysOnChart.

## `monitorOutput` (type: `string`):

Which rows a monitored run delivers. The first run of a list delivers the whole list.

## `includeDroppedOut` (type: `boolean`):

Also deliver one row per product that left the list since the last run (movement "dropped", previousRank).

## `monitorStoreName` (type: `string`):

Named key-value store that keeps the lists between runs. Use one name per schedule.

## `maxItemsPerStartUrl` (type: `integer`):

Top N of each list. Amazon ranks at most 100 per list (50 per page).

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

Most rows in the whole run. 0 = no limit (lists x products per list).

## `compact` (type: `boolean`):

Core fields only (rank, ASIN, title, link, price, stars, ratings, image, list, category) - trimmed for AI/MCP pipelines.

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

Requests go direct first, then Apify datacenter exits; this proxy is the last step, inside a small per-run budget. Your own proxy URLs are used for every request.

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

Lists (and product pages) fetched at the same time.

## Actor input object example

```json
{
  "categoryUrls": [
    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics",
    "https://www.amazon.com/best-sellers-books-Amazon/zgbs/books"
  ],
  "marketplace": "amazon.com",
  "allDepartments": false,
  "depthOfCrawl": 1,
  "maxCategories": 100,
  "language": "auto",
  "dedupeAsins": false,
  "detailedInformation": false,
  "monitorMode": false,
  "monitorOutput": "new",
  "includeDroppedOut": false,
  "monitorStoreName": "amazon-bestsellers-monitor",
  "maxItemsPerStartUrl": 50,
  "maxItems": 0,
  "compact": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 4
}
```

# Actor output Schema

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

One item per ranked product per list: rank, ASIN, title, price, stars, ratings, image, category path, list type (+ movement and product details when switched on).

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

Lists read, lists Amazon shows empty, lists not read and why, filtered rows, monitor counts, transport and field fill.

# 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",
        "https://www.amazon.com/best-sellers-books-Amazon/zgbs/books"
    ],
    "maxItemsPerStartUrl": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/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",
        "https://www.amazon.com/best-sellers-books-Amazon/zgbs/books",
    ],
    "maxItemsPerStartUrl": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/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",
    "https://www.amazon.com/best-sellers-books-Amazon/zgbs/books"
  ],
  "maxItemsPerStartUrl": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call topapi/amazon-bestsellers-scraper --silent --output-dataset

```

## MCP server setup

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