Leer hoe je Amazon-producten scrape met Python

Als je een Amazon-scraping tutorial hebt gevolgd en daarna vastliep op een muur van CAPTCHAs, 503-fouten of gewoon compleet lege resultaten — welkom bij de club. De meeste Python-gidsen voor Amazon scraping die online rondzwerven, zijn geschreven in 2022 of 2023 en gebruiken selectors en technieken die Amazon inmiddels allang heeft aangepast.

Ik heb jarenlang gewerkt aan data-extractietools bij Thunderbit, en één ding kan ik je uit de praktijk vertellen: Amazon is een van de lastigste sites om betrouwbaar te scrapen. Het platform verandert voortdurend zijn HTML-structuur, zet een zeslagen anti-botverdediging in en toont via A/B-tests zelfs verschillende paginalay-outs aan verschillende gebruikers. In deze gids neem ik je mee door een Python Amazon-scraper die in 2025 écht werkt — met gecontroleerde CSS-selectors, een gelaagde anti-blockingstrategie en tips voor scheduling en export die de meeste tutorials volledig overslaan. En voor iedereen die gewoon data nodig heeft zonder te willen worstelen met Python, laat ik ook zien hoe hetzelfde werk in ongeveer twee klikken doet.

Wat is Amazon product scraping?

Amazon product scraping is het geautomatiseerd ophalen van publiek beschikbare data — zoals productnamen, prijzen, beoordelingen, aantallen reviews, afbeeldingen, beschikbaarheid en meer — van Amazon-productpagina’s en zoekresultaten. In plaats van handmatig informatie over te nemen uit honderden listings, bezoekt een scraper elke pagina, leest de HTML en zet de data die jij wilt in een gestructureerd formaat zoals CSV, Excel of een database.

Zie het als het inhuren van een onvermoeibare stagiair die in de tijd dat jij je koffie opdrinkt al duizend productpagina’s kan doorlopen. Alleen maakt deze stagiair nooit spelfouten en heeft hij geen lunchpauze nodig.

Waarom Amazon-producten scrapen met Python?

Amazon huisvest naar schatting in meer dan 30 categorieën, aangestuurd door ongeveer . Third-party sellers zijn inmiddels goed voor 69% van de totale GMV. Zelfs een klein deel van die catalogus handmatig volgen is onmogelijk. Daarom scrapen teams Amazon:

Alleen al de snelheid waarmee Amazon prijzen wijzigt maakt automatisering onmisbaar: Amazon past prijzen aan, waarbij de prijs van een gemiddeld product ongeveer elke 10 minuten verandert. Ter vergelijking: concurrenten zoals Best Buy en Walmart wijzigen prijzen slechts zo’n 50.000 keer per maand. Dat kan geen enkel menselijk team bijhouden.

Python geeft je volledige controle over het scrapingproces — jij bepaalt wat je ophaalt, hoe je fouten afhandelt en waar je de data opslaat. Maar dat betekent ook dat jij verantwoordelijk bent voor onderhoud, anti-blocking en het bijhouden van Amazon’s frequente HTML-wijzigingen.

Wat je van Amazon kunt scrapen — en wat niet

Van publiek toegankelijke productpagina’s kun je meestal het volgende extraheren:

• Producttitel (naam, merk)
• Prijs (huidige prijs, oorspronkelijke prijs, actieprijs)
• Beoordeling (ster-gemiddelde)
• Aantal reviews
• Productafbeeldingen (URL van hoofdfoto)
• Beschikbaarheid / voorraadstatus
• ASIN (Amazon Standard Identification Number)
• Productbeschrijving en bullets
• Verkopersinformatie
• Productvarianten (maat, kleur, enz.)

Wat je beter niet doet:

• Data achter een inlogmuur: uitgebreide reviewpagina’s, persoonlijke accountgegevens, bestelgeschiedenis
• Persoonsgegevens: namen van kopers, adressen, betaalinformatie
• Auteursrechtelijk beschermd materiaal voor herpublicatie: productomschrijvingen en afbeeldingen zijn prima voor analyse, maar publiceer ze niet als je eigen content

Amazon’s blokkeert 50+ bekende bots (waaronder GPTBot, Scrapy en ClaudeBot) en verbiedt paden zoals accounts, winkelwagens en verlanglijstjes. Productdetailpagina’s zijn niet expliciet verboden, maar Amazon’s gebruiksvoorwaarden staan geautomatiseerde toegang wel degelijk niet toe. Rechtbanken maken doorgaans onderscheid tussen schending van de ToS (civiel) en strafbare overtredingen onder de CFAA — meer over de legaliteit aan het eind van deze gids.

Tools en libraries die je nodig hebt

Dit is de Python stack voor deze tutorial:

Optioneel (voor content die via JavaScript wordt geladen):

• selenium of playwright — headless browser-automatisering

Je Python-omgeving instellen

Open je terminal en voer uit:

1mkdir amazon-scraper && cd amazon-scraper
2python -m venv venv
3source venv/bin/activate  # Op Windows: venv\Scripts\activate
4pip install requests beautifulsoup4 lxml curl_cffi pandas

Controleer of alles goed is geïnstalleerd:

1import requests, bs4, curl_cffi, pandas
2print("All good!")

Als je zonder fouten "All good!" ziet, ben je klaar om te starten.

Waarom de meeste Amazon scraping tutorials breken — en waarom deze anders is

Dit is precies het stuk dat de meeste gidsen overslaan, en het is waarschijnlijk ook de reden dat je dit artikel leest.

Amazon werkt zijn HTML-structuur, class names en element-ID’s regelmatig bij. De scraping-community meldt dat door DOM-wijzigingen en veranderingen in fingerprinting. De bekendste misser? De selector #priceblock_ourprice, die in honderden tutorials uit 2018–2023 opdook. Die ID bestaat niet meer op Amazon-productpagina’s.

Een snelle vergelijking van wat kapot is versus wat nu werkt:

Elke code snippet in deze gids is getest op live Amazon-pagina’s in 2025. Ik laat je de echte CSS-selectors zien, inclusief de verwachte output — geen copy-paste uit 2022.

Voor je begint

• Moeilijkheidsgraad: Gemiddeld (basiskennis Python wordt verondersteld)
• Benodigde tijd: ~30–45 minuten voor de volledige tutorial; ~10 minuten voor de basis-scraper
• Wat je nodig hebt: Python 3.9+, Chrome-browser (om Amazon-pagina’s te inspecteren), een terminal en optioneel de als je de no-code aanpak wilt vergelijken

Stap 1: Stuur je eerste verzoek naar Amazon

Open in je browser een Amazon-productpagina en kopieer de URL. We beginnen met een simpele requests.get():

1import requests
2url = "https://www.amazon.com/dp/B0DGNFM9YJ"
3response = requests.get(url)
4print(response.status_code)
5print(response.text[:500])

Als je dit uitvoert, krijg je vrijwel zeker een 503-statuscode of een pagina waarop staat: "To discuss automated access to Amazon data please contact…" Dat is Amazon’s WAF (Web Application Firewall) die je Python-script herkent. Een kale requests.get() zonder de juiste headers haalt tegen Amazon ongeveer .

Je zult iets zien als: 503 en een blokkadepagina in de HTML. Dat is normaal — we lossen het in de volgende stap op.

Stap 2: Stel aangepaste headers en TLS-imitatie in

Alleen een User-Agent toevoegen is tegenwoordig niet genoeg. Amazon vergelijkt je HTTP-headers met je TLS-fingerprint. Als je zegt Chrome 120 te zijn, maar je TLS-handshake verraadt dat je Python’s requests gebruikt, word je .

De meest betrouwbare aanpak in 2025 is curl_cffi gebruiken met browser-imitatie:

1from curl_cffi import requests as cfreq
2headers = {
3    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
4    "Accept-Language": "en-US,en;q=0.9",
5    "Accept-Encoding": "gzip, deflate, br",
6    "Referer": "https://www.google.com/",
7    "DNT": "1",
8    "Connection": "keep-alive",
9    "Upgrade-Insecure-Requests": "1",
10}
11url = "https://www.amazon.com/dp/B0DGNFM9YJ"
12response = cfreq.get(url, headers=headers, impersonate="chrome124")
13print(response.status_code)
14print(len(response.text))

Met curl_cffi dat Chrome 124 imiteert, stijgt de slagingskans tot ongeveer — een verbetering van 47x ten opzichte van gewone requests. Je zou nu een 200-statuscode moeten zien en een veel langere HTML-respons (100.000+ tekens).

Als je nog steeds een 503 krijgt, probeer dan een andere impersonate-waarde (bijv. "chrome131") of wacht even kort voor je opnieuw probeert.

Stap 3: Parse de HTML en haal productdata eruit

Nu we de volledige HTML hebben, gaan we de data extraheren met BeautifulSoup en gecontroleerde 2025-selectors:

1from bs4 import BeautifulSoup
2soup = BeautifulSoup(response.text, "lxml")
3# Producttitel
4title_el = soup.select_one("span#productTitle")
5title = title_el.get_text(strip=True) if title_el else None
6# Prijs
7price_el = soup.select_one(
8    "div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen"
9)
10if not price_el:
11    price_el = soup.select_one("span.priceToPay .a-offscreen")
12if not price_el:
13    price_el = soup.select_one(".apexPriceToPay .a-offscreen")
14price = price_el.get_text(strip=True) if price_el else None
15# Beoordeling
16rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17rating = rating_el.get_text(strip=True) if rating_el else None
18# Aantal reviews
19reviews_el = soup.select_one("span#acrCustomerReviewText")
20reviews = reviews_el.get_text(strip=True) if reviews_el else None
21# Beschikbaarheid
22avail_el = soup.select_one("div#availability span")
23availability = avail_el.get_text(strip=True) if avail_el else None
24# URL van hoofafbeelding
25img_el = soup.select_one("#landingImage")
26image_url = img_el.get("src") if img_el else None
27print(f"Title: {title}")
28print(f"Price: {price}")
29print(f"Rating: {rating}")
30print(f"Reviews: {reviews}")
31print(f"Availability: {availability}")
32print(f"Image: {image_url}")

Verwachte output (voorbeeld):

1Title: Apple AirPods Pro (2nd Generation) with USB-C
2Price: $189.99
3Rating: 4.7 out of 5 stars
4Reviews: 98,432 ratings
5Availability: In Stock
6Image: https://m.media-amazon.com/images/I/61SUj2...

Let op de meerdere fallback-selectors voor prijs — Amazon gebruikt verschillende containers afhankelijk van het producttype, de dealstatus en de A/B-testvariant. Door elke extractie in een conditie te zetten, voorkom je dat je scraper crasht zodra een selector niet matcht.

Stap 4: Scrape meerdere producten uit zoekresultaten

Om een echte dataset op te bouwen, wil je meestal beginnen op een Amazon-zoekresultatenpagina, ASIN’s verzamelen en daarna elke productdetailpagina scrapen.

1import time
2import random
3def get_search_asins(keyword, max_pages=1):
4    """Verzamel ASIN's uit Amazon-zoekresultaten."""
5    asins = []
6    for page in range(1, max_pages + 1):
7        search_url = f"https://www.amazon.com/s?k={keyword}&page={page}"
8        resp = cfreq.get(search_url, headers=headers, impersonate="chrome124")
9        if resp.status_code != 200:
10            print(f"Search page {page} returned {resp.status_code}")
11            break
12        search_soup = BeautifulSoup(resp.text, "lxml")
13        results = search_soup.select('div[data-component-type="s-search-result"]')
14        for r in results:
15            asin = r.get("data-asin")
16            if asin:
17                asins.append(asin)
18        print(f"Page {page}: found {len(results)} products")
19        time.sleep(random.uniform(2, 5))  # Beleefde pauze
20    return asins
21asins = get_search_asins("wireless+earbuds", max_pages=2)
22print(f"Collected {len(asins)} ASINs")

Elke ASIN hoort bij een nette product-URL: https://www.amazon.com/dp/{ASIN}. Dat is betrouwbaarder dan de volledige zoekresultaat-URL’s, die sessiespecifieke parameters kunnen bevatten.

Stap 5: Afhandeling van paginering en scrapen op schaal

Laten we nu zoekverzameling en detailpagina-scraping combineren tot een volledige pipeline:

1import pandas as pd
2def scrape_product(asin):
3    """Scrape een enkele Amazon-productdetailpagina."""
4    url = f"https://www.amazon.com/dp/{asin}"
5    try:
6        resp = cfreq.get(url, headers=headers, impersonate="chrome124")
7        if resp.status_code != 200:
8            return None
9        soup = BeautifulSoup(resp.text, "lxml")
10        title_el = soup.select_one("span#productTitle")
11        price_el = (
12            soup.select_one("div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen")
13            or soup.select_one("span.priceToPay .a-offscreen")
14            or soup.select_one(".apexPriceToPay .a-offscreen")
15        )
16        rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17        reviews_el = soup.select_one("span#acrCustomerReviewText")
18        avail_el = soup.select_one("div#availability span")
19        img_el = soup.select_one("#landingImage")
20        return {
21            "asin": asin,
22            "title": title_el.get_text(strip=True) if title_el else None,
23            "price": price_el.get_text(strip=True) if price_el else None,
24            "rating": rating_el.get_text(strip=True) if rating_el else None,
25            "reviews": reviews_el.get_text(strip=True) if reviews_el else None,
26            "availability": avail_el.get_text(strip=True) if avail_el else None,
27            "image_url": img_el.get("src") if img_el else None,
28            "url": url,
29        }
30    except Exception as e:
31        print(f"Error scraping {asin}: {e}")
32        return None
33# Scrape alle verzamelde ASIN's
34products = []
35for i, asin in enumerate(asins):
36    print(f"Scraping {i+1}/{len(asins)}: {asin}")
37    product = scrape_product(asin)
38    if product:
39        products.append(product)
40    time.sleep(random.uniform(2, 5))  # Willekeurige pauze tussen verzoeken
41df = pd.DataFrame(products)
42print(f"\nScraped {len(df)} producten succesvol")
43print(df.head())

De willekeurige pauze van 2–5 seconden is cruciaal. Perfect regelmatige timing (bijvoorbeeld exact elke 3 seconden) ziet er verdacht uit voor Amazon’s gedragsanalyse. Willekeurige intervallen bootsen menselijk browsegedrag na.

Stap 6: Scraped Amazon-data opslaan als CSV

1df.to_csv("amazon_products.csv", index=False, encoding="utf-8-sig")
2print("Opgeslagen naar amazon_products.csv")

Je zou nu een nette CSV moeten hebben met kolommen voor ASIN, titel, prijs, beoordeling, reviews, beschikbaarheid, afbeeldings-URL en product-URL. Hier stoppen de meeste tutorials — maar als je een echte workflow bouwt, is CSV pas het begin.

Anti-blocking diepgaand uitgelegd: hoe je scraper blijft draaien

Geblokkeerd worden is het voor iedereen die probeert Amazon-producten met Python te scrapen. Amazon’s zeslagen verdediging bestaat uit IP-reputatie-analyse, TLS-fingerprinting, controle van de browseromgeving, gedragsbiometrie, CAPTCHAs en ML-gestuurde anomaliedetectie. Hieronder staat een gelaagde strategie om elk onderdeel aan te pakken.

Roteer User-Agents en volledige headers

Eén statische User-Agent wordt snel opgepakt. Wissel daarom tussen een lijst met actuele browserstrings:

1import random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.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/143.0.0.0 Safari/537.36",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
6    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
7]
8def get_headers():
9    return {
10        "User-Agent": random.choice(USER_AGENTS),
11        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
12        "Accept-Language": "en-US,en;q=0.9",
13        "Accept-Encoding": "gzip, deflate, br",
14        "Referer": "https://www.google.com/",
15        "DNT": "1",
16        "Connection": "keep-alive",
17    }

Eén detail waar veel mensen over struikelen: je Accept-Language moet overeenkomen met de geografische locatie die je IP suggereert. Accept-Language: en-US sturen vanaf een Duits IP is een rode vlag.

TLS-fingerprint-imitatie met curl_cffi

We hebben dit al besproken in Stap 2, maar het is het herhalen waard: deze techniek levert de grootste verbetering in succesratio op. Standaard Python requests haalt ongeveer 2% succes tegen Amazon. Met curl_cffi-imitatie zit je rond de 94%. Dat is het verschil tussen een werkende scraper en een kapotte.

1from curl_cffi import requests as cfreq
2# Roteer ook de browser-imitaties
3BROWSERS = ["chrome120", "chrome124", "chrome131"]
4response = cfreq.get(
5    url,
6    headers=get_headers(),
7    impersonate=random.choice(BROWSERS),
8)

Proxy-rotatie

Voor meer dan een paar pagina’s scrapen heb je proxy-rotatie nodig. Amazon volgt IP-adressen en blokkeert elk IP dat te veel verzoeken verstuurt.

1PROXIES = [
2    "http://user:pass@proxy1.example.com:8080",
3    "http://user:pass@proxy2.example.com:8080",
4    "http://user:pass@proxy3.example.com:8080",
5]
6proxy = random.choice(PROXIES)
7response = cfreq.get(
8    url,
9    headers=get_headers(),
10    impersonate="chrome124",
11    proxies={"http": proxy, "https": proxy},
12)

Residential proxies werken beter dan datacenter-proxies (Amazon blokkeert datacenter-IP’s proactief), maar ze zijn ook duurder. Voor een klein project kun je starten met een en later opschalen.

Rate limiting en exponential backoff

Geen enkel concurrerend artikel dat ik vond behandelt dit goed, maar het is essentieel. Als je een 503- of CAPTCHA-respons krijgt, probeer dan niet direct opnieuw — dat is een snelle route naar een permanente ban.

1import time
2import random
3def fetch_with_backoff(url, max_retries=3):
4    """Haal een URL op met exponentiële backoff bij fouten."""
5    for attempt in range(max_retries):
6        response = cfreq.get(
7            url,
8            headers=get_headers(),
9            impersonate=random.choice(BROWSERS),
10        )
11        if response.status_code == 200:
12            return response
13        # Exponentiële backoff met jitter
14        wait = min(2 ** attempt + random.uniform(0, 1), 30)
15        print(f"Poging {attempt+1} mislukt ({response.status_code}). Wachten {wait:.1f}s...")
16        time.sleep(wait)
17    return None  # Alle pogingen opgebruikt

De formule wait = min(2^attempt + jitter, max_delay) zorgt ervoor dat je vertragingen oplopen (2s, 4s, 8s...) maar nooit onredelijk lang worden. De willekeurige jitter voorkomt dat je retry-patroon kan worden herkend.

Selenium- of Playwright-fallback voor JS-rendered content

Sommige Amazon-pagina’s (vooral met dynamische prijswidgets of variantselecties) hebben JavaScript nodig om volledig te renderen. Wanneer curl_cffi onvolledige HTML teruggeeft, is een headless browser je fallback:

1from playwright.sync_api import sync_playwright
2def scrape_with_browser(url):
3    with sync_playwright() as p:
4        browser = p.chromium.launch(headless=True)
5        page = browser.new_page()
6        page.goto(url, wait_until="domcontentloaded")
7        page.wait_for_timeout(3000)  # Laat JS renderen
8        html = page.content()
9        browser.close()
10        return html

Dit is trager — 3–5 seconden per pagina versus minder dan 1 seconde met curl_cffi. Gebruik het alleen wanneer nodig.

In mijn ervaring verwerkt curl_cffi meer dan 90% van de Amazon-productpagina’s zonder browser.

Samenvatting anti-blocking

Verder dan CSV: scraped Amazon-data exporteren naar Google Sheets, Airtable en meer

Elke tutorial die ik heb bekeken stopt bij CSV-export. Maar echte bedrijfsworkflows hebben data nodig in Google Sheets, databases of tools zoals Airtable en Notion.

Exporteren naar Google Sheets met gspread

Stel eerst een Google service account in (eenmalige setup):

1. Ga naar → APIs & Services → Credentials
2. Maak een service account aan en download het JSON-sleutelbestand
3. Sla het op in ~/.config/gspread/service_account.json
4. Deel je spreadsheet met de client_email uit het JSON-bestand

Daarna:

1import gspread
2from gspread_dataframe import set_with_dataframe
3gc = gspread.service_account()
4sh = gc.open("Amazon Scrape Data")
5worksheet = sh.sheet1
6set_with_dataframe(worksheet, df)
7print("Data geëxporteerd naar Google Sheets!")

Hiermee schrijf je je volledige DataFrame rechtstreeks naar een Google Sheet — live, deelbaar en direct bruikbaar voor dashboards.

Opslaan in SQLite voor lokale analyse

Voor grotere datasets of historische tracking is SQLite ideaal — geen serverinstallatie, alleen één bestand:

1import sqlite3
2conn = sqlite3.connect("amazon_products.db")
3df.to_sql("products", conn, if_exists="append", index=False)
4print(f"{len(df)} producten opgeslagen in SQLite")
5# Later opvragen:
6historical = pd.read_sql_query(
7    "SELECT * FROM products WHERE price IS NOT NULL ORDER BY rowid DESC LIMIT 100",
8    conn,
9)

Het no-code alternatief

Als je geen zin hebt om Python-exportscripts te onderhouden, biedt gratis export naar Google Sheets, Airtable, Notion, Excel, CSV en JSON — inclusief afbeeldingsvelden die direct in Airtable en Notion worden weergegeven. Geen gspread-setup, geen API-credentials, helemaal geen code. Voor teams die data in hun bestaande tools willen laten stromen, is dat een enorme tijdsbesparing.

Geautomatiseerde Amazon-scrapes plannen — het ontbrekende hoofdstuk

Prijsmonitoring en voorraadtracking vereisen terugkerende scrapes, niet eenmalige runs. Toch kon ik geen enkel concurrerend artikel vinden dat scheduling behandelt. Hier lees je hoe je je Python-scraper automatiseert.

Cron jobs (Linux/macOS)

Open je crontab:

1crontab -e

Voeg een regel toe om je scraper dagelijks om 6 uur ’s ochtends te draaien:

10 6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

Of elke 6 uur:

10 */6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

Windows Taakplanner

Maak een batchbestand run_scraper.bat:

1@echo off
2cd /d "C:\path\to\amazon-scraper"
3call venv\Scripts\activate
4python scraper.py
5deactivate

Open daarna Taakplanner → Basisopdracht maken → stel de trigger in (Dagelijks, Elk uur) → Actie: "Een programma starten" → blader naar run_scraper.bat.

GitHub Actions (gratis laag)

Voor een cloudgebaseerd schema zonder infrastructuur:

1name: Amazon Scraper
2on:
3  schedule:
4    - cron: "0 6 * * *"  # Dagelijks om 6:00 UTC
5  workflow_dispatch:       # Handmatige trigger
6jobs:
7  scrape:
8    runs-on: ubuntu-latest
9    steps:
10      - uses: actions/checkout@v3
11      - name: Set up Python
12        uses: actions/setup-python@v4
13        with:
14          python-version: "3.11"
15      - name: Install dependencies
16        run: pip install -r requirements.txt
17      - name: Run scraper
18        run: python scraper.py
19      - name: Commit results
20        run: |
21          git config user.name 'GitHub Actions'
22          git config user.email 'actions@github.com'
23          git add data/
24          git diff --staged --quiet || git commit -m "Update scraped data"
25          git push

Sla proxygegevens op in GitHub Secrets en je hebt een gratis, geautomatiseerde scrapingpipeline.

No-code alternatief: Thunderbit’s Scheduled Scraper

Voor teams die cron-syntax of cloudinfrastructuur niet willen beheren, heeft Thunderbit een ingebouwde . Je beschrijft het schema in gewone taal (bijv. "elke dag om 8 uur" of "elke maandag"), voegt je Amazon-URL’s toe en klikt op "Schedule." Geen terminal, geen YAML-bestanden, geen deploymentpipeline. Vooral handig voor ecommerce-teams die continu prijs- of voorraadmonitoring draaien.

Python zelfbouw vs. Scraper API vs. no-code: welke aanpak past bij jou?

Dit is een vraag die ik op fora voortdurend zie, en geen enkel hoogrankend artikel geeft hier een gestructureerd antwoord op. Dus hier is mijn eerlijke mening:

Python is de juiste keuze als je wilt leren, elk detail wilt aanpassen en onderhoud geen probleem vindt. Scraper API’s nemen anti-blocking van je over, maar vereisen nog steeds code. En Thunderbit is de snelste route voor sales, ecommerce-operations of iedereen die gewoon data nodig heeft — zonder selectors, zonder code, zonder onderhoud wanneer Amazon zijn HTML verandert.

Hoe Thunderbit Amazon-producten in 2 klikken scrapt

Ik ben natuurlijk niet objectief — mijn team heeft dit gebouwd. Maar de workflow is echt zo eenvoudig:

1. Installeer de
2. Open een Amazon-zoekresultatenpagina of productpagina
3. Klik op "AI Suggest Fields" (of gebruik direct de Amazon-scraper template)
4. Klik op "Scrape"

Thunderbit’s AI leest de pagina, herkent de datastructuur en zet alles om in een nette tabel. Je kunt gratis exporteren naar Excel, Google Sheets, Airtable of Notion. De echte winst: wanneer Amazon volgende week zijn HTML weer verandert (en dat zal gebeuren), past Thunderbit’s AI zich automatisch aan. Geen kapotte scripts, geen selector-updates.

Voor het verrijken van productlijsten met data van detailpagina’s volgt Thunderbit’s Subpage Scraping-functie automatisch links naar productpagina’s en haalt extra velden op zoals afbeeldingen, beschrijvingen en varianten — iets waarvoor je in Python aanzienlijk meer code nodig hebt.

Tips om je Python Amazon-scraper op lange termijn werkend te houden

Als je voor Python gaat, zo beperk je onderhoudsproblemen:

• Controleer selectors regelmatig. Amazon wijzigt ze vaak. Bookmark dit artikel — ik werk de selector-tabel bij wanneer dingen veranderen.
• Monitor je succesratio. Houd de verhouding tussen 200-responses en 503’s/CAPTCHAs bij. Stel een alert in (zelfs een simpele e-mail) zodra je succesratio onder de 80% zakt.
• Sla ruwe HTML op. Bewaar de volledige HTML-respons naast je geparse data. Als selectors veranderen, kun je historische data opnieuw parsen zonder opnieuw te scrapen.
• Roteer proxies en User-Agents vaak. Statische fingerprints worden op schaal binnen enkele uren gemarkeerd.
• Gebruik exponential backoff. Probeer nooit meteen opnieuw na een blokkade.
• Containerize met Docker. Verpak je scraper in een Docker-container voor eenvoudige deployment en portabiliteit.
• Voeg datavalidatie toe. Controleer of prijzen numeriek zijn, beoordelingen tussen 1 en 5 liggen en titels niet leeg zijn. Eén team meldde een na het toevoegen van validatielagen.

Of, als dat allemaal klinkt als meer werk dan je op je genomen hebt, overweeg dan of een no-code tool zoals Thunderbit beter past bij jouw use case. Er is niets mis met de snellere route kiezen — ik heb genoeg jaren scrapers gedebugd om te weten dat de beste code soms de code is die je helemaal niet hoeft te schrijven.

Juridische en ethische overwegingen bij het scrapen van Amazon

Omdat dit in elk gesprek over Amazon scraping terugkomt, hier een korte noot over de juridische situatie:

• Scraping van publiek beschikbare data is in de VS doorgaans legaal. De baanbrekende uitspraak (2022) stelde dat toegang tot publieke data de CFAA niet schendt. Meer recent hebben (2024) en (2024) dit principe bevestigd.
• Amazon’s ToS verbieden geautomatiseerde toegang. Dit is een civiele kwestie (contractbreuk), geen strafrechtelijke. Rechtbanken maken daar doorgaans onderscheid tussen.
• Amazon v. Perplexity (2025) is een lopende zaak rond AI-scraping van Amazon-pagina’s. Er werd in maart 2026 een voorlopige voorziening afgegeven. De moeite waard om te volgen.
• Blijf bij publieke pagina’s. Scrape geen content achter een login, geen persoonlijke data en niets achter authenticatie.
• Respecteer rate limits. Bestook Amazon’s servers niet. Een vertraging van 2–5 seconden tussen verzoeken is redelijk.
• Gebruik data verantwoord. Scrape voor analyse, niet om auteursrechtelijk beschermd materiaal opnieuw te publiceren.
• Raadpleeg juridisch advies bij grootschalig commercieel gebruik, zeker als je in de EU zit (GDPR is van toepassing op persoonsgegevens).

Voor een diepere duik, bekijk onze gids over .

Afronding

Je hebt nu een werkende Python Amazon-scraper met gecontroleerde 2025-selectors, een gelaagde anti-blockingstrategie die veel verder gaat dan alleen "voeg een User-Agent toe", praktische planningsopties voor continue monitoring, en exportmethoden waarmee je data in Google Sheets, databases of elk ander teamtool belandt.

Korte samenvatting:

• Python + curl_cffi + BeautifulSoup geeft je volledige controle en ongeveer 94% succes wanneer je TLS-imitatie gebruikt
• Anti-blocking vraagt om meerdere lagen: header-rotatie, TLS-imitatie, proxy-rotatie, rate limiting en exponential backoff
• Scheduling verandert een eenmalig script in een doorlopende monitoringpipeline (cron, GitHub Actions of Thunderbit’s ingebouwde scheduler)
• Export verder dan CSV — Google Sheets, SQLite, Airtable, Notion — is waar de echte businesswaarde zit
• Thunderbit biedt een 2-klikken-alternatief voor niet-developers of iedereen die liever data analyseert dan selectors debugt

Als je de code wilt uitproberen, is alles in deze gids klaar om te kopiëren en uit te voeren. En als je liever helemaal geen code schrijft, kun je met de no-code aanpak meteen op Amazon testen.

Voor meer, bekijk ook onze gidsen over , en . Je kunt ook stap-voor-stap walkthroughs bekijken op het .

Veel succes met scrapen — en moge je selectors het redden tot de volgende Amazon-update.

FAQ’s

1. Waarom wordt mijn Python Amazon-scraper na een paar verzoeken geblokkeerd?

Amazon gebruikt een zeslagen verdedigingssysteem: IP-reputatie-analyse, TLS-fingerprinting (JA3/JA4), detectie van de browseromgeving, gedragsbiometrie, CAPTCHA-uitdagingen en ML-gestuurde anomaliedetectie. Een basis-script met requests en alleen een User-Agent-header haalt slechts ongeveer succes. Je hebt TLS-imitatie (curl_cffi), volledige header-rotatie, proxy-rotatie en rate limiting met random jitter nodig voor betrouwbare toegang.

2. Welke Python libraries zijn in 2025 het beste voor Amazon-producten scrapen?

curl_cffi voor HTTP-verzoeken met TLS-imitatie (de grootste afzonderlijke verbetering), BeautifulSoup4 met lxml voor HTML-parsing, pandas voor dataverwerking en export, en Selenium of Playwright als fallback voor content die via JavaScript wordt gerenderd. Python wordt gebruikt door van de scraping-developers.

3. Is het legaal om Amazon-productdata te scrapen?

Het scrapen van publiek beschikbare data is in de VS doorgaans legaal, ondersteund door uitspraken zoals hiQ v. LinkedIn en Meta v. Bright Data. Amazon’s gebruiksvoorwaarden verbieden geautomatiseerde toegang, maar rechtbanken maken onderscheid tussen ToS-schendingen (civiel) en strafbare feiten. Vermijd altijd content achter een login, respecteer rate limits en vraag juridisch advies bij grootschalig commercieel gebruik.

4. Kan ik Amazon scrapen zonder code te schrijven?

Ja. Tools zoals laten je Amazon-producten in 2 klikken scrapen met een Chrome-extensie. De AI-gestuurde veldherkenning structureert de data automatisch, en je kunt gratis exporteren naar Excel, Google Sheets, Airtable of Notion. Als Amazon zijn HTML wijzigt, past Thunderbit’s AI zich aan zonder handmatige updates.

5. Hoe vaak verandert Amazon zijn HTML-selectors, en hoe houd ik mijn scraper up-to-date?

Vaak en zonder waarschuwing. De scraping-community meldt dat van de crawlers wekelijks fixes nodig heeft door DOM-wijzigingen. Blijf voorop door je succesratio te monitoren, ruwe HTML op te slaan voor herparsing en selectors regelmatig te testen op live pagina’s. AI-tools zoals Thunderbit passen zich automatisch aan en nemen die onderhoudslast weg.

Meer leren