# Amazon Reviews Scraper US (`axesso_data/amazon-reviews-scraper-us`) Actor

Fast Amazon review scraper for the Amazon.com (US) marketplace. Filter reviews by star rating and verified purchases and sort them by most recent or most helpful. Optimized for speed, it returns real-time data directly from the product page with no cache or database in between.

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

## Pricing

from $0.50 / 1,000 reviews

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 (US)

This Actor extracts detailed, real-time reviews directly from **Amazon.com (US)** product pages. It is a **speed-optimized** variant of our review scrapers: by focusing on a single marketplace and a lean set of filters, it returns results noticeably faster than our general multi-marketplace Actor.

> **Built for speed, US-only.** ⚡
> - ✅ **Amazon.com (US) only** — no `domainCode` needed.
> - ✅ **Faster** than our general Amazon Review Scraper.
> - ✅ Filter by **star rating** and **verified purchases**, sort by **recent** or **helpful**.
> - ❌ **No keyword search.**
> - ❌ **No format or media filters.**
>
> Need other marketplaces, keyword search or additional filters? Use our [general Amazon Review Scraper](https://apify.com/axesso_data/amazon-reviews-scraper) instead.

Here’s how it works:

1. **Input Parameters:** You simply provide the ASIN of the Amazon.com product, optionally together with a star filter, a verified-purchase filter, a sort option and the number of pages to scrape — provided as a list to process many ASINs in one run.

2. **Data Extraction:** The Actor retrieves the product’s reviews including star ratings, review titles, full descriptions, helpful votes, review dates, and any attached images or videos.

3. **Real-Time Output:** Unlike cached or preprocessed data, our scraper retrieves up-to-date reviews directly from Amazon. This ensures the results are always fresh and reliable.

4. **Download Options:** Once the reviews are extracted, the data can be downloaded in your preferred format, such as JSON, CSV, Excel, XML, or HTML.

### Input data
The Actor accepts input in JSON format. The provided JSON includes one mandatory JSON array field `input`, where each entry describes one ASIN to scrape with the following fields:

- `asin` (Required) The Amazon Standard Identification Number of the product whose reviews you want to scrape.
- `sortBy` (Optional) The sorting method for reviews. Use `recent` for the most recent reviews or `helpful` for the most helpful ones. Default is `recent`.
- `maxPages` (Optional) The maximum number of review pages to scrape. For instance, `1` limits scraping to the first page. Max value is 10 pages, as this is the limit predefined by Amazon. Default value is 1.
- `starFilter` (Optional) Restricts returned reviews to a star rating or sentiment bucket. Valid values: `all_stars`, `one_star`, `two_star`, `three_star`, `four_star`, `five_star`, `positive`, `negative`. Defaults to `all_stars` when omitted.
- `isVerified` (Optional) When `true`, restricts returned reviews to verified purchases only. Valid values: `true`, `false`. Default is `false`.

> **Note:** This Actor scrapes **Amazon.com (US) only**, so no `domainCode` is required. Keyword search, format filters and media filters are **not** supported here — use our general Amazon Review Scraper for those.

The `input` field is an array, allowing you to pass multiple ASINs in one run. Each ASIN can be configured with its own filters and options, enabling the scraping of up to millions of reviews in a single run.

Here an example of a sample input:

    {
    "input": [
        {
        "asin": "B08C1W5N87",
        "sortBy": "recent",
        "starFilter": "four_star",
        "maxPages": 1
        },
        {
        "asin": "B09G7ZMVJP",
        "sortBy": "helpful",
        "isVerified": true,
        "maxPages": 1
        },
        {
        "asin": "B086K4ZMT3",
        "sortBy": "recent",
        "starFilter": "five_star",
        "maxPages": 2
        }
    ]
    }

### Output data

    [
        {
            "statusCode": 200,
            "statusMessage": "FOUND",
            "asin": "B08C1W5N87",
            "currentPage": 1,
            "sortStrategy": "recent",
            "domainCode": "com",
            "filters": {
                "starFilter": "four_star",
                "isVerified": "false"
            },
            "text": "Awesome small pliers. Good enough for most jobs when camping or adjusting bikes or anything in an emergency.",
            "date": "Reviewed in the United States on May 20, 2026",
            "rating": "5.0 out of 5 stars",
            "title": "Great little pliers. Keep in my EDC.",
            "userName": "A. Ross",
            "numberOfHelpful": 0,
            "imageUrlList": [],
            "verified": true,
            "vine": false,
            "videos": [
                {
                    "url": "https://m.media-amazon.com/images/I/D1dyzU-l9oL.mp4",
                    "thumbnailUrl": "https://m.media-amazon.com/images/I/41AxxKWWwKL.jpg",
                    "extension": "mp4"
                }
            ],
            "videoUrlList": [
                "https://m.media-amazon.com/images/I/D1dyzU-l9oL.mp4"
            ]
        }
    ]

### Marketplace
This Actor supports the **Amazon.com (US)** marketplace only. All requests are served from US proxies and no `domainCode` parameter is required. If you need reviews from other Amazon marketplaces (e.g. `de`, `co.uk`, `co.jp`), use our general Amazon Review Scraper.

### How much does Amazon Reviews Scraper cost?
Estimating the resources required for data scraping can be difficult due to the diverse nature of use cases. Therefore, it is advisable to conduct a test scrape using a small sample of input data and generate a limited amount of output. This will allow you to determine the cost per scrape, which can then be multiplied by the total number of scrapes you plan to perform. 

### Penalty Entries
If filter options are applied that reduce the result set to zero reviews, or if an invalid ASIN is provided resulting in a 404 response, the Actor will return two penalty entries in the output. These entries indicate that no reviews could be retrieved based on the given parameters.

This mechanism is required to prevent misuse of the Actor, as such requests still incur backend fetching costs. By applying penalty entries, we ensure the service is used responsibly and discourage excessive requests that are unlikely to return meaningful data.

### What to consider when using this Actor?
We are performing Web Crawling activities for over a decade. All our expertises are included in this Actor, this means the user of this Actor is not required to deal with any inconveniences of web scraping. 

In details it means we cover the whole lifecycle including

1. **Proxy Rotation:** We Use our own Proxy Pool including several million proxies in all countries worldwide avoiding that our Scraper can be blocked.
 
2. **Geo Targeting:** This Actor targets the Amazon.com (US) marketplace, so every request is served exclusively through proxies located in the USA. This guarantees you always receive the US version of the reviews with the correct locale and currency.

3. **Captchas and 503 Status Code:** Captchas and temporary blocks are completely handled by this Actor under the hood ensuring the user to get always the required data.

4. **Further rotation** As already mentioned, our Actor is covering all required activities to ensure a smooth user experience at any point in time.

### Use cases for our Actors**

1. **Market Research:** Businesses can utilize our actors to gather product information, pricing data, customer reviews, and seller details from Amazon. This information can help in understanding market trends, competitor analysis, and identifying gaps in the market.

2. **Price Monitoring:** E-commerce retailers can track prices of their own products as well as competitor products on Amazon using our actors. This enables them to adjust their pricing strategies in real-time to stay competitive and maximize profits.

3. **Inventory Management:** Sellers can automate inventory management by leveraging our actors to monitor stock levels, product availability, and any changes in product attributes on Amazon. This ensures timely restocking while preventing stockouts or overstocking..

4. **Product Catalog Management:** Retailers with large product catalogs can efficiently update their product listings on Amazon using our actors. This includes extracting product titles, descriptions, images, and specifications from their database and synchronizing them with Amazon listings.

5. **Review Monitoring and Sentiment Analysis:** Brands can monitor customer reviews of their products on Amazon using our actors. By analyzing sentiment and identifying common issues or positive feedback, brands can improve their products and customer satisfaction.

6. **Lead Generation:** Businesses can leverage our actors to scrape Amazon for contact information of sellers or manufacturers to identify potential suppliers, distributors, or partners. This data can be used for targeted outreach and business development efforts.

7. **Content Aggregation and Curation:** Content creators, bloggers, and publishers can use our actors to aggregate product information, images, and customer reviews from Amazon to create curated content such as product reviews, comparison articles, or buying guides.

8. **Price Comparison Websites:** Price comparison websites can utilize our actors to collect pricing data from Amazon and other e-commerce platforms. This enables consumers to compare prices across different retailers and make informed purchasing decisions.

9. **Ad Campaign Optimization:** Advertisers can scrape Amazon using our actors to gather insights into popular products, keywords, and advertising strategies. This data can be used to optimize Amazon PPC (pay-per-click) campaigns and maximize return on ad spend (ROAS).

# Actor input Schema

## `input` (type: `array`):

List of inputs, each entry refers to one ASIN to be pulled from Amazon.com (US). Full list of valid parameters can be found in the README tab.

## Actor input object example

```json
{
  "input": [
    {
      "asin": "B08C1W5N87",
      "sortBy": "recent",
      "maxPages": 1,
      "starFilter": "five_star",
      "isVerified": false
    }
  ]
}
````

# 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 = {
    "input": [
        {
            "asin": "B08C1W5N87",
            "sortBy": "recent",
            "maxPages": 1,
            "starFilter": "five_star",
            "isVerified": false
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("axesso_data/amazon-reviews-scraper-us").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 = { "input": [{
            "asin": "B08C1W5N87",
            "sortBy": "recent",
            "maxPages": 1,
            "starFilter": "five_star",
            "isVerified": False,
        }] }

# Run the Actor and wait for it to finish
run = client.actor("axesso_data/amazon-reviews-scraper-us").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 '{
  "input": [
    {
      "asin": "B08C1W5N87",
      "sortBy": "recent",
      "maxPages": 1,
      "starFilter": "five_star",
      "isVerified": false
    }
  ]
}' |
apify call axesso_data/amazon-reviews-scraper-us --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Reviews Scraper US",
        "description": "Fast Amazon review scraper for the Amazon.com (US) marketplace. Filter reviews by star rating and verified purchases and sort them by most recent or most helpful. Optimized for speed, it returns real-time data directly from the product page with no cache or database in between.",
        "version": "1.0",
        "x-build-id": "7tC2XBdXrH9Iu8Kcy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/axesso_data~amazon-reviews-scraper-us/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-axesso_data-amazon-reviews-scraper-us",
                "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/axesso_data~amazon-reviews-scraper-us/runs": {
            "post": {
                "operationId": "runs-sync-axesso_data-amazon-reviews-scraper-us",
                "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/axesso_data~amazon-reviews-scraper-us/run-sync": {
            "post": {
                "operationId": "run-sync-axesso_data-amazon-reviews-scraper-us",
                "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": [
                    "input"
                ],
                "properties": {
                    "input": {
                        "title": "Input data",
                        "type": "array",
                        "description": "List of inputs, each entry refers to one ASIN to be pulled from Amazon.com (US). Full list of valid parameters can be found in the README tab."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
