Hoe je Walmart scrapt met Python (zonder geblokkeerd te worden)

Walmart past op sommige producten de prijzen aan. Als je ooit hebt geprobeerd dat programmatically bij te houden, ken je de frustratie: je script draait 20 minuten goed en begint daarna stilletjes CAPTCHA-pagina’s terug te geven die zich voordoen als normale 200 OK-antwoorden.

Ik heb veel tijd gestoken in het uitpluizen van Walmart’s anti-botmaatregelen in ons dataverzamelingswerk bij , en ik wil alles delen wat ik heb geleerd — de methoden die in 2025 écht werken, de stille mislukkingen die je data besmetten, en de eerlijke afweging tussen zelf een scraper bouwen, betalen voor een scraping-API of gewoon een no-code tool gebruiken. Deze gids behandelt drie extractiemethoden (HTML-parsing, __NEXT_DATA__ JSON en interceptie van interne API’s), foutafhandeling die klaar is voor productie en die in de meeste tutorials volledig ontbreekt, en een nuchter afwegingskader om de juiste aanpak te kiezen. Er zit hier iets tussen, of je nu in Python codeert of gewoon tegen lunchtijd een spreadsheet vol prijzen wilt hebben.

Waarom Walmart scrapen met Python?

Walmart is de grootste retailer ter wereld op basis van omzet — in FY2025, en staat . De site host ongeveer , terwijl Walmart’s CFO spreekt over op de marketplace. Ongeveer , wat betekent dat de catalogus voortdurend beweegt — verkopers komen en gaan, varianten wijzigen en voorraad verschuift dagelijks.

Juist die dynamiek maakt scrapen waardevol. Een kwartaalrapport laat niet zien wat een nachtelijke scrape wel kan vastleggen. Dit zijn de meest voorkomende toepassingen die ik tegenkom:

Alleen al de markt voor software voor prijsmonitoring van concurrenten bereikte en zal naar verwachting groeien tot $5,09 miljard in 2033. Consumentengedrag drijft die uitgaven: , en 83% vergelijkt op meerdere sites.

Python is de standaardtaal voor dit werk. Apify’s Infrastructure Report 2026 schat dat , en de kernbibliotheek (requests) wordt . Als je op enige schaal scrapt, doe je dat vrijwel zeker in Python.

Waarom Walmart een van de moeilijkste sites is om te scrapen

Walmart is specifiek lastig omdat het twee commerciële anti-botproducten achter elkaar inzet: als edge WAF- en TLS-fingerprintinglaag, en als de gedragsmatige JavaScript-challenge-laag. Scrape.do noemt deze combinatie “zeldzaam en extreem moeilijk om te omzeilen”.

, waarbij Akamai alleen al op 9/10 zit. In mijn ervaring klopt dat aardig.

Hier krijg je daadwerkelijk mee te maken:

Akamai Bot Manager inspecteert je TLS-fingerprint (JA3/JA4-hash), HTTP/2-framevolgorde, header-volgorde en hoofdlettergebruik, en sessiecookies (_abck, ak_bmsc). Een standaard Python-requests call stuurt een TLS-fingerprint die geen echte browser ooit produceert — Akamai markeert die al voordat je verzoek de servers van Walmart bereikt.

PerimeterX/HUMAN draait ná Akamai en voert JavaScript-fingerprinting uit (px.js) waarmee eigenschappen van navigator, canvas-rendering, WebGL, audio context en gedragsbiometrie (muisbewegingen, scrolsnelheid, toetsenborddynamiek) worden gecontroleerd. De zichtbare fout is de beruchte — een knop die je ongeveer 10 seconden ingedrukt moet houden terwijl gedragssignalen worden bemonsterd. Oxylabs is daar duidelijk over: “Walmart gebruikt het 'Press & Hold'-model van CAPTCHA, aangeboden door PerimeterX, en dat is volgens de kennis zeer moeilijk op code-niveau op te lossen.”

Het echt gevaarlijke gedrag is de stille blokkade. Walmart geeft HTTP 200 met een CAPTCHA-body terug in plaats van een 403. : “Walmart geeft een 200 OK-statuscode terug, zelfs wanneer het een CAPTCHA-pagina serveert. Je kunt niet alleen op de statuscode vertrouwen om te weten of je verzoek is geslaagd.” Je script parseert de CAPTCHA-HTML vrolijk als “product niet gevonden” en gaat verder. De helft van je dataset is rommel, en je merkt het niet.

Dan is er nog het store-gebonden dataprobleem. Walmart-prijzen en voorraad zijn locatieafhankelijk en worden gestuurd door cookies zoals locDataV3 en assortmentStoreId. Zonder de juiste cookies krijg je “standaard landelijke” data die compleet lijkt, maar niet overeenkomt met wat echte shoppers zien. Ontbrekende cookies geven geen blokkeerpagina — ze leveren verkeerde data zonder zichtbare fout op, en dat is nog erger.

Drie manieren om data van Walmart te halen (en hoe ze zich tot elkaar verhouden)

Voordat we stap voor stap beginnen: dit zijn de drie belangrijkste extractiebenaderingen. De meeste tutorials van concurrenten behandelen er maar één of twee. Ik loop ze alle drie langs, zodat je kunt kiezen wat bij jouw situatie past.

HTML-parsing is de slechtste optie voor Walmart — de site draait op Next.js-bundles met gehashte CSS-klassen die bij elke deploy veranderen. De __NEXT_DATA__ JSON-methode is de pragmatische keuze die door elke serieuze open-source Walmart scraper uit 2024–2026 wordt gebruikt. Interceptie van interne API’s is het krachtigst, maar heeft kanttekeningen die de meeste tutorials wegmoffelen. En Thunderbit is de juiste keuze als je helemaal geen custom pipeline nodig hebt.

Je Python-omgeving instellen om Walmart te scrapen

Dit heb je nodig:

• Moeilijkheidsgraad: Gemiddeld
• Benodigde tijd: ~30 minuten voor de setup, plus tijd om te coderen
• Wat je nodig hebt: Python 3.10+, pip, een code-editor en (voor productiegebruik) een proxyservice of scraping-API

Maak je projectmap en virtuele omgeving aan:

1mkdir walmart-scraper && cd walmart-scraper
2python -m venv venv
3source venv/bin/activate  # On Windows: venv\Scripts\activate

Installeer de vereiste bibliotheken:

1pip install curl_cffi parsel beautifulsoup4 lxml

curl_cffi is in 2025 de standaard voor het scrapen van moeilijke doelwitten. Het is een libcurl-binding die exacte browser-TLS-fingerprints kan imiteren. : “Walmart gebruikt TLS-fingerprinting als onderdeel van de botdetectie, en zelfs het instellen van de User-Agent om een echte browser te simuleren zal dat niet omzeilen.” Gewone requests of httpx kunnen Akamai niet passeren, ongeacht welke headers je instelt. curl_cffi met impersonate="chrome124" maakt hier het verschil.

Je wilt ook json (ingebouwd), csv (ingebouwd), time, random en logging gebruiken voor de productiepatronen die we verderop behandelen.

Stap voor stap: Walmart-productpagina’s scrapen met Python

Stap 1: Haal de Walmart-productpagina op

Je eerste taak is een HTTP-verzoek doen dat niet meteen wordt geblokkeerd. Hier is de standaard set headers die in 2024–2026 veel wordt gebruikt door Scrapfly, Scrapingdog, Oxylabs en ScrapeOps:

1from curl_cffi import requests
2HEADERS = {
3    "User-Agent": (
4        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
5        "AppleWebKit/537.36 (KHTML, like Gecko) "
6        "Chrome/124.0.0.0 Safari/537.36"
7    ),
8    "Accept": (
9        "text/html,application/xhtml+xml,application/xml;q=0.9,"
10        "image/avif,image/webp,*/*;q=0.8"
11    ),
12    "Accept-Language": "en-US,en;q=0.9",
13    "Accept-Encoding": "gzip, deflate, br",
14    "Upgrade-Insecure-Requests": "1",
15    "Sec-Fetch-Dest": "document",
16    "Sec-Fetch-Mode": "navigate",
17    "Sec-Fetch-Site": "none",
18    "Sec-Fetch-User": "?1",
19    "Referer": "https://www.google.com/",
20}
21session = requests.Session(impersonate="chrome124")
22url = "https://www.walmart.com/ip/Apple-AirPods-Pro-2nd-Generation/1752657021"
23response = session.get(url, headers=HEADERS)

De parameter impersonate="chrome124" doet hier het zware werk. Die vertelt curl_cffi om exact Chrome 124’s TLS ClientHello, HTTP/2-framevolgorde en pseudo-header-volgorde na te bootsen. Zonder dat ziet Akamai een Python-specifieke JA3-hash en blokkeert het je nog voordat je verzoek de applicatielaag van Walmart bereikt.

Hoe een geblokkeerde respons eruitziet: als je "Robot or human?" ziet in de HTML-titel van de respons, of als de respons doorverwijst naar walmart.com/blocked, ben je gepakt. Het lastige is dat Walmart vaak een 200-statuscode met de CAPTCHA-body terugstuurt — dus alleen response.ok controleren is niet genoeg.

Voor elk productie- of herhaald gebruik heb je residential proxies nodig. Datacenter-IP’s worden direct door Akamai’s IP-reputatiesysteem afgekeurd. Ik bespreek de volledige foutafhandeling en proxystrategie verderop in het productiegedeelte.

Stap 2: Parse productdata uit de __NEXT_DATA__ JSON

Walmart.com is een Next.js-applicatie en de server-side gerenderde HTML embedt de volledige hydration-payload in één script-tag: <script id="__NEXT_DATA__" type="application/json">. Dat is de goudmijn.

: “In 2026 gebruikt Walmart Next.js met gestructureerde JSON in __NEXT_DATA__-script-tags, waardoor het extraheren van verborgen data betrouwbaarder is dan traditionele CSS-selector-parsing.” Elke prominente open-source Walmart scraper — , , — gebruikt deze methode.

Zo haal je het eruit:

1import json
2from parsel import Selector
3sel = Selector(text=response.text)
4raw = sel.xpath('//script[@id="__NEXT_DATA__"]/text()').get()
5data = json.loads(raw)
6product = data["props"]["pageProps"]["initialData"]["data"]["product"]
7idml = data["props"]["pageProps"]["initialData"]["data"].get("idml", {})

De meeste tutorials stoppen hier. Hieronder staat een volledige JSON-padkaart voor de velden die je echt nodig hebt — geverifieerd op live Walmart-pagina’s in 2024–2026:

Het pad longDescription is de valkuil waar mensen vaak intrappen. Een ScrapeHero-post uit 2023 plaatste het op product.longDescription, maar bronnen uit 2024+ zetten het consequent op de sibling-key idml. Lees altijd eerst idml.longDescription en val terug op product.longDescription voor oudere pagina’s.

Hier is het veilige extractiepatroon met .get()-ketens:

1def extract_product(data):
2    product = data["props"]["pageProps"]["initialData"]["data"]["product"]
3    idml = data["props"]["pageProps"]["initialData"]["data"].get("idml", {})
4    price_info = product.get("priceInfo", {})
5    current_price = price_info.get("currentPrice", {})
6    image_info = product.get("imageInfo", {})
7    return {
8        "name": product.get("name"),
9        "brand": product.get("brand"),
10        "price": current_price.get("price"),
11        "price_string": current_price.get("priceString"),
12        "short_desc": product.get("shortDescription"),
13        "long_desc": idml.get("longDescription", product.get("longDescription")),
14        "images": [img.get("url") for img in image_info.get("allImages", [])],
15        "rating": product.get("averageRating"),
16        "review_count": product.get("numberOfReviews"),
17        "variants": product.get("variantCriteria"),
18        "availability": product.get("availabilityStatus"),
19        "seller": product.get("sellerDisplayName"),
20        "manufacturer": product.get("manufacturerName"),
21    }

Voor gebruikers die helemaal geen gedoe willen met JSON-padnavigatie, herkent en structureert de deze velden automatisch — zonder handmatig pad-mappen. Je klikt op "AI Suggest Fields", de pagina wordt gelezen en je krijgt een tabel. Maar als je een custom pipeline bouwt, is bovenstaande kaart je referentie.

Stap 3: Intercepteer de interne API-endpoints van Walmart voor rijkere data

Geen enkel concurrerend artikel behandelt deze methode goed. Het is de krachtigste extractieroute — en de meest complexe.

De frontend van Walmart roept een . De endpoints bevinden zich onder www.walmart.com/orchestra/*:

• /orchestra/pdp/graphql/... — productdetail-hydratatie + variantwissels
• /orchestra/snb/graphql/... — search-n-browse paginering
• /orchestra/reviews/graphql/... — gepagineerde reviews

Deze geven schone, gestructureerde JSON terug met data die __NEXT_DATA__ soms afkapt — variantniveau-prijzen, realtime voorraadcounts en volledige reviewpaginering.

De adder onder het gras waar blogposts omheen draaien: Walmart gebruikt . De request body verstuurt alleen een SHA-256-hash (persistedQuery.sha256Hash), niet de querytekst. Als die hash niet bekend is bij de server, krijg je PersistedQueryNotFound. Walmart roteert deze hashes bij deploys. Daarom publiceren geen van de bekende open-source Walmart scrapers kant-en-klare /orchestra/-code die je zomaar kunt kopiëren en plakken.

De praktische, eerlijke versie van deze methode is een DevTools-oefening:

1. Open een Walmart-productpagina in Chrome
2. Open DevTools → Network-tab, filter op "Fetch/XHR"
3. Gebruik de pagina normaal — klik op varianten, scroll naar reviews, wijzig storelocatie
4. Zoek requests naar /orchestra/*-endpoints die JSON met productdata teruggeven
5. Klik met rechts op de request → "Copy as cURL"
6. Zet het cURL-commando om naar Python met curl_cffi

Zo ziet een opnieuw afgespeelde API-call eruit:

1import json
2from curl_cffi import requests
3session = requests.Session(impersonate="chrome124")
4# Eerst de sessie opwarmen door de productpagina te bezoeken
5session.get("https://www.walmart.com/ip/some-product/1234567", headers=HEADERS)
6# Daarna de interne API-call opnieuw afspelen (gekopieerd uit DevTools)
7api_url = "https://www.walmart.com/orchestra/pdp/graphql"
8api_headers = {
9    **HEADERS,
10    "accept": "application/json",
11    "content-type": "application/json",
12    "referer": "https://www.walmart.com/ip/some-product/1234567",
13    "wm_qos.correlation_id": "your-copied-correlation-id",
14}
15payload = {
16    # Plak hier exact de request body uit DevTools
17    "variables": {"productId": "1234567"},
18    "extensions": {
19        "persistedQuery": {
20            "version": 1,
21            "sha256Hash": "the-hash-you-copied"
22        }
23    }
24}
25api_response = session.post(api_url, headers=api_headers, json=payload)
26api_data = api_response.json()

De stap waarin je de sessie opwarmt is cruciaal. Walmart’s PerimeterX-cookies (_px3, _pxhd, ACID) moeten eerst door de initiële HTML-fetch worden gezet voordat de API-call kan slagen. Zonder die cookies krijg je een 412 of 403.

Wanneer deze methode gebruiken: wanneer je data nodig hebt die __NEXT_DATA__ niet bevat — diepe variantprijzen, gepagineerde reviews voorbij de eerste batch, of realtime voorraadniveaus. Voor de meeste use-cases is __NEXT_DATA__ voldoende en veel eenvoudiger.

Walmart zoekresultaten en meerdere pagina’s scrapen

Zoekresultaten volgen een vergelijkbaar __NEXT_DATA__-patroon, maar met een ander JSON-pad:

1search_url = "https://www.walmart.com/search?q=laptops&page=1"
2response = session.get(search_url, headers=HEADERS)
3sel = Selector(text=response.text)
4raw = sel.xpath('//script[@id="__NEXT_DATA__"]/text()').get()
5data = json.loads(raw)
6search_result = data["props"]["pageProps"]["initialData"]["searchResult"]
7items = search_result["itemStacks"][0]["items"]
8# Gesponsorde producten eruit filteren
9organic_items = [i for i in items if i.get("__typename") == "Product"]
10for item in organic_items:
11    print(item.get("name"), item.get("priceInfo", {}).get("currentPrice", {}).get("price"))

Paginering werkt door de page-parameter op te hogen: &page=1, &page=2, enzovoort. Maar hier is de niet-gedocumenteerde limiet: Walmart beperkt zoekresultaten tot 25 pagina’s, ongeacht het werkelijke totaal. : “Walmart stelt het maximale aantal toegankelijke resultaatpagina’s in op 25, ongeacht hoeveel pagina’s er beschikbaar zijn.”

Workarounds om dieper te gaan:

• Sortering omwisselen: voer dezelfde zoekopdracht uit met &sort=price_low en daarna met &sort=price_high om ongeveer 50 pagina’s dekking te krijgen
• Prijsbereik opsplitsen: voeg &min_price=X&max_price=Y toe om de catalogus in kleinere vensters te verdelen
• Categorieën opsplitsen: zoek binnen specifieke categorieën in plaats van sitebreed

Let op dat itemStacks een array is. Scrapfly hardcodeert [0] in hun repo, maar categorie- en browsepagina’s bevatten soms meerdere stacks (“Top picks”, “More results”). Het robuuste patroon loopt door alle stacks:

1for stack in search_result.get("itemStacks", []):
2    for item in stack.get("items", []):
3        if item.get("__typename") == "Product":
4            # verwerk item
5            pass

Ook goed om te weten: Walmart’s robots.txt . Productdetailpagina’s (/ip/...) en de meeste categoriepagina’s (/cp/...) zijn niet verboden. Als je je zorgen maakt over compliance, begin dan met productpagina’s en categorietakken in plaats van zoekresultaten.

Laat stille blokkades je data niet ruïneren: foutafhandeling klaar voor productie

De meeste tutorials vallen hier uit elkaar. Ze laten zien hoe je één pagina ophaalt, één product parseert en het daarbij laat. In productie haal je duizenden pagina’s op, en Walmart probeert je actief tegen te houden. Het verschil tussen een demo-scraper en een scraper die echt werkt, zit in hoe die met fouten omgaat.

Detecteer stille blokkades voordat ze je data vervuilen

De allerbelangrijkste functie in een Walmart-scraper is de block-detectie. Op basis van consensus tussen leveranciers zoals , , en heb je vier onafhankelijke checks nodig:

1BLOCK_MARKERS = (
2    "Robot or human",
3    "Press & Hold",
4    "Press & Hold",
5    "px-captcha",
6    "perimeterx",
7)
8def is_walmart_blocked(response) -> bool:
9    # 1. Redirect naar het speciale blokkeer-endpoint
10    if "/blocked" in str(response.url):
11        return True
12    # 2. Harde statuscodes
13    if response.status_code in (403, 412, 428, 429, 503):
14        return True
15    # 3. 200 OK met CAPTCHA-body (het geval van stille blokkade)
16    body = response.text or ""
17    if any(m.lower() in body.lower() for m in BLOCK_MARKERS):
18        return True
19    # 4. Sanity check op responsgrootte — echte PDP’s zijn 300-900 KB
20    if len(response.content) < 50_000 and "/ip/" in str(response.url):
21        return True
22    return False

Die vierde check — de responsgrootte — vangt gevallen op waarin Walmart een uitgeklede pagina terugstuurt die geen duidelijke CAPTCHA-markers bevat, maar ook niet de productdata die je nodig hebt.

Retry-logica met exponentiële backoff en jitter

Als een request faalt, wil je Walmart niet meteen opnieuw bestoken. Het standaardpatroon gebruikt exponentiële backoff met jitter om retries uit elkaar te trekken:

1import time
2import random
3import logging
4from curl_cffi import requests as cffi_requests
5log = logging.getLogger("walmart")
6def fetch_with_retry(session, url, max_retries=5, base_delay=2, max_delay=60):
7    for attempt in range(max_retries):
8        try:
9            response = session.get(url, headers=HEADERS, timeout=15)
10            if response.status_code in (429, 503):
11                raise Exception(f"Throttled: {response.status_code}")
12            if is_walmart_blocked(response):
13                raise Exception("Stille blokkade gedetecteerd")
14            return response
15        except Exception as e:
16            if attempt == max_retries - 1:
17                raise
18            wait = min(max_delay, base_delay * (2 ** attempt)) + random.uniform(0, 3)
19            log.warning(f"Poging {attempt + 1} mislukt: {e}. Opnieuw proberen over {wait:.1f}s")
20            time.sleep(wait)
21    return None

De jitter (random.uniform(0, 3)) is niet cosmetisch — die zorgt ervoor dat workers niet tegelijk opnieuw gaan proberen, wat Akamai’s velocity-detectors kan triggeren.

Rate limiting

Zowel als komen voor Walmart uit op een willekeurige vertraging van 3–6 seconden per request: “beperk je requests door 3–6 seconden tussen pagina’s te wachten en je vertragingen te randomiseren.”

1import time
2import random
3def rate_limited_fetch(session, url):
4    response = fetch_with_retry(session, url)
5    time.sleep(random.uniform(3.0, 6.0))
6    return response

Op schaal kun je aiolimiter gebruiken voor async rate limiting:

1from aiolimiter import AsyncLimiter
2limiter = AsyncLimiter(max_rate=10, time_period=60)  # 10 requests per minuut

Datavalidatie

Zelfs als de respons niet geblokkeerd is, kan de geparseerde data fout zijn (verkeerde winkel, uitgeklede payload). Valideer voordat je naar output schrijft:

1def validate_product(product):
2    """Geeft True terug als de productdata er legitiem uitziet."""
3    if not product.get("name"):
4        return False
5    price = (product.get("priceInfo") or {}).get("currentPrice", {}).get("price")
6    if not isinstance(price, (int, float)) or price <= 0:
7        return False
8    if product.get("availabilityStatus") not in ("IN_STOCK", "OUT_OF_STOCK", "LIMITED_STOCK"):
9        return False
10    return True

Sessie-logging

Houd je succesratio per sessie bij. Wanneer die 10 minuten onder 80% zakt, is er iets veranderd — je IP is verbrand, je cookies zijn verlopen of Walmart heeft een nieuwe anti-botregel uitgerold.

1class ScrapeMetrics:
2    def __init__(self):
3        self.total = 0
4        self.success = 0
5        self.blocks = 0
6        self.errors = 0
7    def record(self, result):
8        self.total += 1
9        if result == "success":
10            self.success += 1
11        elif result == "blocked":
12            self.blocks += 1
13        else:
14            self.errors += 1
15    @property
16    def success_rate(self):
17        return (self.success / self.total * 100) if self.total > 0 else 0
18    def check_health(self):
19        if self.total > 20 and self.success_rate < 80:
20            log.critical(f"Succesratio daalde naar {self.success_rate:.1f}% — overweeg proxies te roteren of te pauzeren")

Niet glamoureus. Maar wel wat je data schoon houdt.

DIY Python vs. scraping-API vs. no-code: de juiste aanpak kiezen om Walmart te scrapen

Veel ontwikkelaars springen meteen in het bouwen van een custom scraper zonder zich af te vragen of dat wel de juiste keuze is. . Forumgebruikers noemen het “in principe 9/10” en vragen zich af “of een dedicated web scraping API niet overkill is.” Het antwoord hangt af van volume, budget en technische capaciteit.

Wanneer DIY Python logisch is

DIY wint als je al een proxycontract hebt, strakke controle nodig hebt over headers, postcode-targeting of verkoperssegmenten, miljoenen pagina’s per maand indexeert waardoor API-kosten per record oplopen, of on-prem/compliance-garanties nodig hebt. De trade-off is echte engineeringtijd: een productieklare Scrapy-spider met paginering, retries, proxyrotatie, TLS-impersonatie en meerdere schema’s per paginatype kost , plus 4–8 uur onderhoud per maand wanneer Walmart fingerprints roteert.

Wanneer een scraping-API je tijd bespaart

Scraping-API’s nemen de anti-botlaag voor je uit handen. laten succesratio’s zien van en 98% voor Scrape.do op Walmart. Instapprijzen liggen rond de $40–$49 per maand voor tools zoals , en . Als je een team van 2–5 engineers hebt en je scrapingvolume 10K–1M pagina’s per maand is, is een API bijna altijd de juiste keuze. Je ruilt kosten per request in voor vrijwel geen onderhoud.

Wanneer no-code de juiste keuze is

past bij een heel ander profiel. Als je een PM, analist of e-commerce operator bent en je hebt vanmiddag nog Walmart-productdata in een spreadsheet nodig — niet pas volgende sprint — dan is een no-code tool het eerlijke antwoord.

De workflow: installeer de , ga naar een Walmart-product- of zoekpagina, klik op "AI Suggest Fields", en Thunderbit’s AI leest de pagina en stelt kolommen voor (productnaam, prijs, beoordeling, enz.). Klik op "Scrape" en de data verschijnt in een tabel. Exporteer naar Excel, Google Sheets, Airtable of Notion — allemaal gratis, zonder paywall.

Thunderbit handelt anti-bot in de cloud af, dus je hebt geen last van CAPTCHAs, proxies of TLS-fingerprinting. De AI past zich automatisch aan lay-outwijzigingen aan, dus onderhoud is niet nodig. Voor gebruikers die helemaal geen gedoe willen met JSON-padnavigatie, is dit de minst weerbarstige route.

Eerlijke beperkingen: Thunderbit is niet gebouwd voor 100K+ pagina’s per dag. Kredietbudgetten en cloudlimieten maken ingest op hoge schaal economisch minder aantrekkelijk dan ruwe API’s. Ook kun je niet per se een specifieke postcode of ASN vastzetten, tenzij de tool dat ondersteunt. Voor doorlopende, grootschalige pipelines zijn DIY of een scraping-API nog steeds de betere keuze.

Ruwe prijsinschatting: 1.000 Walmart-productrijen in Thunderbit kosten ongeveer 2.000 credits (~$0,60–$1,10 op Starter/Pro-plannen). Dat is vergelijkbaar met Oxylabs’ Walmart API en goedkoper dan de meeste hobby-tier scraping-API’s bij laag volume. voor actuele details.

Je gescrapete Walmart-data exporteren

Zodra je de data hebt, moet die ergens bruikbaar terechtkomen. Drie formaten dekken de meeste behoeften:

CSV — het eenvoudigste formaat dat analisten ook echt openen:

1import csv
2def export_csv(products, filename="walmart_products.csv"):
3    fieldnames = ["name", "price", "availability", "rating", "review_count", "seller", "url"]
4    with open(filename, "w", newline="", encoding="utf-8-sig") as f:
5        writer = csv.DictWriter(f, fieldnames=fieldnames, quoting=csv.QUOTE_MINIMAL)
6        writer.writeheader()
7        for p in products:
8            writer.writerow({k: p.get(k) for k in fieldnames})

Gebruik utf-8-sig voor compatibiliteit met Excel. De BOM-marker voorkomt dat Excel speciale tekens verpest.

JSONL — het productieformaat voor scraping-pipelines:

1import json
2import gzip
3def export_jsonl(products, filename="walmart_products.jsonl.gz"):
4    with gzip.open(filename, "at", encoding="utf-8") as f:
5        for p in products:
6            f.write(json.dumps(p, ensure_ascii=False) + "\n")

(bij een onderbroken write verlies je alleen de laatste regel), is streambaar met constant geheugen en houdt geneste data zoals varianten en reviews intact.

Excel — voor eenmalige overdracht aan een analist:

1from openpyxl import Workbook
2def export_excel(products, filename="walmart_products.xlsx"):
3    wb = Workbook(write_only=True)
4    ws = wb.create_sheet("Products")
5    ws.append(["Naam", "Prijs", "Beschikbaarheid", "Beoordeling", "Reviews", "Verkoper"])
6    for p in products:
7        ws.append([p.get("name"), p.get("price"), p.get("availability"),
8                    p.get("rating"), p.get("review_count"), p.get("seller")])
9    wb.save(filename)

Thunderbit dekt het exportverhaal voor niet-Python-gebruikers: met één klik exporteren naar Google Sheets, Airtable, Notion, Excel, CSV en JSON — allemaal gratis in de basislaag. Voor doorlopende monitoring kan Thunderbit’s scheduled scraper automatisch terugkerende extracties uitvoeren.

Eén kanttekening bij scheduling: gebruik . GitHub Actions-runners zitten op Azure-IP-reeksen die Walmart’s anti-bot direct blokkeert. Gebruik APScheduler op een VPS, of routeer al het verkeer via residential proxies.

Juridische en ethische richtlijnen voor het scrapen van Walmart

Forumgebruikers uiten dit bezwaar expliciet: “Ik speel best kat-en-muis met ontwikkelaars, maar ben huiverig om met hun juridische afdeling te spelen.”

Walmart’s Gebruiksvoorwaarden het gebruik van “any robot, spider… or other manual or automatic device to retrieve, index, 'scrape,' 'data mine' or otherwise gather any Materials” zonder “express prior written consent.”

Walmart’s robots.txt /search, /account, /api/ en tientallen interne endpoints. Productdetailpagina’s (/ip/...) en reviews (/reviews/product/) zijn niet verboden.

Het hiQ v. LinkedIn-precedent (9th Circuit, ) stelde vast dat het scrapen van publiek beschikbare data waarschijnlijk niet in strijd is met de federale CFAA. Maar hetzelfde hof oordeelde later dat en legde daar een op. Meer recente beslissingen uit 2024 (, ) hebben CFAA verder ingeperkt en copyright-preemption-verweren gecreëerd, maar die uitspraken draaiden om specifieke ToU-taal die niet één-op-één op Walmart van toepassing is.

Praktische richtlijnen: Overbelast servers niet. Respecteer rate limits. Scrape geen persoonlijke of gebruikersdata. Gebruik data verantwoord. Publieke Walmart-productpagina’s op bescheiden snelheid scrapen voor eigen onderzoek is juridisch gezien een heel ander risicoprofiel dan op commerciële schaal scrapen tegen Walmart’s voorwaarden in. Als je een product bouwt op basis van Walmart-data, praat dan met een jurist en bekijk Walmart’s officiële .

Disclaimer: Dit is educatieve informatie, geen juridisch advies.

Conclusie en belangrijkste inzichten

Walmart scrapen met Python is een uitdaging van dankzij de dubbele anti-botstack van Akamai + PerimeterX. Niet onmogelijk — maar je hebt de juiste tools en patronen nodig.

Belangrijkste inzichten:

• __NEXT_DATA__ JSON-extractie is de pragmatische keuze voor de meeste use-cases. Dat is wat elke serieuze open-source Walmart scraper uit 2024–2026 gebruikt. Het basispad is props.pageProps.initialData.data.product voor PDP’s en searchResult.itemStacks voor search/browse.
• curl_cffi met impersonate="chrome124" is verplicht. Gewone requests of httpx kunnen Akamai’s TLS-fingerprinting niet passeren, ongeacht de headers.
• Stille blokkades zijn het echte gevaar. Walmart geeft 200 OK terug met CAPTCHA-bodies. Controleer de responsinhoud, niet alleen de statuscode.
• Productiescrapers hebben meer nodig dan happy-path code. Exponentiële backoff met jitter, block-detectie op vier signalen, rate limiting van 3–6 seconden per request, datavalidatie en sessiegezondheidsmonitoring zijn allemaal essentieel.
• Interne API-interceptie via /orchestra/* is krachtig maar fragiel. Gebruik het als DevTools-oefening voor specifieke databehoeften, niet als primaire extractiemethode.
• Walmart limiteert zoekresultaten tot 25 pagina’s. Ga breder met sorteer-omwisselingen en prijsbereik-splitsing.
• Kies je aanpak eerlijk: DIY Python voor developers met maatwerkbehoeften en hoge volumes. Scraping-API’s voor teams op middelgrote schaal zonder scraping engineer. voor zakelijke gebruikers die vanmiddag data in Google Sheets willen.

Als je de no-code route wilt proberen, heeft de een gratis laag — je kunt een handvol Walmart-pagina’s scrapen en zelf de resultaten bekijken. Als je voor de Python-route gaat, zijn de codepatronen in dit artikel beproefd in productie. Hoe dan ook: je hebt nu een kaart van Walmart’s verdedigingslinie en drie routes erdoorheen.

Voor meer over webscrapingtechnieken kun je onze gidsen bekijken over , , en . Je kunt ook tutorials bekijken op het .

FAQ’s

Is het legaal om Walmart-productdata te scrapen?

Walmart’s Gebruiksvoorwaarden verbieden geautomatiseerd scrapen zonder schriftelijke toestemming. Het 9th Circuit-arrest hiQ v. LinkedIn (2022) stelde vast dat de federale CFAA waarschijnlijk niet van toepassing is op het scrapen van publieke pagina’s, maar dezelfde zaak eindigde wel met een tegen de scraper. Publieke productpagina’s op bescheiden tempo scrapen voor eigen onderzoek brengt een heel ander risicoprofiel met zich mee dan commerciële extractie op schaal. Raadpleeg een jurist als je een bedrijf bouwt op basis van Walmart-data.

Waarom wordt mijn Walmart scraper steeds geblokkeerd?

De meest voorkomende oorzaken zijn: het gebruik van gewone requests of httpx (die een Python-specifieke TLS-fingerprint uitsturen die Akamai direct herkent), ontbrekende of onjuiste headers, geen proxyrotatie, requests die sneller komen dan 3–6 seconden per pagina, en ontbrekende sessiecookies (_px3, _abck, locDataV3). Schakel over naar curl_cffi met impersonate="chrome124", gebruik residential proxies en implementeer de block-detectie- en retrypatronen uit dit artikel.

Welke data kan ik met Python van Walmart scrapen?

Productnamen, prijzen (actueel en rollback), afbeeldingen, korte en lange beschrijvingen, beoordelingen, aantal reviews, voorraadstatus, verkopersnamen, fabrikantinformatie, variantopties (maat, kleur) en categoriedeling. Met de __NEXT_DATA__-methode zijn al deze gegevens beschikbaar als gestructureerde JSON. Interceptie van interne API’s kan daarnaast variantniveau-prijzen, realtime voorraadcounts en gepagineerde reviewdata opleveren.

Heb ik proxies nodig om Walmart te scrapen?

Ja, voor elk productie- of herhaald gebruik. — zelfs met perfecte headers wordt een niet-residential IP gemarkeerd door Akamai’s IP-reputatiesysteem. Residential of mobiele proxies zijn vereist. Datacenter-IP’s worden vrijwel direct verbrand. Reken grofweg op $3–$17 per 1.000 pagina’s, afhankelijk van je proxyprovider en tier.

Kan ik Walmart scrapen zonder code te schrijven?

Ja. is een AI-gestuurde Chrome-extensie die Walmart in twee klikken scrapt: eerst "AI Suggest Fields" om automatisch productdatavelden te detecteren, daarna "Scrape" om de data op te halen. De tool handelt anti-botchallenges in de cloud af en exporteert direct naar Excel, Google Sheets, Airtable of Notion — allemaal gratis. Het is vooral geschikt voor analisten, PM’s en zakelijke gebruikers die snel data nodig hebben zonder een custom pipeline te bouwen. Voor grootschalige of sterk aangepaste scraping zijn Python of een scraping-API nog steeds beter.

Meer lezen