Amazon product reviews are a goldmine. Star ratings, verified purchase flags, review dates, helpful vote counts, written feedback, it's all publicly visible and genuinely useful for competitor research, sentiment analysis, and product development.
The challenge is volume. One product might have thousands of reviews. Doing it manually isn't an option. This guide covers how to scrape Amazon product reviews at scale using three tools: Apify, Outscraper, and Crawlbase.
Three tools cover most use cases, depending on how technical your setup needs to be.
Apify is a cloud scraping platform built around pre-built scripts called Actors. The Amazon Reviews Scraper Actor handles proxies and CAPTCHA solving internally. You get results in JSON, CSV, Excel, or XML with no infrastructure to manage. It works well for scheduled monitoring and filtered review pulls.
Outscraper is a no-code dashboard built for batch jobs. Paste in ASINs, configure filters, download results. It also has a Python SDK for teams that want programmatic access. A solid choice for analysts who need review data across many products without writing custom scripts.
Crawlbase is a developer-focused crawling API. You send a request with the amazon-product-reviews scraper parameter, and it returns structured JSON instead of raw HTML. No parsing layer needed. Best suited for teams integrating review collection into a larger data pipeline.
You'll also need Python 3 and pip installed, plus accounts on whichever platforms you use.
Each tool has a different workflow. Here's how to get running with all three.
Sign up for an Apify account and open the Amazon Reviews Scraper in the Apify Store. The key input fields are: ASIN or product URL, sortBy (top or recent), filter_by_ratings, filter_by_verified_purchase_only, and filter_by_keywords.
For programmatic runs, the official apify/apify-client-python library lets you trigger the Actor from Python. Install it with pip install apify-client, then:
///
from apify_client import ApifyClient
client = ApifyClient('YOUR_APIFY_TOKEN')
run_input = { 'startUrls': [{'url': 'https://www.amazon.com/product-reviews/B08N5WRWNW'}], 'maxReviews': 500, 'filterByRatings': [1, 2, 3, 4, 5], }
run = client.actor('junglee/amazon-reviews-scraper').call(run_input=run_input)
for item in client.dataset(run['defaultDatasetId']).iterate_items(): print(item)
///
Amazon caps pagination at 100 reviews per unfiltered query. To go beyond that, run the Actor multiple times using different filter_by_keywords values. Each keyword opens a separate filtered view, each returning up to 100 results.
Log in to Outscraper and navigate to the Amazon Reviews Scraper. Paste your ASINs or product URLs, set your parameters (review count, sort order, star rating filter, verified purchases only), pick CSV or JSON, and start the job.
For Python access, Outscraper publishes an official SDK at outscraper/amazon-scraper-python. Install and run:
///
pip install amazon-scraper-by-outscraper
///
///
from amazon_scraper_by_outscraper import AmazonClient
client = AmazonClient(api_key='YOUR_API_KEY')
results = client.get_reviews('B08N5WRWNW', limit=100)
for review in results: print(review)
///
Outscraper supports multiple Amazon storefronts including amazon.com, amazon.co.uk, amazon.de, and amazon.co.jp.
Sign up for Crawlbase and grab your API token. The official Amazon scraping examples are at ScraperHub/amazon-scraper. Install the library and point it at your target review page:
///
pip install crawlbase
///
///
from crawlbase import CrawlingAPI
api = CrawlingAPI({'token': 'YOUR_TOKEN'})
asin_url = 'https://www.amazon.com/product-reviews/B08N5WRWNW'
response = api.get(asin_url, {'scraper': 'amazon-product-reviews'})
if response['status_code'] == 200: print(response['body'])
///
The response is structured JSON with reviewer names, ratings, dates, titles, and body text. For pagination, increment the pageNumber query parameter and loop until results are empty.
If you're using Crawlbase without its internal proxy layer, you'll need rotating residential proxies underneath. GoProxies rotating residential proxies integrate cleanly with API-based setups and pull from 30 million ethically sourced residential IPs across 200+ locations.
Amazon's defenses are layered. Getting through them consistently requires the right setup.
Rotating residential proxies are the foundation. Each request goes through a different residential IP, which prevents per-IP rate limit accumulation. Datacenter IPs get flagged on the first request. Residential IPs pass the initial classification check. GoProxies supports country, state, and city-level targeting, so you can match your proxy location to the Amazon storefront you're scraping.
Beyond proxies, a few practices make a real difference:
Sessions and cookies help maintain consistent browsing context across requests. Initialize a session before hitting review pages rather than firing cold requests.
Randomized delays between requests mimic human behavior more closely than fixed intervals. Amazon's behavioral analysis detects mechanical patterns.
User agents should rotate alongside IPs. A static user agent string combined with a rotating IP is still a detectable pattern.
Retry logic with exponential backoff handles transient blocks gracefully without hammering the server.
For heavy-duty setups, keep concurrency controlled. Parallel requests across many ASINs are fine. Just ramp up gradually once you've confirmed stable success rates.
Amazon runs one of the more aggressive anti-bot systems in e-commerce.
Every incoming IP is evaluated against reputation databases. Datacenter IPs are blocked almost immediately. Residential IPs receive a lower suspicion score and pass through.
Amazon inspects your HTTPS connection characteristics to determine whether the client looks like a real browser. A plain Python requests session has a different TLS signature than Chrome.
Click patterns, scroll events, navigation flow, and session duration all feed a bot-confidence score. Review pages are particularly aggressive targets for this analysis.
High bot-confidence scores trigger CAPTCHA challenges. Managed tools like Apify and Outscraper handle these internally. Custom setups need a CAPTCHA solving layer or strong enough proxy rotation to avoid triggering them.
Amazon limits review pagination to 10 pages of 10 results each. This is a platform constraint, not a bug. The keyword filter workaround is covered in the step-by-step section above.
Switch to rotating residential proxies and add request delays. If you're on a managed tool and still hitting CAPTCHAs, reduce concurrency.
Indicates a rate limit or IP-level block. Verify your proxies are residential and that rotation is working. On managed tools, add delays between runs.
This is Amazon's pagination limit, not a scraper bug. Use filter_by_keywords across multiple runs to collect beyond 100 results per product.
Check whether the product actually has those data points, as not every review includes images or helpful votes. If fields are missing across the board, the page structure may have changed. Update your parsing logic or check for Actor updates on managed platforms.
A well-structured Amazon review record typically includes:
That's a rich dataset for sentiment analysis, product benchmarking, or brand monitoring. If you want to collect it at scale without constant blocks, GoProxies gives you the residential IP infrastructure to keep the operation running cleanly.
Scraping publicly available data is generally legal in the United States. Amazon product reviews are visible to anyone with a browser, no login required.
The Ninth Circuit's ruling in hiQ Labs v. LinkedIn affirmed that scraping publicly accessible data does not violate the Computer Fraud and Abuse Act.
That said, Amazon's Terms of Service prohibit automated access. ToS violations carry no criminal liability but can result in IP blocks or account suspension.
The practical guidance: scrape what's publicly visible, avoid collecting personal data beyond what's part of the public review record, pace your requests responsibly, and don't overload Amazon's servers.
Amazon offers the Product Advertising API 5.0 (PA-API), which provides structured access to product data including some review information.
The pros: it's official, structured, and won't get you blocked. The cons: access is tied to your Amazon Associates account and scales with revenue. Starting limits are 1 request per second and 8,640 requests per day, with increases tied to shipped item revenue. If your account hasn't generated qualifying sales in the past 30 days, access is suspended.
For review-specific data collection at scale, the API's rate limits and eligibility requirements make it impractical for most research or data pipeline use cases. Scraping gives you more flexibility, at the cost of managing the anti-bot layer yourself.
All three tools covered in this guide offer free tiers. Apify provides monthly credits, Outscraper and Crawlbase both have starter plans. For small, one-off pulls, free tiers are fine.
At scale, free scraping has real drawbacks. Free proxy layers are shared, which means higher block rates and lower success rates. Rate limits on free plans cap how much data you can collect per run. Reliability becomes inconsistent under load.
The other risk is IP reputation. Free tools often route traffic through shared or lower-quality IP pools, which Amazon has already flagged. Your requests start at a disadvantage before you've made a single call.
For anything beyond testing, investing in quality proxy infrastructure pays for itself quickly in time saved debugging failed runs.
Scraping Amazon product reviews is manageable with the right tools. Apify and Outscraper handle the infrastructure for you: proxies, CAPTCHAs, scheduling. Crawlbase gives you API-level control if you're building a custom pipeline.
The main constraints to plan around: the 100-review pagination cap, Amazon's residential-vs-datacenter IP discrimination, and TLS fingerprinting. Address those, and the rest is straightforward.
GoProxies Research Team is a group of analysts and writers focused on web data, online privacy, and proxy technology. They produce practical, research-backed content that helps readers understand digital trends, tools, and best practices.
The rich text element allows you to create and format headings, paragraphs, blockquotes, images, and video all in one place instead of having to add and format them individually. Just double-click and easily create content.
A rich text element can be used with static or dynamic content. For static content, just drop it into any page and begin editing. For dynamic content, add a rich text field to any collection and then connect a rich text element to that field in the settings panel. Voila!
Headings, paragraphs, blockquotes, figures, images, and figure captions can all be styled after a class is added to the rich text element using the "When inside of" nested selector system.
Yes, scraping more than 100 Amazon reviews per product is possible. Amazon limits pagination to 10 pages of 10 results each, but running multiple filtered queries using the filter_by_keywords parameter opens separate review views, each returning up to 100 results.
Yes, you need proxies to scrape Amazon reviews at any meaningful scale. Amazon blocks datacenter IPs almost immediately, so rotating residential proxies are the standard choice. Managed tools like Apify and Outscraper handle proxies internally. Custom setups require your own proxy layer.
Amazon product reviews typically contain star rating, review title, body text, reviewer name, date, verified purchase status, helpful vote count, and attached images. Some tools also extract the reviewer's profile ID and the product ASIN, which is useful for joining datasets across multiple products.
