Walmart ändrar sina priser på vissa varor flera gånger per dag. Om du någon gång har försökt följa det programmatiskt vet du hur frustrerande det är: ditt skript fungerar i 20 minuter och börjar sedan tyst returnera CAPTCHA-sidor som ser ut som vanliga 200 OK-svar.
Jag har lagt mycket tid på att arbeta igenom Walmarts antibot-försvar i vårt datauttag på Thunderbit, och jag vill dela med mig av allt jag har lärt mig — metoderna som faktiskt fungerar 2025, de tysta fel som förgiftar din data, och de ärliga avvägningarna mellan att bygga din egen scraper, betala för ett scraping-API och bara använda ett no-code-verktyg. Den här guiden går igenom tre extraktionsmetoder (HTML-parsning, __NEXT_DATA__-JSON och avlyssning av interna API:er), felsäkring i produktionsklass som de flesta guider hoppar över helt, och ett rakt beslutsunderlag för att välja rätt väg. Här finns något oavsett om du skriver Python eller bara vill ha ett kalkylblad fullt av priser till lunch.
Varför scrapa Walmart med Python?
Walmart är världens största återförsäljare sett till intäkter — 680,985 miljarder dollar under räkenskapsåret 2025, och har hållit plats #1 på Fortune Global 500 i 12 år i rad. Sajten har ungefär 420 miljoner aktiva listningar, och Walmarts CFO har nämnt "en halv miljard SKU:er" på marknadsplatsen. Omkring 95 % av dessa listningar kommer från tredjepartssäljare, vilket gör katalogen mycket föränderlig — säljare byts ut, varianter ändras och lagerstatus skiftar dagligen.
Den här volatiliteten är anledningen till att scraping spelar roll. En kvartalsrapport kan inte fånga det som en nattlig scraping kan. Här är de vanligaste användningsfallen jag ser:
| Användningsfall | Vem behöver det | Vad de extraherar |
|---|---|---|
| Övervakning av konkurrentpriser | E-handelsdrift, omprissättningsverktyg | Priser, kampanjer, MAP-efterlevnad |
| Berikning av produktkataloger | Försäljnings- och merchandisingteam | Beskrivningar, bilder, specifikationer, varianter |
| Spårning av lagerstatus | Supply chain, dropshippers | Lagerstatus, säljarinformation |
| Marknadsanalys och trendspaning | Marknadsföring, produktchefer | Betyg, recensioner, sortiment i kategorier |
| Leadgenerering | Säljteam | Säljar-namn, produktantal, kategorier |
Marknaden för programvara för övervakning av konkurrentpriser nådde ensam 1,92 miljarder dollar 2025 och väntas nå 5,09 miljarder dollar till 2033. Konsumentbeteendet driver satsningen: 94 % av kunderna jämför priser när de handlar online, och 83 % jämför över flera sajter.
Python är standardspråket för det här arbetet. Apifys Infrastructure Report 2026 sätter Python på 71,7 % av all web scraping, och kärnbiblioteket (requests) laddas ner cirka 30 miljoner gånger per vecka. Om du scrapar i någon större skala gör du det nästan säkert i Python.
Varför Walmart är en av de svåraste sajterna att scrapa
Walmart är särskilt svår eftersom den kör två kommersiella antibot-produkter i serie: Akamai Bot Manager som edge-WAF och TLS-fingeravtryckslager, samt PerimeterX (omprofilerat till HUMAN Security) som beteendebaserat JavaScript-utmaningslager. Scrape.do kallar denna kombination "ovanlig och extremt svår att kringgå".
ScrapeOps ger Walmart betyget 9/10 i övergripande scraping-svårighet, med Akamai ensam på 9/10. Enligt min erfarenhet stämmer det ganska väl.
Det här är vad du faktiskt möter:
Akamai Bot Manager granskar ditt TLS-fingeravtryck (JA3/JA4-hash), ordningen på HTTP/2-ramar, header-ordning och -versaler samt sessionscookies (_abck, ak_bmsc). Ett vanligt Python-anrop med requests skickar ett TLS-fingeravtryck som ingen riktig webbläsare producerar — Akamai stoppar det innan din begäran ens når Walmarts servrar.
PerimeterX/HUMAN kör efter Akamai och exekverar JavaScript-baserad fingeravtrycksinsamling (px.js) som kontrollerar navigator-egenskaper, canvas-rendering, WebGL, ljudkontext och beteendebiometri (musrörelser, skrollhastighet, tangenttryck). Det synliga misslyckandet är den ökända "Press & Hold"-utmaningen — en knapp du måste hålla nere i ungefär 10 sekunder medan beteendesignaler samplas. Oxylabs är tydliga: "Walmart använder 'Press & Hold'-modellen för CAPTCHA, som tillhandahålls av PerimeterX, och den är nästan omöjlig att lösa från kod."
Det verkligt farliga beteendet är den tysta blockeringen. Walmart returnerar HTTP 200 med en CAPTCHA-body i stället för 403. ScrapingBee bekräftar: "Walmart returnerar en 200 OK-statuskod även när den levererar en CAPTCHA-sida. Du kan inte förlita dig på statuskoden ensam för att veta om din begäran lyckades." Ditt skript tolkar glatt CAPTCHA-HTML som "produkt hittades inte" och går vidare. Halva datasetet blir skräp, och du märker det inte.
Sedan finns problemet med butiksstyrd data. Walmarts priser och lager är platsberoende och styrs av cookies som locDataV3 och assortmentStoreId. Utan rätt cookies får du "standard nationell" data som kan se komplett ut men inte matcha det riktiga kunder ser. Saknade cookies ger ingen blockeringssida — de ger fel data utan synligt fel, vilket är ännu värre.
Tre metoder för att extrahera data från Walmart (och hur de står sig mot varandra)
Innan vi går steg för steg, här är de tre huvudsakliga extraktionssätten. De flesta konkurrentguider täcker bara ett eller två. Jag går igenom alla tre så att du kan välja det som passar din situation.
| Metod | Tillförlitlighet | Datakompletthet | Svårighet mot antibot | Underhållsbörda |
|---|---|---|---|---|
| HTML + BeautifulSoup | ⚠️ Låg (selektorer går sönder vid varje deploy) | Måttlig | Hög | Hög |
__NEXT_DATA__-JSON | ✅ Bra | Hög | Medel-hög | Medel |
| Avlyssning av interna API:er | ✅ Bäst | Högst (varianter, lager, recensioner) | Medel-hög | Låg (strukturerad JSON) |
| Thunderbit (no-code) | ✅ Bra | Hög | Låg (hanteras av AI) | Ingen |
HTML-parsning är det sämsta alternativet för Walmart — sajten levererar Next.js-bundles med hashade CSS-klassnamn som ändras vid varje deploy. Metoden med __NEXT_DATA__-JSON är det pragmatiska val som används av varje seriös öppen Walmart-scraper från 2024–2026. Avlyssning av interna API:er är den kraftfullaste metoden men kommer med förbehåll som de flesta guider slätar över. Och Thunderbit är rätt val när du inte behöver någon egen pipeline alls.
Testa Thunderbit för Walmart-scraping
Så sätter du upp din Python-miljö för att scrapa Walmart
Det här behöver du:
- Svårighetsgrad: Medel
- Tid som krävs: Cirka 30 minuter för uppsättning, plus kodtid
- Det du behöver: Python 3.10+, pip, en kodredigerare och (för produktion) en proxytjänst eller ett scraping-API
Skapa projektmappen och den virtuella miljön:
mkdir walmart-scraper && cd walmart-scraper
python -m venv venv
source venv/bin/activate # På Windows: venv\Scripts\activate
Installera de nödvändiga biblioteken:
pip install curl_cffi parsel beautifulsoup4 lxml
curl_cffi är 2025 års standard för att scrapa svåra mål. Det är en libcurl-bindning som kan efterlikna exakta TLS-fingeravtryck från webbläsare. Bright Data förklarar: "Walmart använder TLS-fingeravtryck som en del av sin botdetektering, och även om du sätter User-Agent för att simulera en riktig webbläsare kommer det inte att kringgå det." Vanliga requests eller httpx kan inte passera Akamai oavsett vilka headers du sätter. curl_cffi med impersonate="chrome124" är det som gör skillnad.
Du vill också ha json (inbyggt), csv (inbyggt), time, random och logging för de produktionsmönster vi går igenom senare.
Steg för steg: Scrapa Walmarts produktsidor med Python
Steg 1: Hämta Walmarts produktsida
Din första uppgift är att göra en HTTP-begäran som inte blockeras direkt. Här är den klassiska uppsättningen headers som används av Scrapfly, Scrapingdog, Oxylabs och ScrapeOps under 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)
Parametern impersonate="chrome124" gör det tunga arbetet här. Den säger åt curl_cffi att matcha Chrome 124:s exakta TLS ClientHello, HTTP/2-ramordning och pseudo-header-sekvens. Utan den ser Akamai en Python-specifik JA3-hash och stoppar dig innan din begäran ens når Walmarts applikationslager.
Så ser ett blockerat svar ut: Om du ser "Robot or human?" i sidans HTML-titel, eller om svaret omdirigeras till walmart.com/blocked, har du blivit stoppad. Det knepiga är att Walmart ofta returnerar statuskod 200 med CAPTCHA-body — så att bara kontrollera response.ok räcker inte.
För all produktion eller upprepad användning behöver du residential proxies. Datacenter-IP:er bränns direkt av Akamais IP-reputationssystem. Jag går igenom fullständig felhantering och proxystra tegi i avsnittet om produktion längre ned.
Steg 2: Tolka produktdata från __NEXT_DATA__-JSON
Walmart.com är en Next.js-applikation, och den serverrenderade HTML:n bäddar in hela hydrationspayloaden i en enda script-tagg: <script id="__NEXT_DATA__" type="application/json">. Det här är guldgruvan.
Scrapflys guide från 2026 bekräftar: "År 2026 använder Walmart Next.js med strukturerad JSON i script-taggarna __NEXT_DATA__, vilket gör extraktion av dold data mer tillförlitlig än traditionell CSS-selektorsparsing." Varje välkänd öppen Walmart-scraper — Scrapflys, Oxylabs', python-scrapy-playbooks — använder den här metoden.
Så här extraherar du den:
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 flesta guider slutar här. Nedan finns en fullständig karta över JSON-sökvägar för de fält du faktiskt bryr dig om — verifierad mot live-Walmart-sidor under 2024–2026:
| Datafält | JSON-sökväg (under initialData) | Typ | Kommentarer |
|---|---|---|---|
| Produktnamn | data > product > name | Sträng | — |
| Varumärke | data > product > brand | Sträng | — |
| Aktuellt pris (nummer) | data > product > priceInfo > currentPrice > price | Flyttal | Kan skilja sig beroende på butikscookie |
| Aktuellt pris (sträng) | data > product > priceInfo > currentPrice > priceString | Sträng | Formaterat t.ex. "$9.99" |
| Kort beskrivning | data > product > shortDescription | HTML-sträng | Tolka med BeautifulSoup för text |
| Lång beskrivning | data > idml > longDescription | HTML-sträng | Finns i idml, INTE i product — det här är fällan som äldre guider ofta har fel om |
| Alla bilder | data > product > imageInfo > allImages | Array | Lista med objekt av typen {id, url} |
| Genomsnittligt betyg | data > product > averageRating | Flyttal | Nyckeln är averageRating, inte det äldre rating |
| Antal recensioner | data > product > numberOfReviews | Heltal | — |
| Varianter | data > product > variantCriteria | Array | Alternativgrupper (storlek, färg) |
| Tillgänglighet | data > product > availabilityStatus | Sträng | IN_STOCK, OUT_OF_STOCK, LIMITED_STOCK |
| Säljare | data > product > sellerDisplayName | Sträng | — |
| Tillverkare | data > product > manufacturerName | Sträng | — |
Sökvägen longDescription är den enda fällan som brukar ställa till det. Ett ScrapeHero-inlägg från 2023 placerade den på product.longDescription, men källor från 2024 och framåt lägger den konsekvent på systernyckeln idml. Läs alltid idml.longDescription först och falla tillbaka till product.longDescription för äldre sidor.
Här är det säkra extraktionsmönstret med .get()-kedjor:
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"),
}
För användare som inte vill hantera JSON-sökvägar alls identifierar och strukturerar Thunderbits AI dessa fält automatiskt — ingen manuell sökvägsmappning behövs. Du klickar på "AI Suggest Fields", den läser sidan och du får en tabell. Men om du bygger en egen pipeline är kartan ovan din referens.
Steg 3: Avlyssna Walmarts interna API-endpoints för rikare data
Ingen konkurrentartikel täcker den här metoden ordentligt. Det är den mest kraftfulla extraktionsvägen — och den mest komplicerade.
Walmarts frontend anropar ett federerat GraphQL-backend byggt på Apollo Gateway. Endpoints ligger under www.walmart.com/orchestra/*:
/orchestra/pdp/graphql/...— produktdetalj-hydrering + växlingsbara varianter/orchestra/snb/graphql/...— sök-och-browse-paginering/orchestra/reviews/graphql/...— paginerade recensioner
Dessa returnerar ren, strukturerad JSON med data som __NEXT_DATA__ ibland trunkerar — pris på variantnivå, lagerantal i realtid, fullständig paginering av recensioner.
Fällan som blogginlägg brukar glida förbi: Walmart använder Apollo persisted queries. Begärans body skickar bara en SHA-256-hash (persistedQuery.sha256Hash), inte själva frågetexten. Om hashen inte känns igen av servern får du PersistedQueryNotFound. Walmart roterar dessa hashvärden vid deploys. Det är därför ingen av de stora öppna Walmart-scraperna publicerar kod för /orchestra/ som går att klistra in direkt.
Den praktiska och ärliga versionen av metoden är en DevTools-övning:
- Öppna en Walmart-produktsida i Chrome
- Öppna DevTools → fliken Network, filtrera på "Fetch/XHR"
- Surfa på sidan som vanligt — klicka på varianter, skrolla till recensioner, ändra butiksläge
- Leta efter begäranden till
/orchestra/*-endpoints som returnerar JSON med produktdata - Högerklicka på begäran → "Copy as cURL"
- Konvertera cURL-kommandot till Python med
curl_cffi
Så här ser ett återuppspelat API-anrop ut:
import json
from curl_cffi import requests
session = requests.Session(impersonate="chrome124")
# Först: värm upp sessionen genom att besöka produktsidan
session.get("https://www.walmart.com/ip/some-product/1234567", headers=HEADERS)
# Sedan: spela upp det interna API-anropet (kopierat från 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 = {
# Klistra in exakt request body från 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 för att värma upp sessionen är avgörande. Walmarts PerimeterX-cookies (_px3, _pxhd, ACID) måste sättas av den första HTML-hämtningen innan API-anropet kommer att lyckas. Utan dem får du 412 eller 403.
När du ska använda den här metoden: När du behöver data som __NEXT_DATA__ inte innehåller — djup variantprissättning, paginerade recensioner bortom första batchen eller lagerantal i realtid. För de flesta användningsfall räcker __NEXT_DATA__ och är mycket enklare.
Så scrapar du Walmarts sökresultat och flera sidor
Sökresultat följer ett liknande __NEXT_DATA__-mönster, men med en annan JSON-sökväg:
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"]
# Filtrera bort sponsrade 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 fungerar genom att öka page-parametern: &page=1, &page=2 osv. Men här finns den odokumenterade begränsningen: Walmart begränsar sökresultat till 25 sidor oavsett det faktiska totala antalet. Scrapfly bekräftar: "Walmart sätter det maximala antalet resultatsidor som kan nås till 25, oavsett hur många sidor som faktiskt finns tillgängliga."
Workarounds för att få bredare täckning:
- Byta sorteringsordning: Kör samma sökning med
&sort=price_lowoch sedan&sort=price_highför att få ungefär 50 sidor täckning - Dela upp efter prisintervall: Lägg till
&min_price=X&max_price=Yför att bryta upp katalogen i mindre fönster - Dela upp efter kategori: Sök inom specifika kategorier i stället för hela sajten
Observera att itemStacks är en array. Scrapfly hårdkodar [0] i sitt repo, men kategori- och bläddringssidor innehåller ibland flera stackar ("Top picks", "More results"). Det robusta mönstret itererar över alla stackar:
for stack in search_result.get("itemStacks", []):
for item in stack.get("items", []):
if item.get("__typename") == "Product":
# bearbeta item
pass
Värt att notera också: Walmarts robots.txt blockerar /search. Produktsidor (/ip/...) och de flesta kategorisidor (/cp/...) är inte blockerade. Om du oroar dig för efterlevnad, börja med produktsidor och kategoriträd snarare än sökning.
Låt inte tysta blockeringar förstöra din data: produktionsklar felhantering
De flesta guider faller sönder här. De visar hur du hämtar en sida, tolkar en produkt och kallar det klart. I produktion hämtar du tusentals sidor, och Walmart försöker aktivt stoppa dig. Skillnaden mellan en demo-scraper och en scraper som faktiskt fungerar är hur den hanterar fel.
Upptäck tysta blockeringar innan de korrumperar din data
Den viktigaste funktionen i en Walmart-scraper är blockdetektorn. Baserat på branschens samsyn hos ScrapingBee, Scrapingdog, Oxylabs och Decodo behöver du fyra oberoende kontroller:
BLOCK_MARKERS = (
"Robot or human",
"Press & Hold",
"Press & Hold",
"px-captcha",
"perimeterx",
)
def is_walmart_blocked(response) -> bool:
# 1. Omdirigering till den dedikerade block-endpointen
if "/blocked" in str(response.url):
return True
# 2. Hårda statuskoder
if response.status_code in (403, 412, 428, 429, 503):
return True
# 3. 200 OK med CAPTCHA-body (det tysta blockfallet)
body = response.text or ""
if any(m.lower() in body.lower() for m in BLOCK_MARKERS):
return True
# 4. Rimlig kontroll av svarslängd — riktiga PDP:er är 300–900 KB
if len(response.content) < 50_000 and "/ip/" in str(response.url):
return True
return False
Den fjärde kontrollen — svarslängden — fångar fall där Walmart returnerar en nedbantad sida som inte innehåller några uppenbara CAPTCHA-markörer men inte heller produktdata du behöver.
Omförsök med exponentiell backoff och jitter
När en begäran misslyckas vill du inte bombardera Walmart direkt. Standardmönstret använder exponentiell backoff med jitter för att sprida ut omförsök:
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"Throttlad: {response.status_code}")
if is_walmart_blocked(response):
raise Exception("Tyst blockering upptäckt")
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"Försök {attempt + 1} misslyckades: {e}. Försöker igen om {wait:.1f}s")
time.sleep(wait)
return None
Jitter-delen (random.uniform(0, 3)) är inte kosmetisk — den desynkroniserar arbetare så att en hel flotta av scrapers inte retry-pulserar in i samma sekund och triggar Akamais hastighetsdetektorer.
Hastighetsbegränsning
Både Thunderbit och Scrape.do landar i en slumpmässig fördröjning på 3–6 sekunder per begäran för Walmart: "stryp dina begäranden genom att vänta 3–6 sekunder mellan sidladdningar och slumpa dina fördröjningar."
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 kan du överväga aiolimiter för asynkron rate limiting:
from aiolimiter import AsyncLimiter
limiter = AsyncLimiter(max_rate=10, time_period=60) # 10 begäran per minut
Datavalidering
Även när svaret inte är blockerat kan den parsade datan vara fel (fel butik, försämrad payload). Validera innan du skriver till utdata:
def validate_product(product):
"""Returnerar True om produktdatan ser legitim 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
Sessionsloggning
Spåra din träffsäkerhet per session. När den sjunker under 80 % i 10 minuter har något förändrats — antingen är din IP bränd, dina cookies har gått ut eller så har Walmart infört en ny antibot-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"Träffsäkerheten sjönk till {self.success_rate:.1f}% — överväg att rotera proxies eller pausa")
Inte glamoröst. Men det är det som håller din data ren.
DIY-Python vs scraping-API vs no-code: välj rätt sätt att scrapa Walmart
Många utvecklare kastar sig direkt in i att bygga en egen scraper utan att fråga sig om det verkligen är rätt val. ScrapeOps ger Walmart 9/10 i svårighetsgrad. Forumanvändare beskriver det som "i princip 9/10" och undrar om "ett dedikerat web scraping-API skulle vara överdrivet." Svaret beror på volym, budget och teknisk kapacitet.
| Faktor | DIY-Python (requests + proxies) | Scraping-API (Oxylabs, Bright Data, etc.) | No-code-verktyg (Thunderbit) |
|---|---|---|---|
| Tid till första rad | Timmar | 15–60 min | ~2 min |
| Tid till produktion | 40–80 tim | 4–16 tim | ~30 min |
| Hantering av antibot | Du hanterar det (svårt) | Hanteras av leverantören | Hanteras automatiskt |
| Kostnad i liten skala (<1K sidor/mån) | Låg (proxykostnader ~4–8 USD/GB) | 40–49 USD/mån i instegsnivåer | Gratis–15 USD/mån |
| Kostnad i stor skala (100K+ sidor/mån) | Lägre per begäran | Högre per begäran | Varierar |
| Anpassning | Full kontroll | API-parametrar | Begränsat av UI/fält |
| Löpande underhåll | 4–8 tim/mån | Nästan noll | Inget (AI anpassar sig) |
| Bäst för | Utvecklare som bygger egna pipelines | Produktion i mellanskala | Affärsanvändare, snabba engångsextraktioner |
När DIY-Python är rätt val
DIY vinner när du redan har ett proxkontrakt, behöver strikt kontroll över headers, postnummermålning eller säljargrupper, indexerar miljoner sidor per månad där avgifter per post ackumuleras, eller behöver on-prem eller efterlevnadsgarantier. Avvägningen är verklig utvecklingstid: en produktionsklar Scrapy-spider med paginering, omförsök, proxyrotation, TLS-imitation och flera sidtypsscheman tar 40–80 timmar senior Python-utveckling, plus 4–8 timmar per månad i underhåll när Walmart roterar fingeravtryck.
När ett scraping-API sparar tid
Scraping-API:er hanterar antibot-lagret så att du slipper. ScrapeOps-benchmarkar visar lyckandefrekvenser på 99 % för Zyte API och 98 % för Scrape.do på Walmart. Instegspriser ligger runt 40–49 USD/månad för verktyg som ScraperAPI, Oxylabs och Scrapingdog. Om du är ett team på 2–5 utvecklare och din scrapingvolym är 10K–1M sidor per månad är ett API nästan alltid rätt val. Du byter kostnad per begäran mot noll underhåll.
När no-code är rätt val
Thunderbit passar en helt annan profil. Om du är PM, analytiker eller e-handelsansvarig och behöver Walmart-data i ett kalkylblad i eftermiddag — inte nästa sprint — är ett no-code-verktyg det ärliga svaret.
Arbetsflödet: installera Thunderbit Chrome Extension, gå till en Walmart produkt- eller söksida, klicka på "AI Suggest Fields", och Thunderbits AI läser sidan och föreslår kolumner (produktnamn, pris, betyg osv.). Klicka på "Scrape", och datan fylls i en tabell. Exportera till Excel, Google Sheets, Airtable eller Notion — allt gratis, utan betalvägg.
Thunderbit hanterar antibot i molnet, så du behöver inte brottas med CAPTCHA, proxies eller TLS-fingeravtryck. AI:n anpassar sig automatiskt till layoutändringar, så det krävs inget underhåll. För användare som inte vill hantera JSON-sökvägar alls är det här vägen med minst motstånd.
Ärliga begränsningar: Thunderbit är inte byggt för 100K+ sidor per dag. Kreditbudgetar och molnbegränsningar gör högvolymsingest oekonomisk jämfört med råa API:er. Du kan inte heller låsa en specifik postkod eller ASN om inte verktyget stöder det. För löpande pipelines med hög volym är DIY eller ett scraping-API fortfarande rätt väg.
Pris i grova drag: 1 000 Walmart-produktrader i Thunderbit kostar ungefär 2 000 krediter (~0,60–1,10 USD på Starter/Pro-planer). Det är jämförbart med Oxylabs Walmart-API och billigare än de flesta scraping-API:er på hobby-nivå vid låg volym. Se Thunderbits priser för aktuella detaljer.
Scrapa Walmart-produktdata med AI Get Started Free
Exportera din scrapade Walmart-data
När du väl har datan behöver du få ut den i ett användbart format. Tre format täcker de flesta behov:
CSV — det enklaste formatet som analytiker faktiskt öppnar:
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})
Använd kodningen utf-8-sig för Excel-kompatibilitet. BOM-markören hindrar Excel från att förvränga specialtecken.
JSONL — produktionsformatet för scraping-pipelines:
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 är krasch-säkert (en avbruten skrivning tappar bara den sista raden), strömmande med konstant minne och bevarar nästlad data som varianter och recensioner intakt.
Excel — för engångsleveranser till analytiker:
from openpyxl import Workbook
def export_excel(products, filename="walmart_products.xlsx"):
wb = Workbook(write_only=True)
ws = wb.create_sheet("Products")
ws.append(["Namn", "Pris", "Tillgänglighet", "Betyg", "Recensioner", "Säljare"])
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 täcker exportdelen för icke-Python-användare: ett klick för att exportera till Google Sheets, Airtable, Notion, Excel, CSV och JSON — allt gratis på basnivån. För löpande övervakning kan Thunderbits schemalagda scraper köra återkommande extraktioner automatiskt.
En sak att tänka på vid schemaläggning: använd inte GitHub Actions för Walmart-scraping. GitHub Actions-runners ligger på Azure-IP-intervall som Walmarts antibot blockerar direkt. Använd APScheduler på en VPS, eller routa all trafik genom residential proxies.
Juridiska och etiska riktlinjer för att scrapa Walmart
Forumanvändare uttrycker detta bekymmer rakt ut: "Jag är okej med katt-och-råtta-leken med utvecklare, men tveksam till att spela med deras juridiska team."
Walmarts användarvillkor förbjuder uttryckligen användning av "any robot, spider… or other manual or automatic device to retrieve, index, 'scrape,' 'data mine' or otherwise gather any Materials" utan "express prior written consent."
Walmarts robots.txt blockerar /search, /account, /api/ och dussintals interna endpoints. Produktsidor (/ip/...) och recensioner (/reviews/product/) är inte blockerade.
Prejudikatet hiQ v. LinkedIn (9:e kretsen, 2022) slog fast att scraping av offentligt tillgänglig data sannolikt inte bryter mot den federala CFAA. Men samma domstol slog senare fast att hiQ bröt mot LinkedIns användaravtal och meddelade ett domslut på 500 000 dollar genom samtycke mot bolaget. Mer aktuella beslut från 2024 (Meta v. Bright Data, X Corp. v. Bright Data) snävade ytterligare in CFAA och skapade försvar om upphovsrättsföreträde, men dessa avgöranden berodde på specifika ToU-formuleringar som inte direkt går att överföra till Walmart.
Praktiska riktlinjer: Överbelasta inte servrar. Respektera rate limits. Scrapa inte person- eller användardata. Använd data ansvarsfullt. Att scrapa offentliga Walmart-produktsidor i måttlig takt för egen research är en helt annan riskprofil än att scrape:a i kommersiell skala mot Walmarts villkor. Om du bygger en produkt på Walmart-data, prata med en jurist och titta på Walmarts officiella affiliate- och seller-API:er.
Ansvarsfriskrivning: Detta är utbildningsinformation, inte juridisk rådgivning.
Slutsats och viktiga lärdomar
Att scrapa Walmart med Python är en 9/10-svårighetsutmaning tack vare dess dubbla antibot-stack med Akamai + PerimeterX. Inte omöjligt — men du behöver rätt verktyg och mönster.
Viktiga lärdomar:
- JSON-extraktion från
__NEXT_DATA__är det pragmatiska valet för de flesta användningsfall. Det är vad varje seriös öppen Walmart-scraper från 2024–2026 använder. Baskvägen ärprops.pageProps.initialData.data.productför produktsidor ochsearchResult.itemStacksför sök/bläddring. curl_cffimedimpersonate="chrome124"är obligatoriskt. Vanligarequestsellerhttpxkan inte passera Akamais TLS-fingeravtryck oavsett headers.- Tysta blockeringar är den verkliga faran. Walmart returnerar 200 OK med CAPTCHA-body. Kontrollera innehållet i svaret, inte bara statuskoderna.
- Produktionsscrapers behöver mer än happy-path-kod. Exponentiell backoff med jitter, blockdetektering på fyra signaler, rate limiting på 3–6 sekunder per begäran, datavalidering och övervakning av sessionens hälsa är alla nödvändiga.
- Avlyssning av interna API:er via
/orchestra/*är kraftfull men skör. Använd det som en DevTools-övning för specifika databehov, inte som din primära extraktionsmetod. - Walmart sätter gränsen för sökresultat till 25 sidor. Gå bredare med byte av sorteringsordning och uppdelning efter prisintervall.
- Välj metod ärligt: DIY-Python för utvecklare med egna behov och hög volym. Scraping-API:er för mellanstora team utan scrapingingenjör. Thunderbit för affärsanvändare som vill ha data i Google Sheets i eftermiddag.
Om du vill testa no-code-vägen har Thunderbit Chrome Extension en gratisnivå — du kan scrapa ett par Walmart-sidor och se resultaten själv. Om du kör Python-vägen är kodmönstren i den här artikeln testade i produktion. Oavsett vilket har du nu en karta över Walmarts försvar och tre vägar igenom dem.
För mer om web scraping-tekniker, kolla in våra guider om hur man web scraper med Python, bästa automatiserade web scraping-verktyg och web scraping utan att bli blockerad. Du kan också titta på tutorials på Thunderbits YouTube-kanal.
Vanliga frågor
Är det lagligt att scrapa Walmart-produktdata?
Walmarts användarvillkor förbjuder automatiserad scraping utan skriftligt medgivande. 9:e kretsens dom i hiQ v. LinkedIn (2022) fastställde att den federala CFAA sannolikt inte gäller för scraping av offentliga sidor, men samma mål slutade med ett domslut om avtalsbrott på 500 000 dollar mot scrapersidan. Att scrapa offentliga produktsidor i måttlig takt för egen research innebär en helt annan riskprofil än kommersiell extraktion i stor skala. Rådgör med en jurist om du bygger en verksamhet på Walmart-data.
Varför blir min Walmart-scraper hela tiden blockerad?
De vanligaste orsakerna är: att använda vanliga requests eller httpx (som skickar ett Python-specifikt TLS-fingeravtryck som Akamai stoppar direkt), saknade eller felaktiga headers, ingen proxyrotation, för höga begärandefrekvenser snabbare än 3–6 sekunder per sida och saknade sessionscookies (_px3, _abck, locDataV3). Byt till curl_cffi med impersonate="chrome124", använd residential proxies och implementera blockdetekterings- och omförsöksmönstren som beskrivs i den här artikeln.
Vilken data kan jag scrapa från Walmart med Python?
Produktnamn, priser (aktuella och tidigare), bilder, korta och långa beskrivningar, betyg, antal recensioner, lagerstatus, säljar-namn, tillverkarinformation, variantalternativ (storlek, färg) och kategoriplacering. Med metoden __NEXT_DATA__ är allt detta tillgängligt som strukturerad JSON. Avlyssning av interna API:er kan dessutom ge prisnivå per variant, lagerantal i realtid och paginerad recensionsdata.
Behöver jag proxies för att scrapa Walmart?
Ja, för all produktion eller upprepad användning. Walmarts antibot-system blockerar vanliga begäranden konsekvent — även med perfekta headers kommer en icke-residential IP att flaggas av Akamais IP-reputationssystem. Residential- eller mobilproxies krävs. Datacenter-IP:er bränns nästan omedelbart. Räkna med ungefär 3–17 USD per 1 000 sidor beroende på proxyleverantör och nivå.
Kan jag scrapa Walmart utan att skriva kod?
Ja. Thunderbit är ett AI-drivet Chrome-tillägg som scrapar Walmart i två klick: "AI Suggest Fields" för att autoidentifiera kolumner med produktdata, och sedan "Scrape" för att extrahera datan. Det hanterar antibot-utmaningar i molnet och exporterar direkt till Excel, Google Sheets, Airtable eller Notion — allt gratis. Det passar bäst för analytiker, PM:er och affärsanvändare som behöver data snabbt utan att bygga en egen pipeline. För högvolyms- eller kraftigt anpassad scraping är Python eller ett scraping-API fortfarande bättre.
Testa Thunderbit för AI-driven Walmart-scraping Get Started Free
Läs mer
