Cum să extragi date din Walmart cu Python (și să nu fii blocat)

Walmart își schimbă prețurile la anumite produse de mai multe ori pe zi. Dacă ai încercat vreodată să urmărești asta programatic, știi cât de frustrant este: scriptul merge 20 de minute, apoi începe, pe ascuns, să returneze pagini CAPTCHA deghizate în răspunsuri normale 200 OK.

Am petrecut mult timp lucrând la apărarea anti-bot a Walmart ca parte din munca noastră de extragere de date la Thunderbit și vreau să împărtășesc tot ce am învățat — metodele care chiar funcționează în 2025, eșecurile tăcute care îți otrăvesc datele și compromisurile oneste dintre a-ți scrie propriul scraper, a plăti pentru un API de scraping și a folosi pur și simplu un instrument no-code. Acest ghid acoperă trei metode de extragere (parsing HTML, JSON __NEXT_DATA__ și interceptarea API-ului intern), tratarea erorilor la nivel de producție pe care majoritatea tutorialelor o omit complet și un cadru sincer de decizie pentru alegerea abordării potrivite. Există ceva util aici, indiferent dacă scrii în Python sau doar vrei un spreadsheet plin de prețuri până la prânz.

De ce să extragi date din Walmart cu Python?

Walmart este cel mai mare retailer din lume după venituri — 680,985 miliarde de dolari în anul fiscal 2025, ocupând locul 1 în Fortune Global 500 timp de 12 ani consecutivi. Site-ul găzduiește aproximativ 420 de milioane de listări active, iar CFO-ul Walmart a vorbit despre „jumătate de miliard de SKU-uri” pe marketplace. Aproximativ 95% dintre aceste listări provin de la vânzători terți, ceea ce înseamnă că portofoliul este volatil — vânzătorii se schimbă, variantele se modifică și stocul oscilează zilnic.

Această volatilitate este motivul pentru care scraping-ul contează. Un raport trimestrial nu poate surprinde ceea ce poate surprinde un scraping nocturn. Iată cele mai comune cazuri de utilizare pe care le întâlnesc:

Caz de utilizare	Cine are nevoie de el	Ce extrag
Monitorizarea prețurilor concurenței	Operațiuni e-commerce, instrumente de repricing	Prețuri, promoții, conformitate MAP
Îmbogățirea catalogului de produse	Echipe de vânzări și merchandising	Descrieri, imagini, specificații, variante
Urmărirea disponibilității în stoc	Supply chain, dropshipperi	Starea stocului, informații despre vânzător
Cercetare de piață și analiză de tendințe	Marketing, product managers	Evaluări, recenzii, sortiment pe categorie
Generare de lead-uri	Echipe de vânzări	Nume de vânzători, număr de produse, categorii

Numai piața software-ului de monitorizare a prețurilor concurenței a ajuns la 1,92 miliarde de dolari în 2025 și este estimată să atingă 5,09 miliarde până în 2033. Comportamentul consumatorilor alimentează cheltuielile: 94% dintre clienți compară prețurile atunci când cumpără online, iar 83% compară prețurile pe mai multe site-uri.

Python este limbajul implicit pentru acest tip de muncă. Raportul Apify Infrastructure Report 2026 indică Python la 71,7% din tot web scraping-ul, iar biblioteca de bază (requests) are ~30 de milioane de descărcări pe săptămână. Dacă faci scraping la orice scară, aproape sigur îl faci în Python.

De ce Walmart este unul dintre cele mai greu de extras site-uri

Walmart este dificil în mod special pentru că rulează două produse comerciale anti-bot în serie: Akamai Bot Manager ca strat edge WAF și de TLS fingerprinting, și PerimeterX (redenumit HUMAN Security) ca strat comportamental de provocare JavaScript. Scrape.do numește această combinație „rară și extrem de greu de ocolit”.

ScrapeOps acordă Walmart nota 9/10 la dificultatea generală de scraping, iar Akamai singur primește tot 9/10. Din experiența mea, este o evaluare corectă.

Iată cu ce te confrunți de fapt:

Akamai Bot Manager inspectează fingerprint-ul TLS (hash JA3/JA4), ordinea cadrelor HTTP/2, ordinea și capitalizarea headerelor și cookie-urile de sesiune (_abck, ak_bmsc). Un apel standard requests din Python emite un fingerprint TLS pe care niciun browser real nu îl produce — Akamai îl marchează înainte ca cererea ta să ajungă măcar la serverele Walmart.

PerimeterX/HUMAN rulează după Akamai, executând fingerprinting JavaScript (px.js) care verifică proprietățile navigator, randarea canvas, WebGL, contextul audio și biometria comportamentală (mișcarea mouse-ului, viteza de scroll, dinamica tastării). Eșecul vizibil este celebra provocare „Press & Hold” — un buton pe care trebuie să-l ții apăsat aproximativ 10 secunde, în timp ce sunt eșantionate semnalele comportamentale. Oxylabs este direct: „Walmart folosește modelul CAPTCHA ‘Press & Hold’, oferit de PerimeterX, despre care se știe că este aproape imposibil de rezolvat din cod.”

Comportamentul cu adevărat periculos este blocarea tăcută. Walmart returnează HTTP 200 cu un body CAPTCHA în loc de un 403. ScrapingBee confirmă: „Walmart returnează un cod de stare 200 OK chiar și atunci când servește o pagină CAPTCHA. Nu te poți baza doar pe codul de stare ca să știi dacă cererea a reușit.” Scriptul tău parsează fericit HTML-ul CAPTCHA ca „produs negăsit” și merge mai departe. Jumătate din dataset este gunoi, iar tu nu știi asta.

Apoi apare problema datelor dependente de magazin. Prețurile și stocul Walmart depind de locație, fiind controlate de cookie-uri precum locDataV3 și assortmentStoreId. Fără cookie-urile potrivite, primești date „naționale implicite” care par complete, dar nu se potrivesc cu ceea ce văd cumpărătorii reali. Cookie-urile lipsă nu produc o pagină de blocare — produc date greșite, fără eșec vizibil, ceea ce este și mai rău.

Trei metode de a extrage date din Walmart (și cum se compară)

Înainte de pașii detaliați, iată cele trei abordări principale de extragere. Majoritatea tutorialelor concurente acoperă doar una sau două. Le voi parcurge pe toate trei, ca să poți alege ce se potrivește situației tale.

Metodă	Fiabilitate	Completitudinea datelor	Dificultatea anti-bot	Efort de mentenanță
HTML + BeautifulSoup	⚠️ Scăzută (selectorii se rup la fiecare deploy)	Medie	Ridicată	Ridicat
JSON `__NEXT_DATA__`	✅ Bună	Ridicată	Medie-ridicată	Mediu
Interceptarea API-ului intern	✅ Cea mai bună	Cea mai ridicată (variante, stoc, recenzii)	Medie-ridicată	Redus (JSON structurat)
Thunderbit (no-code)	✅ Bună	Ridicată	Scăzută (gestionată de AI)	Niciunul

Parsingul HTML este cea mai proastă opțiune pentru Walmart — site-ul livrează bundle-uri Next.js cu nume de clase CSS hashuite care se schimbă la fiecare deploy. Metoda JSON __NEXT_DATA__ este alegerea pragmatică folosită de orice scraper serios open-source pentru Walmart din 2024–2026. Interceptarea API-ului intern este cea mai puternică, dar vine cu avertismente pe care majoritatea tutorialelor le trec sub tăcere. Iar Thunderbit este alegerea corectă când nu ai nevoie deloc de un pipeline personalizat.

Încearcă Thunderbit pentru scraping Walmart

Configurarea mediului Python pentru scraping Walmart

Ai nevoie de următoarele:

Dificultate: Intermediară
Timp necesar: ~30 de minute pentru configurare, plus timpul de codare
Ce îți trebuie: Python 3.10+, pip, un editor de cod și (pentru utilizare în producție) un serviciu de proxy sau un API de scraping

Creează folderul proiectului și mediul virtual:

mkdir walmart-scraper && cd walmart-scraper
python -m venv venv
source venv/bin/activate  # Pe Windows: venv\Scripts\activate

Instalează bibliotecile necesare:

pip install curl_cffi parsel beautifulsoup4 lxml

curl_cffi este standardul din 2025 pentru scraping pe ținte dificile. Este un binding libcurl care poate imita exact fingerprint-urile TLS ale browserelor. Bright Data explică: „Walmart folosește TLS fingerprinting ca parte a detecției bot-urilor, iar simplul fapt că setezi User-Agent-ul să simuleze un browser real nu va ocoli asta.” requests sau httpx simple nu pot trece de Akamai, indiferent ce headere setezi. curl_cffi cu impersonate="chrome124" este ceea ce face diferența.

Vei mai dori și json (builtin), csv (builtin), time, random și logging pentru modelele de producție pe care le vom acoperi mai târziu.

Pas cu pas: extragerea paginilor de produs Walmart cu Python

Pasul 1: preia pagina de produs Walmart

Prima ta sarcină este să faci o cerere HTTP care să nu fie blocată imediat. Iată setul canonic de headere folosit în 2024–2026 de Scrapfly, Scrapingdog, Oxylabs și ScrapeOps:

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)

Parametrul impersonate="chrome124" face aici munca grea. Îi spune lui curl_cffi să potrivească exact TLS ClientHello, ordinea cadrelor HTTP/2 și secvența pseudo-headerelor din Chrome 124. Fără el, Akamai vede un hash JA3 specific Python și te blochează înainte ca cererea ta să ajungă la stratul aplicației Walmart.

Cum arată un răspuns blocat: dacă vezi "Robot or human?" în titlul HTML al răspunsului sau dacă răspunsul redirecționează către walmart.com/blocked, ai fost prins. Partea dificilă este că Walmart returnează adesea un cod de stare 200 cu body-ul CAPTCHA — deci verificarea response.ok singură nu este suficientă.

Pentru orice utilizare de producție sau repetată, vei avea nevoie de proxy-uri rezidențiale. IP-urile de datacenter sunt arse instantaneu de sistemul de reputație IP al Akamai. Voi acoperi strategia completă de tratare a erorilor și proxy-uri în secțiunea de producție de mai jos.

Pasul 2: parsează datele produsului din JSON-ul `__NEXT_DATA__`

Walmart.com este o aplicație Next.js, iar HTML-ul randat pe server încorporează întregul payload de hidratare într-un singur tag script: <script id="__NEXT_DATA__" type="application/json">. Acesta este filonul de aur.

Ghidul Scrapfly din 2026 confirmă: „În 2026, Walmart folosește Next.js cu JSON structurat în tag-urile script __NEXT_DATA__, ceea ce face extragerea datelor ascunse mai fiabilă decât parsingul clasic cu selectori CSS.” Orice scraper open-source de profil înalt pentru Walmart — Scrapfly, Oxylabs, python-scrapy-playbook — folosește această metodă.

Iată cum îl extragi:

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", {})

Cele mai multe tutoriale se opresc aici. Mai jos este o hartă completă a căilor JSON pentru câmpurile care contează cu adevărat — verificată pe pagini Walmart live din 2024–2026:

Câmp de date	Cale JSON (sub `initialData`)	Tip	Observații
Nume produs	`data > product > name`	String	—
Marcă	`data > product > brand`	String	—
Preț curent (număr)	`data > product > priceInfo > currentPrice > price`	Float	Poate diferi în funcție de cookie-ul magazinului
Preț curent (șir)	`data > product > priceInfo > currentPrice > priceString`	String	Formatat, de ex. "$9.99"
Descriere scurtă	`data > product > shortDescription`	Șir HTML	Parsează cu BeautifulSoup pentru text
Descriere lungă	`data > idml > longDescription`	Șir HTML	Se află pe `idml`, NU în `product` — aceasta este capcana pe care tutorialele mai vechi o prezintă greșit
Toate imaginile	`data > product > imageInfo > allImages`	Array	Listă de obiecte `{id, url}`
Evaluare medie	`data > product > averageRating`	Float	Cheia este `averageRating`, nu vechiul `rating`
Număr de recenzii	`data > product > numberOfReviews`	Integer	—
Variante	`data > product > variantCriteria`	Array	Grupuri de opțiuni (mărime, culoare)
Disponibilitate	`data > product > availabilityStatus`	String	`IN_STOCK`, `OUT_OF_STOCK`, `LIMITED_STOCK`
Vânzător	`data > product > sellerDisplayName`	String	—
Producător	`data > product > manufacturerName`	String	—

Calea longDescription este singura capcană care îi prinde pe oameni. Un articol ScrapeHero din 2023 o plasa la product.longDescription, dar sursele din 2024+ o pun consecvent pe cheia soră idml. Citește întotdeauna mai întâi idml.longDescription și revino la product.longDescription pentru paginile mai vechi.

Iată modelul sigur de extracție folosind lanțuri .get():

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"),
    }

Pentru utilizatorii care nu vor să se ocupe deloc de navigarea căilor JSON, AI-ul Thunderbit identifică și structurează automat aceste câmpuri — fără mapare manuală a căilor. Apeși „AI Suggest Fields”, citește pagina și primești un tabel. Dar dacă construiești un pipeline personalizat, harta de mai sus este referința ta.

Pasul 3: interceptează endpoint-urile API interne ale Walmart pentru date mai bogate

Niciun articol concurent nu acoperă corect această metodă. Este cea mai puternică cale de extragere — și cea mai complicată.

Front-endul Walmart apelează un backend GraphQL federat construit pe Apollo Gateway. Endpoint-urile se află sub www.walmart.com/orchestra/*:

/orchestra/pdp/graphql/... — hidratarea detaliilor produsului + schimbarea variantelor
/orchestra/snb/graphql/... — paginare search-n-browse
/orchestra/reviews/graphql/... — recenzii paginate

Acestea returnează JSON curat, structurat, cu date pe care __NEXT_DATA__ uneori le trunchiază — prețuri la nivel de variantă, număr de stoc în timp real, paginare completă a recenziilor.

Capcana despre care blogurile ocolesc adevărul: Walmart folosește persisted queries Apollo. Body-ul cererii trimite doar un hash SHA-256 (persistedQuery.sha256Hash), nu textul query-ului. Dacă hash-ul este necunoscut serverului, primești PersistedQueryNotFound. Walmart rotește aceste hash-uri la deploy. De aceea niciun scraper open-source Walmart de profil înalt nu publică cod /orchestra/ gata de copiat și lipit.

Varianta practică și sinceră a acestei metode este un exercițiu în DevTools:

Deschide o pagină de produs Walmart în Chrome
Deschide DevTools → tabul Network, filtrează după „Fetch/XHR”
Navighează pagina normal — apasă pe variante, derulează până la recenzii, schimbă locația magazinului
Urmărește cererile către endpoint-urile /orchestra/* care returnează JSON cu date despre produs
Click dreapta pe cerere → „Copy as cURL”
Convertește comanda cURL în Python folosind curl_cffi

Iată cum arată un apel API reluat:

import json
from curl_cffi import requests

session = requests.Session(impersonate="chrome124")

# Mai întâi, încălzește sesiunea vizitând pagina produsului
session.get("https://www.walmart.com/ip/some-product/1234567", headers=HEADERS)

# Apoi redă apelul API intern (copiat din 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 = {
    # Lipește exact body-ul cererii din 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()

Pasul de încălzire a sesiunii este critic. Cookie-urile PerimeterX ale Walmart (_px3, _pxhd, ACID) trebuie setate de prima cerere HTML înainte ca apelul API să poată reuși. Fără ele, vei primi un 412 sau 403.

Când să folosești această metodă: când ai nevoie de date pe care __NEXT_DATA__ nu le include — prețuri profunde pe variantă, recenzii paginate după primul lot sau număr de stoc în timp real. Pentru majoritatea cazurilor, __NEXT_DATA__ este suficient și mult mai simplu.

Extragerea rezultatelor de căutare Walmart și a mai multor pagini

Rezultatele de căutare urmează un model __NEXT_DATA__ similar, dar cu o cale JSON diferită:

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"]

# Filtrează produsele sponsorizate
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"))

Paginarea funcționează prin incrementarea parametrului page: &page=1, &page=2 etc. Dar există o limită neredocumentată: Walmart limitează rezultatele de căutare la 25 de pagini, indiferent de numărul total real. Scrapfly confirmă: „Walmart stabilește numărul maxim de pagini de rezultate accesibile la 25, indiferent de numărul total de pagini disponibile.”

Soluții ocolitoare pentru acoperire mai profundă:

Schimbarea ordinii de sortare: rulează aceeași interogare cu &sort=price_low și apoi cu &sort=price_high pentru a obține o acoperire de ~50 de pagini
Segmentarea pe intervale de preț: adaugă &min_price=X&max_price=Y pentru a împărți catalogul în ferestre mai mici
Segmentarea pe categorie: caută în categorii specifice, nu la nivelul întregului site

Observă că itemStacks este un array. Scrapfly hardcodează [0] în repo-ul lor, dar paginile de categorie și browse conțin uneori mai multe stive („Top picks”, „More results”). Modelul robust iterează prin toate stivele:

for stack in search_result.get("itemStacks", []):
    for item in stack.get("items", []):
        if item.get("__typename") == "Product":
            # procesează item-ul
            pass

Merită menționat și faptul că robots.txt al Walmart interzice /search. Paginile de detaliu produs (/ip/...) și majoritatea paginilor de categorie (/cp/...) nu sunt interzise. Dacă te preocupă conformitatea, începe cu paginile de produs și arborii de categorii, nu cu search-ul.

Nu lăsa blocările tăcute să-ți strice datele: tratarea erorilor la nivel de producție

Majoritatea tutorialelor se rup aici. Îți arată cum să preiei o pagină, să parsezi un produs și gata. În producție, preiei mii de pagini, iar Walmart încearcă activ să te oprească. Diferența dintre un scraper demonstrativ și unul care chiar funcționează este modul în care gestionează eșecul.

Detectează blocările tăcute înainte să-ți corupă datele

Cea mai importantă funcție într-un scraper Walmart este detectorul de blocare. Pe baza consensului dintre ScrapingBee, Scrapingdog, Oxylabs și Decodo, ai nevoie de patru verificări independente:

BLOCK_MARKERS = (
    "Robot or human",
    "Press &amp; Hold",
    "Press & Hold",
    "px-captcha",
    "perimeterx",
)

def is_walmart_blocked(response) -> bool:
    # 1. Redirecționare către endpoint-ul dedicat de blocare
    if "/blocked" in str(response.url):
        return True
    # 2. Coduri de stare dure
    if response.status_code in (403, 412, 428, 429, 503):
        return True
    # 3. 200 OK cu body CAPTCHA (cazul de blocare tăcută)
    body = response.text or ""
    if any(m.lower() in body.lower() for m in BLOCK_MARKERS):
        return True
    # 4. Sensul lungimii răspunsului — PDP-urile reale au 300–900 KB
    if len(response.content) < 50_000 and "/ip/" in str(response.url):
        return True
    return False

Această a patra verificare — lungimea răspunsului — prinde cazurile în care Walmart returnează o pagină simplificată care nu conține markeri CAPTCHA evidenți, dar nici datele despre produs de care ai nevoie.

Logică de retry cu backoff exponențial și jitter

Când o cerere eșuează, nu vrei să lovești imediat din nou Walmart. Modelul standard folosește backoff exponențial cu jitter pentru a desincroniza reîncercările:

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("A fost detectată o blocare tăcută")

            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"Încercarea {attempt + 1} a eșuat: {e}. Reîncerc în {wait:.1f}s")
            time.sleep(wait)

    return None

Jitter-ul (random.uniform(0, 3)) nu este doar estetic — desincronizează workerii, astfel încât o flotă de scrapers să nu reîncerce simultan în aceeași secundă și să declanșeze detectoarele de viteză ale Akamai.

Limitarea ratei

Atât Thunderbit, cât și Scrape.do converg către o întârziere randomizată de 3–6 secunde per cerere pentru Walmart: „limitează-ți cererile așteptând 3–6 secunde între încărcările de pagină și randomizează întârzierile.”

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

La scară mare, ia în calcul aiolimiter pentru limitare async a ratei:

from aiolimiter import AsyncLimiter
limiter = AsyncLimiter(max_rate=10, time_period=60)  # 10 cereri pe minut

Validarea datelor

Chiar și atunci când răspunsul nu este blocat, datele parse-uite pot fi greșite (magazin greșit, payload degradat). Validează înainte de a scrie în output:

def validate_product(product):
    """Returnează True dacă datele produsului par legitime."""
    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

Logarea sesiunii

Urmărește rata de succes pe sesiune. Când scade sub 80% timp de 10 minute, ceva s-a schimbat — fie IP-ul tău a fost ars, cookie-urile au expirat, fie Walmart a implementat o regulă nouă anti-bot.

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"Rata de succes a scăzut la {self.success_rate:.1f}% — ia în calcul rotația proxy-urilor sau o pauză")

Nu e spectaculos. Dar asta îți păstrează datele curate.

Python făcut de la zero vs. API de scraping vs. no-code: cum alegi abordarea potrivită pentru Walmart

Mulți dezvoltatori sar direct la scrierea unui scraper personalizat fără să se întrebe dacă asta este într-adevăr alegerea corectă. ScrapeOps acordă Walmart nota 9/10 la dificultate. Utilizatorii de forum îl descriu ca fiind „practic 9/10” și se întreabă „dacă un API dedicat de web scraping nu ar fi prea mult”. Răspunsul depinde de volum, buget și capacitatea de inginerie.

Factor	Python DIY (requests + proxy-uri)	API de scraping (Oxylabs, Bright Data etc.)	Instrument no-code (Thunderbit)
Timp de configurare până la primul rând	Ore	15–60 min	~2 min
Timp de configurare până la producție	40–80 ore	4–16 ore	~30 min
Gestionarea anti-bot	O gestionezi tu (greu)	Gestionată de furnizor	Gestionată automat
Cost la scară mică (<1K pagini/lună)	Redus (proxy-urile costă ~$4–8/GB)	Tiers de pornire de $40–$49/lună	Gratuit–$15/lună
Cost la scară mare (100K+ pagini/lună)	Cost mai mic per cerere	Cost mai mare per cerere	Variabil
Personalizare	Control total	Parametri API	Limitat de UI/câmpuri
Mentenanță continuă	4–8 ore/lună	Aproape zero	Niciuna (AI se adaptează)
Cel mai bun pentru	Dezvoltatori care construiesc pipeline-uri personalizate	Scraping de producție la scară medie	Utilizatori business, extrageri rapide, punctuale

Când are sens Python DIY

DIY câștigă atunci când ai deja un contract de proxy, ai nevoie de control strict asupra headerelor, țintirii după cod poștal sau cohortelor de vânzători, indexezi milioane de pagini pe lună unde taxele API per înregistrare se acumulează sau ai nevoie de garanții on-prem ori de conformitate. Compromisul este timpul real de inginerie: un spider Scrapy pregătit pentru producție, cu paginare, retry-uri, rotație de proxy-uri, impersonare TLS și mai multe scheme de tipuri de pagini, ia 40–80 de ore de muncă Python la nivel senior, plus 4–8 ore pe lună mentenanță pe măsură ce Walmart rotește fingerprint-urile.

Când un API de scraping îți economisește timp

API-urile de scraping gestionează stratul anti-bot, ca să nu fii nevoit tu. Benchmark-urile ScrapeOps arată rate de succes de 99% pentru Zyte API și 98% pentru Scrape.do pe Walmart. Prețurile din tier-ul de intrare pornesc de la 40–49 $/lună pentru instrumente precum ScraperAPI, Oxylabs și Scrapingdog. Dacă ai o echipă de 2–5 ingineri și volumul tău de scraping este între 10K și 1M de pagini pe lună, un API este aproape întotdeauna alegerea potrivită. Schimbi costul per cerere cu mentenanță zero.

Când no-code este alegerea corectă

Thunderbit se potrivește unui profil complet diferit. Dacă ești PM, analist sau operator e-commerce și ai nevoie de date despre produsele Walmart într-un spreadsheet în după-amiaza asta — nu în următorul sprint — un instrument no-code este răspunsul onest.

Fluxul de lucru: instalezi extensia Chrome Thunderbit, deschizi o pagină de produs sau de căutare Walmart, dai click pe „AI Suggest Fields”, iar AI-ul Thunderbit citește pagina și sugerează coloane (nume produs, preț, evaluare etc.). Dai click pe „Scrape”, iar datele se populează într-un tabel. Export în Excel, Google Sheets, Airtable sau Notion — toate gratuit, fără paywall.

Thunderbit gestionează anti-bot în cloud, astfel încât nu te ocupi de CAPTCHA, proxy-uri sau TLS fingerprinting. AI-ul se adaptează automat la schimbările de layout, deci nu există mentenanță. Pentru utilizatorii care nu vor să se ocupe deloc de navigarea căilor JSON, aceasta este calea cu cea mai mică rezistență.

Limitări oneste: Thunderbit nu este construit pentru 100K+ pagini pe zi. Bugetele de credite și limitele cloud fac ingestia la volum mare neeconomicoasă comparativ cu API-urile brute. De asemenea, nu poți fixa un cod poștal sau un ASN specific decât dacă instrumentul permite asta. Pentru pipeline-uri continue, de volum mare, DIY sau un API de scraping rămâne soluția potrivită.

Estimare rapidă de preț: 1.000 de rânduri de produse Walmart pe Thunderbit costă aproximativ 2.000 de credite (~0,60–1,10 $ pe planurile Starter/Pro). Asta este comparabil cu API-ul Walmart de la Oxylabs și mai ieftin decât majoritatea API-urilor de scraping pentru hobby, la volum mic. Verifică prețurile Thunderbit pentru detalii actuale.

Extrage date despre produsele Walmart cu AI Get Started Free

Exportarea datelor Walmart extrase

După ce ai datele, ai nevoie să le pui undeva util. Trei formate acoperă majoritatea nevoilor:

CSV — formatul cel mai comun, pe care chiar îl deschid analiștii:

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})

Folosește codarea utf-8-sig pentru compatibilitate cu Excel. Marcajul BOM împiedică Excel să strice caracterele speciale.

JSONL — formatul de producție pentru pipeline-uri de scraping:

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 este sigur la crash (o scriere întreruptă pierde doar ultima linie), poate fi transmis în flux cu memorie constantă și păstrează intacte datele imbricate, precum variantele și recenziile.

Excel — pentru predări punctuale către analiști:

from openpyxl import Workbook

def export_excel(products, filename="walmart_products.xlsx"):
    wb = Workbook(write_only=True)
    ws = wb.create_sheet("Products")
    ws.append(["Nume", "Preț", "Disponibilitate", "Evaluare", "Recenzii", "Vânzător"])
    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 acoperă povestea exportului și pentru utilizatorii care nu scriu Python: export cu un click în Google Sheets, Airtable, Notion, Excel, CSV și JSON — totul gratuit în planul de bază. Pentru monitorizare continuă, funcția de scheduled scraper a Thunderbit poate rula automat extracții recurente.

O precizare despre programare: nu folosi GitHub Actions pentru scraping Walmart. Runner-ele GitHub Actions se află pe intervale IP Azure pe care anti-bot-ul Walmart le blochează instant. Folosește APScheduler pe un VPS sau rutează tot traficul prin proxy-uri rezidențiale.

Ghid legal și etic pentru scraping Walmart

Utilizatorii de forum spun explicit asta: „Nu mă deranjează să mă joc de-a șoarecele și pisica cu dezvoltatorii, dar mă tem să mă joc cu echipa lor juridică.”

Termenii de utilizare Walmart interzic explicit folosirea „oricărui robot, spider… sau alt dispozitiv manual ori automat pentru a prelua, indexa, ‘scrape’, ‘data mine’ sau a colecta în alt mod orice materiale” fără „consimțământ scris expres prealabil”.

robots.txt al Walmart interzice /search, /account, /api/ și zeci de endpoint-uri interne. Paginile de detaliu produs (/ip/...) și recenziile (/reviews/product/) nu sunt interzise.

Precedentul hiQ v. LinkedIn (al 9-lea Circuit, 2022) a stabilit că extragerea datelor public disponibile este puțin probabil să încalce CFAA federal. Dar același complet a decis ulterior că hiQ a încălcat User Agreement-ul LinkedIn și a emis împotriva sa un consimțământ judiciar de 500.000 de dolari. Decizii mai recente din 2024 (Meta v. Bright Data, X Corp. v. Bright Data) au restrâns și mai mult CFAA și au creat apărări legate de preempțiunea copyright-ului, dar acele hotărâri s-au bazat pe formulări specifice ale ToU care nu se aplică limpede la Walmart.

Ghid practic: nu supraîncărca serverele. Respectă rate limit-urile. Nu extrage date personale sau ale utilizatorilor. Folosește datele responsabil. Scraping-ul paginilor publice de produse Walmart la o rată modestă, pentru cercetare personală, are un profil de risc foarte diferit față de scraping-ul la scară comercială, împotriva Termenilor Walmart. Dacă construiești un produs pe baza datelor Walmart, vorbește cu un avocat și ia în calcul API-urile oficiale affiliate și seller.

Declinarea responsabilității: aceste informații au scop educațional, nu reprezintă consultanță juridică.

Concluzie și concluzii-cheie

Scraping-ul Walmart cu Python este o provocare de dificultate 9/10 datorită stivei sale anti-bot duale Akamai + PerimeterX. Nu este imposibil — dar ai nevoie de instrumentele și modelele potrivite.

Concluzii-cheie:

Extragerea JSON __NEXT_DATA__ este alegerea pragmatică pentru majoritatea cazurilor. Este metoda folosită de orice scraper serios open-source pentru Walmart din 2024–2026. Calea de bază este props.pageProps.initialData.data.product pentru PDP-uri și searchResult.itemStacks pentru search/browse.
curl_cffi cu impersonate="chrome124" este obligatoriu. requests sau httpx simple nu pot trece de TLS fingerprinting-ul Akamai, indiferent de headere.
Blocările tăcute sunt adevăratul pericol. Walmart returnează 200 OK cu body-uri CAPTCHA. Verifică conținutul răspunsului, nu doar codurile de stare.
Scraperele de producție au nevoie de mai mult decât codul happy-path. Backoff exponențial cu jitter, detectarea blocării pe patru semnale, limitarea ratei la 3–6 secunde per cerere, validarea datelor și monitorizarea sănătății sesiunii sunt esențiale.
Interceptarea API-ului intern prin /orchestra/* este puternică, dar fragilă. Folosește-o ca exercițiu DevTools pentru nevoi specifice de date, nu ca metodă principală de extragere.
Walmart plafonează rezultatele de căutare la 25 de pagini. Mărește acoperirea prin schimbarea ordinii de sortare și segmentarea pe intervale de preț.
Alege onest abordarea: Python DIY pentru dezvoltatori cu nevoi personalizate și volum mare. API-uri de scraping pentru echipe la scară medie care nu au un inginer de scraping. Thunderbit pentru utilizatori business care vor date în Google Sheets în după-amiaza asta.

Dacă vrei să încerci varianta no-code, extensia Chrome Thunderbit are un plan gratuit — poți extrage câteva pagini Walmart și să vezi singur rezultatele. Dacă mergi pe varianta Python, modelele de cod din acest articol sunt testate în producție. Oricum ar fi, acum ai o hartă a apărării Walmart și trei căi prin ea.

Pentru mai multe despre tehnici de web scraping, vezi ghidurile noastre despre cum să faci web scraping cu Python, cele mai bune instrumente automate de web scraping și web scraping fără să fii blocat. Poți urmări și tutoriale pe canalul Thunderbit de YouTube.

Întrebări frecvente

Este legal să extragi date despre produsele Walmart?

Termenii de utilizare Walmart interzic scraping-ul automat fără consimțământ scris. Hotărârea hiQ v. LinkedIn a celui de-al 9-lea Circuit (2022) a stabilit că CFAA federal este puțin probabil să se aplice la scraping-ul paginilor publice, dar același caz s-a încheiat cu o hotărâre de 500.000 de dolari pentru încălcarea contractului împotriva scraperului. Extragerea paginilor publice de produse la rate modeste, pentru cercetare personală, are un profil de risc foarte diferit față de extragerea la scară comercială. Consultă un avocat dacă vrei să construiești o afacere pe date Walmart.

De ce scraperul meu Walmart este blocat în continuare?

Cele mai comune cauze sunt: folosirea simplă a requests sau httpx (care emit un TLS fingerprint specific Python pe care Akamai îl marchează imediat), headere lipsă sau greșite, fără rotație de proxy-uri, rate de cereri mai rapide de 3–6 secunde per pagină și cookie-uri de sesiune lipsă (_px3, _abck, locDataV3). Treci la curl_cffi cu impersonate="chrome124", folosește proxy-uri rezidențiale și implementează modelele de detectare a blocării și retry descrise în acest articol.

Ce date pot extrage din Walmart cu Python?

Nume de produse, prețuri (curent și rollback), imagini, descrieri scurte și lungi, evaluări, număr de recenzii, disponibilitate în stoc, numele vânzătorilor, informații despre producător, opțiuni de variantă (mărime, culoare) și plasarea în categorie. Folosind metoda __NEXT_DATA__, toate acestea sunt disponibile ca JSON structurat. Interceptarea API-ului intern poate returna suplimentar prețuri la nivel de variantă, numărul de stoc în timp real și date de recenzii paginate.

Am nevoie de proxy-uri pentru a extrage date din Walmart?

Da, pentru orice utilizare de producție sau repetată. Sistemele anti-bot ale Walmart blochează constant cererile simple — chiar și cu headere perfecte, un IP non-rezidențial va fi marcat de sistemul de reputație IP al Akamai. Sunt necesare proxy-uri rezidențiale sau mobile. IP-urile de datacenter sunt arse aproape imediat. Calculează aproximativ 3–17 $ per 1.000 de pagini, în funcție de furnizorul și nivelul proxy-urilor.

Pot extrage date din Walmart fără să scriu cod?

Da. Thunderbit este o extensie Chrome bazată pe AI care extrage Walmart în doi pași: „AI Suggest Fields” pentru a detecta automat coloanele de date ale produselor, apoi „Scrape” pentru a extrage datele. Gestionează provocările anti-bot în cloud și exportă direct în Excel, Google Sheets, Airtable sau Notion — gratuit. Este cel mai potrivit pentru analiști, PM-uri și utilizatori business care au nevoie rapid de date, fără a construi un pipeline personalizat. Pentru scraping de volum mare sau foarte personalizat, Python sau un API de scraping rămân soluția mai bună.

Încearcă Thunderbit pentru scraping AI Walmart Get Started Free

Află mai multe

Cum să extragi date din Walmart cu Python în 2026 (și să nu fii blocat)