# Amazon Best Sellers Scraper (`axiomworks/amazon-sellers-scraper`) Actor

Scrape public Amazon Best Sellers and New Releases category pages and get ranked product records with ASIN, title, category, marketplace, and product path. The Actor preserves the rank displayed on each card, so gaps caused by items loaded only after scrolling remain visible.

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

## Pricing

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

**Returns:** one row per ranked product with rank, asin, title, price, rating, reviewCount, categoryTitle, and sourceUrl.

**Input:** `{"categories":["electronics"],"marketplace":"amazon.com","maxItems":30}`

**Best for:** category research, assortment comparisons, and repeat ranking checks.

```json
{"rank":1,"asin":"B08JHCVHTY","title":"blink plus plan with monthly auto-renewal","categoryTitle":"Amazon Best Sellers: Best Electronics","price":"$11.99","rating":4.4,"sourceUrl":"https://www.amazon.com/gp/bestsellers/electronics/?pg=1"}
```

This Amazon scraper reads public ranking charts. Use it as an Amazon API for structured Best Sellers and New Releases records across supported marketplaces. The short sample above is from a local run; Amazon's ranks and visible fields can change.

### What does Amazon Best Sellers Scraper do?

Amazon Best Sellers Scraper reads public category ranking pages and turns the visible product cards into structured records. It supports Best Sellers and New Releases lists on the ten marketplaces shown in the input schema. A run can cover several category slugs or several starting URLs. Turn on `includeSubcategories` to add immediate child charts linked on each starting page, up to `maxSubcategories`. This is off by default and still respects the run-wide `maxItems` cap. Use category slugs, numeric IDs, or nested category paths such as `electronics/281407` when you want the Actor to construct ranking URLs for one marketplace and one list type. Use starting URLs when you already know the exact category pages you need, including pages from different supported marketplaces.

The Actor requests static HTML at a modest pace. It reads Amazon's displayed rank from each card, rather than assigning a new rank by position in the dataset. This matters because a static page may expose fewer products than the complete list. For example, page one can show ranks 1 through 30 while some additional cards load only after browser scrolling. A second static page may begin at rank 51. Gaps in the returned ranks reflect what the page supplied; they do not imply that the missing ranks represent unavailable products.

Results are deduplicated within a run by marketplace, list type, category, and ASIN. A product appearing on two different lists or in two categories remains a distinct ranking record, because its context and rank can differ. The `maxItems` setting is a strict output cap across all requested pages. The Actor stops collecting after it saves that many unique items. Malformed input fails with a validation message. A well-formed chart that is empty or remains blocked finishes successfully with zero items and a status message asking you to check the category URL, category slug, or proxy country. Other targets can still return results.

### What data can you get?

The dataset has these fields. A nullable field is returned as `null` when the card does not show it. The `productPath` is copied from the card link before its referral suffix and query; `sourceUrl` identifies the actual ranking page requested.

| Field | Meaning |
| --- | --- |
| `id` | Stable identifier combining marketplace, list type, category, and ASIN. |
| `sourceUrl` | URL of the ranking page that supplied the record. |
| `listType` | `bestsellers` or `new-releases`. |
| `category` | Category slug or category ID from the ranking URL. |
| `categoryTitle` | Human-readable title shown in the ranking page title. |
| `marketplace` | Marketplace domain, such as `amazon.com`. |
| `rank` | Rank printed on the product card. |
| `asin` | Product identifier printed in the card markup. |
| `title` | Product title shown on the ranking page. |
| `productPath` | Product link path copied from the card before its referral suffix and query. |
| `imageUrl` | Image URL from the product card, when present. |
| `price` | Displayed price text, when present. |
| `priceValue` | Numeric value parsed from the displayed price. |
| `currency` | Currency code inferred from the displayed price symbol. |
| `rating` | Displayed star rating, when present. |
| `reviewCount` | Displayed number of ratings or reviews. |
| `scrapedAt` | UTC timestamp when the card was parsed. |

Price, rating, review count, and image availability depend on the page and product. A missing price can mean the page omitted it; it is not a zero price. Prices and currency are page observations, not a separate product offer lookup. Amazon may localize a page according to the request's region, so check the `currency` value before comparing prices from different runs. This Actor does not visit product detail pages and does not claim stock, shipping, seller, or historical price data.

### How to use

To collect a common category, enter its slug in `categories`, choose a `marketplace`, and choose the ranking `listType`. `electronics`, `books`, and `kitchen` are examples of slugs. For a quick agent check, use `{"categories":["electronics"],"maxPagesPerCategory":1,"maxItems":1}`. Start with one page and a small `maxItems` value to check the fields available for your category. Increase `maxPagesPerCategory` if you need more of the ranking, keeping in mind that static HTML may omit cards that the site inserts on scroll.

For an exact ranking page, paste its URL into `startUrls`. Supported forms include `/gp/bestsellers/<category>/`, `/gp/new-releases/<category>/`, `/zgbs/<category>/`, and pasted chart URLs such as `/Best-Sellers-Electronics/zgbs/electronics/281407/ref=...`. Locale prefixes before `/gp/` are also accepted. Each URL must use HTTPS and one of the supported Amazon marketplace hosts. The Actor reads the final category ID from nested chart URLs and normalizes the page number query for each requested page. If you enable child charts, it reads the page sidebar and visits immediate child links after the starting chart. URLs for product pages, search results, or unsupported hosts are rejected with a clear error.

The default proxy setting uses Apify residential proxy with a country that matches the chosen marketplace when all target URLs use the same marketplace. You can change `proxyConfiguration` in the input. The Actor spaces requests and retries blocked responses with a fresh proxy session and backoff. It does not complete CAPTCHAs. If Amazon continues to block a page, that page contributes no placeholder records.

### Input

| Input | Description | Default |
| --- | --- | --- |
| `categories` | Category slugs or numeric category IDs to collect when `startUrls` is empty. | Empty; the Console prefill suggests `electronics`. |
| `startUrls` | Exact supported ranking category URLs; takes precedence over `categories`. | Empty. |
| `marketplace` | Marketplace used to build URLs from category slugs. | `amazon.com`. |
| `listType` | Ranking used with category slugs. | `bestsellers`. |
| `maxPagesPerCategory` | Maximum pages for each target, from 1 to 5. | 2. |
| `maxItems` | Maximum saved records across the run, from 1 to 10000. | 50. |
| `includeSubcategories` | Add immediate child charts linked from each starting page. | `false`. |
| `minRating` | Minimum displayed star rating, 0 to 5. Zero disables filtering. | 0. |
| `minReviewCount` | Minimum displayed rating/review count. Zero disables filtering. | 0. |
| `maxSubcategories` | Maximum child charts to add across the run, from 1 to 50. | 10. |
| `proxyConfiguration` | Apify Proxy configuration for target requests. | Residential proxy. |

A basic input for one category is:

```json
{
  "marketplace": "amazon.com",
  "categories": ["electronics"],
  "listType": "bestsellers",
  "maxPagesPerCategory": 1,
  "maxItems": 30
}
```

For a New Releases page, use `startUrls` instead of category slugs:

```json
{
  "startUrls": [
    { "url": "https://www.amazon.com/gp/new-releases/electronics/" }
  ],
  "maxPagesPerCategory": 1,
  "maxItems": 7
}
```

The URL example asks for up to seven unique results. If seven valid cards exist, the dataset contains seven items. If the page yields fewer valid cards, the dataset contains fewer. The limit applies to saved records, not to a rank threshold. A record at rank 51 can therefore be included in a larger run that requests a second page.

### Output

Each dataset item is one product in one ranking context. This is an example from a local Best Sellers run; product descriptions and page content can change between runs:

```json
{
  "id": "amazon.com:bestsellers:electronics:B0DN45YMP6",
  "sourceUrl": "https://www.amazon.com/gp/bestsellers/electronics/?pg=1",
  "listType": "bestsellers",
  "category": "electronics",
  "categoryTitle": "Amazon Best Sellers: Best Electronics",
  "marketplace": "amazon.com",
  "rank": 26,
  "asin": "B0DN45YMP6",
  "title": "JBL Vibe Beam 2 - Noise Cancelling Earbuds - Black | JBL Pure Bass sound, Active Noise Cancelling with Smart Ambient, 4 mics for crisp, clear calls, Water and dust resistant",
  "productPath": "/JBL-Vibe-Beam-Cancelling-Technology/dp/B0DN45YMP6",
  "imageUrl": "https://images-na.ssl-images-amazon.com/images/I/618f5yBk26L._AC_UL300_SR300,200_.jpg",
  "price": null,
  "priceValue": null,
  "currency": null,
  "rating": 4.1,
  "reviewCount": 7368,
  "scrapedAt": "2026-10-01T20:24:18.513Z"
}
```

The example illustrates the output shape and a source page that omitted price from the parsed card during this local run. A later run may have different ranks, prices, products, timestamps, or null fields. The output is current page data, not an assertion that a product is permanently a new release or that its rank remains stable. Save the dataset from each run if you need to compare rankings over time; the Actor does not maintain a history across runs.

A run with `includeSubcategories: true` and `maxSubcategories: 1` returned an additional record from the first Electronics child chart. Its `category` was `281407`, its `categoryTitle` was `Amazon Best Sellers: Best Electronics Accessories & Supplies`, and its `sourceUrl` pointed to the nested `/zgbs/electronics/281407/` chart. The child chart is read only when the option is enabled.

A local Electronics test with `minRating: 4.5`, `minReviewCount: 100`, and `maxItems: 7` saved seven records; all had ratings of at least 4.5 and counts above 100.

Set `minRating` and `minReviewCount` to create a shortlist before saving records. For example, `{"categories":["electronics"],"minRating":4.5,"minReviewCount":100,"maxItems":7}` asks for seven matching records, subject to page limits and available cards. Both thresholds must match when enabled. A missing rating or count fails its enabled threshold; zero leaves that field unfiltered. Filtered cards are not saved or charged, and the original Amazon rank is retained. The Actor can still fetch pages containing excluded cards. If no cards match, it succeeds with zero items and asks you to lower the thresholds or choose another chart.

Nested paths work with both list types. `{"categories":["electronics/281407"],"maxItems":1}` requests the Electronics Accessories & Supplies chart directly. The `category` field remains the final path component, `281407`, as it does for the equivalent starting URL. Category paths are passed to Amazon without guessing a department name from a product ASIN. Empty components, query strings, and arbitrary external URLs are invalid category inputs; use `startUrls` for complete chart URLs.

### How much does it cost?

The Actor is charged per result saved to the dataset. The `maxItems` input caps the number of records that can be saved and charged in a run. The exact current rate and billing details are shown on the Actor's Pricing tab. A page that yields no records does not create result events. A record is charged once when it is saved, even if a later page repeats the same product in the same ranking context.

### Use with AI agents (MCP)

Apify's MCP server lets an AI agent find and call this Actor using its input and output schemas. Configure the MCP endpoint for the Store path `axiomworks/amazon-sellers-scraper`:

```text
https://mcp.apify.com/?tools=axiomworks/amazon-sellers-scraper
```

Example prompts:

- "Collect up to 20 products from Amazon.com electronics Best Sellers and return rank, title, ASIN, and product path."
- "Read the Amazon.com electronics New Releases list and show rank, price, currency, and rating for the first seven saved products."
- "Collect one page each for books and kitchen, then group the returned records by category and source URL."

### Integrations and API

Use the Apify API client to start a run and read the dataset. Replace the actor ID and token in the examples with your own authorized values. Store tokens in environment variables or your integration's secret manager; the Actor input does not require Amazon credentials.

Python:

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("axiomworks/amazon-sellers-scraper").call(run_input={
    "categories": ["electronics"],
    "marketplace": "amazon.com",
    "maxItems": 20,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rank"], item["title"], item["sourceUrl"])
```

JavaScript:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('axiomworks/amazon-sellers-scraper').call({
    categories: ['electronics'],
    marketplace: 'amazon.com',
    maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    process.stdout.write(`${item.rank}: ${item.title} (${item.sourceUrl})\n`);
}
```

cURL:

```bash
curl -X POST 'https://api.apify.com/v2/acts/AxiomWorks~amazon-sellers-scraper/run-sync-get-dataset-items' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"categories":["electronics"],"marketplace":"amazon.com","maxItems":20}'
```

The synchronous endpoint is convenient for a small run. For longer runs, start the Actor asynchronously and fetch items from its default dataset after it finishes. Keep the source URL and extraction timestamp when moving records into a spreadsheet, database, or dashboard; those fields explain where and when each observation was made.

### FAQ

**Why are some ranks missing?** Amazon's static HTML can omit cards that load after scrolling. The Actor reports printed ranks from cards actually returned by the requested pages. It does not invent records for gaps.

**Why is a price null?** Some product cards do not display a price, or a page variant may use a different presentation. The Actor returns `null` rather than inventing a price. The same principle applies to rating, review count, image, and currency.

**Can I mix marketplaces?** Yes, with supported `startUrls`. Category slugs use the single `marketplace` input. For a mixed-marketplace run, provide explicit URLs and review each record's `marketplace` and `currency` fields.

**What happens if Amazon blocks a page?** The Actor retries blocked HTTP responses or CAPTCHA pages with backoff and a fresh proxy session. It never solves a CAPTCHA. After retries are exhausted, it warns and moves on without creating error items.

**Can I get seller information or product details?** This Actor reads ranking cards only. It does not open product detail pages and does not output seller identities, availability, or shipping terms.

### Is it legal to scrape Amazon?

The Actor reads public ranking pages, and you are responsible for deciding whether your use complies with applicable law and Amazon's terms. Amazon's terms may restrict automated access. Consider the volume, purpose, jurisdiction, and handling of the resulting data for your use case. This Actor is an independent tool and is not affiliated with or endorsed by Amazon. It does not access accounts, authenticated pages, or private customer data.

### Feedback

If a supported ranking page returns no records, or a field that appears on the page is consistently missing, share the marketplace, category URL, list type, and approximate run time when reporting the problem. A short sample of the page layout or a run log can help identify a markup change. Do not include account credentials or private data in a report. Suggestions for supported ranking categories and clearer field descriptions are welcome through the Actor's Apify feedback channel.

# Actor input Schema

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

Amazon category slugs, numeric IDs or nested paths, e.g. \["electronics"], \["281407"] or \["electronics/281407"]. Used when startUrls is empty; marketplace and listType construct the chart URLs. Supply categories or startUrls.

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

Whether to collect child category charts linked from starting pages, e.g. true; default false. Limited by maxSubcategories and the shared maxItems budget.

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

HTTPS Amazon category chart URLs, e.g. \[{"url":"https://www.amazon.com/zgbs/electronics/"}]. Accepts /gp/bestsellers/, /gp/new-releases/ and nested /zgbs/ paths on supported www.amazon hosts. Nonempty startUrls overrides categories, marketplace and listType; product and search URLs are invalid.

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

Marketplace domain used only with categories, e.g. amazon.de; default amazon.com. Each startUrls entry determines its own marketplace. Prices and language can depend on the proxy exit country.

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

Chart type used only with categories: bestsellers (default) or new-releases, e.g. new-releases. Each startUrls entry determines its own chart type.

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

Maximum pages per starting or child chart, 1-5, e.g. 1; default 2. Static HTML commonly exposes 30 items per page, with rank gaps; extra pages may be empty.

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

Maximum linked child charts to add across all starting targets, 1-50, e.g. 3; default 10. Used only when includeSubcategories is true.

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

Maximum ranking records saved across all targets and pages, 1-10000, e.g. 7; default 50. Deduplicates within each marketplace/list/category/ASIN context. Stops early when fewer records exist or targets remain blocked.

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

Minimum displayed star rating, 0-5, e.g. 4.5; default 0 disables filtering. Cards with missing ratings are excluded only when enabled. maxItems counts matching saved records across all charts.

## `minReviewCount` (type: `integer`):

Minimum displayed review/rating count, e.g. 100; default 0 disables filtering. Cards with missing counts are excluded only when enabled. Filtered cards are not saved or charged; empty matches succeed with a status message.

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

Apify Proxy settings, e.g. {"useApifyProxy":true,"apifyProxyGroups":\["RESIDENTIAL"]}. Defaults to residential; country matches the marketplace when all targets share one. Repeatedly blocked or empty charts contribute zero records; check the category URL or proxy country.

## Actor input object example

```json
{
  "categories": [
    "electronics"
  ],
  "includeSubcategories": false,
  "startUrls": [],
  "marketplace": "amazon.com",
  "listType": "bestsellers",
  "maxPagesPerCategory": 1,
  "maxSubcategories": 10,
  "maxItems": 30,
  "minRating": 0,
  "minReviewCount": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Ranked Amazon products from the default dataset

# 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"
    ],
    "startUrls": [],
    "marketplace": "amazon.com",
    "listType": "bestsellers",
    "maxPagesPerCategory": 1,
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/amazon-sellers-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"],
    "startUrls": [],
    "marketplace": "amazon.com",
    "listType": "bestsellers",
    "maxPagesPerCategory": 1,
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/amazon-sellers-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"
  ],
  "startUrls": [],
  "marketplace": "amazon.com",
  "listType": "bestsellers",
  "maxPagesPerCategory": 1,
  "maxItems": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call axiomworks/amazon-sellers-scraper --silent --output-dataset

```

## MCP server setup

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