Ik heb 4 manieren getest om Amazon Best Sellers te scrapen met Python en ...

Afgelopen weekend heb ik een flinke pot koffie opgemaakt om Amazon’s Best Sellers-pagina op vier verschillende manieren te scrapen. Twee methodes werkten prima, één methode liep bijna uit op een IP-ban, en één methode had letterlijk maar twee klikken nodig. Dit is alles wat ik heb geleerd.

Amazon is een gigantische marktplaats — , , en een Best Sellers Rank (BSR)-systeem dat elk uur wordt bijgewerkt. Als je FBA-productonderzoek doet, concurrentieprijzen analyseert of gewoon trends wilt spotten voordat je concurrenten dat doen, dan is Best Seller-data goud waard.

Maar die data uit Amazon halen en in een spreadsheet krijgen? Daar wordt het interessant. Ik heb requests + BeautifulSoup, Selenium, een scraping-API en (onze eigen no-code AI-webscraper) getest om te zien welke aanpak echt resultaat oplevert — en welke je vooral naar een CAPTCHA-pagina laat staren.

Wat zijn Amazon Best Sellers eigenlijk (en waarom zou je erom geven)?

Amazon Best Sellers Rank (BSR) is Amazon’s realtime ranglijst van producten per categorie, gebaseerd op verkoopvolume. Zie het als een populariteitswedstrijd die elk uur wordt bijgewerkt op basis van recente en historische verkoopdata. Amazon zelf omschrijft het zo:

"The Amazon Best Sellers calculation is based on Amazon sales and is updated hourly to reflect recent and historical sales of every item sold on Amazon." —

De Best Sellers-pagina laat de top 100 producten per categorie zien, verdeeld over twee pagina’s van elk 50 producten. Pagina 1 bevat rang #1–50, pagina 2 rang #51–100. Amazon heeft bevestigd dat pageviews en klantbeoordelingen géén invloed hebben op BSR — het draait puur om verkopen.

Wie heeft hier iets aan? E-commerceverkopers die producten zoeken voor FBA, salesteams die concurrentie-inzichten bouwen, operationele teams die prijsontwikkelingen volgen en marketeers of onderzoekers die categoriegroei analyseren. In mijn ervaring komt iedereen die op of tegen Amazon verkoopt uiteindelijk op het punt dat deze data in een spreadsheet moet belanden.

Waarom Amazon Best Sellers scrapen met Python?

Handmatig productonderzoek kost enorm veel tijd. Uit een blijkt dat werknemers 9,3 uur per week kwijt zijn aan het zoeken en verzamelen van informatie. Voor e-commerce teams betekent dat urenlang door Amazon-pagina’s klikken, productnamen en prijzen kopiëren en alles in spreadsheets plakken — om het volgende week weer opnieuw te doen.

Hier is een snel overzicht van de use cases die het scrapen van Best Sellers de moeite waard maken:

De ROI is echt: uit een onder 2.700 commerceprofessionals blijkt dat AI-tools e-commerceprofessionals gemiddeld . En verkopers die geautomatiseerde prijsmonitoring gebruiken, winnen de Buy Box , tegenover 42% bij handmatige trackers — een stijging van 37% in omzet door sneller te reageren op prijsveranderingen.

4 manieren om Amazon Best Sellers te scrapen met Python: een snelle vergelijking

Voordat we in de stap-voor-stap handleidingen duiken, hier de vergelijking die ik zelf graag vooraf had gehad. Deze tabel helpt je de juiste methode te kiezen:

Wil je de basis van Python scraping leren? Begin dan met methode 1 of 2. Heb je productieklare betrouwbaarheid nodig? Kies methode 3. Wil je binnen twee klikken resultaat zonder code te schrijven? Ga direct naar methode 4.

Voor je begint

• Moeilijkheidsgraad: Beginner tot gemiddeld (afhankelijk van methode)
• Benodigde tijd: ~15 minuten voor Thunderbit, ~45 minuten voor Python-methodes
• Wat je nodig hebt: Python 3.8+ (voor methodes 1–3), Chrome browser, (voor methode 4) en een Amazon Best Sellers-categorie-URL

Methode 1: Amazon Best Sellers scrapen met requests + BeautifulSoup

Dit is de lichte, beginnersvriendelijke aanpak — geen browserautomatisering, alleen HTTP-verzoeken en HTML-parsing. Ik heb er ook het meest van geleerd over Amazon’s anti-scrapingverdediging.

Stap 1: Je omgeving instellen

Installeer de benodigde pakketten:

1pip install requests beautifulsoup4 pandas

Stel daarna je imports in:

1import requests
2from bs4 import BeautifulSoup
3import pandas as pd
4import random
5import time

Stap 2: Een verzoek sturen met realistische headers

Amazon blokkeert verzoeken die op bots lijken. De meest basale verdediging is een User-Agent-header die een echte browser nabootst. Hieronder staat een voorbeeld met een set actuele, realistische User-Agent strings (bron: , maart 2026):

1USER_AGENTS = [
2    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
3    "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",
4    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
5    "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; 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]
8headers = {"User-Agent": random.choice(USER_AGENTS)}
9url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
10response = requests.get(url, headers=headers)
11print(response.status_code)  # Should be 200

Zie je statuscode 200? Dan zit je goed. Krijg je 503 of word je doorgestuurd naar een CAPTCHA-pagina, dan heeft Amazon je verzoek gemarkeerd.

Stap 3: Productdata parsen met BeautifulSoup

Inspecteer de HTML van de Amazon-pagina met de DevTools van je browser (rechterklik → Inspecteren). De productcontainers gebruiken de ID gridItemRoot. In elke container vind je de productnaam, prijs, beoordeling en URL.

1soup = BeautifulSoup(response.text, "html.parser")
2products = []
3for item in soup.find_all("div", id="gridItemRoot"):
4    title_tag = item.find("div", class_="_cDEzb_p13n-sc-css-line-clamp-3_g3dy1")
5    price_tag = item.find("span", class_="_cDEzb_p13n-sc-price_3mJ9Z")
6    link_tag = item.find("a", class_="a-link-normal")
7    title = title_tag.get_text(strip=True) if title_tag else "N/A"
8    price = price_tag.get_text(strip=True) if price_tag else "N/A"
9    url = "https://www.amazon.com" + link_tag["href"] if link_tag else "N/A"
10    products.append({"Title": title, "Price": price, "URL": url})

Waarschuwing: De klassenamen met het _cDEzb_-voorvoegsel zijn CSS-module-hashes die Amazon regelmatig opnieuw genereert. De ID gridItemRoot en de klasse a-link-normal zijn stabieler, maar controleer je selectors altijd in DevTools voordat je de scraper draait.

Stap 4: Exporteren naar CSV

1df = pd.DataFrame(products)
2df.to_csv("amazon_best_sellers.csv", index=False)
3print(f"Scraped {len(products)} products")

Wat je kunt verwachten — en wat er misgaat

In mijn test leverde deze methode ongeveer 30 producten op in plaats van 50. Dat is geen bug in de code — het is Amazon’s lazy loading. Slechts ongeveer 30 producten worden in de eerste paginalaadfase gerenderd; de rest verschijnt pas na scrollen, en daarvoor is JavaScript-uitvoering nodig die requests niet aankan.

Andere beperkingen:

• IP-bans ontstaan snel zonder proxy-rotatie (ik werd geblokkeerd na ongeveer 15 verzoeken in korte tijd)
• CSS-selectors breken zodra Amazon de pagina-indeling aanpast — en dat gebeurt regelmatig
• Geen ingebouwde paginering

Voor het leren van Python scraping is deze aanpak prima. Voor productiegebruik is hij kwetsbaar.

Methode 2: Amazon Best Sellers scrapen met Selenium

Selenium lost het lazy-loadingprobleem op door een echte browser te gebruiken — zwaarder in setup, maar je vangt wel alle 50 producten per pagina.

Stap 1: Selenium installeren

1pip install selenium pandas

Goed nieuws: vanaf Selenium 4.6+ heb je webdriver-manager niet meer nodig. Selenium Manager regelt het downloaden van drivers automatisch.

1from selenium import webdriver
2from selenium.webdriver.chrome.options import Options
3from selenium.webdriver.common.by import By
4from selenium.webdriver.common.keys import Keys
5import time
6import pandas as pd
7options = Options()
8options.add_argument("--headless=new")
9options.add_argument("--window-size=1920,1080")
10options.add_argument("--disable-blink-features=AutomationControlled")
11driver = webdriver.Chrome(options=options)

De vlag --headless=new (geïntroduceerd in Chrome 109+) gebruikt dezelfde renderingpipeline als Chrome met venster, waardoor Amazon het moeilijker kan detecteren.

Stap 2: voorbij de lazy loading scrollen

Dit is de stap die Selenium de extra moeite waard maakt. Amazon Best Sellers laadt in eerste instantie maar ongeveer 30 producten — de rest verschijnt na scrollen.

1def scroll_page(driver, scrolls=5, delay=2):
2    for _ in range(scrolls):
3        driver.find_element(By.TAG_NAME, "body").send_keys(Keys.PAGE_DOWN)
4        time.sleep(delay)
5driver.get("https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/")
6time.sleep(3)
7scroll_page(driver)

Na het scrollen zouden alle 50 producten in de DOM moeten staan. Ik merkte dat 5 keer Page Down met een vertraging van 2 seconden voldoende was, maar afhankelijk van je verbindingssnelheid moet je dit mogelijk aanpassen.

Stap 3: Productdata ophalen

1items = driver.find_elements(By.ID, "gridItemRoot")
2products = []
3for item in items:
4    try:
5        title = item.find_element(By.CSS_SELECTOR, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1").text
6    except:
7        title = "N/A"
8    try:
9        price = item.find_element(By.CSS_SELECTOR, "span._cDEzb_p13n-sc-price_3mJ9Z").text
10    except:
11        price = "N/A"
12    try:
13        url = item.find_element(By.CSS_SELECTOR, "a.a-link-normal").get_attribute("href")
14    except:
15        url = "N/A"
16    products.append({"Title": title, "Price": price, "URL": url})

Het is belangrijk om elke extractie in try/except te zetten — sommige producten kunnen niet op voorraad zijn of ontbreken aan bepaalde velden, en je wilt niet dat één fout element je hele scrape laat crashen.

Stap 4: Paginering afhandelen

Amazon splitst 100 Best Sellers over twee pagina’s met verschillende URL-structuren:

1urls = [
2    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
3    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/ref=zg_bs_pg_2_electronics?_encoding=UTF8&pg=2"
4]
5all_products = []
6for url in urls:
7    driver.get(url)
8    time.sleep(3)
9    scroll_page(driver)
10    # ... extract products as above ...
11    all_products.extend(products)
12driver.quit()

Wat je kunt verwachten

In mijn test haalde Selenium alle 50 producten per pagina binnen — een duidelijke winst ten opzichte van requests + BS4. Nadeel: het kostte ongeveer 45 seconden per pagina (inclusief scrollvertragingen), en ik werd alsnog gemarkeerd nadat ik het te vaak zonder proxy-rotatie draaide. Ook met anti-detectie-instellingen is Selenium nog steeds herkenbaar voor Amazon’s botdetectie — voor serieuze schaal heb je extra maatregelen nodig (zie de anti-ban playbook hieronder).

Andere pijnpunten:

• WebDriver-versieverschillen komen af en toe nog voor, al is dat met Selenium Manager veel minder geworden
• CSS-selectors moeten worden bijgewerkt zodra Amazon de DOM wijzigt
• Hoog geheugengebruik — elke browserinstantie gebruikt 200–400 MB RAM

Methode 3: Amazon Best Sellers scrapen met een scraping-API

Scraping-API’s zijn de aanpak van “laat iemand anders het zware werk doen”. Diensten zoals Scrape.do, Oxylabs en ScrapingBee regelen proxy-rotatie, JavaScript-rendering en anti-botmaatregelen — jij stuurt alleen een URL en krijgt HTML of JSON terug.

Hoe het werkt

Je stuurt je doel-URL naar het API-endpoint. De API rendert de pagina met een echte browser op hun infrastructuur, roteert proxies, handelt CAPTCHA’s af en stuurt schone HTML terug. Daarna parse je de geretourneerde HTML gewoon weer met BeautifulSoup.

Stap 1: Een verzoek sturen via de API

Hier is een voorbeeld met Scrape.do (prijzen beginnen bij $29/maand voor 150.000 credits, waarbij 1 credit = 1 request, ongeacht rendering):

1import requests
2from bs4 import BeautifulSoup
3api_token = "YOUR_API_TOKEN"
4target_url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
5api_url = f"https://api.scrape.do?token={api_token}&url={target_url}&render=true&geoCode=us"
6response = requests.get(api_url)
7soup = BeautifulSoup(response.text, "html.parser")

Vanaf hier is het parsen identiek aan methode 1 — dezelfde selectors, dezelfde extractielogica.

Prijsvergelijking in de praktijk

Hier zijn de tarieven van de belangrijkste API’s per 1.000 Amazon-verzoeken, op hun voordeligste tarief:

Voor- en nadelen

Voordelen: Hoge betrouwbaarheid ( op Amazon bij topproviders), geen driver-onderhoud, anti-bot wordt automatisch afgehandeld, schaalbaar.

Nadelen: Betaald per request (kosten lopen op bij schaal), je moet nog steeds parsingscode schrijven, en CSS-selectorwijzigingen blijven een risico. Voor 100.000 pagina’s per maand is het kostenverschil enorm: zelf bouwen kost over drie jaar ongeveer — een besparing van 71%.

Het omslagpunt ligt meestal rond 500K–1M requests per maand. Daaronder wegen de tijdsbesparingen van een API vaak ruimschoots op tegen de kosten.

Methode 4: Amazon Best Sellers scrapen met Thunderbit (geen Python nodig)

Volledige openheid: ik werk bij Thunderbit, dus houd daar rekening mee. Dat gezegd hebbende: ik heb alle vier de methodes echt achter elkaar getest, en het verschil in snelheid naar data was opvallend.

is een AI-webscraper die draait als Chrome-extensie. Het basisidee: in plaats van CSS-selectors of Python-code te schrijven, leest de AI de pagina en bepaalt zelf welke data moet worden uitgehaald. Voor Amazon Best Sellers heeft Thunderbit kant-en-klare templates die met één klik werken.

Stap 1: Installeer de Thunderbit Chrome-extensie

Ga naar de en klik op "Add to Chrome." Maak een gratis account aan — de gratis versie geeft je genoeg credits om dit uit te proberen.

Stap 2: Open de Amazon Best Sellers-pagina

Open een Amazon Best Sellers-categoriepagina in Chrome. Bijvoorbeeld: https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/

Stap 3: Klik op "AI Suggest Fields"

Open de Thunderbit-zijbalk en klik op "AI Suggest Fields." De AI analyseert de paginstructuur en stelt kolommen voor: Productnaam, Prijs, Beoordeling, Image URL, Verkoper, Product URL en Rang. In mijn test herkende hij binnen ongeveer 3 seconden alle relevante velden correct.

Je kunt kolommen hernoemen, verwijderen of toevoegen. Je kunt zelfs per veld aangepaste AI-prompts toevoegen — bijvoorbeeld "categoriseer als Electronics/Apparel/Home" om een categorietag aan elk product toe te voegen.

Stap 4: Klik op "Scrape"

Druk op de knop "Scrape". Thunderbit vult een gestructureerde tabel met alle productdata van de pagina. In cloudmodus verwerkt het tot 50 pagina’s tegelijk parallel, waarbij lazy loading en paginering automatisch worden afgehandeld.

Stap 5: Gratis exporteren

Klik op "Export" en kies je bestemming: Excel, Google Sheets, Airtable of Notion. Exporteren is gratis op elk plan — zonder verborgen kosten.

Het hele proces duurde bij mij ongeveer 90 seconden: van het openen van de pagina tot een complete spreadsheet. Ter vergelijking: methode 1 kostte ongeveer 20 minuten (inclusief debuggen van het lazy-loadingprobleem), methode 2 ongeveer 35 minuten (inclusief Selenium-setup) en methode 3 ongeveer 15 minuten (inclusief het aanmaken van een API-account).

Waarom Thunderbit goed werkt op Amazon

Omdat de AI de pagina elke keer opnieuw leest, past het zich automatisch aan layoutwijzigingen aan — geen CSS-selectors om te onderhouden. Daarmee tackelt het direct de meest voorkomende klacht op scrapingforums: "Een basic web scraper is niet genoeg, je moet allerlei catches toevoegen voor elementwijzigingen." Wanneer Amazon zijn DOM verandert (en dat gebeurt regelmatig), hoef je niets bij te werken.

Cloud scraping verwerkt proxy-rotatie, rendering en anti-botmaatregelen transparant. Voor gebruikers die een oplossing willen die gewoon werkt, haalt dit de hele anti-banhoofdpijn weg.

Het anti-ban playbook: hoe je voorkomt dat Amazon je blokkeert

Amazon’s botdetectie is agressief. Tijdens het testen werd mijn IP tijdelijk geblokkeerd, en forumgebruikers melden hetzelfde: "errors everywhere, amazon even started redirecting me to the homepage." Als je via Python werkt (methodes 1–3), dan is deze sectie essentieel.

Hier is een gelaagde strategie, van basis tot geavanceerd:

1. Wissel User-Agent strings af

Elke keer dezelfde User-Agent sturen is verdacht. Gebruik de set van 5+ strings uit het codevoorbeeld van methode 1 en kies per verzoek willekeurig één:

1headers = {"User-Agent": random.choice(USER_AGENTS)}

2. Voeg willekeurige vertragingen tussen verzoeken toe

Vaste vertragingen zijn herkenbaar (patronen). Willekeurige vertragingen zijn veiliger:

1time.sleep(random.uniform(2, 5))

Ik merkte dat 2–5 seconden tussen verzoeken me onder de radar hield bij kleine batches (onder 50 requests). Voor grotere runs kun je beter 3–7 seconden aanhouden.

3. Gebruik proxy-rotatie

Dit is de grote. laten zien dat residential proxies op Amazon gemiddeld ~94% succes halen, tegenover ~59% voor datacenter proxies — een verschil van 35 procentpunt. Amazon’s detectiestack gebruikt TLS-fingerprinting, gedragsanalyse en rate limiting per IP, waardoor standaard datacenter-IP’s binnen seconden worden gemarkeerd.

Residential proxies zijn duurder ($2–$12 per GB, afhankelijk van de provider), maar veel betrouwbaarder. Voorbeeld:

1proxies = {
2    "http": "http://user:pass@residential-proxy.example.com:8080",
3    "https": "http://user:pass@residential-proxy.example.com:8080"
4}
5response = requests.get(url, headers=headers, proxies=proxies)

4. Versterk je browser fingerprint (Selenium)

1options.add_argument('--disable-blink-features=AutomationControlled')
2options.add_experimental_option("excludeSwitches", ["enable-automation"])
3options.add_experimental_option('useAutomationExtension', False)
4# Na initialisatie van de driver, verwijder de navigator.webdriver-flag
5driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
6    'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
7})

5. Beheer sessies en cookies

Door cookies tussen requests te bewaren, lijkt je scraper meer op een echte usersessie:

1session = requests.Session()
2# Bezoek eerst de homepage om realistische cookies te krijgen
3session.get("https://www.amazon.com", headers=headers)
4time.sleep(2)
5# Scrape daarna je doelpagina
6response = session.get(target_url, headers=headers)

6. Wanneer je de hoofdpijn gewoon moet overslaan

Voor gebruikers die dit allemaal niet willen beheren, verwerkt Thunderbit’s cloud scraping proxy-rotatie, rendering en anti-botmaatregelen transparant. Scraping-API’s nemen ook de meeste van deze zorgen uit handen. In mijn ervaring kost het debuggen van anti-banproblemen vaak meer tijd dan het schrijven van de scrapingcode zelf — dus de "werkt gewoon"-aanpak levert echt ROI op.

Subpage enrichment: productdetailpagina’s scrapen voor rijkere data

De Best Sellers-lijst toont alleen basisinformatie — titel, prijs, beoordeling, rang. Maar de echte waarde voor FBA-onderzoek zit op individuele productdetailpagina’s. Dit mis je als je alleen de lijst scrape:

Dat veld "Datum eerste beschikbaarheid" is vooral waardevol — het laat zien hoe lang een product al op de markt is, en dat is een belangrijk signaal voor concurrentieanalyse. En het aantal verkopers plus de Buy Box-eigenaar helpt je inschatten of een niche interessant genoeg is om in te stappen (als Amazon zelf >30% Buy Box-aandeel heeft, is concurreren extreem lastig).

Python-aanpak: door product-URL’s loopen

Nadat je product-URL’s van de lijstpagina hebt verzameld, loop je er met een vertraging doorheen:

1for product in products:
2    time.sleep(random.uniform(3, 6))
3    detail_response = session.get(product["URL"], headers={"User-Agent": random.choice(USER_AGENTS)})
4    detail_soup = BeautifulSoup(detail_response.text, "html.parser")
5    # Extract brand
6    brand_tag = detail_soup.find("a", id="bylineInfo")
7    product["Brand"] = brand_tag.get_text(strip=True) if brand_tag else "N/A"
8    # ASIN uit de paginabron of URL halen
9    # Datum eerste beschikbaarheid uit de productdetails-tabel halen
10    # ... extra velden ...

Eerlijk gewaarschuwd: 100 individuele productpagina’s opvragen vergroot je banrisico flink. Reken op proxy-rotatie en langere vertragingen.

Thunderbit-aanpak: subpagina’s met één klik scrapen

Nadat je de lijstpagina in een tabel hebt gescrapet, klik je op "Scrape Subpages" in Thunderbit. De AI bezoekt elke product-URL en verrijkt de tabel automatisch met extra kolommen — merk, ASIN, specificaties, kenmerken. Geen extra code, selectors of setup nodig. Vooral handig voor e-commerce teams die het volledige plaatje nodig hebben voor sourcing-beslissingen, maar geen detailpagina-parser willen schrijven en onderhouden.

Terugkerende scrapes automatiseren: Best Sellers in de tijd volgen

Een eenmalige scrape is nuttig, maar voortdurende monitoring is waar het echte concurrentievoordeel zit. Bijhouden welke producten stijgen en dalen, trends vroeg signaleren en prijswijzigingen volgen over weken of maanden — dat is wat casual onderzoek onderscheidt van datagedreven beslissingen.

Python-aanpak: plannen met cron

Op Linux/Mac kun je je Python-script inplannen met cron. Hier is de crontab-regel voor een dagelijkse scrape om 8:00 uur:

10 8 * * * /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1

Voor een wekelijkse scrape op maandag om 9:00 uur:

10 9 * * 1 /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1

Op Windows gebruik je Task Scheduler om hetzelfde te doen. Voor planning die altijd doorloopt zonder je laptop aan te laten staan, kun je deployen naar een VPS of AWS Lambda — maar dat maakt de infrastructuur wel complexer.

Voeg logging en foutmeldingen toe om mislukte runs te signaleren. Er is weinig vervelender dan ontdekken dat je scraper twee weken geleden stilletjes is stukgelopen.

Thunderbit-aanpak: Scheduled Scraper in gewone taal

Thunderbit’s Scheduled Scraper laat je het interval in natuurlijke taal beschrijven — typ "elke maandag om 9 uur" of "elke dag om 8 uur" en de AI begrijpt het schema. Scrapes draaien op Thunderbit’s cloudservers (er hoeft geen browser of computer aan te staan), en data wordt automatisch geëxporteerd naar Google Sheets of Airtable. Zo maak je een live monitoringdashboard zonder serverbeheer — ideaal voor operationele teams die blijvend inzicht willen zonder DevOps-overhead.

Juridische en ethische aandachtspunten bij het scrapen van Amazon

Ik ben geen advocaat, en dit is geen juridisch advies. Maar een scraping-tutorial zonder de juridische kant te bespreken zou onverantwoord zijn — forumgebruikers brengen ToS-zorgen expliciet ter sprake, en terecht.

Amazon’s robots.txt: Volgens de stand van 2026 bevat Amazon’s robots.txt meer dan 80 specifieke Disallow-paden, maar /gp/bestsellers/ is niet expliciet geblokkeerd voor standaard user agents. Wel krijgen meer dan 35 AI-specifieke user agents (ClaudeBot, GPTBot, Scrapy, enz.) een generieke Disallow: /. Het ontbreken van een specifieke blokkade betekent niet dat Amazon scraping goedkeurt.

Amazon’s Algemene Voorwaarden: Amazon’s (bijgewerkt in mei 2025) verbieden expliciet het "use any automated process or technology to access, acquire, copy, or monitor any part of the Amazon Website" zonder schriftelijke toestemming. Dit is niet theoretisch — Amazon in november 2025 vanwege ongeautoriseerde geautomatiseerde toegang en kreeg een voorlopige voorziening toegewezen.

Het hiQ v. LinkedIn-precedent: In (Ninth Circuit, 2022) oordeelde de rechtbank dat het scrapen van publiek beschikbare data waarschijnlijk niet in strijd is met de Computer Fraud and Abuse Act. Maar hiQ schikte uiteindelijk en stemde ermee in te stoppen met scrapen — winnen op CFAA-basis beschermt je dus niet tegen contractbreukclaims.

Praktische richtlijnen:

• Scrape alleen publiek beschikbare data (prijzen, BSR, producttitels — geen PII)
• Respecteer rate limits en overbelast servers niet
• Gebruik de data voor legitieme concurrentie-inzichten
• Raadpleeg je eigen juridisch adviseur voordat je op schaal gaat scrapen
• Wees je ervan bewust dat inmiddels uitgebreide privacywetgeving hebben

Thunderbit’s cloud scraping gebruikt standaard browserachtige verzoekpatronen, maar je moet altijd zelf laten toetsen of dit juridisch binnen de regels valt.

Welke methode moet je kiezen? Een snelle beslissingsgids

De korte versie:

• "Ik leer Python en wil een weekendproject." → Methode 1 (requests + BeautifulSoup). Je leert veel over HTTP-verzoeken, HTML-parsing en Amazon’s anti-botverdediging.
• "Ik moet JavaScript-zware pagina’s of ingelogde sessies scrapen." → Methode 2 (Selenium). Zwaarder, maar geschikt voor dynamische content.
• "Ik draai productiescrapes op schaal." → Methode 3 (Scraping API). Laat iemand anders proxies en rendering beheren. De is onder 500K requests per maand in het voordeel van API’s.
• "Ik ben geen developer en wil binnen 2 minuten data." → Methode 4 (). Geen code, geen selectors, geen onderhoud.
• "Ik wil doorlopende monitoring zonder serverbeheer." → Thunderbit Scheduled Scraper. Instellen en vergeten.

Conclusie en belangrijkste inzichten

Na een weekend testen bleef dit het meest hangen:

requests + BeautifulSoup is prima om te leren, maar door de lazy-loadingbeperking (slechts ~30 van de 50 producten) en fragiele CSS-selectors is het minder geschikt voor productie.

Selenium lost het lazy-loadingprobleem op en vangt alle 50 producten per pagina, maar is traag, geheugenzwaar en blijft detecteerbaar voor Amazon’s botverdediging.

Scraping-API’s bieden de beste betrouwbaarheid voor scraping op productieschaal — op Amazon — maar de kosten lopen op en je moet nog steeds parsingscode schrijven.

Thunderbit leverde veruit de snelste time-to-data. De AI verwerkt layoutwijzigingen, lazy loading, paginering en anti-botmaatregelen zonder enige configuratie. Voor niet-technische gebruikers of teams die terugkerende data willen zonder DevOps-overhead is dit de meest praktische optie.

De belangrijkste les? Amazon’s anti-botmaatregelen en frequente layoutwijzigingen zorgen ervoor dat onderhoudsarme oplossingen op de lange termijn het meeste tijd besparen. Elk uur dat je kwijt bent aan kapotte selectors en proxy-rotatie is een uur dat je niet aan echte analyse besteedt.

Wil je de no-code aanpak proberen? geeft je genoeg credits om een paar Best Sellers-categorieën te scrapen en het zelf te zien. Liever Python gebruiken? De codevoorbeelden hierboven helpen je op weg. Hoe dan ook: je hebt Amazon Best Seller-data straks in een spreadsheet in plaats van dat je naar een browsertabblad zit te staren.

Voor meer over webscraping-aanpakken kun je onze gidsen bekijken over , en . Je kunt ook stap-voor-stap uitlegvideo’s bekijken op het .

Meer weten