Walmart endrer prisene på noen varer flere ganger om dagen. Hvis du noen gang har prøvd å følge med programmatisk, kjenner du smerten: skriptet ditt fungerer i 20 minutter, og så begynner det stille å returnere CAPTCHA-sider forkledd som vanlige 200 OK-responser.
Jeg har brukt mye tid på å jobbe meg gjennom Walmarts anti-bot-forsvar som en del av datainnhentingsarbeidet vårt hos Thunderbit, og jeg vil dele alt jeg har lært — metodene som faktisk fungerer i 2025, de stille feilene som forurenser dataene dine, og de ærlige avveiingene mellom å skrive din egen scraper, betale for et scraping API og bare bruke et no-code-verktøy. Denne guiden dekker tre ekstraksjonsmetoder (HTML-parsing, __NEXT_DATA__-JSON og avlytting av interne API-er), produksjonsklar feilhåndtering som de fleste tutorials hopper helt over, og et ærlig rammeverk for å velge riktig tilnærming. Her er noe nyttig enten du skriver Python eller bare vil ha et regneark fullt av priser før lunsj.
Hvorfor skrape Walmart med Python?
Walmart er verdens største forhandler målt i omsetning — 680,985 milliarder dollar i regnskapsåret 2025, og har hatt førsteplassen på Fortune Global 500 i 12 år på rad. Nettstedet har rundt 420 millioner aktive oppføringer, og Walmarts CFO har omtalt "en halv milliard SKU-er" på markedsplassen. Omtrent 95 % av disse oppføringene kommer fra tredjepartsselgere, noe som gjør katalogen svært ustabil — selgere kommer og går, varianter endres, og lagerstatus skifter daglig.
Det er denne ustabiliteten som gjør skraping viktig. En kvartalsrapport kan ikke fange opp det en nattlig skraping kan. Her er de vanligste bruksområdene jeg ser:
| Bruksområde | Hvem trenger det | Hva de henter ut |
|---|---|---|
| Overvåking av konkurrentpriser | E-handelsteam, prisverktøy | Priser, kampanjer, MAP-overholdelse |
| Berikelse av produktkataloger | Salgs- og merchandising-team | Beskrivelser, bilder, spesifikasjoner, varianter |
| Sporing av tilgjengelighet på lager | Forsyningskjede, dropshippere | Lagerstatus, selgerinfo |
| Markedsundersøkelser og trendanalyse | Markedsføring, produktledere | Vurderinger, anmeldelser, sortiment i kategori |
| Leadgenerering | Salgsteam | Selgernavn, antall produkter, kategorier |
Markedet for programvare til overvåking av konkurrentpriser alene nådde 1,92 milliarder dollar i 2025 og forventes å nå 5,09 milliarder dollar innen 2033. Forbrukeratferd driver etterspørselen: 94 % av kundene sammenligner priser når de handler på nett, og 83 % sammenligner på tvers av flere nettsteder.
Python er standardspråket for dette arbeidet. Apifys Infrastructure Report for 2026 anslår Python til 71,7 % av all web scraping, og kjernebiblioteket (requests) lastes ned omtrent 30 millioner ganger i uken. Hvis du skraper i noen som helst skala, gjør du det nesten helt sikkert i Python.
Hvorfor Walmart er et av de vanskeligste nettstedene å skrape
Walmart er spesielt vanskelig fordi de kjører to kommersielle anti-bot-produkter i serie: Akamai Bot Manager som edge WAF- og TLS-fingeravtrykkslag, og PerimeterX (omdøpt til HUMAN Security) som det atferdsbaserte JavaScript-utfordringslaget. Scrape.do kaller denne kombinasjonen «sjeldent og ekstremt vanskelig å omgå».
ScrapeOps gir Walmart 9/10 i samlet skrapingsvanskelighet, med Akamai alene på 9/10. Etter min erfaring stemmer det ganske godt.
Dette er det du faktisk kjemper mot:
Akamai Bot Manager analyserer TLS-fingeravtrykket ditt (JA3/JA4-hash), rekkefølgen på HTTP/2-rammer, header-rekkefølge og bokstavbruk, samt sesjonscookies (_abck, ak_bmsc). Et vanlig Python-kall med requests sender et TLS-fingeravtrykk som ingen ekte nettleser produserer — Akamai flagger det før forespørselen din i det hele tatt når Walmarts servere.
PerimeterX/HUMAN kjører etter Akamai og utfører JavaScript-basert fingeravtrykkinnsamling (px.js) som sjekker navigator-egenskaper, canvas-rendering, WebGL, audio context og atferdsbiometri (musebevegelser, rullehastighet, tastetrykkmønstre). Den synlige feilen er den beryktede "Press & Hold"-utfordringen — en knapp du må holde inne i rundt 10 sekunder mens atferdssignaler samles inn. Oxylabs er krystallklare: «Walmart bruker 'Press & Hold'-modellen for CAPTCHA, levert av PerimeterX, som er kjent for å være nesten umulig å løse fra koden din.»
Den virkelig farlige oppførselen er stille blokkering. Walmart returnerer HTTP 200 med CAPTCHA-innhold i stedet for 403. ScrapingBee bekrefter: «Walmart returnerer en 200 OK-statuskode selv når den serverer en CAPTCHA-side. Du kan ikke stole bare på statuskoden for å vite om forespørselen din lykkes.» Skriptet ditt tolker gladelig CAPTCHA-HTML som «produkt ikke funnet» og går videre. Halvparten av datasettet ditt er søppel, og du vet det ikke.
Så har du butikkspesifikk data. Walmart-priser og lagerbeholdning er stedsspesifikke, styrt av cookies som locDataV3 og assortmentStoreId. Uten riktige cookies får du «standard nasjonal» data som kan se komplett ut, men ikke samsvarer med det ekte kunder ser. Manglende cookies gir ikke en blokkeringsside — de gir feil data uten synlig feil, og det er verre.
Tre metoder for å hente data fra Walmart (og hvordan de sammenlignes)
Før vi går trinn for trinn: her er de tre viktigste ekstraksjonsmetodene. De fleste konkurrentguider dekker bare én eller to. Jeg går gjennom alle tre, så du kan velge den som passer situasjonen din.
| Metode | Pålitelighet | Datakompletthet | Vanskelighetsgrad mot anti-bot | Vedlikeholdsbyrde |
|---|---|---|---|---|
| HTML + BeautifulSoup | ⚠️ Lav (selektorer brytes ved hver deploy) | Moderat | Høy | Høy |
__NEXT_DATA__ JSON | ✅ God | Høy | Middels-høy | Middels |
| Intern API-avlytting | ✅ Best | Høyest (varianter, lager, anmeldelser) | Middels-høy | Lav (strukturert JSON) |
| Thunderbit (no-code) | ✅ God | Høy | Lav (håndtert av AI) | Ingen |
HTML-parsing er det dårligste alternativet for Walmart — nettstedet bruker Next.js-bunter med hashede CSS-klassenavn som endres ved hver deploy. Metoden med __NEXT_DATA__-JSON er det pragmatiske valget som brukes av alle seriøse Walmart-scrapere med åpen kildekode fra 2024–2026. Avlytting av interne API-er er den kraftigste metoden, men den kommer med forbehold som de fleste tutorials glatter over. Og Thunderbit er riktig valg når du ikke trenger en egendefinert pipeline i det hele tatt.
Prøv Thunderbit for Walmart-skraping
Sette opp Python-miljøet ditt for å skrape Walmart
Dette trenger du:
- Vanskelighetsgrad: Middels
- Tid som trengs: Ca. 30 minutter til oppsett, pluss kodetid
- Det du trenger: Python 3.10+, pip, en kodeeditor og (for produksjonsbruk) en proxy-tjeneste eller et scraping API
Opprett prosjektmappen og det virtuelle miljøet:
mkdir walmart-scraper && cd walmart-scraper
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
Installer nødvendige biblioteker:
pip install curl_cffi parsel beautifulsoup4 lxml
curl_cffi er standarden for å skrape vanskelige mål i 2025. Det er en libcurl-binding som kan etterligne eksakte nettleser-TLS-fingeravtrykk. Bright Data forklarer: «Walmart bruker TLS-fingeravtrykk som en del av botdeteksjonen, og selv om du setter User-Agent til å simulere en ekte nettleser, vil det ikke omgå dette.» Vanlig requests eller httpx kan ikke passere Akamai, uansett hvilke headere du setter. curl_cffi med impersonate="chrome124" er det som gjør forskjellen.
Du vil også ha nytte av json (innebygd), csv (innebygd), time, random og logging for produksjonsmønstrene vi kommer til senere.
Trinn for trinn: Skrap Walmarts produktsider med Python
Trinn 1: Hent Walmart-produktsiden
Første oppgave er å gjøre en HTTP-forespørsel som ikke blir blokkert med en gang. Her er det kanoniske header-settet som brukes på tvers av Scrapfly, Scrapingdog, Oxylabs og ScrapeOps i 2024–2026:
from curl_cffi import requests
HEADERS = {
"User-Agent": (
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/124.0.0.0 Safari/537.36"
),
"Accept": (
"text/html,application/xhtml+xml,application/xml;q=0.9,"
"image/avif,image/webp,*/*;q=0.8"
),
"Accept-Language": "en-US,en;q=0.9",
"Accept-Encoding": "gzip, deflate, br",
"Upgrade-Insecure-Requests": "1",
"Sec-Fetch-Dest": "document",
"Sec-Fetch-Mode": "navigate",
"Sec-Fetch-Site": "none",
"Sec-Fetch-User": "?1",
"Referer": "https://www.google.com/",
}
session = requests.Session(impersonate="chrome124")
url = "https://www.walmart.com/ip/Apple-AirPods-Pro-2nd-Generation/1752657021"
response = session.get(url, headers=HEADERS)
Parameteren impersonate="chrome124" gjør den tunge jobben her. Den forteller curl_cffi å matche Chrome 124s eksakte TLS ClientHello, rekkefølgen på HTTP/2-rammer og pseudo-header-sekvens. Uten det ser Akamai en Python-spesifikk JA3-hash og blokkerer deg før forespørselen din i det hele tatt når Walmarts applikasjonslag.
Slik ser et blokkert svar ut: Hvis du ser "Robot or human?" i responsens HTML-tittel, eller hvis responsen omdirigeres til walmart.com/blocked, har du blitt fanget. Det vanskelige er at Walmart ofte returnerer en 200-statuskode med CAPTCHA-innholdet — så det er ikke nok å sjekke response.ok alene.
For all produksjon eller gjentatt bruk trenger du residential proxies. Datacenter-IP-er blir brent umiddelbart av Akamais IP-omdømmesystem. Jeg dekker full feilhåndtering og proxy-strategi i produksjonsdelen nedenfor.
Trinn 2: Parse produktdata fra __NEXT_DATA__-JSON
Walmart.com er en Next.js-applikasjon, og den server-renderede HTML-en legger hele hydrering-lastet inn i én enkelt script-tag: <script id="__NEXT_DATA__" type="application/json">. Dette er gullgruven.
Scrapflys guide fra 2026 bekrefter: «I 2026 bruker Walmart Next.js med strukturert JSON i __NEXT_DATA__-script-tagger, noe som gjør ekstraksjon av skjult data mer pålitelig enn tradisjonell parsing av CSS-selektorer.» Alle åpne Walmart-scrapere med høy profil — Scrapflys, Oxylabs', python-scrapy-playbook sin — bruker denne metoden.
Slik henter du den ut:
import json
from parsel import Selector
sel = Selector(text=response.text)
raw = sel.xpath('//script[@id="__NEXT_DATA__"]/text()').get()
data = json.loads(raw)
product = data["props"]["pageProps"]["initialData"]["data"]["product"]
idml = data["props"]["pageProps"]["initialData"]["data"].get("idml", {})
De fleste tutorials stopper her. Under er et fullstendig kart over JSON-stier for feltene du faktisk bryr deg om — verifisert mot live Walmart-sider i 2024–2026:
| Datafelt | JSON-sti (under initialData) | Type | Merknader |
|---|---|---|---|
| Produktnavn | data > product > name | Streng | — |
| Merke | data > product > brand | Streng | — |
| Nåværende pris (tall) | data > product > priceInfo > currentPrice > price | Flyttall | Kan variere med butikkcookie |
| Nåværende pris (streng) | data > product > priceInfo > currentPrice > priceString | Streng | Formatert, f.eks. "$9.99" |
| Kort beskrivelse | data > product > shortDescription | HTML-streng | Parse med BeautifulSoup for tekst |
| Lang beskrivelse | data > idml > longDescription | HTML-streng | Ligger i idml, IKKE inne i product — dette er fellen eldre tutorials tar feil på |
| Alle bilder | data > product > imageInfo > allImages | Array | Liste over {id, url}-objekter |
| Gjennomsnittlig vurdering | data > product > averageRating | Flyttall | Nøkkelen er averageRating, ikke den eldre rating |
| Antall anmeldelser | data > product > numberOfReviews | Heltall | — |
| Varianter | data > product > variantCriteria | Array | Alternativgrupper (størrelse, farge) |
| Tilgjengelighet | data > product > availabilityStatus | Streng | IN_STOCK, OUT_OF_STOCK, LIMITED_STOCK |
| Selger | data > product > sellerDisplayName | Streng | — |
| Produsent | data > product > manufacturerName | Streng | — |
Stien longDescription er den ene fellen som fanger folk. Et innlegg fra ScrapeHero fra 2023 plasserte den på product.longDescription, men kilder fra 2024 og nyere legger den konsekvent på søskennøkkelen idml. Les alltid idml.longDescription først, og fall tilbake til product.longDescription for eldre sider.
Her er det trygge ekstraksjonsmønsteret med .get()-kjeder:
def extract_product(data):
product = data["props"]["pageProps"]["initialData"]["data"]["product"]
idml = data["props"]["pageProps"]["initialData"]["data"].get("idml", {})
price_info = product.get("priceInfo", {})
current_price = price_info.get("currentPrice", {})
image_info = product.get("imageInfo", {})
return {
"name": product.get("name"),
"brand": product.get("brand"),
"price": current_price.get("price"),
"price_string": current_price.get("priceString"),
"short_desc": product.get("shortDescription"),
"long_desc": idml.get("longDescription", product.get("longDescription")),
"images": [img.get("url") for img in image_info.get("allImages", [])],
"rating": product.get("averageRating"),
"review_count": product.get("numberOfReviews"),
"variants": product.get("variantCriteria"),
"availability": product.get("availabilityStatus"),
"seller": product.get("sellerDisplayName"),
"manufacturer": product.get("manufacturerName"),
}
For brukere som ikke vil forholde seg til JSON-stinavigasjon i det hele tatt, identifiserer og strukturerer Thunderbits AI disse feltene automatisk — ingen manuell kartlegging av stier er nødvendig. Du klikker «AI Suggest Fields», den leser siden, og du får en tabell. Men hvis du bygger en egendefinert pipeline, er kartet over her referansen din.
Trinn 3: Avlytt Walmarts interne API-endepunkter for rikere data
Ingen konkurrentartikkel dekker denne metoden skikkelig. Det er den kraftigste ekstraksjonsveien — og den mest kompliserte.
Walmarts front-end kaller en federert GraphQL-backend bygget på Apollo Gateway. Endepunktene ligger under www.walmart.com/orchestra/*:
/orchestra/pdp/graphql/...— hydrering av produktside + bytte av varianter/orchestra/snb/graphql/...— paginering for søk og browsing/orchestra/reviews/graphql/...— paginerte anmeldelser
Disse returnerer ren, strukturert JSON med data som __NEXT_DATA__ noen ganger trunkerer — prisnivå på variantnivå, sanntidslager, full paginering av anmeldelser.
Haken som blogginnleggene ofte danser rundt: Walmart bruker Apolos persisted queries. Forespørselsbrødteksten sender bare en SHA-256-hash (persistedQuery.sha256Hash), ikke selve query-teksten. Hvis hashen er ukjent for serveren, får du PersistedQueryNotFound. Walmart roterer disse hashene ved deploy. Derfor publiserer ingen av de høyt profilerte Walmart-scraperne med åpen kildekode direkte lim-inn-klar kode for /orchestra/.
Den praktiske og ærlige varianten av denne metoden er en DevTools-øvelse:
- Åpne en Walmart-produktside i Chrome
- Åpne DevTools → Network-fanen, filtrer på "Fetch/XHR"
- Bla normalt på siden — klikk på varianter, scroll til anmeldelser, endre butikkplassering
- Se etter forespørsler til
/orchestra/*-endepunkter som returnerer JSON med produktdata - Høyreklikk forespørselen → "Copy as cURL"
- Konverter cURL-kommandoen til Python med
curl_cffi
Slik ser et gjentatt API-kall ut:
import json
from curl_cffi import requests
session = requests.Session(impersonate="chrome124")
# Først varmer du opp sesjonen ved å besøke produktsiden
session.get("https://www.walmart.com/ip/some-product/1234567", headers=HEADERS)
# Deretter spiller du av det interne API-kallet på nytt (kopiert fra DevTools)
api_url = "https://www.walmart.com/orchestra/pdp/graphql"
api_headers = {
**HEADERS,
"accept": "application/json",
"content-type": "application/json",
"referer": "https://www.walmart.com/ip/some-product/1234567",
"wm_qos.correlation_id": "your-copied-correlation-id",
}
payload = {
# Lim inn den eksakte request bodyen fra DevTools
"variables": {"productId": "1234567"},
"extensions": {
"persistedQuery": {
"version": 1,
"sha256Hash": "the-hash-you-copied"
}
}
}
api_response = session.post(api_url, headers=api_headers, json=payload)
api_data = api_response.json()
Steget med å varme opp sesjonen er kritisk. Walmarts PerimeterX-cookies (_px3, _pxhd, ACID) må settes av den første HTML-hentingen før API-kallet vil lykkes. Uten dem får du en 412 eller 403.
Når du bør bruke denne metoden: Når du trenger data som __NEXT_DATA__ ikke inkluderer — dyp variantprising, paginerte anmeldelser utover første batch, eller sanntidslager. For de fleste bruksområder er __NEXT_DATA__ tilstrekkelig og langt enklere.
Skrape Walmart-søkeresultater og flere sider
Søkeresultater følger et lignende __NEXT_DATA__-mønster, men med en annen JSON-sti:
search_url = "https://www.walmart.com/search?q=laptops&page=1"
response = session.get(search_url, headers=HEADERS)
sel = Selector(text=response.text)
raw = sel.xpath('//script[@id="__NEXT_DATA__"]/text()').get()
data = json.loads(raw)
search_result = data["props"]["pageProps"]["initialData"]["searchResult"]
items = search_result["itemStacks"][0]["items"]
# Filtrer bort sponsede produkter
organic_items = [i for i in items if i.get("__typename") == "Product"]
for item in organic_items:
print(item.get("name"), item.get("priceInfo", {}).get("currentPrice", {}).get("price"))
Paginering fungerer ved å øke page-parameteren: &page=1, &page=2, osv. Men her er den udokumenterte grensen: Walmart begrenser søkeresultater til 25 sider uansett det faktiske totale antallet. Scrapfly bekrefter: «Walmart setter det maksimale antallet resultatsider som kan nås til 25, uavhengig av hvor mange sider som faktisk finnes.»
Arbeidsmetoder for å få bredere dekning:
- Bytte sorteringsrekkefølge: Kjør samme søk med
&sort=price_lowog deretter&sort=price_highfor å få omtrent 50 sider med dekning - Dele opp prisintervaller: Legg til
&min_price=X&max_price=Yfor å bryte katalogen inn i mindre vinduer - Dele opp etter kategori: Søk innenfor spesifikke kategorier i stedet for hele nettstedet
Merk at itemStacks er en array. Scrapfly hardkoder [0] i repoet sitt, men kategori- og browse-sider inneholder noen ganger flere stabler («Top picks», «More results»). Det robuste mønsteret itererer gjennom alle stabler:
for stack in search_result.get("itemStacks", []):
for item in stack.get("items", []):
if item.get("__typename") == "Product":
# behandle elementet
pass
Det er også verdt å merke seg at Walmarts robots.txt ikke tillater /search. Produktsider (/ip/...) og de fleste kategorisider (/cp/...) er ikke forbudt. Hvis du er opptatt av etterlevelse, bør du starte med produktsider og kategoritrær heller enn søk.
Ikke la stille blokkeringer ødelegge dataene dine: produksjonsklar feilhåndtering
De fleste tutorials faller sammen her. De viser deg hvordan du henter én side, parser ett produkt og kaller det en dag. I produksjon henter du tusenvis av sider, og Walmart prøver aktivt å stoppe deg. Forskjellen mellom en demo-scraper og en scraper som faktisk fungerer, er hvordan den håndterer feil.
Oppdag stille blokkeringer før de korrumperer dataene dine
Den aller viktigste funksjonen i en Walmart-scraper er blokkdetektoren. Basert på konsensus fra leverandører som ScrapingBee, Scrapingdog, Oxylabs og Decodo, trenger du fire uavhengige sjekker:
BLOCK_MARKERS = (
"Robot or human",
"Press & Hold",
"Press & Hold",
"px-captcha",
"perimeterx",
)
def is_walmart_blocked(response) -> bool:
# 1. Omdirigering til eget blokkeringsendepunkt
if "/blocked" in str(response.url):
return True
# 2. Harde statuskoder
if response.status_code in (403, 412, 428, 429, 503):
return True
# 3. 200 OK med CAPTCHA-innhold (tilfellet med stille blokkering)
body = response.text or ""
if any(m.lower() in body.lower() for m in BLOCK_MARKERS):
return True
# 4. Sunn fornuft for lengde på responsen — ekte PDP-er er 300–900 KB
if len(response.content) < 50_000 and "/ip/" in str(response.url):
return True
return False
Den fjerde sjekken — responslengde — fanger tilfellene der Walmart returnerer en nedstrippet side som ikke inneholder tydelige CAPTCHA-markører, men heller ikke produktdataene du trenger.
Retry-logikk med eksponentiell backoff og jitter
Når en forespørsel feiler, vil du ikke hamre løs på Walmart med en gang. Standardmønsteret bruker eksponentiell backoff med jitter for å spre retry-forsøkene:
import time
import random
import logging
from curl_cffi import requests as cffi_requests
log = logging.getLogger("walmart")
def fetch_with_retry(session, url, max_retries=5, base_delay=2, max_delay=60):
for attempt in range(max_retries):
try:
response = session.get(url, headers=HEADERS, timeout=15)
if response.status_code in (429, 503):
raise Exception(f"Throttled: {response.status_code}")
if is_walmart_blocked(response):
raise Exception("Stille blokkering oppdaget")
return response
except Exception as e:
if attempt == max_retries - 1:
raise
wait = min(max_delay, base_delay * (2 ** attempt)) + random.uniform(0, 3)
log.warning(f"Forsøk {attempt + 1} mislyktes: {e}. Prøver igjen om {wait:.1f}s")
time.sleep(wait)
return None
Jitteren (random.uniform(0, 3)) er ikke kosmetisk — den desynkroniserer arbeidere, slik at en flåte av scrapers ikke retry-pulser inn i samme sekund og utløser Akamais hastighetsdetektorer.
Rate limiting
Både Thunderbit og Scrape.do lander på en tilfeldig forsinkelse på 3–6 sekunder per forespørsel for Walmart: «begrens forespørslene dine ved å vente 3–6 sekunder mellom sideinnlastinger og randomiser forsinkelsene dine.»
import time
import random
def rate_limited_fetch(session, url):
response = fetch_with_retry(session, url)
time.sleep(random.uniform(3.0, 6.0))
return response
I større skala bør du vurdere aiolimiter for asynkron rate limiting:
from aiolimiter import AsyncLimiter
limiter = AsyncLimiter(max_rate=10, time_period=60) # 10 forespørsler per minutt
Datavalidering
Selv når responsen ikke er blokkert, kan de parsede dataene være feil (feil butikk, degradert payload). Valider før du skriver til output:
def validate_product(product):
"""Returnerer True hvis produktdataene ser legitime ut."""
if not product.get("name"):
return False
price = (product.get("priceInfo") or {}).get("currentPrice", {}).get("price")
if not isinstance(price, (int, float)) or price <= 0:
return False
if product.get("availabilityStatus") not in ("IN_STOCK", "OUT_OF_STOCK", "LIMITED_STOCK"):
return False
return True
Sesjonslogging
Spor suksessraten per sesjon. Når den faller under 80 % i 10 minutter, har noe endret seg — enten er IP-en din brent, cookies har utløpt, eller Walmart har rullet ut en ny anti-bot-regel.
class ScrapeMetrics:
def __init__(self):
self.total = 0
self.success = 0
self.blocks = 0
self.errors = 0
def record(self, result):
self.total += 1
if result == "success":
self.success += 1
elif result == "blocked":
self.blocks += 1
else:
self.errors += 1
@property
def success_rate(self):
return (self.success / self.total * 100) if self.total > 0 else 0
def check_health(self):
if self.total > 20 and self.success_rate < 80:
log.critical(f"Suksessraten falt til {self.success_rate:.1f}% — vurder å rotere proxies eller pause")
Ikke glamorøst. Men det er det som holder dataene dine rene.
DIY Python vs. scraping API vs. no-code: velg riktig tilnærming for å skrape Walmart
Mange utviklere hopper rett i å skrive en egendefinert scraper uten å spørre om det egentlig er riktig valg. ScrapeOps gir Walmart 9/10 i vanskelighetsgrad. Forumbrukere beskriver det som «i praksis 9/10» og lurer på «om et dedikert web scraping API ville være overkill». Svaret avhenger av volum, budsjett og ingeniørkapasitet.
| Faktor | DIY Python (requests + proxies) | Scraping API (Oxylabs, Bright Data, osv.) | No-code-verktøy (Thunderbit) |
|---|---|---|---|
| Oppsettstid til første rad | Timer | 15–60 min | Ca. 2 min |
| Oppsettstid til produksjon | 40–80 t | 4–16 t | Ca. 30 min |
| Håndtering av anti-bot | Du styrer selv (vanskelig) | Håndtert av leverandøren | Håndtert automatisk |
| Kostnad i liten skala (<1K sider/mnd) | Lav (proxykostnader ca. $4–8/GB) | Startnivå $40–$49/mnd | Gratis–$15/mnd |
| Kostnad i stor skala (100K+ sider/mnd) | Lavere per forespørsel | Høyere per forespørsel | Varierer |
| Tilpasning | Full kontroll | API-parametre | Begrenset av UI/felter |
| Løpende vedlikehold | 4–8 t/mnd | Nesten null | Ingen (AI tilpasser seg) |
| Best for | Utviklere som bygger egendefinerte pipeliner | Produksjonsskraping i middels skala | Forretningsbrukere, raske engangshentinger |
Når DIY Python gir mening
DIY vinner når du allerede har en proxy-avtale, trenger streng kontroll over headere, postnummermålretting eller selgergrupper, indekserer millioner av sider per måned der per-post API-gebyrer blir store, eller trenger on-prem- eller compliance-garantier. Avveiningen er reell ingeniørtid: en produksjonsklar Scrapy-spider med paginering, retries, proxy-rotasjon, TLS-impersonering og flere sidetype-skjemaer tar 40–80 timer senior Python-arbeid, pluss 4–8 timer vedlikehold i måneden når Walmart endrer fingeravtrykk.
Når et scraping API sparer deg tid
Scraping API-er håndterer anti-bot-laget for deg. ScrapeOps-benchmarks viser suksessrater på 99 % for Zyte API og 98 % for Scrape.do på Walmart. Startpriser ligger på $40–$49/mnd for verktøy som ScraperAPI, Oxylabs og Scrapingdog. Hvis du er et team på 2–5 ingeniører og skrapingsvolumet ditt er 10K–1M sider per måned, er et API nesten alltid riktig valg. Du bytter per-forespørsel-kostnad mot null vedlikehold.
Når no-code er riktig valg
Thunderbit passer en helt annen profil. Hvis du er PM, analytiker eller e-handelshandler som trenger Walmart-produktdata i et regneark i ettermiddag — ikke i neste sprint — er et no-code-verktøy det ærlige svaret.
Arbeidsflyten: installer Thunderbit Chrome Extension, gå til en Walmart-produkt- eller søkeresultatside, klikk «AI Suggest Fields», og Thunderbits AI leser siden og foreslår kolonner (produktnavn, pris, vurdering osv.). Klikk «Scrape», og dataene fylles inn i en tabell. Eksporter til Excel, Google Sheets, Airtable eller Notion — helt gratis, ingen betalingsmur.
Thunderbit håndterer anti-bot i skyen, så du slipper CAPTCHA-er, proxies og TLS-fingeravtrykk. AI-en tilpasser seg layoutendringer automatisk, så det er ikke noe vedlikehold. For brukere som ikke vil forholde seg til JSON-stinavigasjon i det hele tatt, er dette den enkleste veien.
Ærlige begrensninger: Thunderbit er ikke bygget for 100K+ sider per dag. Kredittbudsjetter og skylimiter gjør høyvoluminnsamling lite kostnadseffektivt sammenlignet med rå API-er. Du kan heller ikke låse til et bestemt postnummer eller ASN med mindre verktøyet støtter det. For løpende, høye volumpipeliner er DIY eller et scraping API fortsatt veien å gå.
Grovt prisoverslag: 1 000 Walmart-produktrader på Thunderbit koster omtrent 2 000 kreditter (ca. $0,60–$1,10 på Starter/Pro-planer). Det er sammenlignbart med Oxylabs' Walmart API og billigere enn de fleste hobby-nivå scraping API-er ved lavt volum. Sjekk Thunderbits priser for oppdatert informasjon.
Skrap Walmart-produktdata med AI Get Started Free
Eksport av dine skrapede Walmart-data
Når du har dataene, trenger du dem et nyttig sted. Tre formater dekker de fleste behov:
CSV — det laveste felles formatet som analytikere faktisk åpner:
import csv
def export_csv(products, filename="walmart_products.csv"):
fieldnames = ["name", "price", "availability", "rating", "review_count", "seller", "url"]
with open(filename, "w", newline="", encoding="utf-8-sig") as f:
writer = csv.DictWriter(f, fieldnames=fieldnames, quoting=csv.QUOTE_MINIMAL)
writer.writeheader()
for p in products:
writer.writerow({k: p.get(k) for k in fieldnames})
Bruk utf-8-sig-koding for Excel-kompatibilitet. BOM-markøren hindrer Excel i å ødelegge spesialtegn.
JSONL — produksjonsformatet for scraping-pipeliner:
import json
import gzip
def export_jsonl(products, filename="walmart_products.jsonl.gz"):
with gzip.open(filename, "at", encoding="utf-8") as f:
for p in products:
f.write(json.dumps(p, ensure_ascii=False) + "\n")
JSONL tåler krasj (en avbrutt skriving mister bare siste linje), er strømmbar med konstant minnebruk og bevarer nestede data som varianter og anmeldelser.
Excel — for engangsleveringer til analytikere:
from openpyxl import Workbook
def export_excel(products, filename="walmart_products.xlsx"):
wb = Workbook(write_only=True)
ws = wb.create_sheet("Products")
ws.append(["Navn", "Pris", "Tilgjengelighet", "Vurdering", "Anmeldelser", "Selger"])
for p in products:
ws.append([p.get("name"), p.get("price"), p.get("availability"),
p.get("rating"), p.get("review_count"), p.get("seller")])
wb.save(filename)
Thunderbit dekker eksporthistorien for ikke-Python-brukere: ett-klikk-eksport til Google Sheets, Airtable, Notion, Excel, CSV og JSON — alt gratis på basisnivået. For løpende overvåking kan Thunderbits planlagte scraper-funksjon kjøre gjentatte ekstraksjoner automatisk.
Et forbehold om planlegging: ikke bruk GitHub Actions til Walmart-skraping. GitHub Actions-runnere ligger på Azure-IP-områder som Walmarts anti-bot blokkerer umiddelbart. Bruk APScheduler på en VPS, eller rute all trafikk gjennom residential proxies.
Juridiske og etiske retningslinjer for å skrape Walmart
Forumbrukere uttrykker dette bekymringspunktet eksplisitt: «Jeg er ok med katt-og-mus-leken med utviklerne, men skeptisk til å leke med det juridiske teamet deres.»
Walmarts bruksvilkår forbyr uttrykkelig bruk av «any robot, spider… or other manual or automatic device to retrieve, index, 'scrape,' 'data mine' or otherwise gather any Materials» uten «express prior written consent».
Walmarts robots.txt forbyr /search, /account, /api/ og dusinvis av interne endepunkter. Produktsider (/ip/...) og anmeldelser (/reviews/product/) er ikke forbudt.
Prejudikatet hiQ v. LinkedIn (9. krets, 2022) slo fast at skraping av offentlig tilgjengelige data trolig ikke bryter den føderale CFAA-loven. Men den samme domstolen slo senere fast at hiQ brøt LinkedIns bruksvilkår og avsa en samtykkedom på 500 000 dollar mot dem. Nyere avgjørelser fra 2024 (Meta v. Bright Data, X Corp. v. Bright Data) innsnevret CFAA ytterligere og etablerte forsvar knyttet til copyright-preemption, men disse avgjørelsene hvilte på spesifikke ToU-formuleringer som ikke overføres direkte til Walmart.
Praktiske retningslinjer: Ikke overbelast servere. Respekter rate limits. Ikke skrap personlige data eller brukerdata. Bruk data ansvarlig. Å skrape offentlige Walmart-produktsider i moderat takt for personlig research er en helt annen risikoprofil enn å skrape i kommersiell skala i strid med Walmarts vilkår. Hvis du bygger et produkt på Walmart-data, snakk med en advokat og se nærmere på Walmarts offisielle affiliate- og seller-API-er.
Ansvarsfraskrivelse: Dette er informasjon til læringsformål, ikke juridisk rådgivning.
Konklusjon og viktigste læringspunkter
Å skrape Walmart med Python er en 9/10-vanskelighetsutfordring takket være den doble anti-bot-stakken fra Akamai + PerimeterX. Ikke umulig — men du trenger riktige verktøy og mønstre.
Viktige læringspunkter:
__NEXT_DATA__-JSON-ekstraksjon er det pragmatiske valget for de fleste bruksområder. Det er det alle seriøse Walmart-scrapere med åpen kildekode fra 2024–2026 bruker. Basisstien erprops.pageProps.initialData.data.productfor PDP-er ogsearchResult.itemStacksfor søk/browsing.curl_cffimedimpersonate="chrome124"er obligatorisk. Vanligrequestsellerhttpxkan ikke passere Akamais TLS-fingeravtrykk, uansett headere.- Stille blokkeringer er den reelle faren. Walmart returnerer 200 OK med CAPTCHA-innhold. Sjekk innholdet i responsen, ikke bare statuskoder.
- Produksjonsscrapere trenger mer enn happy-path-kode. Eksponentiell backoff med jitter, blokkdeteksjon på fire signaler, rate limiting på 3–6 sekunder per forespørsel, datavalidering og helsekontroll av sesjoner er alle nødvendige.
- Avlytting av interne API-er via
/orchestra/*er kraftig, men skjørt. Bruk det som en DevTools-øvelse for spesifikke databehov, ikke som primær ekstraksjonsmetode. - Walmart setter en grense på 25 sider i søkeresultatene. Gå bredere med bytte av sorteringsrekkefølge og oppdeling etter prisintervall.
- Velg tilnærming ærlig: DIY Python for utviklere med egne behov og høyt volum. Scraping API-er for team i middels skala uten scraping-ingeniør. Thunderbit for forretningsbrukere som vil ha data i Google Sheets i ettermiddag.
Hvis du vil prøve no-code-sporet, har Thunderbit Chrome Extension et gratisnivå — du kan skrape noen få Walmart-sider og se resultatene selv. Hvis du går Python-veien, er kodemønstrene i denne artikkelen testet i produksjon. Uansett har du nå et kart over Walmarts forsvar og tre veier gjennom dem.
For mer om web scraping-teknikker, se guidene våre om hvordan webskrape med Python, de beste automatiserte web scraping-verktøyene og web scraping uten å bli blokkert. Du kan også se opplæringsvideoer på Thunderbit YouTube-kanal.
Vanlige spørsmål
Er det lov å skrape Walmart-produktdata?
Walmarts bruksvilkår forbyr automatisert skraping uten skriftlig samtykke. Den 9. kretsens hiQ v. LinkedIn-avgjørelse (2022) slo fast at den føderale CFAA-loven trolig ikke gjelder for skraping av offentlige sider, men samme sak endte med en dom for kontraktsbrudd på 500 000 dollar mot scraperen. Skraping av offentlige produktsider i moderat takt for personlig research innebærer en helt annen risiko enn kommersiell innhenting. Snakk med en advokat hvis du bygger en virksomhet på Walmart-data.
Hvorfor blir Walmart-scraperen min stadig blokkert?
De vanligste årsakene er: bruk av vanlig requests eller httpx (som sender et Python-spesifikt TLS-fingeravtrykk som Akamai flagger umiddelbart), manglende eller feil headere, ingen proxy-rotasjon, forespørselsrater raskere enn 3–6 sekunder per side, og manglende sesjonscookies (_px3, _abck, locDataV3). Bytt til curl_cffi med impersonate="chrome124", bruk residential proxies, og implementer blokkdeteksjons- og retry-mønstrene beskrevet i denne artikkelen.
Hvilke data kan jeg skrape fra Walmart med Python?
Produktnavn, priser (nåværende og rollback), bilder, korte og lange beskrivelser, vurderinger, antall anmeldelser, lagerstatus, selgernavn, produsentinformasjon, variantvalg (størrelse, farge) og plassering i kategori. Med __NEXT_DATA__-metoden er alt dette tilgjengelig som strukturert JSON. Avlytting av interne API-er kan i tillegg returnere prisnivå på variantnivå, sanntids lagerbeholdning og paginerte anmeldelsesdata.
Trenger jeg proxies for å skrape Walmart?
Ja, for all produksjon eller gjentatt bruk. Walmarts anti-bot-systemer blokkerer vanlige forespørsler konsekvent — selv med perfekte headere vil en ikke-residential IP bli flagget av Akamais IP-omdømmesystem. Residential- eller mobilproxies er påkrevd. Datacenter-IP-er blir brent nesten umiddelbart. Budsjetter omtrent $3–$17 per 1 000 sider, avhengig av proxy-leverandør og nivå.
Kan jeg skrape Walmart uten å skrive kode?
Ja. Thunderbit er en AI-drevet Chrome-utvidelse som skraper Walmart i to klikk: «AI Suggest Fields» for å autooppdage kolonner med produktdata, deretter «Scrape» for å hente dataene. Den håndterer anti-bot-utfordringer i skyen og eksporterer direkte til Excel, Google Sheets, Airtable eller Notion — helt gratis. Den passer best for analytikere, PM-er og forretningsbrukere som trenger data raskt uten å bygge en egendefinert pipeline. For høyt volum eller svært skreddersydd skraping er Python eller et scraping API fortsatt et bedre valg.
Prøv Thunderbit for AI-drevet Walmart-skraping Get Started Free
Les mer
