# Amazon Reviews Scraper - Ratings, Review Text + Images (`convertfleetdotonline/amazon-reviews-scraper`) Actor

Amazon reviews scraper - extract product reviews by ASIN or URL: star rating, title, review text, date, verified-purchase flag and images. Analyze sentiment and monitor competitors. No API key. Export CSV, JSON or Excel.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

Scrape and download detailed reviews from any Amazon product **without using the Amazon API**. Extract the rating score, review title and description, reviewer name, review date, verified-purchase badge, helpful votes (reactions) and review images. Download your data as JSON, CSV, Excel, XML or an HTML table straight from the dataset tab.

Works with any Amazon marketplace: amazon.com, amazon.co.uk, amazon.de, amazon.fr, amazon.it, amazon.es, amazon.ca, amazon.com.au and more.

### What data does it extract?

For every product you also get a summary record with the product title, average star rating, total number of ratings and the star-rating histogram (% of 5★ / 4★ / 3★ / 2★ / 1★).

For every review:

| Field | Description |
|---|---|
| `rating` | Star rating of the review (1–5) |
| `title` | Review headline |
| `text` | Full review description |
| `date` / `location` | Review date and reviewer country |
| `reviewer_name` / `reviewer_profile` | Reviewer display name and profile URL |
| `verified_purchase` | Whether Amazon marked it as a Verified Purchase |
| `helpful_votes` | Number of "people found this helpful" reactions |
| `images` | Full-size URLs of photos attached to the review |
| `variant` | Purchased variant (color, size, style...) |
| `review_url` | Direct link to the review |

### Input

```json
{
  "productUrls": ["https://www.amazon.com/dp/B09B8V1LZ3"],
  "maxReviews": 50,
  "sortBy": "recent",
  "filterByStar": "all_stars",
  "verifiedOnly": false
}
````

You can paste full product URLs (`/dp/...`, `/gp/product/...`, `/product-reviews/...`) or bare 10-character ASINs.

### Important: how many reviews can it get?

Since late 2024 Amazon requires a **signed-in session** to browse the full paginated review history. This scraper handles both situations:

- **Without cookies** (default) — it extracts the top reviews Amazon shows on the product page (usually 8–10 per product) plus the complete rating summary and histogram.
- **With cookies** — paste the `Cookie` header from a logged-in Amazon browser session into the `cookies` input and the scraper paginates the full review history up to `maxReviews` (sorting and star filters are applied by Amazon itself).

To copy your cookies: open amazon.com logged in → DevTools → Network tab → click any request → copy the value of the `cookie` request header.

### Proxy

The actor uses Apify Proxy (datacenter) by default and automatically falls back to a direct connection or a stealth browser when Amazon serves a robot check. If your plan includes residential proxies, selecting the `RESIDENTIAL` group in `proxyConfiguration` gives the most reliable results.

### FAQ

**Is scraping Amazon reviews legal?** The actor only extracts publicly available data. Be mindful of personal data (reviewer names) and consult a lawyer for your specific use case.

**Why did I get fewer reviews than `maxReviews`?** Without login cookies Amazon only exposes the product-page top reviews; add cookies to unlock pagination. A warning is logged and stored in the product summary record when this happens.

**Do I need an Amazon API key?**
No — the scraper reads public product pages. Optional login cookies only unlock full review pagination.

**Which marketplaces are supported?**
All major ones: amazon.com, .co.uk, .de, .fr, .it, .es, .ca, .com.au, .in, .co.jp and more — just paste the product URL.

**Can I filter reviews?**
Yes — sort by recent/helpful, filter by star rating (`filterByStar`) or keep only Verified Purchases (`verifiedOnly`).

**How do I export the data?**
JSON, CSV, Excel, XML or an HTML table from the dataset tab, or via the Apify API.

# Actor input Schema

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

One or more Amazon product URLs (https://www.amazon.com/dp/ASIN, /gp/product/ASIN or /product-reviews/ASIN) or bare 10-character ASINs. Any Amazon marketplace domain works (.com, .co.uk, .de, .fr, ...).

## `maxReviews` (type: `integer`):

Maximum number of reviews to extract per product. Note: without login cookies Amazon only exposes the top ~10 reviews on the product page; add the 'cookies' field to paginate the full review history.

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

How Amazon sorts reviews before extraction (applies when paginating review pages with cookies).

## `filterByStar` (type: `string`):

Only keep reviews with this star rating.

## `verifiedOnly` (type: `boolean`):

Only keep reviews marked as Verified Purchase.

## `cookies` (type: `string`):

Optional Cookie header copied from a logged-in Amazon browser session (e.g. 'session-id=...; ubid-main=...; at-main=...'). Amazon requires sign-in to browse the full review history pages; with cookies the scraper paginates up to maxReviews, without them it extracts the top reviews shown on the product page.

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

Routes requests through Apify Proxy. Amazon blocks some datacenter IPs with a captcha; residential proxies are the most reliable if your plan includes them.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.amazon.com/dp/B09B8V1LZ3"
  ],
  "maxReviews": 20,
  "sortBy": "recent",
  "filterByStar": "all_stars",
  "verifiedOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": [
        "https://www.amazon.com/dp/B09B8V1LZ3"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Reviews Scraper - Ratings, Review Text + Images",
        "description": "Amazon reviews scraper - extract product reviews by ASIN or URL: star rating, title, review text, date, verified-purchase flag and images. Analyze sentiment and monitor competitors. No API key. Export CSV, JSON or Excel.",
        "version": "0.1",
        "x-build-id": "UpeHWqzfhweQ0hVK3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/convertfleetdotonline~amazon-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-convertfleetdotonline-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/convertfleetdotonline~amazon-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-convertfleetdotonline-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/convertfleetdotonline~amazon-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-convertfleetdotonline-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": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Amazon product URLs or ASINs",
                        "type": "array",
                        "description": "One or more Amazon product URLs (https://www.amazon.com/dp/ASIN, /gp/product/ASIN or /product-reviews/ASIN) or bare 10-character ASINs. Any Amazon marketplace domain works (.com, .co.uk, .de, .fr, ...).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per product. Note: without login cookies Amazon only exposes the top ~10 reviews on the product page; add the 'cookies' field to paginate the full review history.",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "recent",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "How Amazon sorts reviews before extraction (applies when paginating review pages with cookies).",
                        "default": "recent"
                    },
                    "filterByStar": {
                        "title": "Filter by star rating",
                        "enum": [
                            "all_stars",
                            "five_star",
                            "four_star",
                            "three_star",
                            "two_star",
                            "one_star",
                            "positive",
                            "critical"
                        ],
                        "type": "string",
                        "description": "Only keep reviews with this star rating.",
                        "default": "all_stars"
                    },
                    "verifiedOnly": {
                        "title": "Verified purchases only",
                        "type": "boolean",
                        "description": "Only keep reviews marked as Verified Purchase.",
                        "default": false
                    },
                    "cookies": {
                        "title": "Amazon session cookies (optional)",
                        "type": "string",
                        "description": "Optional Cookie header copied from a logged-in Amazon browser session (e.g. 'session-id=...; ubid-main=...; at-main=...'). Amazon requires sign-in to browse the full review history pages; with cookies the scraper paginates up to maxReviews, without them it extracts the top reviews shown on the product page."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Routes requests through Apify Proxy. Amazon blocks some datacenter IPs with a captcha; residential proxies are the most reliable if your plan includes them.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```