Hoe ik Amazon-recensies scrape met Python (voorbij de loginmuur)

Mijn Amazon-recensiescraper werkte zes weken lang perfect — tot hij op een ochtend ineens 200 OK terugstuurde en een pagina vol lege ruimte. Geen foutmelding, geen CAPTCHA, alleen lege HTML op de plek waar eerst honderden recensies stonden.

Klinkt dat bekend? Je bent niet de enige. Eind 2025 zette Amazon de volledige recensiepaginina’s achter een loginmuur, en daardoor sneuvelde in één klap een enorme hoeveelheid Python-scripts voor webscraping. Ik heb de afgelopen maanden bij van twee kanten aan dit probleem gewerkt — aan onze AI-webscraper én aan mijn eigen Python-pijplijn voor recensies — dus het leek me tijd om de gids te schrijven die ik zelf had willen hebben toen mijn script voor het eerst stilviel. In deze post behandel ik de aanpak die wél werkt: authenticatie op basis van cookies, stabiele selectors die overeind blijven ondanks Amazons CSS-obfuscatie, workarounds voor de limiet van 10 pagina’s, anti-botmaatregelen, en als bonus een sentimentanalyse-sectie die ruwe recensie-tekst omzet in echte bedrijfsinzichten. En als je halverwege denkt: “Ik wil dit codewerk liever niet allemaal blijven onderhouden,” laat ik je zien hoe hetzelfde in ongeveer twee minuten regelt, zonder Python.

Wat is Amazon-recensies scrapen (en waarom is het belangrijk)?

Amazon-recensies scrapen betekent dat je programmatisch klantrecensiegegevens ophaalt — sterrenbeoordelingen, recensietekst, auteursnamen, datums, badges voor geverifieerde aankopen — van productpagina’s op Amazon. Omdat Amazon de review-content (en nooit heeft teruggezet), is webscraping de enige programmatijdse manier om bij deze data te komen.

De cijfers onderstrepen waarom dit relevant is. , en . Alleen al 5 reviews tonen op een productpagina kan . Bedrijven die review-sentiment systematisch analyseren zien . Dit is geen abstracte data science — het is concurrentie-informatie, productverbetering-signalen en marketingtaal, allemaal gewoon in tekstvorm beschikbaar op Amazons servers.

Waarom Amazon-recensies scrapen met Python?

Python blijft hiervoor het standaardgereedschap. Het is de , en het ecosysteem — requests, BeautifulSoup, pandas, Scrapy — maakt webscraping toegankelijk, ook voor mensen die niet fulltime ontwikkelen.

Verschillende teams gebruiken deze data op hun eigen manier:

Een merk voor keukengerei , paste de formule aan en pakte binnen 60 dagen de #1 Best Seller-positie terug. Een fabrikant van fitness-trackers , vond een latexallergieprobleem, bracht een hypoallergene variant uit en verlaagde retouren met 40%. Dat is precies het soort ROI dat de technische inspanning rechtvaardigt.

Loginmuur: waarom je Amazon-recensiescraper ineens stopte

Op 14 november 2024 ging Amazon . Die wijziging werd bevestigd in en op . Als je /product-reviews/{ASIN}/ opent in een incognitovenster, word je doorgestuurd naar een inlogpagina in plaats van naar de reviews.

De symptomen zijn subtiel: je script krijgt een 200 OK, maar de HTML-body bevat een inlogformulier (name="email", id="ap_password") in plaats van recensies. Geen foutcode. Geen CAPTCHA. Gewoon… niets bruikbaars.

Amazon doet dit vanwege anti-botredenen en regionale naleving. De handhaving is niet altijd even consistent — soms laadt een vers browservenster nog een paar reviews voordat de muur verschijnt, vooral op de eerste pagina — maar voor elke scraper die je op schaal draait, moet je ervan uitgaan dat die muur er altijd staat.

Verschillende Amazon-landdomeinen (.de, .co.uk, .co.jp) hanteren die muur apart. Zoals een forumgebruiker het samenvatte: “voor elk land is een aparte login nodig.” Je .com-cookies werken niet op .co.uk.

Featured reviews versus volledige reviews: wat je zonder login nog wel kunt zien

Productpagina’s van Amazon (/dp/{ASIN}/) tonen nog steeds ongeveer zonder authenticatie. Dat zijn handmatig door Amazons algoritme geselecteerde reviews. Ze zijn handig voor een snelle sentimentcheck, maar je kunt ze niet sorteren, filteren of pagineren.

De volledige reviewpagina’s (/product-reviews/{ASIN}/) — met sortering op nieuwste, filtering op sterrenbeoordeling en paginering over honderden reviews — vereisen een login.

Heb je maar een handvol reviews nodig voor een snelle indruk, scrape dan de productpagina. Wil je er honderden of duizenden, dan moet je authenticatie regelen.

Wat je nodig hebt voordat je begint: Python-setup en libraries

Voordat we code schrijven, eerst de basis:

• Moeilijkheidsgraad: Gemiddeld (je bent comfortabel met Python en kent de basis van HTML)
• Benodigde tijd: Ongeveer 45 minuten voor de volledige pijplijn; ongeveer 10 minuten voor een simpele scrape
• Benodigdheden: Python 3.8+, Chrome-browser, een geldig Amazon-account

Installeer de kernlibraries:

1pip install requests beautifulsoup4 lxml pandas textblob

Optioneel (voor geavanceerde sentimentanalyse):

1pip install transformers torch

Wat is een ASIN? Dat is Amazons product-ID van 10 tekens. Je vindt hem in elke product-URL — in amazon.com/dp/B0BCNKKZ91 is de ASIN bijvoorbeeld B0BCNKKZ91. Dat is de sleutel die je in de review-URL gebruikt.

Stap 1: langs de loginmuur met cookie-authenticatie

De betrouwbaarste aanpak is inloggen op Amazon in je browser, je sessiecookies kopiëren en ze injecteren in je Python requests.Session(). Daarmee voorkom je CAPTCHA’s en SMS-2FA die Selenium-gebaseerde loginautomatisering vaak triggert.

Je hebt deze zeven cookies nodig:

Cookies uit Chrome DevTools halen

1. Log in op amazon.com in Chrome
2. Open DevTools (F12 of rechtsklik → Inspecteren)
3. Ga naar Application → Storage → Cookies → https://www.amazon.com
4. Zoek elke cookienaam uit de tabel en kopieer de waarde
5. Zet ze om in een door puntkomma’s gescheiden string voor Python

Zo zet je je sessie op:

1import requests
2session = requests.Session()
3# Plak hier je cookie-waardes
4cookies = {
5    "session-id": "YOUR_SESSION_ID",
6    "session-id-time": "YOUR_SESSION_ID_TIME",
7    "session-token": "YOUR_SESSION_TOKEN",
8    "ubid-main": "YOUR_UBID_MAIN",
9    "at-main": "YOUR_AT_MAIN",
10    "sess-at-main": "YOUR_SESS_AT_MAIN",
11    "x-main": "YOUR_X_MAIN",
12}
13headers = {
14    "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",
15    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
16    "Accept-Language": "en-US,en;q=0.5",
17}
18session.cookies.update(cookies)
19session.headers.update(headers)

Belangrijk: hergebruik hetzelfde session-object voor al je requests. Zo blijven cookies consistent en simuleer je een echte browsersessie. Cookies blijven meestal dagen tot weken geldig onder scrapingbelasting, maar als je opnieuw naar de loginpagina wordt gestuurd, moet je ze opnieuw uit je browser halen.

Voor marktplaatsen buiten .com veranderen de cookienamen iets — amazon.de gebruikt at-acbde in plaats van at-main, amazon.co.uk gebruikt at-acbuk, enzovoort. Elke marktplaats heeft zijn eigen aparte sessie nodig.

Stap 2: bouw de request en parse review-HTML met BeautifulSoup

De Amazon-review-URL volgt dit patroon:

1https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1

De kernfunctie:

1from bs4 import BeautifulSoup
2import time, random
3def get_soup(session, url):
4    time.sleep(random.uniform(2, 5))  # Vriendelijke vertraging
5    response = session.get(url, timeout=15)
6    # Loginmuur detecteren
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("Loginmuur gedetecteerd — vernieuw je cookies")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    return BeautifulSoup(response.text, "lxml")

Een kleine truc die helpt: bezoek vóór de reviewpagina eerst de productpagina. Daarmee bouw je een natuurlijk browsepatroon op in je sessie.

1# Eerst productpagina bezoeken (lijkt op normaal browsen)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# Daarna de reviewpagina openen
6reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
7soup = get_soup(session, reviews_url)

Stap 3: gebruik stabiele selectors om reviewdata te extraheren (vertrouw niet op CSS-classes)

Hier lopen de meeste tutorials uit 2022–2023 vast. Amazon verbergt CSS-classnamen — die veranderen periodiek, en zoals een gefrustreerde ontwikkelaar in een forumthread schreef: “geen van hen had ook maar één patroon in de namen van de span-klassen.”

De oplossing: Amazon gebruikt data-hook-attributen op review-elementen, en die zijn opvallend stabiel. Het zijn semantische identifiers waarop Amazons eigen frontendcode vertrouwt, dus ze worden niet willekeurig gemaakt.

De extractiecode met data-hook-selectors:

1import re
2def extract_reviews(soup):
3    reviews = []
4    review_divs = soup.select('[data-hook="review"]')
5    for div in review_divs:
6        # Sterrenbeoordeling
7        rating_el = div.select_one('[data-hook="review-star-rating"]')
8        rating = None
9        if rating_el:
10            rating_text = rating_el.get_text(strip=True)
11            match = re.search(r'(\d\.?\d?)', rating_text)
12            if match:
13                rating = float(match.group(1))
14        # Titel
15        title_el = div.select_one('[data-hook="review-title"]')
16        title = title_el.get_text(strip=True) if title_el else ""
17        # Tekst
18        body_el = div.select_one('[data-hook="review-body"]')
19        body = body_el.get_text(strip=True) if body_el else ""
20        # Auteur
21        author_el = div.select_one('span.a-profile-name')
22        author = author_el.get_text(strip=True) if author_el else ""
23        # Datum en land
24        date_el = div.select_one('[data-hook="review-date"]')
25        date_text = date_el.get_text(strip=True) if date_el else ""
26        # Formaat: "Reviewed in the United States on January 15, 2025"
27        country_match = re.search(r'Reviewed in (.+?) on', date_text)
28        date_match = re.search(r'on (.+)$', date_text)
29        country = country_match.group(1) if country_match else ""
30        date = date_match.group(1) if date_match else ""
31        # Geverifieerde aankoop
32        verified_el = div.select_one('[data-hook="avp-badge"]')
33        verified = bool(verified_el)
34        reviews.append({
35            "author": author,
36            "rating": rating,
37            "title": title,
38            "content": body,
39            "date": date,
40            "country": country,
41            "verified": verified,
42        })
43    return reviews

Ik draai deze set selectors inmiddels al maanden tegen meerdere ASIN’s, en de data-hook-attributen zijn nog geen enkele keer veranderd. De CSS-classes daarentegen zijn in dezelfde periode al minstens twee keer gewisseld.

Stap 4: omgaan met paginering en Amazons limiet van 10 pagina’s

Amazon beperkt de parameter pageNumber tot 10 pagina’s van telkens 10 reviews — een harde bovengrens van ongeveer 100 reviews per filtercombinatie. De knop “Next page” verdwijnt gewoon na pagina 10.

Basisloop voor paginering:

1all_reviews = []
2for page in range(1, 11):
3    url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
4    soup = get_soup(session, url)
5    page_reviews = extract_reviews(soup)
6    if not page_reviews:
7        break  # Geen reviews meer op deze pagina
8    all_reviews.extend(page_reviews)
9    print(f"Pagina {page}: {len(page_reviews)} reviews")

Hoe haal je meer dan 10 pagina’s Amazon-reviews op?

De workaround is filter-bucketing. Elke combinatie van filterByStar en sortBy krijgt zijn eigen onafhankelijke venster van 10 pagina’s.

Star-filterwaarden: one_star, two_star, three_star, four_star, five_star
Sorteerwaarden: recent, helpful (standaard)

Door alle 5 sterfilters × 2 sorteervolgordes te combineren, kun je tot 100 pagina’s benaderen, dus 1.000 reviews per product — en bij producten met een ongelijke sterrenverdeling kom je vaak dicht bij de volledige reviewset.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # Simpele deduplicatie
5for star in star_filters:
6    for sort in sort_orders:
7        for page in range(1, 11):
8            url = (
9                f"https://www.amazon.com/product-reviews/{asin}"
10                f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
11            )
12            soup = get_soup(session, url)
13            page_reviews = extract_reviews(soup)
14            if not page_reviews:
15                break
16            for review in page_reviews:
17                # Dedupliceren op combinatie van titel + auteur
18                key = (review["title"], review["author"])
19                if key not in seen_titles:
20                    seen_titles.add(key)
21                    all_reviews.append(review)
22            print(f"[{star}/{sort}] Pagina {page}: {len(page_reviews)} reviews")
23print(f"Totaal unieke reviews: {len(all_reviews)}")

Er is overlap 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-botmaatregelen (roteren, afremmen, herhalen)

Amazon gebruikt AWS WAF Bot Control, en dat is aanzienlijk agressiever geworden. Enkelvoudige tegenmaatregelen (alleen User-Agents roteren, of alleen vertraging toevoegen) zijn niet meer genoeg.

Een retry-wrapper die klaar is voor productie:

1import time, random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
4    "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",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
6    "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",
7    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
8]
9def scrape_with_retries(session, url, max_retries=3):
10    for attempt in range(max_retries):
11        try:
12            session.headers["User-Agent"] = random.choice(USER_AGENTS)
13            time.sleep(random.uniform(2, 5))
14            response = session.get(url, timeout=15)
15            # Blokkades detecteren
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"CAPTCHA gedetecteerd. Wachten {wait}s...")
19                time.sleep(wait)
20                continue
21            if response.status_code in (429, 503):
22                wait = (2 ** attempt) * 2
23                print(f"Rate limited ({response.status_code}). Wachten {wait}s...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("Loginmuur — cookies verlopen")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"Poging {attempt + 1} mislukt: {e}")
33    return None

Een opmerking over proxies: Amazon (AWS, GCP, Azure, DigitalOcean) op netwerkniveau. Als je meer dan een paar honderd pagina’s scrape’t, zijn residential proxies in de praktijk bijna verplicht — reken op $50–200+ per maand, afhankelijk van volume. Voor kleinere projecten (onder 100 requests per dag) werkt verstandig throttelen vanaf je eigen IP vaak prima.

Amazon inspecteert ook TLS-fingerprints. Python’s standaard requests-bibliotheek heeft een . Voor scrapers in productie kun je curl_cffi overwegen, omdat die echte browser-TLS-stacks nabootst. Voor scraping op tutorialniveau (een paar honderd pagina’s) lukt requests met goede headers meestal prima.

Stap 6: exporteer je gescrapete Amazon-reviews naar CSV of Excel

Zodra je de reviews hebt verzameld, is het met pandas eenvoudig om ze in een bruikbaar formaat te zetten:

1import pandas as pd
2df = pd.DataFrame(all_reviews)
3df.to_csv("amazon_reviews.csv", index=False)
4print(f"{len(df)} reviews geëxporteerd naar amazon_reviews.csv")

Voorbeeldoutput:

Voor export naar Excel: df.to_excel("amazon_reviews.xlsx", index=False) (hiervoor is openpyxl nodig).

Voor Google Sheets werkt de gspread-bibliotheek, maar die vraagt wel — project aanmaken, twee API’s inschakelen, service-accountcredentials genereren, het sheet delen. Als dat meer setup lijkt dan het scrapen zelf, heb je daar eigenlijk gelijk in. (Dit is precies zo’n moment waarop een tool als die met één klik naar Google Sheets exporteert ineens erg aantrekkelijk wordt.)

Bonus: voeg sentimentanalyse toe aan je gescrapete reviews in 5 regels Python

De meeste scrapinggidsen stoppen bij CSV-export. Maar sentiment score maakt van ruwe data echte beslissingen.

De snelste basisvariant gebruikt TextBlob:

1from textblob import TextBlob
2df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)

Dat geeft je voor elke review een polariteitsscore van -1.0 (zeer negatief) tot +1.0 (zeer positief). Voorbeeldoutput:

De interessante regels zijn de mismatches — een 3-sterrenreview met positieve bewoordingen, of een 5-sterrenreview met negatieve taal. Zulke verschillen onthullen vaak genuanceerde klantmeningen die je met alleen sterrenbeoordelingen mist.

Voor accuratere productiegebruik is Hugging Face Transformers aan te raden. , en vergeleken met lexicon-tools. Het model nlptown/bert-base-multilingual-uncased-sentiment voorspelt zelfs direct 1–5 sterren:

1from transformers import pipeline
2clf = pipeline("sentiment-analysis",
3               model="nlptown/bert-base-multilingual-uncased-sentiment")
4df["predicted_stars"] = df["content"].apply(
5    lambda x: int(clf(str(x)[:512])[0]["label"][0])
6)

Amazon-reviews volgen een — een grote piek bij 5 sterren, een kleinere piek bij 1 ster en een dal in het midden. Daardoor is het gemiddelde stercijfer vaak een slechte benadering van de echte productkwaliteit. Segmenteer de 1-sterrencategorie en zoek daar naar terugkerende thema’s — daar zit vaak precies één oplosbaar defect verstopt.

De eerlijke afweging: zelf Python bouwen vs. betaalde scraping-API’s vs. Thunderbit

Ik heb Python-scrapers voor Amazon onderhouden, en ik ben eerlijk: ze breken. Selectors veranderen, cookies verlopen, Amazon lanceert een nieuwe botdetectielaag, en ineens besteed je je zaterdagochtend aan het debuggen van een scraper in plaats van aan data-analyse. Forumgebruikers melden precies dezelfde frustratie — zelfgemaakte scripts die “vorige maand nog werkten” hebben nu constant patches nodig.

Zo verhouden de drie belangrijkste aanpakken zich tot elkaar:

Python geeft je volledige controle en is oprecht de beste manier om te leren hoe webscraping onder de motorkap werkt. Betaalde API’s (ScrapingBee, Oxylabs, Bright Data) zijn logisch voor productieomgevingen waar uptime belangrijker is dan kosten. En voor teams die reviewdata nodig hebben zonder de ontwikkeloverhead — ecommerce-teams die wekelijks concurrentieproducten monitoren, marketingteams die klanttaal ophalen voor advertentieteksten — is er nog een derde route.

Amazon-recensies scrapen met Thunderbit (geen code, geen onderhoud)

We hebben gebouwd voor precies de situaties waarin het onderhouden van een Python-scraper voelt als overdreven veel werk. De workflow ziet er zo uit:

1. Installeer de
2. Ga in je browser naar de Amazon-productreviewpagina (je bent al ingelogd, dus de loginmuur speelt geen rol)
3. Klik op “AI Suggest Fields” — Thunderbit leest de pagina en stelt kolommen voor zoals Auteur, Rating, Titel, Reviewtekst, Datum en Gecontroleerde aankoop
4. Klik op “Scrape” — de data wordt direct uitgelezen, inclusief ingebouwde paginering
5. Exporteer naar Excel, Google Sheets, Airtable of Notion

Het grootste voordeel is dat Thunderbit’s AI de paginastructuur elke keer opnieuw leest. Geen CSS-selectors om te onderhouden, geen cookiebeheer, geen anti-botcode. Als Amazon hun HTML wijzigt, past de AI zich aan. Voor lezers die programmatische toegang willen zonder volledig zelf te bouwen, biedt Thunderbit ook een — gestructureerde data-extractie via API met AI-gedreven veldherkenning, zonder selectoronderhoud.

Voor meer verdieping in Amazon-data, zie onze gidsen over en .

Tips om Amazon-recensies op schaal te scrapen met Python

Als je reviews over veel ASIN’s ophaalt, bespaar je jezelf een hoop gedoe met deze praktijken:

• Verwerk ASIN’s in batches met pauzes tussen producten, niet alleen tussen pagina’s. Ik gebruik 10–15 seconden pauze tussen ASIN’s.
• Dedupliceer agressief. Wanneer je meerdere combinaties van sterfilters en sorteervolgordes samenvoegt, krijg je overlappende reviews. Gebruik een set van (title, author, date)-tuples als dedup-sleutel.
• Log fouten. Houd bij welke ASIN + pagina + filtercombinaties mislukten, zodat je ze opnieuw kunt proberen zonder alles opnieuw te scrapen.
• Sla grote projecten op in een database. Een simpele SQLite-database schaalt veel beter dan steeds groter wordende CSV-bestanden:

1import sqlite3
2conn = sqlite3.connect("reviews.db")
3df.to_sql("reviews", conn, if_exists="append", index=False)

• Plan terugkerende scrapes. Voor doorlopende monitoring kun je een cronjob instellen of Thunderbit’s Scheduled Scraper gebruiken — beschrijf de URL en het schema, en de rest loopt automatisch zonder server.

Voor aanvullende aanpakken behandelen onze posts over en nog meer opties.

Korte opmerking over juridische en ethische overwegingen

De van Amazon verbieden expliciet “het gebruik van een robot, spider, scraper of andere geautomatiseerde middelen om toegang te krijgen tot Amazon Services.” Tegelijkertijd is recente Amerikaanse jurisprudentie gunstig geweest voor scrapers van publiek beschikbare data. In oordeelde een federale rechtbank dat scraping van publiek toegankelijke data de servicevoorwaarden niet schendt wanneer de scraper geen ingelogde “gebruiker” is.

De nuance: scrapen achter een login (zoals deze tutorial behandelt) brengt je in het contractenrecht, omdat je bij het aanmaken van je account akkoord bent gegaan met Amazon’s ToS. Het scrapen van publiek zichtbare featured reviews brengt minder juridisch risico met zich mee dan scrapen achter de loginmuur.

Praktische richtlijnen: herdistribueer gescrapete data niet commercieel, scrape geen persoonlijke gebruikersgegevens buiten wat publiek zichtbaar is, 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 .

Conclusie: Amazon-recensies scrapen met Python, of de code helemaal overslaan

Korte samenvatting van wat deze gids heeft behandeld:

• De loginmuur is echt, maar op te lossen met cookie-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 stukgaat
• 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 basis of met Hugging Face Transformers voor productie-accuratesse
• Houd anti-botmaatregelen bij de les: throttling, User-Agent-rotatie, exponentiële backoff en residential proxies op 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 is: “Ik heb vrijdag een spreadsheet met reviews van concurrenten nodig,” en niet: “Ik wil een productie-data-pijplijn bouwen,” dan is de onderhoudslast van een eigen scraper misschien simpelweg niet de moeite waard.

regelt authenticatie, selectors, paginering en export in een paar klikken — probeer de en kijk of het bij je workflow past. Nu Amazon zijn anti-botmaatregelen steeds verder aanscherpt, worden AI-gedreven tools die zich in realtime aanpassen steeds minder een luxe en steeds meer een noodzaak.

Je kunt ook ons bekijken voor video-uitleg van scraping-workflows.

FAQ

1. Kun je Amazon-recensies scrapen zonder in te loggen?

Ja, maar alleen de ongeveer 8 “featured reviews” die op de productdetailpagina (/dp/{ASIN}/) worden getoond. De volledige reviewpagina’s met sorteren, filteren en pagineren vereisen sinds eind 2024 authenticatie. Voor de meeste zakelijke use-cases moet je de loginmuur dus afhandelen.

2. Is het legaal om Amazon-recensies te scrapen?

Amazon’s Gebruiksvoorwaarden verbieden geautomatiseerd scrapen. Recente Amerikaanse jurisprudentie (Meta v. Bright Data, 2024; hiQ v. LinkedIn) ondersteunt echter het scrapen van publiek toegankelijkere data. Scrapen achter een login brengt meer juridisch risico met zich mee, omdat je akkoord bent gegaan met Amazon’s ToS. Raadpleeg juridisch advies bij commercieel gebruik.

3. Hoeveel Amazon-recensies kan ik per product scrapen?

Amazon beperkt reviewpagina’s tot 10 per combinatie van sorteervolgorde en sterfilter. Met alle 5 sterfilters × 2 sorteervolgordes kun je tot 100 pagina’s benaderen (ongeveer 1.000 reviews) per product. Met keywordfilters ligt het theoretische maximum hoger, al is de hoeveelheid duplicaten dan aanzienlijk.

4. Wat is de beste Python-library voor Amazon-recensies scrapen?

requests + BeautifulSoup voor statische HTML-parsing is de meest gebruikte en betrouwbare combinatie. Selenium is nuttig wanneer JavaScript-rendering nodig is. Voor een no-code alternatief dat loginmuur en paginering automatisch afhandelt, probeer .

5. Hoe voorkom ik dat ik word geblokkeerd tijdens 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 exponentiële backoff bij 503/429-fouten, gebruik residential proxies op schaal (datacenter-IP’s worden vooraf geblokkeerd) en houd sessiecookies consistent tussen requests. Voor een onderhoudsvrije aanpak handelt Thunderbit anti-botmaatregelen automatisch af via je browsersessie.

Meer leren