# Amazon Product & Seller Scraper (`wilcode/amazon-scraper`) Actor

Scrape Amazon products, prices & sellers fast. Extract titles, images, specs, variant prices, stock status & ASINs, or a seller's full catalog, across 22 Amazon marketplaces

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

## Pricing

from $6.00 / 1,000 products

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 & Seller Scraper

Scrape Amazon **product details**, **variant prices**, and **seller storefront listings** across 22 marketplaces - no Amazon account, login, or API key required.

Use it to track competitor prices, research products before sourcing, build a product database, or monitor everything a specific seller or brand has listed - across marketplaces including the US, UK, Germany, France, Japan, Canada, Australia, UAE, India, and more.

### What is Amazon Product & Seller Scraper and how does it work?

Amazon Product & Seller Scraper is a web scraping tool that extracts data from Amazon using product URLs, bare ASINs, or seller/brand storefront URLs - no category browsing required.

It runs in one of three modes, picked via the **Mode** input:

| Mode | Input used | Output |
|------|-----------|--------|
| `product` | `productUrls` and/or `asins` | One row per product with full details |
| `prices` | `asins` + `domain` | One row per ASIN: price + availability |
| `sellerProducts` | `sellerUrls` | One row per product found in the listing |

Just paste one or more URLs (or ASINs) into the matching input field, pick a mode, and start the run. Results land in the dataset and can be downloaded as JSON/CSV/Excel, or pulled via the Apify API without ever opening the platform UI.

For a full field-by-field breakdown, see the **Input** tab.

### Why scrape Amazon products?

Scraping Amazon can help you:

➡️ **Monitor competitor prices** daily or hourly without manually checking listings.

➡️ **Research products before sourcing** - specs, images, and pricing in one structured row.

➡️ **Track a seller or brand's entire catalog** - everything they currently have listed, and at what price.

➡️ **Feed a product database or repricing tool** with clean, structured data instead of scraped HTML.

### How much will scraping Amazon products cost?

This actor uses Apify's **pay-per-event** pricing - you're charged only for data actually returned, not for compute time:

| Event | Price | Fires when |
|-------|-------|------------|
| Product scraped | $0.008 | A product is successfully scraped in `product` mode |
| Price checked | $0.0015 | An ASIN gets a successful price/availability lookup in `prices` mode |
| Seller product listed | $0.005 | A product row is returned from a seller listing in `sellerProducts` mode |

Failed items (a 404 product, a blocked page, an invalid URL) are **never charged** - you only pay for rows that actually made it into your dataset. `prices` mode is the cheapest way to keep tabs on a large ASIN list; `product` mode costs more because it returns full page detail.

Run a small test batch first to get your actual per-item cost, then multiply by your expected volume.

### Is it legal to scrape Amazon?

Yes - scraping publicly available data such as product titles, prices, specifications, or seller listings is legal. This actor only reads pages a normal shopper can already see; it doesn't log in, bypass paywalls, or access private data. Use the data responsibly and in line with Amazon's own terms for your use case.

### Modes

#### 1. Product details

```json
{
  "mode": "product",
  "productUrls": [{ "url": "https://www.amazon.co.uk/dp/B0CDTV2WH4" }],
  "fetchPrices": true
}
```

Output (abridged):

```json
{
  "success": true,
  "title": "SanDisk Professional 8TB G-Drive Project",
  "asinDetails": { "asin": "B0CDTV2WH4", "parentAsin": "B0CJ9LC292", "asinList": "B0CDTV2WH4,B0CDTVYGWR" },
  "price": 129.99,
  "currency": "GBP",
  "availability": true,
  "images": ["https://m.media-amazon.com/images/I/71main1.jpg"],
  "productDescriptionImages": ["https://m.media-amazon.com/images/S/aplus-media/desc1.jpg"],
  "features": ["Up to 22TB of space"],
  "productOverview": [{ "name": "Brand", "value": "SanDisk" }],
  "productInformation": [{ "name": "Package Dimensions", "value": "12.99 x 10.71 inches" }],
  "variantOptions": [{ "name": "Capacity", "values": ["6 TB", "8 TB"] }],
  "variants": [
    {
      "asin": "B0CDTV2WH4",
      "name": "8 TB",
      "isAvailable": true,
      "price": 129.99,
      "currency": "GBP",
      "image": "https://m.media-amazon.com/images/I/71black.jpg",
      "optionValues": [{ "name": "Capacity", "value": "8 TB" }]
    }
  ]
}
```

Currency always follows the product's own marketplace/domain - no manual override needed.

Best for: full listings you need to research, compare, or re-list elsewhere.

#### 2. Prices only

Give it a list of ASINs and a marketplace, get back price and stock status for each. This is the fastest and cheapest mode - perfect for checking prices on many products every day.

**Example input:**

```json
{
  "mode": "prices",
  "asins": ["B0CDTV2WH4", "B0CDTVYGWR"],
  "domain": "amazon.co.uk"
}
```

**Example output:**

```json
{ "asin": "B0CDTV2WH4", "isAvailable": true, "price": 129.99, "currency": "GBP", "domain": "amazon.co.uk" }
```

Every ASIN you ask for is always returned, even if a price couldn't be found - so you can always tell "no data" apart from "out of stock."

#### 3. Seller products

```json
{
  "mode": "sellerProducts",
  "sellerUrls": [{ "url": "https://www.amazon.com/sp?seller=AJL778CIT9231" }],
  "allPages": true,
  "maxPages": 5
}
```

Supported seller URL formats:

- `https://www.amazon.com/s?me=SELLER_ID&marketplaceID=ATVPDKIKX0DER`
- `https://www.amazon.com/sp?seller=SELLER_ID`
- `https://www.amazon.com/s?me=SELLER_ID`

Each result includes the product's title, ASIN, image, price, rating, review count, and Prime status.

Best for: tracking a competitor's or a brand's full catalog.

### Why choose this actor

- **No technical skill needed** - just paste links or product codes.
- **Accurate by country** - prices, currency, and stock status always match the marketplace you selected.
- **Resilient to blocking** - built-in residential proxy support and automatic retries on a fresh proxy keep runs stable even at high volume.
- **Pay only for results** - pay-per-event pricing means failed items cost nothing.

### Suggested use cases

- **Competitor price monitoring** - run "Prices only" daily against your watch list to catch price changes as they happen.
- **Sourcing research** - use "Product details" to review images, specs, and pricing of similar products before you buy.
- **Brand/seller tracking** - use "Seller products" to see everything a competitor or supplier currently has listed, and at what price.

### Supported marketplaces

`amazon.com` (USD), `amazon.co.uk` (GBP), `amazon.de` / `amazon.fr` / `amazon.it` / `amazon.es` / `amazon.nl` / `amazon.com.be` (EUR), `amazon.pl` (PLN), `amazon.se` (SEK), `amazon.ca` (CAD), `amazon.com.mx` (MXN), `amazon.com.br` (BRL), `amazon.com.au` (AUD), `amazon.co.jp` (JPY), `amazon.in` (INR), `amazon.sg` (SGD), `amazon.ae` (AED), `amazon.sa` (SAR), `amazon.eg` (EGP), `amazon.co.za` (ZAR), `amazon.com.tr` (TRY).

### Error items

When a target can't be scraped - a 404 product page, a blocked/unavailable page, an invalid seller URL - the actor pushes an error row instead of silently skipping it, and **does not charge** for it. You can tell error rows apart from real results by `"success": false`.

```json
{
  "success": false,
  "url": "https://www.amazon.com/dp/B0XXXXXXXX",
  "error": "Product not found. The URL is invalid or the item was removed."
}
```

Common error messages:

- `Product not found. The URL is invalid or the item was removed.`
- `Failed to scrape product. The page may be blocked or unavailable.`
- `Failed to scrape seller page. It may be blocked or unavailable.`
- `Unsupported Amazon domain: <domain>`

In `prices` mode, an ASIN whose lookup couldn't be completed still gets its own row, with `price`/`isAvailable` set to `null` rather than being dropped - so you can distinguish "no data" from genuinely out of stock.

### Tips for best results

- Enable residential proxies for the most stable and accurate results, especially on larger runs - Amazon blocks datacenter traffic aggressively.
- Every product, ASIN, or seller URL you request is always accounted for in the output - if something couldn't be fetched, it's clearly marked instead of silently missing, so you can easily spot and retry it.
- Intended for collecting publicly available Amazon data for legitimate research and business purposes.

### Using Amazon Product & Seller Scraper with the Apify API

The Apify API gives you programmatic access to this actor - start runs, poll status, and fetch dataset results without opening the Apify Console. Use the [`apify-client`](https://www.npmjs.com/package/apify-client) NPM package from Node.js, or the [`apify-client`](https://pypi.org/project/apify-client/) PyPI package from Python. See the **API** tab for ready-to-run code snippets in your language of choice.

### Integrations

This actor can be connected to almost any cloud service or app through Apify's integrations - Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and more - or wired up with webhooks to trigger an action whenever a run finishes.

### Your feedback

We're always working on improving this actor. If you've got technical feedback or found a bug, please open an issue on the actor's **Issues** tab in Apify Console.

# Actor input Schema

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

What to scrape.

- **Product details** — full product data (title, images, features, specs, price, variants) from product URLs or ASINs.
- **Prices only** — price + availability per ASIN via Amazon's twister API. Much faster and cheaper than full product scraping.
- **Seller products** — the product listing of a seller/brand storefront.

## `productUrls` (type: `array`):

Amazon product page URLs (/dp/, /gp/product/, /gp/aw/d/). Used in **Product details** mode.

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

Bare 10-character ASINs, resolved against the **Amazon domain** below. Required in **Prices only** mode; optional in **Product details** mode (in addition to, or instead of, product URLs).

## `sellerUrls` (type: `array`):

Amazon seller storefront URLs. Used in **Seller products** mode. Supported formats:

- `https://www.amazon.com/s?me=SELLER_ID&marketplaceID=ATVPDKIKX0DER`
- `https://www.amazon.com/sp?seller=SELLER_ID`
- `https://www.amazon.com/s?me=SELLER_ID`

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

The Amazon marketplace used for bare ASINs and for **Prices only** mode. Also decides the default currency.

## `fetchPrices` (type: `boolean`):

In **Product details** mode, also call Amazon's twister API for each variant's price and availability. Only runs for products that really have variants (more than one ASIN) — single-ASIN products already carry price data from their page. Costs extra requests.

## `maxAsins` (type: `integer`):

Cap on how many ASINs (and variants) one product may return. `0` = unlimited. When capped, a greedy pass keeps at least one variant per option value (each Size, each Color), and the requested ASIN is always kept.

## `page` (type: `integer`):

Which page of seller results to fetch. Ignored when **Scrape all pages** is on.

## `allPages` (type: `boolean`):

Walk every page of the seller's listing, up to **Max pages**.

## `maxPages` (type: `integer`):

Safety limit for **Scrape all pages** (hard cap: 20).

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

Amazon blocks datacenter and direct traffic aggressively — **residential proxies are strongly recommended**. Each retry automatically uses a fresh proxy session. You may also supply your own proxy URLs instead of Apify Proxy.

## `maxRequestRetries` (type: `integer`):

Retries per page fetch, each on a fresh proxy. A blocked page, a failed request, or a page that loaded with missing variants all trigger a retry.

## Actor input object example

```json
{
  "mode": "product",
  "productUrls": [
    {
      "url": "https://www.amazon.com/dp/B0CDTV2WH4"
    }
  ],
  "domain": "amazon.com",
  "fetchPrices": false,
  "maxAsins": 100,
  "page": 1,
  "allPages": false,
  "maxPages": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxRequestRetries": 3
}
```

# Actor output Schema

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

Product details, prices, or seller-listing rows depending on the run's mode. See the dataset schema for field-level detail.

# 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 = {
    "productUrls": [
        {
            "url": "https://www.amazon.com/dp/B0CDTV2WH4"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("wilcode/amazon-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 = {
    "productUrls": [{ "url": "https://www.amazon.com/dp/B0CDTV2WH4" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("wilcode/amazon-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 '{
  "productUrls": [
    {
      "url": "https://www.amazon.com/dp/B0CDTV2WH4"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call wilcode/amazon-scraper --silent --output-dataset

```

## MCP server setup

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