# Amazon Product & Best Sellers Rank Scraper (`xtracto/amazon-products-scraper`) Actor

Track Amazon products from ASINs or URLs: Best Sellers Rank (all ranks), buy-box price and seller, rating, review count, availability and buy-box-competition signal. Built for daily snapshots — spot buy-box hijacks and BSR velocity over time.

- **URL**: https://apify.com/xtracto/amazon-products-scraper.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Product & Best Sellers Rank Scraper

Turn a list of Amazon ASINs or product links into clean, structured product data — including **Best Sellers Rank (BSR)**, **buy-box price**, seller, star rating, review count and availability. Run it on a daily schedule to watch how a product's rank and buy box move over time.

### Why use this actor

- **No account, no login, no API key** — just paste product IDs or URLs and run.
- **Best Sellers Rank for every product** — the broad department rank plus every sub-category rank, so you can track BSR velocity (how fast a product is climbing or falling).
- **Buy-box intelligence** — buy-box price and a signal for whether other sellers are competing for the buy box (useful for spotting buy-box hijacks on your own listings).
- **Built for snapshots over time** — one tidy record per product per run; save each day's run and you have a rank/price history with zero extra work.
- **Stable JSON output** ready for spreadsheets, databases, dashboards or alerting pipelines. Export to JSON, CSV or Excel.
- **Handles blocks automatically** and retries — no scrapers or browsers to babysit.

### How it works

1. Enter one or more **ASINs** (the 10-character product code) and/or full **product URLs**.
2. Pick the **marketplace** (Amazon US, UK or Germany).
3. The actor opens each product page and reads the title, price, rating, reviews, availability, Best Sellers Rank and buy-box details.
4. Each product becomes one row in your dataset. Run it again tomorrow to build a time series.

You don't manage any of the fetching, retries, or blocking — just the list of products you care about.

### Input

```json
{
    "mode": "product",
    "asins": ["B09B8V1LZ3", "B07ZPKN6YR"],
    "urls": ["https://www.amazon.com/dp/B0BDHWDR12"],
    "domain": "amazon.com",
    "maxItems": 0,
    "maxConcurrency": 3,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US"
    }
}
````

| Field | Type | Description |
| --- | --- | --- |
| `mode` | string | Currently `product` — fetch full detail for each ASIN/URL. |
| `asins` | array | Amazon product IDs, e.g. `B09B8V1LZ3`. Add as many as you like. |
| `urls` | array | Full product URLs (`/dp/...` or `/gp/product/...`); the ID is detected automatically. |
| `domain` | string | Marketplace: `amazon.com`, `amazon.co.uk` or `amazon.de`. |
| `maxItems` | integer | Cap the number of products this run. `0` = all provided. |
| `maxConcurrency` | integer | How many products to fetch in parallel. |
| `proxyConfiguration` | object | Residential proxy recommended, matched to the marketplace's country (US for amazon.com). |

### Output

One record per product. Real sample captured from a live run (the price and availability
below reflect the run's delivery region — with a US Residential proxy on amazon.com the
price shows in USD and availability as "In Stock"; see Notes):

```json
{
    "_input": "B07ZPKN6YR",
    "_source": "S1-product",
    "_scrapedAt": "2026-07-10T09:12:04Z",
    "asin": "B07ZPKN6YR",
    "url": "https://www.amazon.com/dp/B07ZPKN6YR",
    "domain": "amazon.com",
    "title": "Apple iPhone 11, 64GB, Black - Unlocked (Renewed)",
    "buyBoxPrice": 2625152.5,
    "buyBoxPriceText": "IDR2,625,152.50",
    "currency": "IDR",
    "primaryBsrRank": 25,
    "primaryBsrCategory": "Amazon Renewed",
    "bsrRanks": [
        { "rank": 25, "category": "Amazon Renewed" },
        { "rank": 16, "category": "Renewed Smartphones" },
        { "rank": 21, "category": "Cell Phones" }
    ],
    "sellerName": null,
    "shipsFrom": null,
    "hasOtherSellers": true,
    "rating": 4.2,
    "ratingCount": 60371,
    "availability": "This item cannot be shipped to your selected delivery location...",
    "isPrime": true,
    "imageUrl": "https://m.media-amazon.com/images/I/61MG3m5FhIL._AC_SY445_.jpg"
}
```

| Field | Type | Description |
| --- | --- | --- |
| `asin` | string | The product's 10-character Amazon ID. |
| `url` | string | Product page URL. |
| `domain` | string | Marketplace the product was read from. |
| `title` | string | Product title. |
| `buyBoxPrice` | number | Current buy-box price as a number. |
| `buyBoxPriceText` | string | Price exactly as shown on the page. |
| `currency` | string | Currency of the price (e.g. USD, GBP, EUR). |
| `primaryBsrRank` | number | The broadest Best Sellers Rank (top-level department). |
| `primaryBsrCategory` | string | The category that `primaryBsrRank` belongs to. |
| `bsrRanks` | array | Every Best Sellers Rank line: `{ rank, category }` (usually a broad rank plus 1–2 sub-category ranks). |
| `sellerName` | string | null | Buy-box seller ("Sold by"), when shown on the page (see Notes). |
| `shipsFrom` | string | null | Who the item ships from, when shown. |
| `hasOtherSellers` | boolean | Whether other sellers / buying options are competing for the buy box — a signal for buy-box-hijack monitoring. |
| `rating` | number | Average star rating out of 5. |
| `ratingCount` | number | Number of ratings. |
| `availability` | string | Availability text (e.g. "In Stock"). |
| `isPrime` | boolean | Whether the buy box shows a Prime offer. |
| `imageUrl` | string | Main product image. |

Failed lookups never fail silently — they produce a record with `_error` and `_errorDetail` (e.g. `not_found` for a dead ASIN) so nothing disappears from your dataset.

### Notes & limits

- **Use a Residential proxy set to the marketplace's country** (US for amazon.com). Prices, availability and delivery details are shown per country, so the country must match to get accurate values. Datacenter proxies are often shown a block page.
- **Seller "Sold by" / "Ships from" can be blank.** Amazon loads the buy-box seller separately for some products; when it isn't on the main page these fields are `null` (the rest of the record is still complete). `hasOtherSellers` still tells you when buy-box competition exists.
- **Best Sellers Rank isn't shown for every product** (for example, some first-party Amazon devices don't carry a BSR); those records have `primaryBsrRank: null` and an empty `bsrRanks`.
- **For time-series tracking**, schedule the actor (e.g. daily) with the same product list and keep each run's dataset — `primaryBsrRank` gives you BSR velocity and `buyBoxPrice`/`sellerName` give you buy-box-change history.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. Currently 'product' — fetch full detail for each ASIN or product URL you provide.

## `asins` (type: `array`):

Amazon product IDs (the 10-character code, e.g. B09B8V1LZ3). Add as many as you like. Combine with Product URLs below.

## `urls` (type: `array`):

Full Amazon product URLs (amazon.com/dp/... or amazon.com/gp/product/...). The product ID is detected automatically.

## `domain` (type: `string`):

Which Amazon marketplace the products belong to.

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

Cap the number of products scraped this run. 0 = scrape every ASIN/URL provided.

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

How many products to fetch at the same time. Lower this if you hit blocks.

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

Residential proxy strongly recommended — matches the marketplace's country for correct prices and availability (US for amazon.com). Datacenter proxies are often shown a block page.

## Actor input object example

```json
{
  "mode": "product",
  "asins": [
    "B09B8V1LZ3",
    "B07ZPKN6YR"
  ],
  "urls": [
    "https://www.amazon.com/dp/B0BDHWDR12"
  ],
  "domain": "amazon.com",
  "maxItems": 0,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "mode": "product",
    "asins": [
        "B09B8V1LZ3",
        "B07ZPKN6YR"
    ],
    "urls": [
        "https://www.amazon.com/dp/B0BDHWDR12"
    ],
    "domain": "amazon.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/amazon-products-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 = {
    "mode": "product",
    "asins": [
        "B09B8V1LZ3",
        "B07ZPKN6YR",
    ],
    "urls": ["https://www.amazon.com/dp/B0BDHWDR12"],
    "domain": "amazon.com",
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/amazon-products-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "product",
  "asins": [
    "B09B8V1LZ3",
    "B07ZPKN6YR"
  ],
  "urls": [
    "https://www.amazon.com/dp/B0BDHWDR12"
  ],
  "domain": "amazon.com"
}' |
apify call xtracto/amazon-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=xtracto/amazon-products-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product & Best Sellers Rank Scraper",
        "description": "Track Amazon products from ASINs or URLs: Best Sellers Rank (all ranks), buy-box price and seller, rating, review count, availability and buy-box-competition signal. Built for daily snapshots — spot buy-box hijacks and BSR velocity over time.",
        "version": "0.1",
        "x-build-id": "TDANhzaZFWjNYLidf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~amazon-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-amazon-products-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/xtracto~amazon-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-amazon-products-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/xtracto~amazon-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-amazon-products-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "product"
                        ],
                        "type": "string",
                        "description": "What to scrape. Currently 'product' — fetch full detail for each ASIN or product URL you provide.",
                        "default": "product"
                    },
                    "asins": {
                        "title": "ASINs",
                        "type": "array",
                        "description": "Amazon product IDs (the 10-character code, e.g. B09B8V1LZ3). Add as many as you like. Combine with Product URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Full Amazon product URLs (amazon.com/dp/... or amazon.com/gp/product/...). The product ID is detected automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "domain": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "amazon.com",
                            "amazon.co.uk",
                            "amazon.de"
                        ],
                        "type": "string",
                        "description": "Which Amazon marketplace the products belong to.",
                        "default": "amazon.com"
                    },
                    "maxItems": {
                        "title": "Max products (0 = all)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the number of products scraped this run. 0 = scrape every ASIN/URL provided.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max products in parallel",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many products to fetch at the same time. Lower this if you hit blocks.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Residential proxy strongly recommended — matches the marketplace's country for correct prices and availability (US for amazon.com). Datacenter proxies are often shown a block page.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
