# Amazon Product & Reviews Scraper (`dami_studio/amazon-scraper`) Actor

Scrape Amazon product details (title, price, rating, review count, bullets, hi-res images), search results, and on-page top reviews from server-rendered HTML. No login, no key. Give ASINs for product+reviews or queries for paginated listings. 7 marketplaces.

- **URL**: https://apify.com/dami\_studio/amazon-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** E-commerce, Integrations, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 product returneds

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 Product & Reviews Scraper

Scrape Amazon product details, search-result listings, and on-page top customer
reviews from server-rendered HTML. No login and no API key required. Give the
actor a list of **ASINs** for full product details + reviews, or a list of
**search queries** for paginated result listings. Supports 7 marketplaces
(`com`, `co.uk`, `de`, `fr`, `it`, `es`, `ca`), and forces each marketplace's
native currency/language via an i18n cookie so prices come back consistently.

### What it does

- **ASIN / product mode** — for each ASIN, returns title, price, currency,
  rating, review count, brand, availability, feature bullets, **hi-res images**,
  and the top reviews embedded in the product page.
- **Search mode** — for each query, paginates through Amazon's result pages
  (up to `maxItems`) and returns asin, title, price, currency, rating,
  reviewCount, a **thumbnail image (~200px)**, sponsored flag, and url.

### Input

```json
{
  "asins": ["B0BS1PRC4L"],
  "searchQueries": ["wireless earbuds"],
  "domain": "com",
  "maxItems": 50,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

Provide `asins`, `searchQueries`, or both. At least one is required — an empty
input returns an uncharged `BAD_INPUT` diagnostic row (it does not crash the run).

Residential proxies are strongly recommended: Amazon captcha-checks datacenter
IPs quickly. Use a proxy country matched to the marketplace (e.g. US residential
for `amazon.com`).

### Sample output

Product row (ASIN mode):

```json
{
  "ok": true,
  "type": "product",
  "asin": "B0BS1PRC4L",
  "url": "https://www.amazon.com/dp/B0BS1PRC4L",
  "title": "Example Wireless Earbuds",
  "price": "$49.99",
  "currency": "USD",
  "rating": "4.5",
  "reviewCount": "1,234 ratings",
  "brand": "ExampleBrand",
  "availability": "In Stock",
  "featureBullets": ["40h battery life", "IPX5 water resistant"],
  "images": ["https://m.media-amazon.com/images/I/hi-res-1.jpg"],
  "reviews": [
    { "id": "R1", "author": "Jane", "rating": "5.0", "title": "Great", "date": "...", "verifiedPurchase": true, "helpfulVotes": "3 people found this helpful", "body": "..." }
  ],
  "reviewsParsed": 1
}
```

Search row (search mode):

```json
{
  "ok": true,
  "type": "search",
  "query": "wireless earbuds",
  "asin": "B0XXXXXXXX",
  "title": "Example Wireless Earbuds",
  "price": "$49.99",
  "currency": "USD",
  "rating": "4.5",
  "reviewCount": "1,234",
  "images": ["https://m.media-amazon.com/images/I/thumb-200px.jpg"],
  "sponsored": false,
  "url": "https://www.amazon.com/dp/B0XXXXXXXX"
}
```

Both modes expose images as an **`images` array** so the output schema is uniform
downstream. The difference is content: product mode yields hi-res image URLs,
search mode yields a single ~200px thumbnail URL.

#### Nullable fields

These fields can be `null`/empty when Amazon does not render them for a given
product or listing: `price`, `rating`, `reviewCount`, `brand`, `availability`,
`images` (empty array), and `reviews` (empty array). Plan downstream pipelines
to tolerate nulls.

### Pricing

Pay-per-result: you are charged once per successfully parsed product/search row
(`ok: true`). **Blocked, failed, truncated, or empty results are never charged** —
those come back as `ok: false` diagnostic rows with an `errorCode`
(`BLOCKED`, `RATE_LIMITED`, `SERVER_ERROR`, `NETWORK`, `NO_RESULTS`, `BAD_INPUT`).

### Troubleshooting

- **`BLOCKED` / robot check** — Amazon served a captcha/robot-check page. Use a
  residential proxy (or one in the marketplace's country) and retry. Datacenter
  IPs get blocked quickly.
- **Truncated search results** — if a later page (page 2+) is blocked mid-run,
  the actor returns the rows it already collected and adds a diagnostic row
  explaining the truncation. Add/rotate a residential proxy and retry for the
  full set.
- **`NO_RESULTS`** — the page loaded but nothing matched your input; check the
  ASIN/query and the selected `domain`.
- **`BAD_INPUT`** — you provided neither ASINs nor search queries.

# Actor input Schema

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

List of Amazon ASINs (10-character product IDs, e.g. B0BS1PRC4L) to scrape. Each ASIN returns full product details (including hi-res images) plus the on-page top customer reviews. Individual fields (price, rating, reviewCount, brand, availability, images, reviews) can be null/empty when Amazon does not render them on the page. Find the ASIN in a product URL: amazon.com/dp/<ASIN>. Leave empty if you only want search results.

## `searchQueries` (type: `array`):

List of search terms (e.g. "wireless earbuds", "4k monitor") to scrape from Amazon search result pages. Each query returns products with asin, title, price, rating, reviewCount, url and an images array, paginated until maxItems is reached. Note: search-mode images contain only a small (~200px) thumbnail URL — product/ASIN mode returns hi-res images. Fields like price, rating and reviewCount can be null when Amazon omits them for a listing. Leave empty if you only want product details by ASIN.

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

Which Amazon marketplace (TLD) to scrape. The matching i18n preference cookie is sent automatically to force the marketplace's native currency and language so prices come back consistently (instead of being geo-priced by the proxy exit IP).

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

Maximum number of search result products to return per search query. The actor paginates through ?page=N until this many products are collected or the results run out. Ignored in ASIN-only mode.

## `notionConnector` (type: `string`):

Optional. Write each product as a page into your Notion when the run finishes. Authorize a Notion connector once in Settings → API & Integrations → MCP connectors, then pick it here. Leave empty to skip (default) — results are always saved to the dataset regardless.

## `notionParentId` (type: `string`):

Optional. The Notion data source ID of the database to write into (only used if a Notion connector is set). Leave empty to create the pages privately in your workspace instead.

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

Proxy used for all Amazon requests. Residential proxies are strongly recommended — datacenter IPs get captcha'd / robot-checked quickly. Use a proxy country matched to the marketplace (e.g. US residential for amazon.com).

## Actor input object example

```json
{
  "asins": [
    "B0BS1PRC4L"
  ],
  "searchQueries": [
    "wireless earbuds"
  ],
  "domain": "com",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Scraped rows are stored in the default dataset (one row per result). Blocked/empty/error runs return a single uncharged diagnostic row instead.

# 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": [
        "B0BS1PRC4L"
    ],
    "searchQueries": [
        "wireless earbuds"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/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 = {
    "asins": ["B0BS1PRC4L"],
    "searchQueries": ["wireless earbuds"],
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/amazon-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 '{
  "asins": [
    "B0BS1PRC4L"
  ],
  "searchQueries": [
    "wireless earbuds"
  ]
}' |
apify call dami_studio/amazon-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product & Reviews Scraper",
        "description": "Scrape Amazon product details (title, price, rating, review count, bullets, hi-res images), search results, and on-page top reviews from server-rendered HTML. No login, no key. Give ASINs for product+reviews or queries for paginated listings. 7 marketplaces.",
        "version": "0.1",
        "x-build-id": "b6204SvBlg1ZYJHcW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dami_studio~amazon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dami_studio-amazon-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/dami_studio~amazon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dami_studio-amazon-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/dami_studio~amazon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dami_studio-amazon-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": {
                    "asins": {
                        "title": "ASINs (product mode)",
                        "type": "array",
                        "description": "List of Amazon ASINs (10-character product IDs, e.g. B0BS1PRC4L) to scrape. Each ASIN returns full product details (including hi-res images) plus the on-page top customer reviews. Individual fields (price, rating, reviewCount, brand, availability, images, reviews) can be null/empty when Amazon does not render them on the page. Find the ASIN in a product URL: amazon.com/dp/<ASIN>. Leave empty if you only want search results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries (search mode)",
                        "type": "array",
                        "description": "List of search terms (e.g. \"wireless earbuds\", \"4k monitor\") to scrape from Amazon search result pages. Each query returns products with asin, title, price, rating, reviewCount, url and an images array, paginated until maxItems is reached. Note: search-mode images contain only a small (~200px) thumbnail URL — product/ASIN mode returns hi-res images. Fields like price, rating and reviewCount can be null when Amazon omits them for a listing. Leave empty if you only want product details by ASIN.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "domain": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "com",
                            "co.uk",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "ca"
                        ],
                        "type": "string",
                        "description": "Which Amazon marketplace (TLD) to scrape. The matching i18n preference cookie is sent automatically to force the marketplace's native currency and language so prices come back consistently (instead of being geo-priced by the proxy exit IP).",
                        "default": "com"
                    },
                    "maxItems": {
                        "title": "Max items (search mode)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of search result products to return per search query. The actor paginates through ?page=N until this many products are collected or the results run out. Ignored in ASIN-only mode.",
                        "default": 50
                    },
                    "notionConnector": {
                        "title": "Notion connector (optional)",
                        "type": "string",
                        "description": "Optional. Write each product as a page into your Notion when the run finishes. Authorize a Notion connector once in Settings → API & Integrations → MCP connectors, then pick it here. Leave empty to skip (default) — results are always saved to the dataset regardless."
                    },
                    "notionParentId": {
                        "title": "Notion target data source ID",
                        "type": "string",
                        "description": "Optional. The Notion data source ID of the database to write into (only used if a Notion connector is set). Leave empty to create the pages privately in your workspace instead."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy used for all Amazon requests. Residential proxies are strongly recommended — datacenter IPs get captcha'd / robot-checked quickly. Use a proxy country matched to the marketplace (e.g. US residential for amazon.com).",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
