Amazon Review Scraping: How to Scrape Amazon Reviews Without a Login

Amazon review scraping means saving the public customer reviews on a product page as structured rows: star rating, title, text, date, country, verified-purchase flag and the variant the reviewer bought. The quickest way to scrape Amazon reviews is a ready-made Actor that reads them without an Amazon account or cookies: paste product URLs, set how many reviews you want, and export the rows.

This guide shows the no-code route and the API route (curl, Python, Node.js and AI agents over MCP), then what Amazon shows logged-out visitors and what it keeps behind its sign-in page. Everything below comes from a real run on 22 October 2026: the input, the output, the log and the exact cost.

What data you can get from Amazon reviews

The Amazon Reviews Scraper writes one row per review. These are the fields that matter:

Reviewer names and avatars are saved only when you switch on Include personal information; they are off by default. The rows come from the reviews Amazon publishes on the public product page. The complete review history behind Amazon's sign-in page is not part of the output (more on that below).

How to scrape Amazon reviews without code

1. Open the Actor's page in the Scrape.ly Store.
2. Paste one or more product URLs into Amazon product URLs. Short links on a.co and amzn.to are followed, and the domain picks the marketplace: the preset Reviews from amazon.de, 5 reviews shows a German product.
3. Set Max reviews per product and, if you like, a sort order and filters. This is the exact input of our run, the Actor's documented example product (an Apple AirTag):

{
  "productUrls": [{ "url": "https://www.amazon.com/dp/B0CWXNS552" }],
  "maxReviews": 5,
  "sort": "helpful",
  "filterByRatings": ["allStars"],
  "includeGdprSensitive": false
}

4. Click Start. A handful of reviews takes seconds.
5. Export the dataset as JSON, CSV or Excel.

The fields that matter most:

• productUrls: product pages to read. One run can hold many products, across marketplaces.
• maxReviews: stop after this many reviews per product (default 10).
• sort: helpful follows the order on the public product page; recent reorders by date.
• filterByRatings: allStars, fiveStar to oneStar, or positive and critical. critical is the quickest way to find defects.
• reviewsCutoffDate and reviewsFilterByKeywords: keep reviews on or after a date (2026-09-01 or 30 days) or reviews that contain one of your words, such as "battery".

Scrape Amazon reviews with the API

Create an API token under Settings → API & Integrations in the dashboard and export it as SCRAPELY_TOKEN.

Our run took 8 seconds, so the synchronous endpoint works: it starts the run, waits up to 45 seconds and returns the reviews as a JSON array (?format=csv for CSV).

curl -X POST "https://api.scrape.ly/v2/actors/shelfbright~amazon-reviews-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $SCRAPELY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productUrls": [{"url": "https://www.amazon.com/dp/B0CWXNS552"}], "maxReviews": 5, "sort": "helpful"}'

For a long list of products the run can pass 45 seconds; the call then answers 408 while the run keeps going. Don't call it again (that would start a second run); use a client, which waits as long as needed.

Python (pip install scrapely-client-python), here pulling critical reviews for two products:

import os
from scrapely_client import ScrapelyClient

client = ScrapelyClient(os.environ["SCRAPELY_TOKEN"], api_url="https://api.scrape.ly")

run = client.actor("shelfbright/amazon-reviews-scraper").call(
    run_input={
        "productUrls": [{"url": "https://www.amazon.com/dp/B0CWXNS552"}, {"url": "https://www.amazon.de/dp/B09B8RF4PY"}],
        "maxReviews": 10,
        "filterByRatings": ["critical"],
    }
)
print(run.status)  # SUCCEEDED, FAILED, ABORTED or TIMED-OUT
for review in client.dataset(run.default_dataset_id).iterate_items():
    print(review["productAsin"], review["ratingScore"], review["isVerified"], review["reviewTitle"])

Node.js (npm install scrapely-client):

import { ScrapelyClient } from 'scrapely-client';

const client = new ScrapelyClient({ token: process.env.SCRAPELY_TOKEN, baseUrl: 'https://api.scrape.ly' });

const run = await client.actor('shelfbright/amazon-reviews-scraper').call({
  productUrls: [{ url: 'https://www.amazon.com/dp/B0CWXNS552' }],
  maxReviews: 5,
  sort: 'helpful',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((r) => [r.ratingScore, r.date, r.variant, r.reviewTitle]));

For AI agents, add the Scrape.ly MCP server. In Cursor, ~/.cursor/mcp.json:

{
  "mcpServers": {
    "scrapely": {
      "url": "https://api.scrape.ly/mcp",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}

In Claude Code, run claude mcp add --transport http scrapely https://api.scrape.ly/mcp and sign in with /mcp. Then ask: "Use scrapely to run shelfbright/amazon-reviews-scraper on https://www.amazon.com/dp/B0CWXNS552 with critical reviews only, and summarize the top three complaints." The agent reads the input schema, runs the Actor and works with the rows. See the MCP docs and the Python client.

A real run: the 5 most helpful reviews of an AirTag

We ran the input above on 22 October 2026. It returned 5 reviews in 8 seconds and was charged $0.0215.

Reviewers are private people, so the table leaves them out; the run saved no names (personal information was off), and we also dropped the profile links and review permalinks from our stored sample. Every row carried the product's totals as Amazon shows them: 12,162 reviews and 60,137 ratings. The full first record also had the "Reviewed in the United States on August 13, 2026" line, the helpful-vote count and the variant attributes as key-value pairs.

All five of Amazon's top reviews were 5-star and verified. That is the point of helpful sorting: it mirrors what a shopper sees first. For product research, run the same product with filterByRatings: ["critical"] next to it.

The log, without the platform's start-up lines:

2026-10-22T18:26:22.216Z [Scrapely] Container started (setup 0.9 s)
2026-10-22T18:26:23.484Z [scrapely.actor] INFO  Reading reviews for 1 product URL(s), up to 5 each, sort=helpful.
2026-10-22T18:26:29.013Z [scrapely.actor] INFO  Datacenter bytes=2581981. Residential bytes=0.
2026-10-22T18:26:29.013Z [scrapely.actor] INFO  [Status message]: Saved 5 reviews from 1 product URL(s).
2026-10-22T18:26:29.494Z [Scrapely] Container state: status=exited exitCode=0 oomKilled=false

About 2.6 MB of datacenter traffic and no residential proxy: one product page, read once.

What it costs

The Actor charges $0.004 per review saved, which is $4.00 per 1,000 reviews. Platform usage (compute and proxy) is billed on top.

For our run: 5 reviews × $0.004 = $0.02 in review fees. The run was charged $0.0215 in total, because it also used $0.0011 of compute, $0.0004 of datacenter proxy traffic and under $0.0001 of storage writes. A product with no reviews, a wrong ASIN or a filter with no match saves no row and pays no review fee: when we first tried a product URL that no longer exists, the run finished in 4 seconds with "No results: Loaded a 404 page. The product does not exist." and $0.0006 of usage.

For a catalog: 200 products with about 8 featured reviews each is roughly 1,600 reviews, or about $6.40 in review fees.

What to watch out for

• Amazon shows logged-out visitors a featured set. Public product pages carry a featured selection of reviews, about 8 in the publisher's tests, not the full history. Scrape.do's October 2026 check found that both full-review URLs, /product-reviews/ and the newer /portal/customer-reviews/, send logged-out visitors to Amazon's sign-in page. The Actor stays on the public page by design, so maxReviews: 100 on one product still returns the featured set.
• Filters work inside that set. Sort, star, date and keyword filters apply to the featured reviews. To widen coverage, add more products, variants (reviewsUseProductVariantFilter) or marketplaces: amazon.de and amazon.com show different reviews.
• Bot walls on big batches. Amazon blocks bursts of product pages. The Actor uses datacenter exits and switches to residential automatically when one is blocked; if a dozen product pages in a row are blocked, it stops early, keeps what it saved and tells you how many URLs to run again later.
• Totals are Amazon's. totalCategoryReviews comes from the product page and can differ from other sources.
• Pages change. Amazon updates its layout from time to time, which can cause occasional gaps. Because your code reads fields, not HTML, a fix to the Actor needs no change on your side.

Is it legal to scrape Amazon reviews?

The Actor reads only what Amazon shows without signing in, and it never logs in. Amazon's own Conditions of Use (last updated August 14, 2026) are strict: the license to use the site "does not include … any use of data mining, robots, or similar data gathering and extraction tools". Whether those terms bind you, and what follows if you break them, depends on your jurisdiction and your use.

Reviews also carry personal data. A reviewer's name, avatar and profile link identify a private person under the GDPR and the CCPA, which is why the Actor saves names only when you ask. Logged-in scraping is a different matter: Scrape.do's own guide warns that "data behind a login wall may not be considered public data". This is not legal advice; if reviews feed a product, a model or a resale dataset, ask a lawyer.

Why Scrape.ly for Amazon review scraping

• No account, no cookies. Cookie-injection tutorials tie scraping to your own Amazon login and its terms. The Actor reads the public product page only, which keeps you on the public-data side of the line.
• Rows, not HTML. No selectors to fix when Amazon redesigns: you get ratingScore, isVerified and variant as fields, in JSON, CSV or Excel.
• Privacy by default. Reviewer names and avatars stay out unless you switch them on.
• One workflow for the whole product. Pair it with the Amazon Product Scraper for prices, ratings and review counts across a search (see how to scrape Amazon), schedule both, and hand the analysis to an AI agent over MCP.

FAQ

Can you scrape all reviews of an Amazon product?

Not without signing in. Logged out, Amazon shows a featured set on the product page; the full reviews listing redirects to sign-in. The Actor returns that public set, and covers more ground across variants and marketplaces.

Is there an Amazon reviews API?

You can call this Actor as one: the same token and endpoints shown above return reviews as JSON or CSV. The Amazon API page on Scrape.ly lists it next to the Amazon Product and Bestsellers scrapers, with setup steps for Python, JavaScript, HTTP and MCP.

Can you scrape Amazon reviews with Python?

Yes. Install scrapely-client-python, call shelfbright/amazon-reviews-scraper with your product URLs, and iterate over the dataset, as in the example above. No headless browser or proxy setup on your side.

Do I need proxies or an Amazon account?

No account. A datacenter proxy is built in and used by default, and blocked requests switch to residential automatically.

Can I scrape reviews from amazon.de and other Amazon stores?

Yes. The marketplace comes from the URL, so https://www.amazon.de/dp/… reads the German store, and each product URL in a run can point to a different store.

How do I find negative Amazon reviews?

Set filterByRatings to critical (or oneStar, twoStar), and add reviewsFilterByKeywords such as "broke" or "battery" to narrow it down. Our guide to price scraping shows how to put the same Actors on a schedule.