# Amazon Reviews Scraper - Ratings, Text, Verified Purchases (`thirdwatch/amazon-reviews-scraper`) Actor

Scrape written Amazon product reviews by ASIN or URL. Get ratings, titles, text, authors, dates, verified-purchase and Vine labels, helpful votes, images, media, and review links. Best coverage on Amazon US.

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

## Pricing

from $0.50 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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 Reviews Scraper — Ratings, Text & Verified Purchases

> Scrape Amazon product reviews by ASIN or product URL and export ratings, review text, authors, dates, verified-purchase status, helpful votes, images, and Vine labels.

### What you get from the Amazon Reviews Scraper

Turn written Amazon customer reviews into analysis-ready rows without copying pages by hand or connecting an Amazon account. Add one or many Amazon product URLs or ASINs, choose the review order and result limit, and download the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

Amazon US is the recommended market and can return hundreds of written reviews for products with enough review volume. The Actor deduplicates reviews automatically when multiple review feeds overlap.

#### Quick start

1. Add Amazon product URLs or 10-character ASINs.
2. Keep **United States** selected for the broadest reliable coverage.
3. Choose **Most Recent** or **Most Helpful**.
4. Set the maximum reviews per product and click **Start**.
5. Open the dataset to filter, export, schedule, or connect the results to another workflow.

### Amazon review output fields

| Field | Description |
|---|---|
| `review_id` | Stable review identifier when the source provides one |
| `asin` | Amazon Standard Identification Number for the product |
| `country` | Selected Amazon market code |
| `rating` | Review rating from 1 to 5 |
| `title` | Review headline |
| `text` | Full written review text |
| `author` | Public reviewer display name |
| `date` | Public review date or date label |
| `verified_purchase` | Whether Amazon marks the review as a verified purchase |
| `vine_review` | Whether the review is marked as an Amazon Vine review, when available |
| `helpful_votes` | Numeric helpful-vote count, when available |
| `helpful_votes_text` | Original helpful-vote label, when available |
| `image_urls` | Images attached to the review, when available |
| `media_urls` | Other media attached to the review, when available |
| `url` | Amazon product or review URL |
| `source` | Public source label for the review record, when available |

Fields can be empty when a reviewer did not provide that information or the selected Amazon market does not expose it publicly.

### Example Amazon review output

```json
{
  "review_id": "R2X9P4M7K3L8Q1",
  "asin": "B0D1XD1ZV3",
  "country": "us",
  "rating": 5,
  "title": "Comfortable and easy to use",
  "text": "Setup took only a few minutes and the product has worked reliably every day.",
  "author": "Morgan",
  "date": "Reviewed in the United States on June 18, 2026",
  "verified_purchase": true,
  "vine_review": false,
  "helpful_votes": 7,
  "image_urls": [],
  "media_urls": [],
  "url": "https://www.amazon.com/dp/B0D1XD1ZV3",
  "source": "woot-amazon-reviews"
}
````

### Amazon Reviews Scraper input parameters

| Parameter | Required | Default | Description |
|---|---:|---|---|
| `productUrlsOrAsins` | Yes | Example ASIN | Amazon product URLs or 10-character ASINs. Multiple products can be processed in one run. |
| `country` | No | `us` | Amazon market: `us`, `uk`, `in`, `de`, `fr`, `es`, `it`, `ca`, `jp`, `au`, `ae`, or `sa`. US provides the strongest coverage. |
| `maxReviewsPerProduct` | No | `25` | Maximum written review rows per product. Accepts 1–700. |
| `sortBy` | No | `recent` | Review order: `recent` or `helpful`. |
| `proxyConfiguration` | No | Preconfigured | Connection settings used for non-US Amazon markets. Most users should keep the default. |

#### Example input

```json
{
  "productUrlsOrAsins": [
    "B0D1XD1ZV3",
    "https://www.amazon.com/dp/B09V3KXJPB"
  ],
  "country": "us",
  "maxReviewsPerProduct": 100,
  "sortBy": "recent"
}
```

### Amazon review data use cases

- **Brand and product teams:** Find recurring complaints, feature requests, and product strengths.
- **Marketplace sellers:** Compare customer experience across your catalog and competing ASINs.
- **Market researchers:** Build review corpora for category, positioning, and trend analysis.
- **Data and AI teams:** Feed written feedback into sentiment analysis, topic modeling, or classification pipelines.
- **Customer-experience teams:** Schedule recurring runs to monitor newly posted reviews.

### Amazon Reviews Scraper limitations

- Amazon US provides the recommended and most complete no-login path. Other storefronts are best effort because anonymous review availability varies by market.
- The Actor returns written reviews, not star-only ratings. Amazon's displayed rating count can therefore be higher than the number of available review records.
- A product may return fewer rows than requested when fewer written reviews are publicly available.
- Review author names are public display names. Handle personal data lawfully and only for a legitimate purpose.
- Amazon can change public availability without notice; retry later if a normally accessible product temporarily returns no reviews.

### Compared to other Amazon review scrapers

- Compared with `crawlerbros/amazon-reviews-scraper`, this Actor can retrieve substantially more than the small inline-review sample for supported Amazon US products and does not require users to configure residential access for the recommended US mode.
- Compared with broader Amazon product crawlers, this Actor is focused on written review analysis, including verified-purchase, Vine, helpful-vote, and attached-media fields where available.
- If you need prices, offers, availability, and product specifications rather than review text, use [Amazon Product Scraper](https://apify.com/thirdwatch/amazon-product-scraper).

### Amazon Reviews Scraper FAQ

#### Can I scrape Amazon reviews using only an ASIN?

Yes. Add a 10-character ASIN to `productUrlsOrAsins`; a full product URL is not required.

#### Does it scrape verified-purchase reviews?

Yes. Each result includes `verified_purchase` when that label is publicly available. The Actor does not filter exclusively to verified purchases.

#### Can it scrape reviews from multiple Amazon products?

Yes. Add multiple URLs or ASINs to the same run. `maxReviewsPerProduct` is applied separately to every product.

#### Why are there fewer reviews than Amazon's rating count?

Amazon combines written reviews and star-only ratings in its headline count. This Actor returns written review records, so the totals are not expected to match.

#### Can I schedule Amazon review monitoring?

Yes. Use an Apify schedule to run the Actor daily, weekly, or monthly, then send new datasets through webhooks or integrations.

#### Can I use the results through an API?

Yes. Every run produces a default dataset accessible through the Apify API, JavaScript and Python clients, webhooks, Make, Zapier, and other Apify integrations.

### Related Thirdwatch Actors

- [Amazon Product Scraper](https://apify.com/thirdwatch/amazon-product-scraper) — prices, ratings, availability, and product details
- [Shopify Reviews Scraper](https://apify.com/thirdwatch/shopify-reviews-scraper) — product reviews from Shopify stores
- [Google Maps Reviews Scraper](https://apify.com/thirdwatch/google-maps-reviews-scraper) — local business review data

Explore more data tools from [Thirdwatch](https://thirdwatch.dev/).

**Last verified: 2026-07**

# Actor input Schema

## `productUrlsOrAsins` (type: `array`):

Amazon product URLs or 10-character ASINs to collect reviews from.

## `country` (type: `string`):

Amazon country storefront.

## `maxReviewsPerProduct` (type: `integer`):

Maximum review rows returned for each ASIN.

## `sortBy` (type: `string`):

Order reviews by helpfulness or recency.

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

Connection settings for non-US storefronts. Keep the default unless you have a custom routing requirement.

## Actor input object example

```json
{
  "productUrlsOrAsins": [
    "B0D1XD1ZV3"
  ],
  "country": "us",
  "maxReviewsPerProduct": 25,
  "sortBy": "recent",
  "proxyConfiguration": {
    "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 = {
    "productUrlsOrAsins": [
        "B0D1XD1ZV3"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/amazon-reviews-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 = { "productUrlsOrAsins": ["B0D1XD1ZV3"] }

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/amazon-reviews-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 '{
  "productUrlsOrAsins": [
    "B0D1XD1ZV3"
  ]
}' |
apify call thirdwatch/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Reviews Scraper - Ratings, Text, Verified Purchases",
        "description": "Scrape written Amazon product reviews by ASIN or URL. Get ratings, titles, text, authors, dates, verified-purchase and Vine labels, helpful votes, images, media, and review links. Best coverage on Amazon US.",
        "version": "1.1",
        "x-build-id": "9y0GwJ2aG4jzR26db"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thirdwatch~amazon-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thirdwatch-amazon-reviews-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/thirdwatch~amazon-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thirdwatch-amazon-reviews-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/thirdwatch~amazon-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thirdwatch-amazon-reviews-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",
                "required": [
                    "productUrlsOrAsins"
                ],
                "properties": {
                    "productUrlsOrAsins": {
                        "title": "Product URLs or ASINs",
                        "type": "array",
                        "description": "Amazon product URLs or 10-character ASINs to collect reviews from.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Amazon Market",
                        "enum": [
                            "us",
                            "uk",
                            "in",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "ca",
                            "jp",
                            "au",
                            "ae",
                            "sa"
                        ],
                        "type": "string",
                        "description": "Amazon country storefront.",
                        "default": "us"
                    },
                    "maxReviewsPerProduct": {
                        "title": "Maximum Reviews per Product",
                        "minimum": 1,
                        "maximum": 700,
                        "type": "integer",
                        "description": "Maximum review rows returned for each ASIN.",
                        "default": 25
                    },
                    "sortBy": {
                        "title": "Sort Reviews",
                        "enum": [
                            "recent",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Order reviews by helpfulness or recency.",
                        "default": "recent"
                    },
                    "proxyConfiguration": {
                        "title": "Connection Settings",
                        "type": "object",
                        "description": "Connection settings for non-US storefronts. Keep the default unless you have a custom routing requirement.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
