# Amazon India Reviews Scraper (`w3crawler/amazon-reviews-scraper`) Actor

Scrapes public Amazon India customer reviews with direct HTML extraction and explicit access diagnostics.

- **URL**: https://apify.com/w3crawler/amazon-reviews-scraper.md
- **Developed by:** [w3crawler](https://apify.com/w3crawler) (community)
- **Security:** Limited permissions
- **Stats:** 4 total users, 3 monthly users, 91.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Amazon India Reviews Scraper

Collect public Amazon.in customer reviews from product or review URLs. Each saved row combines review content, rating, reviewer identity and public profile link, date and country, verified-purchase status, helpful votes, attached images, and product-level rating context when Amazon publishes it.

### Get started

1. Open the [Actor Store page](https://apify.com/w3crawler/amazon-reviews-scraper) and select **Try for free** or open the **Input** tab.
2. Add one or more Amazon.in product or customer-review URLs to `productUrls`; the Actor extracts the ASIN and requests the public review pages.
3. Set `maxReviewsPerProduct` and `maxPages` to the depth you need; the defaults keep 10 reviews from up to 5 review pages per product.
4. Start the Actor, open the dataset, and export the rows as JSON, CSV, or Excel. Open **Run summary** (`OUTPUT_SUMMARY`) to check the outcome and counts.

### Input

`productUrls` is required. The other fields are optional and use the defaults below; unsupported field names and out-of-range values are rejected before requests start.

| Field | Type | Required? | Default | Meaning |
| --- | --- | --- | --- | --- |
| `productUrls` | string array | Required | Not supplied | Amazon.in product or review URLs. The Actor extracts the ASIN from each URL and requests its public review pages. |
| `maxReviewsPerProduct` | integer | Optional | `10` | Maximum live reviews to save for each product, from 1 to 50. |
| `maxPages` | integer | Optional | `5` | Maximum public review pages requested per product, from 1 to 10. |
| `requestDelayMs` | integer | Optional | `0` | Delay between review-page requests, 0–10,000 ms. No retry or proxy rotation is performed. |
| `requestTimeoutMs` | integer | Optional | `60000` | Timeout for each direct public request, 5,000–120,000 ms. |
| `headless` | boolean | Optional | `true` | Compatibility field; this direct-only Actor does not launch a browser. |
| `proxyConfiguration` | object | Optional | `{}` | Compatibility field; this Actor never configures or uses a proxy. |

Example input with the required `productUrls` field supplied. The remaining values are the schema defaults.

```json
{
  "productUrls": ["https://www.amazon.in/dp/B0HFWYS1SZ"],
  "maxReviewsPerProduct": 10,
  "maxPages": 5,
  "requestDelayMs": 0,
  "requestTimeoutMs": 60000,
  "headless": true,
  "proxyConfiguration": {}
}
```

The Actor reads public Amazon.in review and product pages through serialized direct HTTPS requests. It does not sign in, use a proxy, or launch a browser. `headless` and `proxyConfiguration` are retained only so older saved inputs continue to start. A URL that contains a recognizable ASIN is normalized to that ASIN; review pages are requested directly, and the product page supplies the product title and rating context.

### Output

The dataset contains one row per public review saved for each requested product. Only reviews visible on the requested public pages become rows. Optional values are omitted when Amazon does not publish them; no diagnostic or placeholder rows are written.

| Field | Type | Availability | Meaning |
| --- | --- | --- | --- |
| `sourceUrl` | string | Always | Product URL supplied in the input, normalized to the Amazon.in product page. |
| `canonicalUrl` | string | Always | Canonical public URL for the review row. |
| `position` | integer | When published | One-based position of the row in the run output. |
| `inputMode` | string | When published | Input path used for the row; `productUrls` for normal runs. |
| `reviewId` | string | Always | Amazon review identifier parsed from the public review page. |
| `rating` | number | When published | Review star rating, from 1 to 5. |
| `reviewTitle` | string | When published | Review headline with embedded star text removed. |
| `reviewText` | string | When published | Visible review body text as displayed publicly. |
| `reviewerName` | string | When published | Public reviewer display name. |
| `reviewerProfileUrl` | string | When published | Public Amazon profile URL for the reviewer. |
| `reviewerProfileId` | string | When published | Account identifier parsed from the reviewer profile URL. |
| `reviewDate` | string | When published | Review date text as displayed by Amazon.in, including the displayed country. |
| `reviewCountry` | string | When published | Country parsed from the review date text, such as `India`. |
| `verifiedPurchase` | boolean | When published | Whether Amazon displays a verified-purchase badge for the review. |
| `helpfulVotes` | integer | When published | Helpful-vote count shown for the review. |
| `reviewImages` | string array | When published | Public image URLs attached to the review. |
| `hasImages` | boolean | When published | Whether at least one review image URL was extracted. |
| `reviewBodyLength` | integer | When published | Character count of the normalized review body. |
| `productAsin` | string | Always | ASIN extracted from the input URL. |
| `productTitle` | string | When published | Product title shown on the public Amazon.in page. |
| `productRating` | string | When published | Overall product rating text, such as `2.5 out of 5`. |
| `productRatingValue` | number | When published | Numeric value parsed from the overall product rating text. |
| `totalReviews` | integer | When published | Product review or rating count shown by Amazon.in. |
| `ratingBreakdown` | object | When published | Percentage distribution across the five star levels as displayed. |
| `productUrl` | string | When published | Input product URL for the review's product. |
| `reviewUrl` | string | Always | Public Amazon.in URL for the individual review. |
| `reviewPosition` | integer | When published | One-based position of the review on the extracted review page. |
| `pageNumber` | integer | When published | Review page number inferred from the request URL. |
| `sourceDomain` | string | When published | Source domain; `amazon.in` for this Actor. |
| `locale` | string | When published | Locale associated with the Amazon.in extraction. |
| `currency` | string | When published | Currency associated with the Amazon.in extraction. |
| `scrapedAt` | string | Always | Time the review row was created, in ISO UTC. |

The example below is a real saved row from the 2026-10-25 run. It is limited to fields declared in the dataset schema; no values were changed.

```json
{
  "sourceUrl": "https://www.amazon.in/dp/B0HFWYS1SZ",
  "canonicalUrl": "https://www.amazon.in/gp/customer-reviews/RIUORKX7CFPDO",
  "position": 3,
  "inputMode": "productUrls",
  "reviewId": "RIUORKX7CFPDO",
  "rating": 1,
  "reviewTitle": "Don't read if you have filthy money.",
  "reviewText": "I usually do not write a review unless things really goes south, the airpods does not pair with the phone properly, even after one successful attempt to connect with different device only one works, it could be one unit faulty, who knows? Nevertheless spend some extra to get a better airdopes available. Manufacturer please note even after tested ok, how could your device be defective? Check the assembly line and ensure entire batch of faulty units to be discarded. It'll save you time and more growth opportunities.",
  "reviewerName": "Zulfiqar Ali",
  "reviewerProfileUrl": "https://www.amazon.in/gp/profile/amzn1.account.AGM6KPN75ER2DJN2PAO6TDMT2K2A?ref=cm_cr_dp_d_bdcrb_top",
  "reviewerProfileId": "AGM6KPN75ER2DJN2PAO6TDMT2K2A",
  "reviewDate": "Reviewed in India on 5 September 2026",
  "reviewCountry": "India",
  "verifiedPurchase": true,
  "helpfulVotes": 3,
  "reviewImages": [
    "https://m.media-amazon.com/images/I/51d3eBkcJwL._SY500_.jpg"
  ],
  "hasImages": true,
  "reviewBodyLength": 519,
  "productAsin": "B0HFWYS1SZ",
  "productTitle": "Linston TWS Wireless Earbuds with Bluetooth, ENC Noise Cancellation, HD Calling, Touch Control, Deep Bass Sound, Fast Charging Case & Comfortable In-Ear Fit – Black",
  "productRating": "2.5 out of 5",
  "productRatingValue": 2.5,
  "totalReviews": 30,
  "ratingBreakdown": {
    "fiveStar": 23,
    "fourStar": 10,
    "threeStar": 10,
    "twoStar": 9,
    "oneStar": 48
  },
  "productUrl": "https://www.amazon.in/dp/B0HFWYS1SZ",
  "reviewUrl": "https://www.amazon.in/gp/customer-reviews/RIUORKX7CFPDO",
  "reviewPosition": 3,
  "pageNumber": 1,
  "sourceDomain": "amazon.in",
  "locale": "en-IN",
  "currency": "INR",
  "scrapedAt": "2026-10-25T20:40:38.289Z"
}
```

`ratingBreakdown` contains `fiveStar`, `fourStar`, `threeStar`, `twoStar`, and `oneStar` percentages; they describe the product, not the individual review. `productRating` preserves Amazon's display text, while `productRatingValue` is the numeric form used for filtering or charts. `reviewImages` contains only publicly displayed image URLs and is omitted when the review has no images. `position` counts saved rows across the run, whereas `reviewPosition` is the position on its review page.

### Run summary

**Run summary** is stored separately from the dataset in the run's key-value store under `OUTPUT_SUMMARY`.

| Field | Meaning |
| --- | --- |
| `actorName` | Actor name recorded by the run. |
| `actorStoreUrl` | Public Store URL recorded by the run; omitted from the example below because older summaries wrote a legacy path. |
| `sourceWebsite` | Amazon site used for the run; `https://www.amazon.in/`. |
| `targetKind` | Kind of record collected; `amazon_review` for this Actor. |
| `status` | Overall Actor run status: `SUCCEEDED` or `FAILED`. |
| `startedAt` | Time the run started, in ISO UTC. |
| `finishedAt` | Time the summary was written, in ISO UTC. |
| `requestCount` | Number of public requests made. |
| `pagesFetched` | Number of review or product pages successfully fetched. |
| `productsRequested` | Number of product targets read from the input. |
| `productsProcessed` | Number of products that completed processing. |
| `successfulItems` | Review rows saved. |
| `invalidReviewCount` | Candidate reviews skipped because required review content was missing or malformed. |
| `diagnosticCount` | Operational issues recorded in the summary and log. |
| `diagnosticItems` | Diagnostic dataset rows; always 0 because the Actor writes none. |
| `requestErrorCount` | Request errors recorded for the run. |
| `blockedCount` | Blocked or denied source responses. |
| `dataAvailable` | Whether at least one source-backed review row was saved. |
| `directTransport` | Whether direct HTTP transport was used; true for this Actor. |
| `usedProxy` | Whether a proxy was used; false for this Actor. |
| `maxReviewsPerProduct` | Review limit used for the run. |
| `maxPages` | Review-page limit used for the run. |
| `runStatus` | Canonical run status; matches `status`. |
| `dataStatus` | Completeness of the saved review rows. |

| Status | Data status | Meaning |
| --- | --- | --- |
| `SUCCEEDED` | `COMPLETE` | Reviews were saved without an extraction problem. |
| `SUCCEEDED` | `PARTIAL` | Some reviews were saved, but a later product or page request failed. |
| `SUCCEEDED` | `NO_RESULTS` | The requests completed cleanly and no public review matched the limits. |
| `FAILED` | `FAILED` | A fatal error occurred before any usable review was saved. |

Example `OUTPUT_SUMMARY` from the 2026-10-25 run. The saved `actorStoreUrl` is omitted from this display.

```json
{
  "actorName": "amazon-reviews-scraper",
  "sourceWebsite": "https://www.amazon.in/",
  "targetKind": "amazon_review",
  "status": "SUCCEEDED",
  "startedAt": "2026-10-25T20:40:35.580Z",
  "finishedAt": "2026-10-25T20:40:38.465Z",
  "requestCount": 2,
  "pagesFetched": 2,
  "productsRequested": 1,
  "productsProcessed": 1,
  "successfulItems": 3,
  "invalidReviewCount": 0,
  "diagnosticCount": 0,
  "diagnosticItems": 0,
  "requestErrorCount": 0,
  "blockedCount": 0,
  "dataAvailable": true,
  "directTransport": true,
  "usedProxy": false,
  "maxReviewsPerProduct": 3,
  "maxPages": 5,
  "runStatus": "SUCCEEDED",
  "dataStatus": "COMPLETE"
}
```

### Coverage and limitations

The Actor supports Amazon.in only. It reads public review pages and the public product page for each supplied ASIN; it does not sign in, access private accounts, use a browser, use a proxy, solve CAPTCHAs, or fetch reviews from other marketplaces. A review becomes a row only when the public page exposes usable review content. Reviews hidden behind sign-in, deleted, or not present on the fetched pages are not recovered.

`maxReviewsPerProduct` is capped at 50 and `maxPages` at 10. The Actor reads pages in their displayed order and does not accept a star filter or sort option, so results are a bounded snapshot rather than every review for a popular product. Review images, helpful votes, and profile links appear only when Amazon publishes them. Product ratings and review totals can change between runs; each row reflects the pages fetched during that run.

Malformed review cards are skipped and counted in `invalidReviewCount`. Blocked, empty, and failed pages are recorded in logs and summary counters rather than written as dataset rows. The saved summary above is complete for its run; `dataStatus` reports `PARTIAL` when some rows are saved but a later page fails.

### Usage and support

Cost depends on the number of product URLs, the review pages requested with `maxPages`, and the number of saved rows; each product normally needs one product-page request plus up to `maxPages` review-page requests. Start with one product, `maxReviewsPerProduct` around 10, and `maxPages` around 2, then inspect the dataset and summary before scaling. See the Actor's Pricing tab for current account rates.

Use the [Actor Issues page](https://apify.com/w3crawler/amazon-reviews-scraper/issues) to report a problem. Include the run ID, the input used, and the run summary; do not include tokens, cookies, or private data. This Actor is not affiliated with Amazon.in. Use it only for public data and in accordance with Amazon.in's terms, robots guidance, and applicable law. Reviews and reviewer profiles contain personal information; use the output only for lawful purposes and do not republish reviewer identities without a valid basis.

# Changelog

This Actor's version history is a separate document: https://apify.com/w3crawler/amazon-reviews-scraper/changelog.md

# Actor input Schema

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

Amazon.in product or review URLs. The actor extracts the ASIN and requests public review pages directly.

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

Maximum number of live reviews to return for each product. Values are clamped to 1 through 50.

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

Maximum number of public review pages to request per product. Values are clamped to 1 through 10.

## `requestDelayMs` (type: `integer`):

Delay between review-page requests. No retry or proxy rotation is performed.

## `requestTimeoutMs` (type: `integer`):

Timeout for each direct public request.

## `headless` (type: `boolean`):

Compatibility field retained for older inputs; this direct-only actor does not launch a browser.

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

Compatibility field retained for older inputs; this actor never configures or uses a proxy.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.amazon.in/dp/B0DG4WXBCF"
  ],
  "maxReviewsPerProduct": 10,
  "maxPages": 5,
  "requestDelayMs": 0,
  "requestTimeoutMs": 30000,
  "headless": true,
  "proxyConfiguration": {}
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing source-backed customer review records. Run errors are reported in logs and the OUTPUT_SUMMARY key-value record.

## `runSummary` (type: `string`):

Run status and counters stored by the Actor.

# 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.in/dp/B0DG4WXBCF"
    ],
    "maxReviewsPerProduct": 10,
    "maxPages": 5,
    "requestDelayMs": 0,
    "requestTimeoutMs": 30000,
    "headless": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("w3crawler/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.in/dp/B0DG4WXBCF"],
    "maxReviewsPerProduct": 10,
    "maxPages": 5,
    "requestDelayMs": 0,
    "requestTimeoutMs": 30000,
    "headless": True,
}

# Run the Actor and wait for it to finish
run = client.actor("w3crawler/amazon-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "productUrls": [
    "https://www.amazon.in/dp/B0DG4WXBCF"
  ],
  "maxReviewsPerProduct": 10,
  "maxPages": 5,
  "requestDelayMs": 0,
  "requestTimeoutMs": 30000,
  "headless": true
}' |
apify call w3crawler/amazon-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,w3crawler/amazon-reviews-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ZwOleOagtkPhTucGV/builds/pBbylFLpGSWZm3PSd/openapi.json