# Amazon Product Scraper: Prices, ASIN & Ratings (`themineworks/amazon-products`) Actor

Scrape Amazon product data by ASIN or keyword: title, price, BSR, rating, seller, features and variants. Multi marketplace. Works as MCP tool in Claude & AI agents.

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

## Pricing

$1.00 / 1,000 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/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 Products Scraper: Price, BSR, Rating & Variants

### Overview

Amazon Products Scraper turns any ASIN or keyword search into clean, structured product JSON: title, price, Best Sellers Rank (BSR), rating, review count, seller, brand, availability, feature bullets, description, images, and optional color and size variants. No Amazon seller account, no SP-API, no login required. Works across 8 Amazon marketplaces.

Amazon's official Selling Partner API requires a registered seller account, app approval, and role authorization before you can read catalog data, and even then it will not hand you a competitor's BSR, buy-box seller, or live variant prices. This actor reads the same public product pages any shopper sees. Point it at ASINs or keywords and get the full product record.

Reliability posture: blocked, empty, or failed runs are never charged. You only pay for a product record that was actually delivered.

✅ No login | ✅ No SP-API approval | ✅ Pay only per product returned | ✅ MCP-ready for AI agents

### Features

ASIN and keyword inputs. Look up specific products or crawl a keyword search result.
8 marketplaces supported. US, UK, DE, FR, JP, IN, CA, AU.
Full product record. Price, BSR, rating, seller, brand, availability, bullets, description, images.
Optional variants. Toggle on to pull every color and size SKU with its own price.
Anti-bot handled. Chromium via Playwright with residential proxy rotation and CAPTCHA retry.

### How it works

The actor drives a full Chromium browser via Playwright with residential proxy rotation, which reliably bypasses PerimeterX. For every ASIN or keyword you provide, it fetches the product or search page, extracts the structured payload Amazon renders to the browser, and emits one record per product. Occasional CAPTCHAs trigger automatic retries with fresh IPs.

You are billed per product returned, at $1 per 1,000 products. Variants are read from the same product page, so enabling `includeVariants` does not raise the per-product charge.

### 🧾 Input configuration

```json
{
  "asins": ["B08N5KWB9H", "B09G9FPHY6"],
  "keywords": ["noise cancelling headphones"],
  "marketplace": "amazon.com",
  "maxProductsPerSearch": 10,
  "includeVariants": false,
  "proxyConfig": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

### 📤 Output format

This is a real record captured from a live run on ASIN `B08N5KWB9H`:

```json
{
  "asin": "B08N5KWB9H",
  "title": "2020 Apple MacBook Air Laptop: Apple M1 Chip, 13” Retina Display, 8GB RAM, 256GB SSD Storage, Backlit Keyboard, FaceTime HD Camera, Touch ID. Works with iPhone/iPad; Silver",
  "rating": 4.8,
  "reviewCount": 13387,
  "brand": "Visit the Apple Store",
  "features": [
    "All-Day Battery Life: go longer than ever with up to 18 hours of battery life.",
    "Powerful Performance: take on everything from professional-quality editing to action-packed gaming with ease.",
    "Stunning Display: with a 13.3 inch Retina display, images come alive with new levels of realism."
  ],
  "images": [
    "https://m.media-amazon.com/images/I/31ilq3hPhEL._AC_.jpg",
    "https://m.media-amazon.com/images/I/41fdD8HKRLL._AC_.jpg"
  ],
  "variants": [],
  "url": "https://www.amazon.com/dp/B08N5KWB9H",
  "charged": false,
  "scraped_at": "2026-07-15T04:21:22.407Z"
}
```

Fields Amazon does not render for a given product (price, BSR, seller, availability, description on some listing layouts) are omitted from that record rather than sent as null or fabricated. `charged` reflects whether that specific product was successfully billed.

Every product record contains these fields:

| Field | Description |
| --- | --- |
| 🆔 `asin` | Amazon product ID. |
| 🏷️ `title` | Full product title. |
| 💵 `price` | Current sale price. |
| 💱 `currency` | Currency symbol ($, £, €, ₹, and so on). |
| 💰 `originalPrice` | List or was-price before discount. |
| 🔻 `discount` | Discount percentage. |
| ⭐ `rating` | Average star rating from 1 to 5. |
| 🗣️ `reviewCount` | Total customer reviews. |
| 📈 `bsr` | Best Sellers Rank (integer). |
| 🗂️ `bsrCategory` | BSR category name. |
| 🏪 `seller` | Sold-by seller name. |
| 🏭 `brand` | Brand name. |
| 📦 `availability` | Stock or shipping status. |
| 📝 `features` | Feature bullet list (array). |
| 📄 `description` | Product description text. |
| 🖼️ `images` | Full-resolution image URLs (array). |
| 🎨 `variants` | Color and size variants with ASINs and prices. |
| 🔗 `url` | Direct product URL. |
| 💳 `charged` | Whether this record was successfully billed (`true`). |
| 🕒 `scraped_at` | ISO-8601 timestamp. |

### 💼 Common use cases

**Product research**
Look up any ASIN in bulk to compare price, rating, and BSR before sourcing or listing. Great for private-label sellers evaluating a niche.

**Price and rank tracking**
Schedule daily runs on a list of ASINs and pipe results to Google Sheets, BigQuery, or a Retool dashboard for a live tracker.

**Competitive intelligence**
Search competitor keywords and grab the top results with BSR and price to spot catalog gaps and pricing whitespace.

**Variant mapping**
Enable `includeVariants` to pull every color and size SKU with its current price, ideal for repricing tools and catalog builders.

**AI product analysis**
Pair with Claude via MCP to ask natural-language questions about any product page. Live pricing and BSR feed straight into the conversation.

### 🚀 Getting started

1. Open Amazon Products Scraper in Apify Console, or call it via API or MCP.
2. Enter ASINs (e.g. `B08N5KWB9H`) or search keywords (e.g. `wireless earbuds`), or both.
3. Pick your Amazon marketplace (default `amazon.com`).
4. Set max products per keyword search, and toggle `includeVariants` if you need every SKU.
5. Click Save & Start, then download the dataset as JSON, CSV, or Excel, or pull via API.

### FAQ

**Do I need an Amazon account or the SP-API?**
No. The scraper reads public product pages, the same data any shopper sees. No seller account, no SP-API approval, no login.

**Does it get past Amazon's anti-bot protection?**
Yes. It drives a full Chromium browser via Playwright with residential proxy rotation, which reliably bypasses PerimeterX. Occasional CAPTCHAs trigger automatic retries with fresh IPs.

**Can I scrape all 8 marketplaces in one run?**
No. One marketplace per run. Start a separate run for each marketplace you need.

**Does including variants cost extra?**
No. Variants are read from the same product page, so the per-product charge is unchanged whether or not variants are included.

**How is it priced?**
Pay-per-result. You are charged per product returned, at $1 per 1,000 products. You pay only for products actually delivered.

### Use in Claude, ChatGPT & any MCP agent

```
https://mcp.apify.com/?tools=themineworks/amazon-products
```

Or call it from code with the Apify client:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/amazon-products').call({
  asins: ['B08N5KWB9H'],
  marketplace: 'amazon.com',
  includeVariants: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

### 🛠️ Complete your Amazon research pipeline

Pair with the rest of the suite for a full Amazon intelligence stack:

- **[Amazon Reviews Scraper](https://apify.com/themineworks/amazon-reviews)**: ratings, review text, and verified-purchase badges by ASIN.
- **[YouTube Channel Scraper](https://apify.com/themineworks/youtube-channel)**: subscribers, video list, and channel stats, no API key.
- **[YouTube Transcript Scraper](https://apify.com/themineworks/youtube-transcript-scraper)**: timestamped captions as clean JSON for RAG and LLMs.

Found a bug or have a feature request? Open an issue on the actor's Apify Console page or reach out through the Apify profile.

# Actor input Schema

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

List of Amazon ASINs (product IDs) to scrape. E.g. \["B08N5KWB9H"]

## `keywords` (type: `array`):

Keywords to search on Amazon. Returns top products per keyword.

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

Amazon marketplace domain to scrape

## `maxProductsPerSearch` (type: `integer`):

Maximum number of products to return per keyword search

## `includeVariants` (type: `boolean`):

Extract color/size variants and their prices

## `proxyConfig` (type: `object`):

Residential proxy strongly recommended for Amazon

## Actor input object example

```json
{
  "asins": [
    "B08N5KWB9H"
  ],
  "keywords": [],
  "marketplace": "amazon.com",
  "maxProductsPerSearch": 3,
  "includeVariants": false,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "asins": [
        "B08N5KWB9H"
    ],
    "keywords": [],
    "maxProductsPerSearch": 3,
    "includeVariants": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/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 = {
    "asins": ["B08N5KWB9H"],
    "keywords": [],
    "maxProductsPerSearch": 3,
    "includeVariants": False,
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/amazon-products").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 '{
  "asins": [
    "B08N5KWB9H"
  ],
  "keywords": [],
  "maxProductsPerSearch": 3,
  "includeVariants": false
}' |
apify call themineworks/amazon-products --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Scraper: Prices, ASIN & Ratings",
        "description": "Scrape Amazon product data by ASIN or keyword: title, price, BSR, rating, seller, features and variants. Multi marketplace. Works as MCP tool in Claude & AI agents.",
        "version": "0.1",
        "x-build-id": "SdYteGvq34Y4JdvKA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/themineworks~amazon-products/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-themineworks-amazon-products",
                "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/themineworks~amazon-products/runs": {
            "post": {
                "operationId": "runs-sync-themineworks-amazon-products",
                "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/themineworks~amazon-products/run-sync": {
            "post": {
                "operationId": "run-sync-themineworks-amazon-products",
                "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": {
                    "asins": {
                        "title": "ASINs",
                        "type": "array",
                        "description": "List of Amazon ASINs (product IDs) to scrape. E.g. [\"B08N5KWB9H\"]",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search on Amazon. Returns top products per keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "marketplace": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "amazon.com",
                            "amazon.co.uk",
                            "amazon.de",
                            "amazon.fr",
                            "amazon.co.jp",
                            "amazon.in",
                            "amazon.ca",
                            "amazon.com.au"
                        ],
                        "type": "string",
                        "description": "Amazon marketplace domain to scrape",
                        "default": "amazon.com"
                    },
                    "maxProductsPerSearch": {
                        "title": "Max products per keyword search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of products to return per keyword search",
                        "default": 20
                    },
                    "includeVariants": {
                        "title": "Include product variants",
                        "type": "boolean",
                        "description": "Extract color/size variants and their prices",
                        "default": false
                    },
                    "proxyConfig": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy strongly recommended for Amazon",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
