Amazon Reviews API: Pull All Reviews for a List of ASINs

Get the full review text for a list of Amazon products in one prompt. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to pull the most recent reviews for these Amazon ASINs, keep the rating, title, text, date and verified-purchase flag, and give me one table with a row per review.

One prompt pulls the reviews for a whole list. 1 min setup · 30-60 hrs saved.

You have a list of Amazon products and you want what buyers wrote about them: the text, the stars, the date, and whether the buyer really bought it. This guide shows the quickest way to get that into your agent or a spreadsheet, what each record contains (we ran it live on 2026-10-16), and the four traps we hit on the way: billing per review, one page meaning ten reviews, an endpoint that came back empty, and reviews in a language you did not expect. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.

Is there an official Amazon reviews API, and what is the easiest way to get reviews?

There is no official Amazon API that returns review text, and the easiest way to get it is Monid. Install it once, add a key, and your agent calls an Amazon reviews endpoint with no portal, no plan and no vendor account to set up.

• Pay for what you run. The Axesso Amazon reviews endpoint is billed per review returned, at $0.0009 a review (Verified 2026-10-16 on the Amazon tools page). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free; only a run bills.
• One install, every tool. The same key and balance call Amazon reviews and every other tool on Monid. When you need Google Maps, Yelp or Zillow next, there is no new account to open.
• Lives inside your agent. Install the CLI, add your key, run the prompt above, and the tools are there whenever your agent needs them, on demand, with nothing to keep running. Your agent reads SKILL.md and learns the rest, so setup is about a minute.

At that price the most recent ten reviews of a product cost $0.009, and our test run billed exactly that (Verified 2026-10-16).

The endpoints and their live prices are listed on the Amazon tools page.

How do you get all the reviews for a list of ASINs?

Run one call per product with the page depth you want, then loop it over your list. Reviews arrive ten to a page, so the depth setting is the only dial that decides how many you get and what you pay.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

Look at the endpoints first

discover and inspect are free and print the schema and the current price:

monid discover -q "amazon reviews"

Pull a product's reviews

monid inspect -p apify -e /axesso_data/amazon-reviews-scraper
monid run -p apify -e /axesso_data/amazon-reviews-scraper \
  -i '{"input":[{"asin":"B0BSHF7WHW","domainCode":"com","maxPages":5,"sortBy":"recent"}]}'

At ten reviews a page, maxPages 5 asks for up to 50 reviews, which is up to $0.045 at the price above (Verified 2026-10-16). We ran the same call on 2026-10-16 with maxPages set to 1 and got ten review rows back in about eight seconds.

Read the total before you loop

Every row carries countReviews, the number of reviews the product has, so the first page tells you where to stop. For the MacBook Pro listing we used it was 89 on 2026-10-16, which is nine pages of ten.

const total = rows[0].countReviews;      // 89
const pages = Math.ceil(total / 10);     // 9

Loop it over your list

Put one ASIN per line in asins.txt, then run:

mkdir -p out
while read -r asin; do
  monid run -p apify -e /axesso_data/amazon-reviews-scraper \
    -i "{\"input\":[{\"asin\":\"$asin\",\"domainCode\":\"com\",\"maxPages\":2,\"sortBy\":\"recent\"}]}" > "out/$asin.json"
done < asins.txt

Each product writes one file with its newest reviews. Raise maxPages only for the products whose countReviews says there is more to read.

Or hand the whole job to an agent

📖 See also Pull an ASIN's whole review history in one call: the paging-to-the-end walkthrough for a single product.

Can you scrape Amazon reviews yourself with Python?

Yes, people do it with requests, BeautifulSoup, Selenium or Playwright, and it works until Amazon changes the page or starts blocking you. A scraper you write is yours to keep alive: when the markup, the blocking or the sign-in behaviour changes, your job breaks, and your table is only as fresh as your last successful run.

Doing it in Python means a proxy or browser setup, a parser for the review block, retry and paging logic, and a repair every time something moves. That is hours before the first useful row, and then upkeep. There is a rules side too: read Amazon's conditions of use before you build anything, because what you may do depends on where you operate and how you use the data.

A call through Monid costs $0.0009 a review (Verified 2026-10-16). Set against hours of your own time, the choice is easy for anything you will run more than once: the collection is maintained for you, and the output is typed JSON instead of HTML you parse. Browser extensions that export reviews to a CSV, and downloadable review datasets, are quicker for a one-off look, but an extension works one page in your own browser and a dataset is a snapshot of one date for the products its author chose.

📖 See also Python web scraping without a scraper: where the do-it-yourself route stops being worth it.

What does Amazon review data look like, and what can you build with it?

Two layers per row: the review, and the product it belongs to. We ran the Axesso endpoint on 2026-10-16 against a MacBook Pro listing, so the fields below are what came back, not what a spec promises.

The review

Each row is one review. Trimmed from the first row:

{ "reviewId": "RLA7OKGSYR43Y",
  "title": "Excelente producto",
  "text": "Excelente producto",
  "date": "Reviewed in the United States on January 8, 2026",
  "rating": "5.0 out of 5 stars",
  "userName": "Juan Carlos Marino",
  "numberOfHelpful": 0,
  "verified": true,
  "vine": false,
  "variationList": [],
  "imageUrlList": [],
  "videoUrlList": [],
  "locale": null }

reviewId is the stable key. rating and date come back as display strings, so parse the number and the date yourself. verified and vine separate buyers from free-product reviewers, numberOfHelpful is the helpful-vote count, and imageUrlList and videoUrlList hold attached media (all empty in our ten rows).

The product, repeated on every row

Every row repeats the product fields: productTitle, countReviews (89), countRatings (384), productRating ("4.7 out of 5") and reviewSummary, the percentage of reviews at each star level. For this product that was 88, 6, 3, 0 and 3 percent from five stars down to one. You get the shape of sentiment without counting anything.

What you can build with it

• A sentiment score per product. Pull the newest reviews for each ASIN and score them, as in scoring an ASIN's reviews for sentiment in 15 minutes.
• A one-star digest. Keep the rows where rating is 1.0 and read what broke. Of our ten rows one was a one-star, "Won't power on", and it named the failure and the repair cost.
• A competitor teardown. Run the same pull for a rival's best-sellers and compare reviewSummary side by side.

What goes wrong when you pull Amazon reviews at scale?

Four things hide until you run more than one product. All four came out of our runs on 2026-10-16.

Why does the bill follow the number of reviews, not the number of products?

Because each review row is a billed unit. The endpoint's own price note says one result is returned per input query, and our run did not match it: one input query returned 10 rows and billed 10 units, $0.009 (Verified 2026-10-16). The cost of a job is the number of reviews you ask for times $0.0009.

• All 89 reviews of the product we used cost $0.0801 (Verified 2026-10-16).
• Raising maxPages raises the bill in proportion. It is a spending dial, not a free flag.
• Work out countReviews first and cap maxPages on products with a long history.

Why did I get only ten reviews?

Because one page is ten reviews, and a quickstart that leaves maxPages at 1 returns one page. Set the depth from countReviews in the first response and page until you reach it.

Why did one endpoint return nothing?

We called /web_wanderer/amazon-reviews-extractor for the same ASIN twice on 2026-10-16, with limit 1, and each run finished with HTTP 200, zero rows and a $0 charge (Verified 2026-10-16). An empty array is a result, not an error (the same shape is covered in what to do when an Amazon ASIN scraper returns nothing), so check the row count before you build on a run. Billing is per row, so an empty run costs nothing, and the same job can go to the Axesso endpoint with one changed -e flag.

if (rows.length === 0) { /* retry on the other Amazon reviews endpoint */ }

Why is a review in the wrong language?

Because the storefront is not the language. Of our ten rows from amazon.com, two were written in Spanish, and only one of those carried a locale object (language es, country US); the other had locale null. If you score sentiment, detect the language of text first or the model will quietly mark what it cannot read. The web_wanderer endpoint takes a language filter if you want one language only.

Where is the ceiling on one product?

The web_wanderer endpoint says in its own input description that Amazon limits a product to 10 pages, 100 reviews, and that you reach more by filtering on star rating, variant and sort order. Its all_stars mode asks for up to 100 reviews per star level, 500 per product. Plan a deep pull as five star-filtered runs, not one run with a big page count.

Which endpoint should I use for which job?

The Axesso row was run on 2026-10-16. The web_wanderer and DataForSEO rows were inspected the same day, and the latency is the endpoint's typical (median) run time. The Axesso price is $0.0009 a review (Verified 2026-10-16). The web_wanderer price is $0.0007 a review plus a flat fee of $0.00002 per run (Verified 2026-10-16). Current figures are on monid.ai/tools.

The DataForSEO row answers a different question: which products rank for a search, not what buyers said about one. If you need to find the ASINs first and read their reviews second, start there. For what a large review pull looks like once it is in hand, I read 10,000 Amazon reviews so you don't have to walks through one. Having two review endpoints is useful in practice: the same job can go to either one from the same balance, with no new signup, if one comes back empty.

When is another route a better fit?

You only need a star rating and a count. No reviews scraper is worth it for a badge. Both numbers are on every row we pulled, but a product page gives you the same two numbers for free.

You need every review of a very popular product. The ceiling on a single run is a hundred reviews, so a product with tens of thousands needs filtered runs per star level, and the call count adds up. Budget it before you start.

You need a contract, not a catalog. If you want a named account manager and an uptime figure in writing, buy from a single vendor directly.

You are republishing review text. Reviews belong to the people who wrote them and to Amazon's terms. Mining them for internal analysis is ordinary. Republishing them on your own pages is a different act.

And the disclosure: we resell these endpoints. The most useful thing in this post is to read countReviews before you set maxPages, which costs nothing and is the same whoever you buy the data from.

Conclusion

The quickest way to get Amazon reviews for a list of ASINs is one call per product through Monid: $0.0009 a review (Verified 2026-10-16), one key for Amazon and everything else, about a minute to set up, and ready inside your agent whenever you need it. Scraping it yourself works until the page changes and costs hours of setup; Monid keeps the collection maintained.

Two things matter more than which endpoint you pick. You pay per review, so maxPages is a spending dial, and countReviews in the first row tells you where the product ends. And an empty run is a normal outcome: check the row count, then send the job to the other endpoint.

How we estimated the time saved: building and running your own Amazon reviews scraper is roughly 10 to 20 hours each for getting past blocking, parsing and paging the review block, and the first month of upkeep. That is 30 to 60 hours. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run monid discover -q "amazon reviews", then monid inspect on the endpoint you pick, then one call with maxPages 1. Ten rows cost $0.009 (Verified 2026-10-16). Start at monid.ai.

FAQ

Published July 2026.