# Amazon ASIN Rating & Review Count Scraper (`k-data-lab/amazon-asin-rating-scraper`) Actor

Bulk-check star rating, review count, 5★–1★ breakdown, price and Best Sellers Rank for Amazon ASINs or URLs on 19 marketplaces. First 100 products every month free, then from $1.60 per 1,000. Only found products are charged.

- **URL**: https://apify.com/k-data-lab/amazon-asin-rating-scraper.md
- **Developed by:** [K-Data Lab](https://apify.com/k-data-lab) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 1 total users, 1 monthly users, 98.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 asin scrapeds

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/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 ASIN Rating & Review Count Scraper – Star Breakdown, Monthly Sales, Price & BSR for 19 Amazon Sites

**Turn a list of ASINs or Amazon product URLs into a clean table of star ratings, review counts and how many units sold last month.** No Amazon account, no API keys, no browser. Paste your list, click **Start**, and download Excel, CSV or JSON.

Perfect for **rating monitoring, review-growth tracking, competitor benchmarking, catalog health checks and daily KPI dashboards**, with your **first 100 products every month free** and then from **$1.60 per 1,000** (just **$1 per 1,000 on the Apify Free plan**), charged only for products that return data.

***

#### 🔍 What does Amazon ASIN Rating Scraper do?

You give it products, and it returns one row per product:

- ⭐ **Average star rating** (e.g. `4.2`)
- 🔢 **Total global ratings count** (e.g. `2958`)
- 📊 **Star breakdown**: % of 5★, 4★, 3★, 2★ and 1★ ratings (when Amazon shows it on the page)
- 💲 **Buy-box price**, as a number and as displayed
- 🏆 **Best Sellers Rank** and its category
- 📈 **Units bought in the past month**, from Amazon's "1K+ bought in past month" badge, as a number (`1000`) you can sort and chart
- 🏭 **Brand** and 📦 **availability** ("In Stock", "Only 3 left in stock")
- 🖼️ **Main product image**
- 🏷️ **Product title** and 🔗 **product link**
- 🌍 **Marketplace** the data came from
- 🕒 **Scrape timestamp**, so repeated runs build a history
- ✅ **Status** per product: found, not sold on that marketplace, or blocked

It accepts:

- **Bare ASINs**: `B0G7RYP439`
- **Product URLs** from any supported Amazon site: `https://www.amazon.de/dp/B0GDHRZFWH`
- **Mixed lists** pasted straight from a spreadsheet column. Duplicates, blank cells, `-` and `TBD` are skipped automatically.

***

#### 🌍 Which Amazon site gets scraped?

| You enter | Scraped on |
|---|---|
| A bare ASIN, e.g. `B0G7RYP439` | The **Marketplace** selected in the input (default amazon.com) |
| A product URL, e.g. `https://www.amazon.co.uk/dp/B0H2BX5FF2` | **That URL's own site** (amazon.co.uk) |

So **one run can cover the US, UK, Germany, Japan and more**. List the same ASIN as URLs on different sites to compare its rating country by country.

> ⚠️ Amazon ratings are **per marketplace**. A product can be 4.6★ with 13,000 ratings on amazon.com and 4.1★ with 400 ratings on amazon.de. Always check the `marketplace` column.

***

#### 🌟 Key features

- **19 Amazon marketplaces**: US, UK, DE, FR, IT, ES, NL, SE, PL, TR, JP, IN, CA, MX, BR, AU, AE, SA, SG
- **Fast**: ~3,400 products in about 5½ minutes on default settings
- **Cheap**: $1.60–2 per 1,000 products ($1 on the Free plan), roughly 2× cheaper than typical full Amazon product scrapers
- **Fair billing**: not-found and blocked products are **never charged**
- **Stable**: each parallel session behaves like one real shopper, with its own IP, cookies and real-browser fingerprint, human-like pacing, rotation, and automatic slow-down if Amazon pushes back
- **Smart proxies**: fast datacenter IPs first, residential only for products that keep getting blocked
- **Clean data**: incomplete pages are retried instead of saved, and Amazon's "Continue shopping" check page is passed automatically
- **Small footprint**: runs on 512 MB, and more memory isn't needed
- **Monitored daily** with live test runs on amazon.com and amazon.de

***

#### ⚖️ Why choose this scraper?

| | **This actor** | Typical Amazon product scrapers |
|---|---|---|
| Price per 1,000 products | **$1.60–2.00** ($1 on Free plan), **first 100 every month free** | $3–5 |
| Charged for not-found / blocked products | **No** | Often yes (every dataset row) |
| Mix several Amazon sites in one run | **Yes, from the URL** | Usually one country per run |
| Default memory | **512 MB** | 1–4 GB |
| ~3,400 products | **~5½ min** | Often much longer (full page parsing) |
| Output | Focused: rating, count, **star breakdown, price, Best Sellers Rank, image** | 40+ fields you may not need |
| Star-rating breakdown (5★…1★ %) | **Included free** | Separate actor, often $4+ per 1,000 |
| Monthly sales signal ("bought in past month") | **Included, as a number** | Often missing or text only |
| Amazon login / cookies needed | **No** | Sometimes |

If you need **ratings, review counts and the numbers around them** (star mix, price, rank) without a full product scrape, this is the fastest and cheapest way to get them.

***

#### 📥 Input

| Field | Required | Description |
|---|---|---|
| **ASINs or product URLs** | ✅ | One per line. Bare ASINs or Amazon product links, mixed freely |
| **Marketplace for bare ASINs** | | `com` (default), `co.uk`, `de`, `co.jp` … Product URLs always use their own site |
| **Parallel sessions** | | Default 40, max 50. Capped automatically to fit the run's memory |
| **Proxy** | | Default: Apify datacenter, auto-escalating to residential. Leave as is |
| **Save raw pages (debug)** | | Stores fetched HTML for troubleshooting. Off by default |

**Example input**

```json
{
  "asins": [
    "B0G7RYP439",
    "B0G7QZ7RMD",
    "https://www.amazon.de/dp/B0GDHRZFWH",
    "https://www.amazon.co.uk/dp/B0H2BX5FF2"
  ],
  "marketplace": "com"
}
```

***

#### 📋 Output fields

| Field | Type | Description |
|---|---|---|
| `asin` | string | The product's ASIN |
| `found` | boolean / null | `true` = product page found · `false` = not sold on this marketplace / delisted · `null` = blocked after all retries |
| `rating` | number / null | Average star rating out of 5. `null` if the product has no ratings yet |
| `ratingsCount` | integer | Total number of global ratings (`0` if none) |
| `starBreakdown` | object / null | % of ratings per star, `{"5": 69, "4": 9, "3": 7, "2": 6, "1": 9}`. `null` when the page doesn't show it (common outside amazon.com) |
| `price` | number / null | Buy-box price as a number. `null` when there is no buy box (e.g. only other sellers) |
| `priceText` | string / null | Price as displayed, with currency, e.g. `$21.99`, `20,69 €` |
| `bestSellersRank` | integer / null | Best Sellers Rank in the main category |
| `bestSellersCategory` | string / null | That category, in the marketplace's language |
| `imageUrl` | string / null | Main product image, high resolution |
| `boughtInPastMonth` | integer / null | Amazon's "bought in past month" badge as a number (lower bound): `200+` → `200`, `1K+` → `1000`. `null` when Amazon shows no badge (low sellers, many non-US sites) |
| `boughtInPastMonthText` | string / null | The badge as displayed, e.g. `1K+ bought in past month` |
| `brand` | string / null | Brand from the product overview |
| `availability` | string / null | Stock message from the buy box, e.g. `In Stock`, `Only 3 left in stock - order soon.` |
| `title` | string | Product title as shown on Amazon |
| `url` | string | Product page link |
| `marketplace` | string | Amazon site the data came from, e.g. `amazon.de` |
| `scrapedAt` | string | Scrape time, UTC, ISO 8601 |
| `error` | string | Only on blocked items: why it couldn't be scraped |

#### 📤 Example output

```json
[
  {
    "asin": "B0G7RYP439",
    "found": true,
    "url": "https://www.amazon.com/dp/B0G7RYP439",
    "title": "Spigen GlasTR EZ Fit Privacy Tempered Glass Screen Protector for Galaxy S26",
    "rating": 4.2,
    "ratingsCount": 2966,
    "starBreakdown": { "5": 69, "4": 9, "3": 7, "2": 6, "1": 9 },
    "price": 21.99,
    "priceText": "$21.99",
    "bestSellersRank": 5054,
    "bestSellersCategory": "Cell Phones & Accessories",
    "imageUrl": "https://m.media-amazon.com/images/I/61ZrMpUo4tL._AC_SL1500_.jpg",
    "boughtInPastMonth": 1000,
    "boughtInPastMonthText": "1K+ bought in past month",
    "brand": "Spigen",
    "availability": "In Stock",
    "marketplace": "amazon.com",
    "scrapedAt": "2026-10-16T01:03:12.623131+00:00"
  },
  {
    "asin": "B0GDHRZFWH",
    "found": true,
    "url": "https://www.amazon.de/dp/B0GDHRZFWH",
    "title": "Spigen Thin Fit MagFit for Samsung Galaxy S26 Plus - Black",
    "rating": 3,
    "ratingsCount": 243,
    "starBreakdown": null,
    "price": null,
    "priceText": null,
    "bestSellersRank": 7808,
    "bestSellersCategory": "Elektronik & Foto",
    "imageUrl": "https://m.media-amazon.com/images/I/61dJd0D2GBL._AC_SL1200_.jpg",
    "marketplace": "amazon.de",
    "scrapedAt": "2026-10-16T01:03:20.026163+00:00"
  }
]
```

The **Output** tab shows these as a table (*Ratings, star breakdown, price & rank*), with product images, ready to export to Excel, CSV, JSON, XML or HTML.

#### 🚧 Not-found and blocked items

Every product you enter gets a row, so nothing silently goes missing:

```json
{ "asin": "B0B7MFZ2SH", "found": false, "marketplace": "amazon.com" }
```

`found: false`: Amazon has no product page for this ASIN on this site. **Not charged.**

```json
{ "asin": "B0XXXXXXXX", "found": null, "error": "Blocked after 6 attempts", "marketplace": "amazon.com" }
```

`found: null`: Amazon blocked all 6 attempts, each on a fresh identity and the last ones on residential IPs. Rare; just run those ASINs again. **Not charged.**

***

#### 💰 How much does it cost to scrape Amazon ratings?

**🎁 Your first 100 products every month are free.** After that, **from $1.60 per 1,000 products**, with bigger discounts on higher Apify plans. It's pay-per-event, so platform usage isn't billed on top.

| Your Apify plan | Per product | Per 1,000 products |
|---|---|---|
| 🎁 Free (try it on your monthly free credit) | $0.001 | **$1.00** |
| Starter | $0.002 | $2.00 |
| Scale | $0.0018 | $1.80 |
| Business / Platinum / Diamond | $0.0016 | **$1.60** |

Plus $0.005 per run. **Not-found and blocked products are always free**, and the first 100 found products each calendar month (UTC) cost nothing. The run log shows how many free products you have left.

| You check (Starter plan) | Cost |
|---|---|
| 100 products once | **$0.005** (all 100 free) |
| 1,000 products once | ≈ $1.81 |
| 10,000 products once | ≈ $19.81 |
| 500 products every weekday (~22 runs/month) | ≈ $21.91 / month |

🎁 **Free trial:** new to Apify? The Free plan's monthly $5 credit covers **about 5,000 products** at the Free-plan price, every month, enough to test on your real catalog before you pay anything.

***

#### 🚀 How to scrape Amazon ratings by ASIN (step by step)

1. Click **Try for free** (or **Start**) on this page and sign in to Apify.
2. Paste your **ASINs or product URLs** into the first field, one per line.
3. Bare ASINs only: pick their **Marketplace** (default amazon.com).
4. Click **Start**. A few hundred products take about a minute.
5. Open the **Output** tab and click **Export** to download Excel, CSV or JSON.
6. Optional: click **Save as a new task**, then **Schedule** it (e.g. every weekday at 08:00) to track ratings over time.

***

#### 📊 Popular use cases

- **Brand & seller rating monitoring**
  - Daily snapshot of every listing's rating and review count
  - Spot a rating drop the morning it happens, before it hurts conversion
- **Competitor benchmarking**
  - Track rival products' review velocity after their launch or promotion
  - Compare your rating to the category's top sellers
- **Multi-country catalog health**
  - Same product, many marketplaces: find the countries where it underperforms
- **Agency & client reporting**
  - Scheduled rating reports to Google Sheets, Slack or email, no manual checking
- **Sales momentum & product research**
  - Sort hundreds of ASINs by `boughtInPastMonth` and `bestSellersRank` to see which products really sell
  - Catch out-of-stock competitors from the `availability` column
- **Product launch tracking**
  - Measure how fast a new ASIN collects its first 100, 500 and 1,000 ratings
- **Data & BI pipelines**
  - Feed ratings into dashboards, pricing models or ML features via API

***

#### 🔌 Integrations & API

Connect results to **Google Sheets, Slack, email, Zapier, Make, Airbyte, GitHub, webhooks** and more under the **Integrations** tab. Or call it from code:

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("k-data-lab/amazon-asin-rating-scraper").call(
    run_input={"asins": ["B0G7RYP439", "https://www.amazon.de/dp/B0GDHRZFWH"]}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["asin"], item.get("rating"), item.get("ratingsCount"))
```

**JavaScript**

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('k-data-lab/amazon-asin-rating-scraper').call({
    asins: ['B0G7RYP439', 'https://www.amazon.de/dp/B0GDHRZFWH'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map(({ asin, rating, ratingsCount }) => ({ asin, rating, ratingsCount })));
```

**cURL** (run and get the results in one request)

```bash
curl -X POST "https://api.apify.com/v2/acts/k-data-lab~amazon-asin-rating-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"asins": ["B0G7RYP439", "B0G7QZ7RMD"]}'
```

***

#### 💡 Tips for best results

- **Test with 10–20 products first** to check the marketplace setting and the output format.
- **Use full product URLs for non-US products.** That way each one is scraped on the right site, even in a mixed list.
- **Variants share reviews.** Color and size variants of one product usually show the same rating and count, because Amazon pools them.
- **Schedule instead of re-running by hand.** The `scrapedAt` field lets you stack runs into a history in Sheets or your database.
- **Leave the proxy and memory defaults alone.** They're tuned for speed and cost.

#### 🤝 When to use this vs a full Amazon product scraper

- **Use this actor** when you need **ratings, review counts, star mix, price, rank, monthly sales badge and stock** for a known list of products, especially many products, often.
- **Use a full product scraper** when you also need descriptions, bullet points, all images, variants or every seller offer.
- **Use a review scraper** when you need the individual review texts.

***

#### ❓ FAQ

**Is there a free allowance?**
Yes. The first 100 products that return data each calendar month (UTC) are free on every plan. The actor keeps the counter in a small key-value store named `k-data-lab-free-quota` in your own Apify account, holding nothing but the number.

**How do I check Amazon ratings for many ASINs at once?**
Paste them all into the input, one per line. A list of thousands is fine; ~3,400 products take about 5½ minutes.

**Which Amazon countries are supported?**
19 sites: amazon.com, .co.uk, .de, .fr, .it, .es, .nl, .se, .pl, .com.tr, .co.jp, .in, .ca, .com.mx, .com.br, .com.au, .ae, .sa and .sg.

**Do I need an Amazon account, cookies or the Amazon API?**
No. Only public product pages are read.

**Why does a product show `found: false`?**
It isn't sold on that marketplace or has been delisted. Check the marketplace, or pass the full product URL. You aren't charged for it.

**Why is `rating` null with `ratingsCount: 0`?**
The product has no ratings yet. That's real data, not an error.

**Does it return the 5-star / 1-star breakdown or the review texts?**
The breakdown, yes: `starBreakdown` gives the % of 5★…1★ ratings whenever the product page shows it. Individual review texts, no. That's what keeps it fast and cheap; use a review scraper for those.

**Can I see how many units a product sold?**
Amazon doesn't publish exact sales, but many listings show a "bought in past month" badge (`50+`, `1K+`, `10K+`). The actor returns it as `boughtInPastMonth` (a sortable number) plus the original text. Combine it with `bestSellersRank` and run it on a schedule to track sales momentum for your own or competitors' products.

**Can I schedule it and send results to Google Sheets?**
Yes. Save your input as a task, add a schedule, and connect the Google Sheets integration.

**Is it legal to scrape Amazon ratings?**
This actor only collects publicly available product data and no personal data. You're responsible for how you use the results. Check Amazon's terms and the laws that apply to you.

**Something doesn't look right. How do I get help?**
Open an issue on the **Issues** tab with the run link and a few example ASINs.

***

#### 💬 Your feedback

Missing a marketplace, field or integration? Tell us on the **Issues** tab. If this actor saves you time, please leave a ⭐ **review**, because it helps other people find it.

🔖 **Tags:** amazon rating scraper · amazon review count · amazon bought in past month · amazon sales estimate · amazon stock checker · asin lookup · bulk asin checker · amazon star rating · review monitoring · amazon competitor tracking · amazon seller tools · ecommerce data · amazon api alternative

# Actor input Schema

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

One per line, or paste a whole spreadsheet column. Accepts bare ASINs (<code>B0G7RYP439</code>) or product links (<code>https://www.amazon.de/dp/B0GDHRZFWH</code>). A link is scraped on its own marketplace, so one run can mix countries. Duplicates and non-ASIN cells are skipped automatically.

## `marketplace` (type: `string`):

Which Amazon store to use for bare ASINs. Product links always use their own store.

## `maxConcurrency` (type: `integer`):

How many products are fetched at once (each with its own IP and cookies). Default 40. It is capped automatically to fit the run memory and slows down by itself if Amazon pushes back.

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

Default: fast Apify datacenter proxies, switching to residential only for products that keep getting blocked. Change this only if you want to force a proxy group or use your own proxies.

## `debugHtml` (type: `boolean`):

Store each fetched page in the run's key-value store so you can inspect what Amazon returned. Leave off for normal use.

## Actor input object example

```json
{
  "asins": [
    "B0G7RYP439",
    "B0G7QZ7RMD",
    "https://www.amazon.de/dp/B0GDHRZFWH"
  ],
  "marketplace": "com",
  "maxConcurrency": 40,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debugHtml": false
}
```

# 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 = {
    "asins": [
        "B0G7RYP439",
        "B0G7QZ7RMD",
        "https://www.amazon.de/dp/B0GDHRZFWH"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("k-data-lab/amazon-asin-rating-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "asins": [
        "B0G7RYP439",
        "B0G7QZ7RMD",
        "https://www.amazon.de/dp/B0GDHRZFWH",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("k-data-lab/amazon-asin-rating-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 '{
  "asins": [
    "B0G7RYP439",
    "B0G7QZ7RMD",
    "https://www.amazon.de/dp/B0GDHRZFWH"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call k-data-lab/amazon-asin-rating-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,k-data-lab/amazon-asin-rating-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/2AuZCyLxKZuO2OyNY/builds/4HGPzq5n2MrNDhdHZ/openapi.json