# Amazon Product & Bestsellers Scraper (`humble-echidna/amazon-products`) Actor

Scrape Amazon.com products and Best Sellers lists: give ASINs, product links or Best Sellers category URLs and get price, list price, rating, review count, availability, seller, Best Sellers Rank and categories. Only-changes mode for price monitoring.

- **URL**: https://apify.com/humble-echidna/amazon-products.md
- **Developed by:** [Michael Costa](https://apify.com/humble-echidna) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

### What does Amazon Product & Bestsellers Scraper do?

**Amazon Product & Bestsellers Scraper** gets **Amazon product data** from amazon.com: give it **ASINs or product
links** and get **price, list price, rating, review count, stock, seller and Best Sellers Rank**; give it **Best
Sellers lists** and get the **top 100** of any category. Logged-out pages only; no login, no cookies.

It is **not** a reviews scraper or a seller-contact finder: it collects no reviews, reviewer names or seller emails.

[Input fields](https://apify.com/humble-echidna/amazon-products/input-schema) ·
[API](https://apify.com/humble-echidna/amazon-products/api) ·
[Use it from Claude, ChatGPT or Cursor (MCP)](#can-i-use-amazon-product-and-bestsellers-scraper-from-an-ai-agent-mcp)

**Jump to:** [Price monitor](#monitor-amazon-prices-get-only-what-changed) ·
[Fields](#what-data-does-amazon-product-and-bestsellers-scraper-return) ·
[Price](#how-much-does-it-cost-to-scrape-amazon-products) ·
[How to use](#how-to-scrape-amazon-products-and-best-sellers) ·
[Input](#input) · [Output](#output) ·
[AI agents (MCP)](#can-i-use-amazon-product-and-bestsellers-scraper-from-an-ai-agent-mcp) · [Limits](#limits) ·
[FAQ](#faq)

**Try it in one click:** the input comes pre-filled with two products (a Rubbermaid container set and a novel) and
the top 10 of the Kitchen & Dining Best Sellers list. That's 12 results, or about $0.024 (12 × $2.00/1,000, plus
$0.00005 for the run start). **Then replace it with what you actually want.**

### Monitor Amazon prices: get only what changed

With **Only new or changed since the last run** on, each run returns (and charges for) only the products whose
**price, in-stock status or Best Sellers rank** changed since your last run with the same input, each with `changes`
and the previous values. The first run returns everything and is the baseline.

1. Put your ASINs in **Products** (and, if you like, lists in **Best Sellers lists**), turn on **Only new or changed
   since the last run** (`"onlyChanges": true`), and click **Start**.
2. Click **Save as a new task** (top right of the actor page). What was returned is remembered in the key-value store
   `amazon-products-changes` in your account, separately for each set of inputs.
3. In Apify Console, open **Schedules**, click **Create new**, set how often (for example daily), then **Add** your
   task.
4. On the task, open the **Integrations** tab and send the changes to **Slack**, **Gmail** or an **HTTP webhook**
   (event `ACTOR.RUN.SUCCEEDED`; `resource.defaultDatasetId` is the run's dataset). A quiet run's dataset is empty.

### What data does Amazon Product & Bestsellers Scraper return?

One result per **product** (`"type": "product"`):

| Field | Example | Notes |
|---|---|---|
| `asin`, `url` | `B079M8FPTW`, `https://www.amazon.com/dp/B079M8FPTW` | Also `id` (= the ASIN) |
| `title` | `Rubbermaid Brilliance Tritan Plastic Food Storage Containers ...` | |
| `price`, `priceText`, `currency` | `25.98`, `$25.98`, `USD` | The price a buyer pays now; `null` when Amazon shows none |
| `listPrice` | `32.48` | Amazon's "List Price"/"Was" price, when higher than `price` |
| `rating`, `reviewsCount` | `4.7`, `59819` | Average stars and number of ratings |
| `availability`, `inStock` | `In Stock`, `true` | `inStock` is `false` for "Currently unavailable" |
| `brand`, `byline` | `Rubbermaid`, `Visit the Rubbermaid Store` | Books: authors and format in `byline` |
| `soldBy`, `shipsFrom` | `Amazon.com`, `Amazon.com` | The featured offer |
| `bestSellersRank` | `[{"rank": 6, "category": "Kitchen & Dining"}, ...]` | From the product details |
| `categories` | `["Home & Kitchen", "Kitchen & Dining", ...]` | Breadcrumb, top first |
| `features`, `imageUrl` | `["100% Leak-proof: ...", ...]`, main image | "About this item" bullets |

One result per **Best Sellers rank** (`"type": "bestseller"`): `rank`, `asin`, `title`, `price`, `rating`,
`reviewsCount`, `imageUrl`, `url`, `category` and `categoryUrl`. Turn on **Add product page details** to add every
product field above to each rank. The full list is under [Output](#output).

### How much does it cost to scrape Amazon products?

You pay per result: **$2.00 per 1,000 results** on the Free plan, $1.50 on Starter, $1.20 on Scale and $1.00 on
Business, plus $0.00005 each time a run starts. A result is one product, or one rank of a Best Sellers list (with or
without product page details).

- **The example below:** 12 results × $2.00/1,000 = $0.024, plus the start fee.
- **A month, for example:** the top 100 of 5 categories weekly: 2,000 results ≈ **$4.00** on the Free plan ($2.00 on Business). 50 of your
  products checked daily with only changes on: if 5 change a day, 150 results ≈ **$0.30**, plus $0.0015 of start
  fees.
- **Caps:** **Max results per run** in the input, and **Maximum cost per run** in the run options. The run stops
  cleanly at whichever comes first.

**Never charged:** products Amazon refuses (a robot check or block page, reported with the reason), products that
don't exist, inputs that aren't valid, and unchanged products when only changes is on.

### How to scrape Amazon products and Best Sellers

1. Open Amazon Product & Bestsellers Scraper and click **Try for free** (or **Start** if you're signed in).
2. Put ASINs or amazon.com product links in **Products**, one per line.
3. Put Best Sellers category links in **Best Sellers lists** (open a category on amazon.com/gp/bestsellers and copy
   its address), and set **Max products per list** (up to 100).
4. Optionally turn on **Add product page details** or **Only new or changed since the last run**.
5. Click **Start**, then open the **Output** tab and export as JSON, CSV or Excel.

### Example: two products and the Kitchen top 10

The pre-filled input:

```json
{"products": ["B079M8FPTW", "1668236516"], "bestsellerUrls": ["https://www.amazon.com/gp/bestsellers/kitchen"],
 "maxItemsPerCategory": 10}
```

It returned 12 results in 7 seconds ([run](https://console.apify.com/view/runs/UVk3bYQyFWeU7WVIz) on 2026-10-08), at
$0.03 at the Free-plan price. One product (real output):

```json
{
  "id": "B079M8FPTW",
  "type": "product",
  "asin": "B079M8FPTW",
  "title": "Rubbermaid Brilliance Tritan Plastic Food Storage Containers BPA Free Airtight Lids Ideal for Lunch Meal Prep & Leftovers Set of 5 (3.2 Cup)",
  "brand": "Rubbermaid",
  "byline": "Visit the Rubbermaid Store",
  "price": 25.98,
  "listPrice": 32.48,
  "currency": "USD",
  "priceText": "$25.98",
  "rating": 4.7,
  "reviewsCount": 59819,
  "availability": "In Stock",
  "inStock": true,
  "soldBy": "Amazon.com",
  "shipsFrom": "Amazon.com",
  "imageUrl": "https://m.media-amazon.com/images/I/81qikuKGJZL._AC_SL1500_.jpg",
  "features": ["100% Leak-proof: Guaranteed no-spill seal and secure latches", "... 7 in all"],
  "categories": ["Home & Kitchen", "Kitchen & Dining", "Storage & Organization", "Food Storage", "Food Containers", "Container Sets"],
  "bestSellersRank": [{"rank": 6, "category": "Kitchen & Dining"}, {"rank": 2, "category": "Food Container Sets"}],
  "url": "https://www.amazon.com/dp/B079M8FPTW",
  "scrapedAt": "2026-10-08T23:19:08.896217Z"
}
```

And the list's rank 2:

```json
{
  "id": "kitchen:B085DTZQNZ",
  "type": "bestseller",
  "rank": 2,
  "asin": "B085DTZQNZ",
  "title": "Owala FreeSip Stainless Steel Water Bottle 24 oz Very, Very Dark",
  "price": 29.99,
  "currency": "USD",
  "priceText": "$29.99",
  "rating": 4.6,
  "reviewsCount": 140775,
  "imageUrl": "https://images-na.ssl-images-amazon.com/images/I/718RbhzhVbL._AC_UL300_SR300,200_.jpg",
  "url": "https://www.amazon.com/dp/B085DTZQNZ",
  "listing": "card",
  "category": "Kitchen & Dining",
  "categoryUrl": "https://www.amazon.com/gp/bestsellers/kitchen",
  "scrapedAt": "2026-10-08T23:19:08.896217Z"
}
```

Rank 1 that day (a Stanley tumbler) came with `"price": null`: Amazon's list showed "MSRP, click for details"
instead of a price.

### Input

| Field | What it does |
|---|---|
| **Products** (`products`) | ASINs (or a book's ISBN-10) or amazon.com product links, one per line. |
| **Best Sellers lists** (`bestsellerUrls`) | amazon.com Best Sellers category links (`/gp/bestsellers/...` or `.../zgbs/...`), one per line. |
| Max products per list (`maxItemsPerCategory`) | 1-100 ranks per list (default 50). |
| Add product page details (`addProductDetails`) | Also fetch each listed product's page and add its fields. |
| Only new or changed since the last run (`onlyChanges`) | Return only products whose price, stock or rank changed. |
| Max results per run (`maxResults`) | Cap the total number of results. |

```json
{
  "products": ["B079M8FPTW", "https://www.amazon.com/dp/1668236516"],
  "bestsellerUrls": ["https://www.amazon.com/gp/bestsellers/electronics"],
  "maxItemsPerCategory": 100,
  "onlyChanges": true
}
```

### Output

A product and a Best Sellers rank look like the [example above](#example-two-products-and-the-kitchen-top-10). With
only changes on, each result also has `changes` (`new`, `price`, `inStock`, `rank`) and `previousPrice`,
`previousInStock`, `previousRank`. With product details on, a rank gets the product fields and `"listing":
"product-page"`, or `detailsError` with the reason when its page couldn't be read.

`id` is stable across runs (the ASIN for a product, `<category>:<ASIN>` for a rank), so you can use it to
deduplicate. Fields Amazon doesn't show for a product are `null`. The run's `RUN_STATS` record lists every input,
what it returned and anything that failed, with the reason, plus how many pages were fetched and refused.

### Run it on a schedule, or from your own code

1. Save your input as a [task](https://docs.apify.com/platform/actors/running/tasks) (**Save as a new task**) and add
   it to a [schedule](https://docs.apify.com/platform/schedules) (Console → Schedules → **Create new**).
2. Collect results: download the dataset as JSON, CSV or Excel; fetch the latest run's results from the
   [API](https://apify.com/humble-echidna/amazon-products/api)
   (`GET https://api.apify.com/v2/actor-tasks/<task id>/runs/last/dataset/items?status=SUCCEEDED&format=json`, with
   your API token); let a [webhook](https://docs.apify.com/platform/integrations/webhooks) tell your system when a
   run succeeds; or connect it to Make, Zapier or n8n through
   [Apify's integrations](https://docs.apify.com/platform/integrations).

#### Can I use Amazon Product & Bestsellers Scraper from an AI agent (MCP)?

Yes, through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp), from Claude, ChatGPT, Cursor or
any other MCP client. Add this to your client's MCP configuration; your client signs you in to Apify:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=humble-echidna/amazon-products"
    }
  }
}
```

To use an [Apify API token](https://console.apify.com/settings/integrations) instead of signing in, add
`"headers": {"Authorization": "Bearer <APIFY_TOKEN>"}` next to `url`.

An agent should pass ASINs or lists, e.g. `{"products": ["B079M8FPTW"], "bestsellerUrls": []}` for one product's
current price, or `{"products": [], "bestsellerUrls": ["https://www.amazon.com/gp/bestsellers/toys-and-games"],
"maxItemsPerCategory": 20}` for a category's top 20.

### Who it's for

Amazon sellers and brands watching their own and competitors' prices, stock and rank; product researchers looking for
what sells in a category; deal and price-alert sites; and analysts who want Best Sellers lists over time without
copying them by hand.

### Why this one?

- **A price monitor built in.** Only new or changed returns just the products whose price, stock or rank moved, so a
  daily check of hundreds of products costs cents.
- **Products and Best Sellers in one run,** with the Best Sellers Rank, list price, seller and shipper of each
  product.
- **Fast and light.** It reads amazon.com's pages directly, with no browser: 5 categories' top 100 (500 results) in
  9 seconds, and 100 products in 4.6 minutes, on 2026-10-08.
- **Blocked pages are free.** A page Amazon refuses is tried once more from another IP, then reported with the
  reason, never charged. (See [Limits](#limits): Amazon refuses many product pages after the first hundred or so.)
- **Reliable.** One failing input never affects the others; the log and `RUN_STATS` say which input failed and why.

### Limits

- **amazon.com only** in this version. Links to other Amazon sites (amazon.de, amazon.co.uk ...) are reported as
  unsupported.
- **Product pages are best effort; Best Sellers lists are the reliable part.** Amazon limits how many product pages
  it serves to this actor. In our tests on 2026-10-08, a run of 100 products got all 100, and the next runs within
  the following 40 minutes got 7 of 100, 3 of 20 and 4 of 20; the rest met robot checks. Blocked products are
  reported with the reason and not charged; run them again later. Best Sellers lists were never affected (all 24
  list pages, including during the product block).
- **Best Sellers lists:** Amazon's list page shows full cards for 30 of every 50 ranks; the other 20 come with rank,
  ASIN and link only (`"listing": "rank-only"`, `title` `null`) unless **Add product page details** is on.
- **The featured offer only:** one price per product (the buy box), not every seller's offer; no variations as
  separate results; no reviews.
- **US prices and delivery:** the pages are read as a visitor from the US with no address set.
- Captchas are never solved, and no logins or cookies of yours are used.

### FAQ

#### Is it legal to scrape Amazon?

What the actor reads is public: the product and Best Sellers pages any logged-out visitor sees. It collects no
personal data (no reviews, reviewer names, or seller contact details). amazon.com's robots.txt doesn't disallow
product pages (`/dp/`) or Best Sellers lists for general crawlers, and the actor obeys it on every request.

But know this: **Amazon's Conditions of Use** (last updated August 14, 2026) grant a license to access Amazon "for
personal and non-commercial use" and say it "does not include ... any collection and use of any product listings,
descriptions, or prices; ... or any use of data mining, robots, or similar data gathering and extraction tools."
Whether those terms bind you and how they apply to public data depends on where you are and what you do with the
data; courts have treated scraping public pages differently from breaking into accounts, but this isn't legal
advice. If your use matters, ask a lawyer. This actor isn't affiliated with or endorsed by Amazon; Amazon's official
option for product data is its Product Advertising API for Amazon Associates.

To be read as an ordinary visitor, the actor sends a common browser User-Agent to amazon.com (Amazon refused our own
bot name with robot checks). It doesn't solve captchas, rotate browser fingerprints or use accounts.

#### Why did a product return nothing?

The run log and the `RUN_STATS` record name each input and the reason: "blocked" (Amazon showed a robot check; this
is common after the first hundred or so product pages, see [Limits](#limits); try again later), "not found" (no such ASIN on amazon.com), or "changed its page layout" (open an issue). None of these
are charged, and every other input in the run is unaffected.

#### Can I get only new or changed products since my last run?

Yes: turn on **Only new or changed since the last run**
([how](#monitor-amazon-prices-get-only-what-changed)).

#### Does it scrape reviews, offers from every seller, or other Amazon sites?

Not in this version. Reviews beyond the rating and count need a login on Amazon now, and this actor never logs in.

#### How fresh is the data?

Live: every run reads amazon.com at that moment.

### Related actors

| Actor | Use it when |
|---|---|
| [Product Price & Stock Monitor](https://apify.com/humble-echidna/product-offers) | You want prices and stock from shops' own websites instead of Amazon |
| [Google Trends Scraper](https://apify.com/humble-echidna/google-trends) | You want to know whether interest in a product is rising before you stock it |
| [Website Change Monitor](https://apify.com/humble-echidna/website-change-monitor) | You want to know when a competitor's page changes |
| [Dataset Transformer](https://apify.com/humble-echidna/dataset-transform) | You want the results flattened into a CSV or Excel sheet your way |

### Feedback and support

Found a bug, or need a field or marketplace that isn't here? Open an issue on the **Issues** tab with the input you
used.

### Versions

Current version: **0.1**. See the Changelog tab for what changed in each version.

# Changelog

This Actor's version history is a separate document: https://apify.com/humble-echidna/amazon-products/changelog.md

# Actor input Schema

## `products` (type: `array`):

Amazon.com products to fetch, one per line: an ASIN (e.g. B079M8FPTW, or a book's ISBN-10 like 1668236516) or a product link (https://www.amazon.com/.../dp/B079M8FPTW). Each line gives one result with price, list price, rating, review count, availability, seller, Best Sellers Rank and categories. Only amazon.com in this version; other Amazon sites are reported as unsupported.

## `bestsellerUrls` (type: `array`):

Amazon.com Best Sellers category pages, one per line, e.g. https://www.amazon.com/gp/bestsellers/kitchen or a sub-category link like https://www.amazon.com/Best-Sellers-Kitchen-Dining/zgbs/kitchen/289913. Each ranked product is one result (rank, ASIN, title, price, rating, review count), up to Max products per list. Leave empty to fetch only Products.

## `maxItemsPerCategory` (type: `integer`):

How many ranks to take from each Best Sellers list, 1-100 (Amazon's lists stop at 100; ranks 51-100 are a second page). Default 50.

## `addProductDetails` (type: `boolean`):

Also fetch each listed product's own page and add its fields (list price, availability, seller, Best Sellers Rank, categories, features). Needed for full data on ranks 31-50 and 81-100, which Amazon's list page names only by ASIN. One extra page per product, so runs take longer; the price per result is the same.

## `onlyChanges` (type: `boolean`):

Return only products that are new, or whose price, in-stock status or rank changed since your last run with the same Products and lists; each comes with `changes` and the previous values. Unchanged products aren't returned or charged. The first run returns everything. The memory is kept in your account's key-value store amazon-products-changes.

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

Stop after this many results in total, e.g. 20. Minimum 1; leave empty (the default) for no limit. The run also stops cleanly at the maximum cost per run you set in the run options, whichever comes first.

## Actor input object example

```json
{
  "products": [
    "B079M8FPTW",
    "1668236516"
  ],
  "bestsellerUrls": [
    "https://www.amazon.com/gp/bestsellers/kitchen"
  ],
  "maxItemsPerCategory": 10,
  "addProductDetails": false,
  "onlyChanges": false
}
```

# Actor output Schema

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

No description

## `runStats` (type: `string`):

No description

# 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 = {
    "products": [
        "B079M8FPTW",
        "1668236516"
    ],
    "bestsellerUrls": [
        "https://www.amazon.com/gp/bestsellers/kitchen"
    ],
    "maxItemsPerCategory": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("humble-echidna/amazon-products").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 = {
    "products": [
        "B079M8FPTW",
        "1668236516",
    ],
    "bestsellerUrls": ["https://www.amazon.com/gp/bestsellers/kitchen"],
    "maxItemsPerCategory": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("humble-echidna/amazon-products").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 '{
  "products": [
    "B079M8FPTW",
    "1668236516"
  ],
  "bestsellerUrls": [
    "https://www.amazon.com/gp/bestsellers/kitchen"
  ],
  "maxItemsPerCategory": 10
}' |
apify call humble-echidna/amazon-products --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,humble-echidna/amazon-products"
        }
    }
}
```

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/ZPfIywnEF0TjiBE1I/builds/29Y0ot63C4Bgc0mae/openapi.json
