Mijn Amazon review scraper werkte zes weken lang perfect — en toen kreeg ik op een ochtend ineens een 200 OK terug met een pagina vol niks. Geen foutmelding, geen CAPTCHA, alleen lege HTML waar eerst honderden reviews stonden.
Klinkt dat bekend? Je bent zeker niet de enige. Eind 2025 zette Amazon complete reviewpagina’s achter een inlogscherm, waardoor heel wat Python-scraping scripts van de ene op de andere dag stukliepen. De afgelopen maanden heb ik bij Thunderbit van twee kanten aan dit probleem gewerkt — aan onze AI scraper én aan mijn eigen Python review-pipeline — dus ik vond dat het tijd was om de gids te schrijven die ik zelf had willen hebben toen mijn script ermee ophield. In deze post neem ik je mee door de aanpak die wél werkt: cookie-based authenticatie, stabiele selectors die Amazons CSS-obfuscatie overleven, omwegen voor de limiet van 10 pagina’s, anti-botmaatregelen en, als bonus, een sentimentanalyse-sectie die ruwe reviewtekst omzet in echte bedrijfsinzichten. En als je halverwege denkt: “Ik wil al die code eigenlijk niet onderhouden”, dan laat ik je zien hoe Thunderbit hetzelfde werk in ongeveer twee minuten doet, zonder Python.
Wat is Amazon review scraping eigenlijk — en waarom is het belangrijk?
Amazon review scraping is het geautomatiseerd ophalen van klantbeoordelingen — sterren, reviewtekst, auteursnamen, datums, labels voor geverifieerde aankoop — van productpagina’s op Amazon. Omdat Amazon reviewcontent al in 2010 uit de Product Advertising API heeft verwijderd en dat nooit heeft teruggedraaid, is webscraping de enige programmeerbare manier om bij deze data te komen.
De cijfers maken duidelijk waarom dit ertoe doet. 95% van de shoppers leest reviews vóór aankoop, en 94% noemt Amazon als hun belangrijkste bron voor productreviews. Alleen al het tonen van 5 reviews op een productpagina kan de conversie met 270% verhogen. Bedrijven die review-sentiment systematisch analyseren, zien tot 15% hogere klantretentie. Dit is geen abstracte data science — dit is concurrentie-informatie, productfeedback en marketingtaal, gewoon als platte tekst op Amazon-servers.
Waarom Amazon reviews scrapen met Python?
Python blijft hier de standaardkeuze. Het is de meest gewilde taal in de Stack Overflow Developer Survey 2024, en het ecosysteem — requests, BeautifulSoup, pandas, Scrapy — maakt webscraping toegankelijk, ook als je geen fulltime developer bent.
Verschillende teams zetten deze data op verschillende manieren in:
| Team | Use case | Wat ze ophalen |
|---|---|---|
| Product / R&D | Terugkerende klachten vinden, fixes prioriteren | Reviewtekst met 1–2 sterren, trefwoordfrequentie |
| Sales | Sentiment van concurrentproducten volgen | Ratings, trends in reviewvolume |
| Marketing | Klanttaal gebruiken voor advertentieteksten | Positieve reviewzinnen, verwijzingen naar features |
| Ecommerce Ops | Sentiment van eigen producten in de tijd volgen | Sterverdeling, ratio van geverifieerde aankopen |
| Marktonderzoek | Categorieleiders vergelijken op functies | Reviewdatasets van meerdere ASIN’s |
Een merk in keukenartikelen analyseerde negatieve reviews en ontdekte dat 22% “de anti-aanbaklaag slijt” noemde, paste de formule aan en pakte binnen 60 dagen de #1 Best Seller-positie terug. Een fitness tracker-bedrijf haalde “bandirritatie” uit reviewtekst, vond een probleem met latexallergie, bracht een hypoallergene variant uit en verlaagde retouren met 40%. Dáár zit de ROI die de technische moeite waard maakt.
Het inlogscherm: waarom je Amazon review scraper ineens stopte
Op 14 november 2024 ging Amazon vereisen dat je inlogt om de volledige productreviewpagina te bekijken. De wijziging werd bevestigd in communityforums en blogs van scraping-aanbieders. Als je /product-reviews/{ASIN}/ bezoekt in een incognitovenster, word je doorgestuurd naar een inlogpagina in plaats van reviewdata.
De symptomen zijn verraderlijk: je script krijgt een 200 OK, maar in de HTML-body staat een inlogformulier (name="email", id="ap_password") in plaats van reviews. Geen foutcode. Geen CAPTCHA. Gewoon... niets bruikbaars.
Amazon doet dit om anti-botredenen en vanwege regionale compliance. De handhaving is niet altijd identiek — soms laadt een verse browser nog een paar reviews voordat de muur verschijnt, vooral op de eerste pagina — maar voor elke scraper die op schaal draait, moet je ervan uitgaan dat die muur altijd aanstaat.
Verschillende Amazon-landdomeinen (.de, .co.uk, .co.jp) hanteren die muur los van elkaar. Zoals iemand op een forum het samenvatte: “je hebt voor elk land een aparte login nodig.” Je .com-cookies werken dus niet op .co.uk.
Featured reviews versus volledige reviews: wat kun je nog wel zien zonder login?
Amazon-productpagina’s (/dp/{ASIN}/) tonen nog steeds ongeveer 8 “featured reviews” zonder authenticatie. Deze worden door Amazons algoritme geselecteerd en zijn handig voor een snelle sentimentcheck, maar je kunt ze niet sorteren, filteren of pagineren.
De volledige reviewpagina’s (/product-reviews/{ASIN}/) — met sorteren op nieuwste, filteren op sterrating en paginering over honderden reviews — vereisen inloggen.
Heb je maar een handvol reviews nodig voor een snelle eerste indruk? Scrape dan de productpagina. Gaat het om honderden of duizenden reviews, dan moet je authenticatie goed regelen.
Wat je nodig hebt voor je begint: Python-setup en libraries
Voordat we code schrijven, eerst de basis:
- Moeilijkheidsgraad: Gemiddeld (je moet comfortabel zijn met Python en basis-HTML begrijpen)
- Benodigde tijd: ongeveer 45 minuten voor de volledige pipeline; ongeveer 10 minuten voor een simpele scrape
- Wat je nodig hebt: Python 3.8+, Chrome-browser, een geldig Amazon-account
Installeer de kernlibraries:
pip install requests beautifulsoup4 lxml pandas textblob
Optioneel (voor geavanceerde sentimentanalyse):
pip install transformers torch
Wat is een ASIN? Dat is Amazons 10-karakter product-ID. Je vindt die in elke product-URL — bijvoorbeeld in amazon.com/dp/B0BCNKKZ91 is de ASIN B0BCNKKZ91. Dat is de sleutel die je in de review-URL gebruikt.
Stap 1: kom langs het inlogscherm met cookie-based authenticatie
De betrouwbaarste aanpak is: log in op Amazon in je browser, kopieer je sessiecookies en injecteer ze in je Python requests.Session(). Zo voorkom je CAPTCHA’s en sms-2FA die Selenium-gebaseerde inlogautomatisering vaak triggert.
Je hebt deze zeven cookies nodig:
| Cookienaam | Doel |
|---|---|
session-id | Roterende sessie-ID |
session-id-time | Tijdstempel van de sessie |
session-token | Roterende sessietoken |
ubid-main | Identificatie van browse-sessie |
at-main | Primair auth-token |
sess-at-main | Auth binnen sessie |
x-main | Identificatie gekoppeld aan e-mailadres |
Hoe je cookies uit Chrome DevTools haalt
- Log in op amazon.com in Chrome
- Open DevTools (F12 of rechtermuisknop → Inspecteren)
- Ga naar Application → Storage → Cookies →
https://www.amazon.com - Zoek elke cookienaam in de tabel en kopieer de waarde
- Zet ze om naar een door puntkomma’s gescheiden string voor Python
Zet je session zo op:
import requests
session = requests.Session()
# Plak hier je cookie-waardes
cookies = {
"session-id": "YOUR_SESSION_ID",
"session-id-time": "YOUR_SESSION_ID_TIME",
"session-token": "YOUR_SESSION_TOKEN",
"ubid-main": "YOUR_UBID_MAIN",
"at-main": "YOUR_AT_MAIN",
"sess-at-main": "YOUR_SESS_AT_MAIN",
"x-main": "YOUR_X_MAIN",
}
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.5",
}
session.cookies.update(cookies)
session.headers.update(headers)
Belangrijk: gebruik overal hetzelfde session-object. Zo blijven cookies consistent en lijkt het gedrag op een echte browsersessie. Cookies blijven meestal dagen tot weken geldig onder scrapingbelasting, maar als je weer login-redirects krijgt, vernieuw ze dan vanuit je browser.
Voor marketplaces buiten .com veranderen cookienamen iets — amazon.de gebruikt bijvoorbeeld at-acbde in plaats van at-main, amazon.co.uk gebruikt at-acbuk, enzovoort. Elke marketplace heeft zijn eigen losse sessie nodig.
Stap 2: bouw de request en parse review-HTML met BeautifulSoup
De Amazon reviews-URL volgt dit patroon:
https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1
De kernfunctie:
from bs4 import BeautifulSoup
import time, random
def get_soup(session, url):
time.sleep(random.uniform(2, 5)) # Netjes wachten
response = session.get(url, timeout=15)
# Detecteer inlogmuur
if "ap_email" in response.text or "Amazon Sign-In" in response.text:
raise Exception("Inlogmuur gedetecteerd — vernieuw je cookies")
if response.status_code != 200:
raise Exception(f"HTTP {response.status_code}")
return BeautifulSoup(response.text, "lxml")
Een kleine truc die helpt: bezoek vóór de reviewpagina eerst de productpagina. Dat laat je sessie er natuurlijker uitzien.
# Bezoek eerst de productpagina (lijkt op normaal browsen)
product_url = f"https://www.amazon.com/dp/{asin}"
session.get(product_url, timeout=15)
time.sleep(random.uniform(1, 3))
# Ga daarna naar de reviewpagina
reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
soup = get_soup(session, reviews_url)
Stap 3: gebruik stabiele selectors om reviewdata op te halen (vertrouw niet op CSS classes)
Hier gaat het bij de meeste tutorials uit 2022–2023 mis. Amazon verbergt CSS class-namen — die veranderen regelmatig, en zoals een gefrustreerde developer op een forum schreef: “geen van hen had ook maar één patroon in de classnamen van span-tags.”
De oplossing: Amazon gebruikt data-hook-attributen op reviewelementen, en die zijn opvallend stabiel. Het zijn semantische identifiers waar Amazons eigen frontend op leunt, dus die worden niet willekeurig aangepast.
| Reviewveld | Stabiele selector (data-hook) | Kwetsbare selector (class) |
|---|---|---|
| Reviewtekst | [data-hook="review-body"] | .review-text-content (verandert) |
| Sterrating | [data-hook="review-star-rating"] | .a-icon-alt (dubbelzinnig) |
| Reviewtitel | [data-hook="review-title"] | .review-title (soms) |
| Auteurnaam | span.a-profile-name | Relatief stabiel |
| Reviewdatum | [data-hook="review-date"] | .review-date (afhankelijk van regio) |
| Geverifieerde aankoop | [data-hook="avp-badge"] | span.a-size-mini |
De extractiecode met data-hook-selectors:
import re
def extract_reviews(soup):
reviews = []
review_divs = soup.select('[data-hook="review"]')
for div in review_divs:
# Sterrating
rating_el = div.select_one('[data-hook="review-star-rating"]')
rating = None
if rating_el:
rating_text = rating_el.get_text(strip=True)
match = re.search(r'(\d\.?\d?)', rating_text)
if match:
rating = float(match.group(1))
# Titel
title_el = div.select_one('[data-hook="review-title"]')
title = title_el.get_text(strip=True) if title_el else ""
# Body
body_el = div.select_one('[data-hook="review-body"]')
body = body_el.get_text(strip=True) if body_el else ""
# Auteur
author_el = div.select_one('span.a-profile-name')
author = author_el.get_text(strip=True) if author_el else ""
# Datum en land
date_el = div.select_one('[data-hook="review-date"]')
date_text = date_el.get_text(strip=True) if date_el else ""
# Formaat: "Reviewed in the United States on January 15, 2025"
country_match = re.search(r'Reviewed in (.+?) on', date_text)
date_match = re.search(r'on (.+)$', date_text)
country = country_match.group(1) if country_match else ""
date = date_match.group(1) if date_match else ""
# Geverifieerde aankoop
verified_el = div.select_one('[data-hook="avp-badge"]')
verified = bool(verified_el)
reviews.append({
"author": author,
"rating": rating,
"title": title,
"content": body,
"date": date,
"country": country,
"verified": verified,
})
return reviews
Ik draai deze selectorset al maanden op meerdere ASIN’s, en de data-hook-attributen zijn nog geen enkele keer gewijzigd. De CSS classes daarentegen zijn in dezelfde periode al minstens twee keer geroteerd.
Stap 4: paginering en Amazons limiet van 10 pagina’s aanpakken
Amazon limiteert de pageNumber-parameter tot 10 pagina’s van 10 reviews per pagina — een harde grens van ongeveer 100 reviews per filtercombinatie. De knop “Next page” verdwijnt simpelweg na pagina 10.
Basislus voor paginering:
all_reviews = []
for page in range(1, 11):
url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break # Geen reviews meer op deze pagina
all_reviews.extend(page_reviews)
print(f"Pagina {page}: {len(page_reviews)} reviews")
Hoe je meer dan 10 pagina’s Amazon reviews krijgt
De workaround is filter-bucketing. Elke combinatie van filterByStar en sortBy krijgt zijn eigen losse venster van 10 pagina’s.
Sterfilterwaarden: one_star, two_star, three_star, four_star, five_star
Sorteerwaarden: recent, helpful (standaard)
Door alle 5 sterfilters × 2 sorteeropties te combineren, kun je tot 100 pagina’s, dus 1.000 reviews per product, benaderen — en bij producten met een ongelijke sterverdeling kom je vaak dicht bij de volledige reviewset.
star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
sort_orders = ["recent", "helpful"]
all_reviews = []
seen_titles = set() # Simpele deduplicatie
for star in star_filters:
for sort in sort_orders:
for page in range(1, 11):
url = (
f"https://www.amazon.com/product-reviews/{asin}"
f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
)
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break
for review in page_reviews:
# Dedup op combinatie van titel + auteur
key = (review["title"], review["author"])
if key not in seen_titles:
seen_titles.add(key)
all_reviews.append(review)
print(f"[{star}/{sort}] Pagina {page}: {len(page_reviews)} reviews")
print(f"Totaal unieke reviews: {len(all_reviews)}")
Er zal overlap zijn tussen buckets, dus deduplicatie is essentieel. Ik gebruik een combinatie van reviewtitel + auteursnaam als snelle sleutel — niet perfect, maar het vangt het overgrote deel van de duplicaten.
Stap 5: omzeil anti-botbeveiliging (roteren, vertragen, opnieuw proberen)
Amazon gebruikt AWS WAF Bot Control, en die is flink agressiever geworden. Eén enkele maatregel — alleen User-Agents roteren of alleen vertraging toevoegen — is niet meer genoeg.
| Techniek | Implementatie |
|---|---|
| User-Agents roteren | Willekeurige keuze uit 10+ echte browserstrings |
| Exponential backoff | 2s → 4s → 8s retryvertraging bij 503’s |
| Request throttling | random.uniform(2, 5) seconden tussen pagina’s |
| Proxy-rotatie | Wisselen tussen residential proxies |
| Session fingerprint | Consistente cookies + headers per sessie |
| TLS-impersonatie | Gebruik curl_cffi in plaats van standaard requests voor productie |
Een retry-wrapper voor productie:
import time, random
USER_AGENTS = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
]
def scrape_with_retries(session, url, max_retries=3):
for attempt in range(max_retries):
try:
session.headers["User-Agent"] = random.choice(USER_AGENTS)
time.sleep(random.uniform(2, 5))
response = session.get(url, timeout=15)
# Detecteer blokkades
if "validateCaptcha" in response.url or "Robot Check" in response.text:
wait = (2 ** attempt) * 5
print(f"CAPTCHA gedetecteerd. Wachten {wait}s...")
time.sleep(wait)
continue
if response.status_code in (429, 503):
wait = (2 ** attempt) * 2
print(f"Rate limited ({response.status_code}). Wachten {wait}s...")
time.sleep(wait)
continue
if "ap_email" in response.text:
raise Exception("Inlogmuur — cookies verlopen")
return BeautifulSoup(response.text, "lxml")
except Exception as e:
if attempt == max_retries - 1:
raise
print(f"Poging {attempt + 1} mislukt: {e}")
return None
Een noot over proxies: Amazon blokkeert bekende datacenter-IP-ranges (AWS, GCP, Azure, DigitalOcean) op netwerkniveau. Als je meer dan een paar honderd pagina’s wilt scrapen, zijn residential proxies in de praktijk bijna verplicht — reken op $50–200+ per maand, afhankelijk van volume. Voor kleinere projecten (minder dan 100 requests per dag) werkt voorzichtig throttlen vanaf je thuis-IP vaak prima.
Amazon inspecteert ook TLS-fingerprints. Python’s standaard requests-library heeft een bekende JA3-hash die door WAF’s vaak vooraf wordt geblokkeerd. Voor productiescrapers kun je beter curl_cffi overwegen, omdat dat echte browser-TLS-stacks nadoet. Voor scraping op tutorial-niveau (een paar honderd pagina’s) werkt requests met goede headers meestal prima.
Stap 6: exporteer je gescrapete Amazon reviews naar CSV of Excel
Zodra je reviews hebt verzameld, zet je ze eenvoudig om naar een bruikbaar formaat met pandas:
import pandas as pd
df = pd.DataFrame(all_reviews)
df.to_csv("amazon_reviews.csv", index=False)
print(f"{len(df)} reviews geëxporteerd naar amazon_reviews.csv")
Voorbeeldoutput:
| author | rating | title | content | date | country | verified |
|---|---|---|---|---|---|---|
| Sarah M. | 5.0 | Beste aankoop van dit jaar | Batterij gaat de hele dag mee, scherm is prachtig... | January 15, 2025 | the United States | True |
| Mike T. | 2.0 | Teleurgesteld na 2 weken | De oplaadpoort stopte met werken... | February 3, 2025 | the United States | True |
| Priya K. | 4.0 | Goede waarde voor de prijs | Doet alles wat ik nodig heb, lichte vertraging bij zware apps... | March 10, 2025 | the United States | False |
Voor Excel-export: df.to_excel("amazon_reviews.xlsx", index=False) (hiervoor is openpyxl nodig).
Voor Google Sheets werkt de gspread-library, maar daarvoor heb je 8+ stappen Google Cloud-configuratie nodig — project aanmaken, twee API’s inschakelen, service-accountcredentials genereren, sheet delen. Als dat meer setup is dan het scrapen zelf, dan zit je er niet ver naast. (Dit is zo’n moment waarop een tool als Thunderbit die met één klik naar Google Sheets exporteert ineens heel aantrekkelijk wordt.)
Bonus: voeg sentimentanalyse toe aan je reviews in 5 regels Python
De meeste scraping-tutorials stoppen bij CSV-export. Maar sentiment scoren is wat ruwe data omzet in zakelijke beslissingen.
De snelste baseline gebruik je met TextBlob:
from textblob import TextBlob
df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)
Dat geeft voor elke review een polariteitsscore van -1.0 (zeer negatief) tot +1.0 (zeer positief). Voorbeeldoutput:
| content (ingekort) | rating | sentiment |
|---|---|---|
| "Battery lasts all day, screen is gorgeous..." | 5.0 | 0.65 |
| "The charging port stopped working after..." | 2.0 | -0.40 |
| "Does everything I need, minor lag on..." | 4.0 | 0.25 |
| "Absolute garbage. Returned immediately." | 1.0 | -0.75 |
| "It's okay. Nothing special but works." | 3.0 | 0.10 |
De interessante regels zijn de mismatches — een 3-sterrenreview met positieve tekst, of een 5-sterrenreview met negatieve taal. Zulke afwijkingen laten vaak genuanceerde klantopinies zien die je uit sterratings alleen niet haalt.
Voor productie-kwaliteit en hogere nauwkeurigheid is Hugging Face Transformers aan te raden. VADER is getraind op tweets, niet op productreviews, en transformermodellen halen meer dan 98% nauwkeurigheid op reviewclassificatie vergeleken met lexicon-tools. Het model nlptown/bert-base-multilingual-uncased-sentiment voorspelt zelfs direct 1–5 sterren:
from transformers import pipeline
clf = pipeline("sentiment-analysis",
model="nlptown/bert-base-multilingual-uncased-sentiment")
df["predicted_stars"] = df["content"].apply(
lambda x: int(clf(str(x)[:512])[0]["label"][0])
)
Amazon reviews volgen een J-vormige verdeling — een grote piek bij 5 sterren, een kleinere piek bij 1 ster en een dal in het midden. Daardoor is de gemiddelde sterrating vaak een slechte proxy voor de echte productkwaliteit. Segmenteer de 1-sterrengroep en zoek naar terugkerende thema’s — daar zit meestal dat ene defect dat je kunt oplossen.
De eerlijke afweging: zelfgebouwde Python vs. betaalde scraping-API’s vs. Thunderbit
Ik heb Python-scrapers voor Amazon onderhouden, en eerlijk is eerlijk: ze breken. Selectors veranderen, cookies verlopen, Amazon zet een nieuwe botdetectielaag live, en ineens ben je zaterdagochtend een scraper aan het debuggen in plaats van data aan het analyseren. Forumbijdragen laten dezelfde frustratie zien — DIY-scripts die “vorige maand nog werkten” hebben nu constant patches nodig.
Zo verhouden de drie hoofdopties zich tot elkaar:
| Criteria | DIY Python (BS4/Selenium) | Betaalde scraping-API | Thunderbit (no-code) |
|---|---|---|---|
| Insteltijd | 1–3 uur | 30 min (API-key) | 2 minuten |
| Kosten | Gratis (+ proxykosten) | $50–200+/maand | Gratis tier beschikbaar |
| Afhandeling van inlogmuur | Handmatig cookiebeheer | Meestal geregeld | Automatisch geregeld |
| Onderhoud | Hoog (selectors breken) | Laag (provider onderhoudt) | Nul (AI past zich aan) |
| Paginering | Custom code nodig | Ingebouwd | Ingebouwd |
| Ondersteuning voor meerdere landen | Aparte sessies per domein | Meestal ondersteund | Browser-based = jouw locale |
| Sentimentanalyse | Zelf code toevoegen | Soms inbegrepen | Exporteren naar Sheets, elders analyseren |
| Beste voor | Leren, volledige controle | Schaal/productiepijplijnen | Snelle data-extractie, niet-dev teams |
Python geeft je volledige controle en is echt de beste manier om webscraping van binnenuit te begrijpen. Betaalde API’s (ScrapingBee, Oxylabs, Bright Data) zijn logisch voor productiepijplijnen waar uptime belangrijker is dan kosten. En voor teams die reviewdata nodig hebben zonder dev-overhead — ecommerce ops die wekelijks concurrentproducten monitoren, marketingteams die klanttaal voor advertentieteksten ophalen — is er een derde route.
Hoe je Amazon reviews scrapt met Thunderbit (zonder code, zonder onderhoud)
Wij bouwden Thunderbit precies voor situaties waarin een Python scraper onderhouden voelt als overkill. De workflow ziet er zo uit:
- Installeer de Thunderbit Chrome-extensie
- Ga in je browser naar de Amazon reviewpagina (je bent al ingelogd, dus de inlogmuur speelt geen rol)
- Klik op "AI Suggest Fields" — Thunderbit leest de pagina en stelt kolommen voor zoals Auteur, Rating, Titel, Reviewtekst, Datum, Geverifieerde aankoop
- Klik op "Scrape" — data wordt direct uitgelezen, inclusief ingebouwde paginering
- Exporteer naar Excel, Google Sheets, Airtable of Notion
Het grootste voordeel is dat Thunderbit’s AI de paginastructuur telkens opnieuw leest. Geen CSS-selectors om te onderhouden, geen cookiebeheer, geen anti-botcode. Als Amazon zijn HTML wijzigt, past de AI zich aan. Voor lezers die programmatische toegang willen zonder alles zelf te bouwen, biedt Thunderbit ook een Extract API — gestructureerde data-extractie via API met AI-gestuurde veldherkenning, zonder selectoronderhoud.
Voor diepere duiken in Amazon-data, zie onze gidsen over hoe je Amazon-producten en reviews scrape en Amazon-verkoopdata extraheren en analyseren.
Tips om Amazon reviews op schaal te scrapen met Python
Als je reviews over veel ASIN’s scrapt, besparen deze gewoontes je een hoop gedoe:
- Batch je ASIN’s met pauzes tussen producten, niet alleen tussen pagina’s. Ik gebruik 10–15 seconden pauze tussen ASIN’s.
- Dedup agressief. Bij het combineren van meerdere sterfilters en sorteeropties krijg je overlappende reviews. Gebruik een set van
(titel, auteur, datum)als dedup-sleutel. - Log fouten. Houd bij welke ASIN + pagina + filtercombinaties mislukken, zodat je ze opnieuw kunt draaien zonder alles opnieuw te scrapen.
- Sla op in een database voor grote projecten. Een eenvoudige SQLite-database schaalt veel beter dan steeds grotere CSV-bestanden:
import sqlite3
conn = sqlite3.connect("reviews.db")
df.to_sql("reviews", conn, if_exists="append", index=False)
- Plan terugkerende scrapes in. Voor doorlopende monitoring kun je een cronjob instellen of Thunderbit’s Scheduled Scraper gebruiken — beschrijf de URL en het schema, en de rest wordt afgehandeld zonder server.
Voor extra aanpakken behandelen onze artikelen over de beste geautomatiseerde webscraping-tools en data van websites naar Excel scrapen meer opties.
Korte noot over juridische en ethische aandachtspunten
Amazon’s Conditions of Use verbieden expliciet “the use of any robot, spider, scraper, or other automated means to access Amazon Services.” Tegelijkertijd is de recente Amerikaanse rechtspraak gunstig geweest voor scrapers van publieke data. In Meta Platforms v. Bright Data (januari 2024) oordeelde een federale rechtbank dat het scrapen van publiek toegankelijke data niet in strijd is met de voorwaarden als de scraper geen ingelogde “user” is.
De nuance: scrapen achter een login (wat deze tutorial behandelt) brengt je in het contractrecht, omdat je bij het aanmaken van je account akkoord bent gegaan met Amazon’s ToS. Publiek zichtbare featured reviews scrapen brengt minder juridisch risico met zich mee dan scrapen achter de inlogmuur.
Praktische richtlijnen: verspreid gescrapete data niet commercieel door, scrape geen persoonlijke gebruikersdata buiten wat publiek wordt getoond, respecteer robots.txt en vraag juridisch advies bij grootschalig of commercieel gebruik. Dit is geen juridisch advies. Voor meer over het juridische landschap, zie ons overzicht van de juridische implicaties van webscraping.
Conclusie: scrape Amazon reviews met Python, of sla de code helemaal over
Korte samenvatting van wat we hebben behandeld:
- De inlogmuur bestaat echt, maar is oplosbaar met cookie-based authenticatie — kopieer 7 cookies uit je browser en injecteer ze in een
requests.Session() - Gebruik
data-hook-selectors, niet CSS classes, voor extractie die niet om de paar weken stukloopt - Combineer sterfilters en sorteeropties om de limiet van 10 pagina’s te omzeilen en 500+ reviews per product te bereiken
- Voeg sentimentanalyse toe met TextBlob voor een snelle baseline of Hugging Face Transformers voor nauwkeurigheid in productie
- Houd anti-botmaatregelen aan: throttling, rotating User-Agents, exponential backoff en residential proxies voor schaal
Python geeft je volledige controle en is de beste manier om te begrijpen wat er onder de motorkap gebeurt. Maar als jouw use case meer is: “Ik wil vrijdag concurrentiereviews in een spreadsheet”, dan is de onderhoudslast van een custom scraper misschien niet de moeite waard.
Thunderbit regelt authenticatie, selectors, paginering en export met een paar klikken — probeer de gratis tier en kijk of het past bij je workflow. Terwijl Amazon anti-botmaatregelen blijft aanscherpen, worden AI-tools die realtime meebewegen steeds minder een nice-to-have en steeds meer een noodzaak.
Je kunt ook ons Thunderbit YouTube-kanaal bekijken voor videowalkthroughs van scraping-workflows.
Veelgestelde vragen
1. Kun je Amazon reviews scrapen zonder in te loggen?
Ja, maar alleen de ongeveer 8 “featured reviews” die op de productdetailpagina (/dp/{ASIN}/) staan. De volledige reviewpagina’s met sorteren, filteren en paginering vereisen sinds eind 2024 authenticatie. Voor de meeste zakelijke use cases moet je dus de inlogmuur oplossen.
2. Is het legaal om Amazon reviews te scrapen?
Amazon’s Terms of Service verbieden geautomatiseerd scrapen. Recente Amerikaanse jurisprudentie (Meta v. Bright Data, 2024; hiQ v. LinkedIn) ondersteunt echter het scrapen van publiek toegankelijke data. Scrapen achter een login brengt meer juridisch risico met zich mee, omdat je akkoord bent gegaan met Amazon’s ToS. Raadpleeg juridisch advies voor commercieel gebruik.
3. Hoeveel Amazon reviews kan ik per product scrapen?
Amazon beperkt reviewpagina’s tot 10 per combinatie van sorteeroptie en sterfilter. Met alle 5 sterfilters × 2 sorteeropties kun je tot 100 pagina’s benaderen, oftewel ongeveer 1.000 reviews per product. Met trefwoordfilters ligt de theoretische bovengrens nog hoger, al is er dan wel veel duplicatie.
4. Wat is de beste Python-library om Amazon reviews te scrapen?
requests + BeautifulSoup voor statische HTML-parsing is de meest gebruikte en betrouwbare combinatie. Selenium is nuttig als JavaScript-rendering nodig is. Wil je een no-code alternatief dat inlogmuur en paginering automatisch afhandelt, probeer dan Thunderbit.
5. Hoe voorkom ik dat ik geblokkeerd word bij het scrapen van Amazon?
Roteer User-Agent-strings uit een pool van 10+ echte browserstrings, voeg willekeurige vertragingen van 2–5 seconden toe tussen requests, implementeer exponential backoff bij 503/429-fouten, gebruik residential proxies op schaal (datacenter-IP’s worden vooraf geblokkeerd) en houd consistente sessiecookies aan tussen requests. Voor een aanpak zonder onderhoud behandelt Thunderbit anti-botbeveiliging automatisch via je browsersessie.
Meer lezen
