Comment extraire des données Walmart avec Python (sans se faire bloquer)

Walmart modifie le prix de certains articles . Si vous avez déjà essayé de suivre ça par programme, vous savez à quel point c’est galère : votre script tourne 20 minutes, puis se met en douce à renvoyer des pages CAPTCHA déguisées en réponses normales 200 OK.

J’ai passé pas mal de temps à contourner les protections anti-bot de Walmart dans le cadre de nos travaux d’extraction de données chez , et je veux partager tout ce que j’ai appris : les méthodes qui marchent vraiment en 2025, les échecs silencieux qui polluent vos données, et les vrais arbitrages entre écrire votre propre scraper, payer une API de scraping ou simplement utiliser un outil no-code. Ce guide couvre trois méthodes d’extraction (analyse HTML, JSON __NEXT_DATA__ et interception des API internes), la gestion d’erreurs prête pour la prod que la plupart des tutos zappent complètement, ainsi qu’un cadre de décision transparent pour choisir la bonne approche. Que vous codiez en Python ou que vous vouliez juste un tableur rempli de prix avant midi, vous trouverez ici ce qu’il vous faut.

Pourquoi extraire Walmart avec Python ?

Walmart est le plus grand distributeur mondial en chiffre d’affaires — pour l’exercice 2025 — et occupe la . Le site héberge environ , et le directeur financier de Walmart parle de sur la marketplace. Environ , ce qui rend le catalogue ultra mouvant : les vendeurs changent, les variantes évoluent et les stocks bougent tous les jours.

C’est justement pour cette volatilité que le scraping est utile. Un rapport trimestriel ne peut pas montrer ce qu’une extraction quotidienne révèle. Voici les cas d’usage les plus fréquents que je vois :

Le marché des logiciels de suivi des prix des concurrents à lui seul a atteint et devrait grimper à 5,09 milliards d’ici 2033. Le comportement des consommateurs alimente cette dépense : , et 83 % comparent plusieurs sites.

Python est le langage par défaut pour ce genre de boulot. Le rapport Infrastructure 2026 d’Apify estime que , et la bibliothèque centrale (requests) cumule . Si vous faites du scraping à une certaine échelle, il y a de fortes chances que vous le fassiez en Python.

Pourquoi Walmart est l’un des sites les plus difficiles à scraper

Walmart est particulièrement coriace parce qu’il utilise deux produits anti-bot commerciaux en série : comme couche WAF en périphérie et de fingerprinting TLS, puis comme couche de défi JavaScript comportemental. Scrape.do décrit cette combinaison comme « rare et extrêmement difficile à contourner ».

, et Akamai seul obtient aussi 9/10. D’après mon expérience, c’est plutôt juste.

Voilà ce à quoi vous vous heurtez vraiment :

Akamai Bot Manager inspecte votre empreinte TLS (hash JA3/JA4), l’ordre des frames HTTP/2, l’ordre et la casse des en-têtes, ainsi que les cookies de session (_abck, ak_bmsc). Un appel Python requests standard émet une empreinte TLS qu’aucun vrai navigateur ne produit — Akamai le repère avant même que votre requête n’atteigne les serveurs de Walmart.

PerimeterX/HUMAN prend ensuite le relais, en lançant un fingerprinting JavaScript (px.js) qui vérifie les propriétés de navigator, le rendu canvas, WebGL, le contexte audio et des signaux comportementaux (déplacement de la souris, vitesse de défilement, dynamique de frappe). L’échec visible est l’infâme challenge : un bouton que vous devez maintenir environ 10 secondes pendant que les signaux comportementaux sont analysés. Oxylabs est très direct : « Walmart utilise le modèle CAPTCHA “Press & Hold”, fourni par PerimeterX, qui est pratiquement impossible à résoudre depuis votre code. »

Le vrai piège, c’est le blocage silencieux. Walmart renvoie HTTP 200 avec un corps CAPTCHA au lieu d’un 403. : « Walmart renvoie un code 200 OK même lorsqu’il affiche une page CAPTCHA. On ne peut pas se fier uniquement au code de statut pour savoir si la requête a réussi. » Votre script analyse tranquillement le HTML du CAPTCHA comme si le produit n’existait pas, puis continue. Résultat : la moitié de votre dataset devient inutilisable sans que vous le sachiez.

Il y a aussi le problème des données dépendantes du magasin. Les prix et les stocks Walmart varient selon la localisation, via des cookies comme locDataV3 et assortmentStoreId. Sans les bons cookies, vous récupérez des données « nationales par défaut » qui peuvent sembler complètes mais ne correspondent pas à ce que voient les vrais clients. Les cookies manquants ne provoquent pas forcément une page bloquée — ils peuvent produire des données fausses sans échec visible, ce qui est pire.

Trois méthodes pour extraire des données de Walmart (et comment elles se comparent)

Avant de passer au pas-à-pas, voici les trois approches principales d’extraction. La plupart des articles concurrents n’en couvrent qu’une ou deux. Ici, je détaille les trois pour que vous puissiez choisir celle qui colle à votre besoin.

L’analyse HTML est la pire option pour Walmart : le site utilise des bundles Next.js avec des classes CSS hachées qui changent à chaque déploiement. La méthode JSON __NEXT_DATA__ est le choix pragmatique adopté par tous les scrapers Walmart open source sérieux de 2024 à 2026. L’interception des API internes est la plus puissante, mais elle traîne aussi des pièges que la plupart des tutos passent sous silence. Et Thunderbit est la bonne solution si vous n’avez pas besoin d’un pipeline sur mesure.

Préparer votre environnement Python pour scraper Walmart

Voici ce qu’il vous faut :

• Difficulté : Intermédiaire
• Temps nécessaire : environ 30 minutes pour l’installation, puis le temps de codage
• Prérequis : Python 3.10+, pip, un éditeur de code et, pour un usage en production, un service de proxy ou une API de scraping

Créez votre dossier projet et votre environnement virtuel :

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

Installez les bibliothèques requises :

1pip install curl_cffi parsel beautifulsoup4 lxml

curl_cffi est la référence de 2025 pour les cibles difficiles. C’est un binding libcurl capable d’imiter exactement les empreintes TLS des navigateurs. : « Walmart utilise le fingerprinting TLS dans sa détection de bots, et le simple fait de définir le User-Agent pour simuler un vrai navigateur ne suffira pas à le contourner. » requests ou httpx classiques ne peuvent pas passer Akamai, quels que soient les en-têtes que vous définissez. Avec curl_cffi et impersonate="chrome124", la différence est réelle.

Vous voudrez aussi json (intégré), csv (intégré), time, random et logging pour les patterns de production qu’on verra plus loin.

Étape par étape : extraire des pages produit Walmart avec Python

Étape 1 : récupérer la page produit Walmart

Votre première tâche consiste à faire une requête HTTP qui ne soit pas bloquée directement. Voici l’ensemble d’en-têtes canonique utilisé par Scrapfly, Scrapingdog, Oxylabs et ScrapeOps entre 2024 et 2026 :

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

Le paramètre impersonate="chrome124" fait ici tout le gros du travail. Il indique à curl_cffi de reproduire exactement le ClientHello TLS, l’ordre des frames HTTP/2 et la séquence des pseudo-en-têtes de Chrome 124. Sans ça, Akamai voit une empreinte JA3 propre à Python et vous bloque avant même que votre requête n’atteigne la couche applicative de Walmart.

À quoi ressemble une réponse bloquée : si vous voyez "Robot or human?" dans le titre HTML de la réponse, ou si la réponse redirige vers walmart.com/blocked, vous avez été détecté. Le piège, c’est que Walmart renvoie souvent un code 200 avec le corps CAPTCHA — il ne suffit donc pas de vérifier response.ok.

Pour tout usage répété ou en production, il vous faudra des proxies résidentiels. Les IP de datacenter sont grillées presque tout de suite par le système de réputation IP d’Akamai. Je détaillerai la stratégie complète de gestion d’erreurs et de proxy dans la section production ci-dessous.

Étape 2 : analyser les données produit depuis le JSON __NEXT_DATA__

Walmart.com est une application Next.js, et le HTML rendu côté serveur embarque tout le payload d’hydratation dans une seule balise script : <script id="__NEXT_DATA__" type="application/json">. C’est la mine d’or.

: « En 2026, Walmart utilise Next.js avec des données JSON structurées dans les balises script __NEXT_DATA__, ce qui rend l’extraction de données cachées plus fiable que l’analyse CSS traditionnelle. » Tous les scrapers Walmart open source les plus connus — , , — utilisent cette méthode.

Voici comment l’extraire :

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

La plupart des tutos s’arrêtent là. Voici une cartographie complète des chemins JSON pour les champs qui comptent vraiment — vérifiée sur des pages Walmart réelles entre 2024 et 2026 :

Le chemin longDescription est le piège qui fait tomber pas mal de monde. Un article de ScrapeHero de 2023 le plaçait sous product.longDescription, mais les sources de 2024 et après l’associent systématiquement à la clé sœur idml. Lisez toujours d’abord idml.longDescription, puis retombez sur product.longDescription pour les vieilles pages.

Voici un modèle d’extraction propre avec des chaînes .get() :

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

Pour les utilisateurs qui ne veulent pas gérer la navigation JSON à la main, l’ identifie et structure automatiquement ces champs — sans qu’il faille mapper les chemins soi-même. Vous cliquez sur « AI Suggest Fields », la page est lue, puis vous obtenez un tableau. Mais si vous montez un pipeline personnalisé, la cartographie ci-dessus reste votre référence.

Étape 3 : intercepter les points de terminaison d’API internes de Walmart pour des données plus riches

Aucun article concurrent n’explique correctement cette méthode. C’est la voie d’extraction la plus puissante — et la plus délicate.

Le front-end de Walmart appelle un . Les points de terminaison sont sous www.walmart.com/orchestra/* :

• /orchestra/pdp/graphql/... — hydratation de la fiche produit + changements de variantes
• /orchestra/snb/graphql/... — pagination de recherche et navigation
• /orchestra/reviews/graphql/... — avis paginés

Ils renvoient un JSON propre et structuré avec des données que __NEXT_DATA__ tronque parfois : prix par variante, stocks en temps réel, pagination complète des avis.

Le piège que les articles de blog évoquent à moitié : Walmart utilise . Le corps de la requête n’envoie qu’un hash SHA-256 (persistedQuery.sha256Hash), pas le texte de la requête. Si le hash n’est pas connu du serveur, vous obtenez PersistedQueryNotFound. Walmart fait tourner ces hashes à chaque déploiement. C’est pour ça qu’aucun scraper Walmart open source très connu n’expose un code /orchestra/ prêt à copier-coller.

La version pratique et honnête de cette méthode ressemble à un exercice DevTools :

1. Ouvrez une page produit Walmart dans Chrome
2. Ouvrez DevTools → onglet Network, filtrez par « Fetch/XHR »
3. Naviguez normalement — cliquez sur les variantes, faites défiler les avis, changez le magasin
4. Repérez les requêtes vers les endpoints /orchestra/* qui renvoient du JSON avec les données produit
5. Faites un clic droit sur la requête → « Copy as cURL »
6. Convertissez la commande cURL en Python avec curl_cffi

Voici à quoi ressemble un appel API rejoué :

1import json
2from curl_cffi import requests
3session = requests.Session(impersonate="chrome124")
4# D’abord, réchauffez la session en visitant la page produit
5session.get("https://www.walmart.com/ip/some-product/1234567", headers=HEADERS)
6# Puis rejouez l’appel API interne (copié depuis DevTools)
7api_url = "https://www.walmart.com/orchestra/pdp/graphql"
8api_headers = {
9    **HEADERS,
10    "accept": "application/json",
11    "content-type": "application/json",
12    "referer": "https://www.walmart.com/ip/some-product/1234567",
13    "wm_qos.correlation_id": "your-copied-correlation-id",
14}
15payload = {
16    # Collez le corps exact de la requête depuis DevTools
17    "variables": {"productId": "1234567"},
18    "extensions": {
19        "persistedQuery": {
20            "version": 1,
21            "sha256Hash": "the-hash-you-copied"
22        }
23    }
24}
25api_response = session.post(api_url, headers=api_headers, json=payload)
26api_data = api_response.json()

L’étape de réchauffement de la session est cruciale. Les cookies PerimeterX de Walmart (_px3, _pxhd, ACID) doivent être posés par la première récupération HTML avant que l’appel API puisse marcher. Sans eux, vous aurez un 412 ou un 403.

Quand utiliser cette méthode : quand vous avez besoin de données que __NEXT_DATA__ n’inclut pas — prix détaillés par variante, avis paginés au-delà du premier lot, ou stocks en temps réel. Pour la plupart des cas d’usage, __NEXT_DATA__ suffit largement et reste bien plus simple.

Extraire les résultats de recherche Walmart et plusieurs pages

Les résultats de recherche suivent un schéma __NEXT_DATA__ similaire, mais avec un chemin JSON différent :

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

La pagination fonctionne en incrémentant le paramètre page : &page=1, &page=2, etc. Mais voici la limite non documentée : Walmart limite les résultats de recherche à 25 pages, quel que soit le nombre total réel de pages. : « Walmart fixe le nombre maximum de pages de résultats accessibles à 25, quel que soit le nombre total de pages disponibles. »

Contournements pour couvrir davantage :

• Inversion de l’ordre de tri : lancez la même requête avec &sort=price_low, puis &sort=price_high pour obtenir environ 50 pages de couverture
• Découpage par tranche de prix : ajoutez &min_price=X&max_price=Y pour fragmenter le catalogue en fenêtres plus petites
• Découpage par catégorie : cherchez dans des catégories précises plutôt qu’à l’échelle du site

Notez que itemStacks est un tableau. Scrapfly hardcode [0] dans son dépôt, mais les pages de catégories et de navigation contiennent parfois plusieurs piles (« Top picks », « More results »). Le pattern robuste consiste à parcourir toutes les piles :

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

À noter aussi : le fichier robots.txt de Walmart . Les pages produit (/ip/...) et la plupart des pages de catégories (/cp/...) ne sont pas interdites. Si la conformité vous préoccupe, commencez par les pages produit et les arborescences de catégories plutôt que par la recherche.

Ne laissez pas les blocages silencieux ruiner vos données : gestion d’erreurs prête pour la prod

La plupart des tutos s’effondrent ici. Ils montrent comment récupérer une page, parser un produit et s’arrêter là. En prod, vous récupérez des milliers de pages, et Walmart essaie activement de vous arrêter. La différence entre un scraper de démo et un scraper vraiment fiable, c’est la façon dont il gère l’échec.

Détecter les blocages silencieux avant qu’ils ne corrompent vos données

La fonction la plus importante d’un scraper Walmart, c’est le détecteur de blocage. D’après le consensus des fournisseurs, notamment , , et , il vous faut quatre vérifications indépendantes :

1BLOCK_MARKERS = (
2    "Robot or human",
3    "Press & Hold",
4    "Press & Hold",
5    "px-captcha",
6    "perimeterx",
7)
8def is_walmart_blocked(response) -> bool:
9    # 1. Redirection vers le point de terminaison de blocage dédié
10    if "/blocked" in str(response.url):
11        return True
12    # 2. Codes de statut explicites
13    if response.status_code in (403, 412, 428, 429, 503):
14        return True
15    # 3. 200 OK avec un corps CAPTCHA (cas du blocage silencieux)
16    body = response.text or ""
17    if any(m.lower() in body.lower() for m in BLOCK_MARKERS):
18        return True
19    # 4. Vérification de la taille de réponse — les vraies PDP font 300 à 900 Ko
20    if len(response.content) < 50_000 and "/ip/" in str(response.url):
21        return True
22    return False

Cette quatrième vérification — la taille de la réponse — attrape les cas où Walmart renvoie une page allégée, sans marqueur CAPTCHA évident, mais sans les données produit dont vous avez besoin non plus.

Logique de retry avec backoff exponentiel et jitter

Quand une requête échoue, vous ne voulez pas marteler Walmart tout de suite. Le pattern standard utilise un backoff exponentiel avec jitter pour décaler les retries :

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

Le jitter (random.uniform(0, 3)) n’est pas juste cosmétique : il désynchronise les workers pour qu’une flotte de scrapers ne retente pas tous en même temps et ne déclenche pas les détecteurs de vélocité d’Akamai.

Limitation du débit

Tant que convergent vers un délai aléatoire de 3 à 6 secondes par requête pour Walmart : « limitez vos requêtes en attendant 3 à 6 secondes entre les chargements de pages et randomisez vos délais. »

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

À grande échelle, pensez à aiolimiter pour la limitation de débit en asynchrone :

1from aiolimiter import AsyncLimiter
2limiter = AsyncLimiter(max_rate=10, time_period=60)  # 10 requêtes par minute

Validation des données

Même si la réponse n’est pas bloquée, les données analysées peuvent être fausses (mauvais magasin, payload dégradé). Validez avant d’écrire la sortie :

1def validate_product(product):
2    """Retourne True si les données produit semblent valides."""
3    if not product.get("name"):
4        return False
5    price = (product.get("priceInfo") or {}).get("currentPrice", {}).get("price")
6    if not isinstance(price, (int, float)) or price <= 0:
7        return False
8    if product.get("availabilityStatus") not in ("IN_STOCK", "OUT_OF_STOCK", "LIMITED_STOCK"):
9        return False
10    return True

Journalisation de session

Suivez votre taux de réussite par session. Lorsqu’il tombe sous 80 % pendant 10 minutes, quelque chose a changé : votre IP est grillée, vos cookies ont expiré, ou Walmart a déployé une nouvelle règle anti-bot.

1class ScrapeMetrics:
2    def __init__(self):
3        self.total = 0
4        self.success = 0
5        self.blocks = 0
6        self.errors = 0
7    def record(self, result):
8        self.total += 1
9        if result == "success":
10            self.success += 1
11        elif result == "blocked":
12            self.blocks += 1
13        else:
14            self.errors += 1
15    @property
16    def success_rate(self):
17        return (self.success / self.total * 100) if self.total > 0 else 0
18    def check_health(self):
19        if self.total > 20 and self.success_rate < 80:
20            log.critical(f"Le taux de réussite est tombé à {self.success_rate:.1f}% — envisagez de changer de proxy ou de faire une pause")

Ce n’est pas glamour. Mais c’est ce qui garde vos données propres.

Python en DIY vs API de scraping vs no-code : choisir la bonne approche pour extraire Walmart

Beaucoup de développeurs se lancent direct dans un scraper custom sans se demander si c’est vraiment le bon choix. . Sur les forums, on lit que c’est « quasiment 9/10 » et qu’on se demande si une API de scraping dédiée ne serait pas excessive. La réponse dépend du volume, du budget et de la capacité d’ingénierie.

Quand le Python DIY a du sens

Le DIY gagne quand vous avez déjà un contrat de proxy, que vous avez besoin d’un contrôle strict des en-têtes, du ciblage par code postal ou des cohortes de vendeurs, que vous indexez des millions de pages par mois où les frais API par enregistrement s’accumulent, ou que vous avez des exigences de conformité / on-premises. Le compromis est réel : un spider Scrapy prêt pour la production avec pagination, retries, rotation de proxies, impersonation TLS et plusieurs schémas de pages prend , plus 4 à 8 heures par mois de maintenance quand Walmart change ses empreintes.

Quand une API de scraping vous fait gagner du temps

Les API de scraping gèrent la couche anti-bot pour vous. Les affichent des taux de réussite de et 98 % pour Scrape.do sur Walmart. Les tarifs d’entrée tournent autour de 40 à 49 $/mois pour des outils comme , et . Si vous êtes une équipe de 2 à 5 ingénieurs et que votre volume se situe entre 10K et 1M de pages par mois, une API est presque toujours le bon choix. Vous échangez un coût par requête contre une maintenance nulle.

Quand le no-code est le bon choix

répond à un autre profil. Si vous êtes PM, analyste ou opérateur e-commerce et que vous avez besoin des données produit Walmart dans un tableur cet après-midi — pas au prochain sprint — un outil no-code est la réponse la plus honnête.

Le flux de travail : installez , allez sur une page produit ou de recherche Walmart, cliquez sur « AI Suggest Fields », et l’IA de Thunderbit lit la page pour proposer les colonnes (nom du produit, prix, note, etc.). Cliquez sur « Scrape », et les données se remplissent dans un tableau. Exportez vers Excel, Google Sheets, Airtable ou Notion — gratuitement, sans paywall.

Thunderbit gère l’anti-bot dans le cloud, donc vous n’avez ni CAPTCHA, ni proxy, ni empreinte TLS à gérer. L’IA s’adapte automatiquement aux changements de mise en page, donc il n’y a pas de maintenance. Pour les utilisateurs qui ne veulent pas bidouiller des chemins JSON, c’est l’option la plus simple.

Limites honnêtes : Thunderbit n’est pas conçu pour 100K+ pages par jour. Les budgets de crédits et les plafonds cloud rendent l’ingestion à très gros volume moins rentable que les API brutes. Vous ne pouvez pas non plus verrouiller un code postal ou un ASN précis, sauf si l’outil le permet. Pour des pipelines continus à haut volume, le DIY ou une API de scraping reste plus adapté.

Estimation rapide des coûts : 1 000 lignes de produits Walmart sur Thunderbit coûtent environ 2 000 crédits (soit ~0,60 à 1,10 $ avec les plans Starter/Pro). C’est comparable à l’API Walmart d’Oxylabs et moins cher que la plupart des API de scraping pour hobbyistes à faible volume. pour les infos à jour.

Exporter vos données Walmart extraites

Une fois les données récupérées, il faut les mettre quelque part d’utile. Trois formats couvrent la majorité des besoins :

CSV — le format le plus universel que les analystes ouvrent vraiment :

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

Utilisez l’encodage utf-8-sig pour assurer la compatibilité avec Excel. Le marqueur BOM évite qu’Excel déforme les caractères spéciaux.

JSONL — le format de prod pour les pipelines de scraping :

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

(une écriture interrompue ne perd que la dernière ligne), se streame avec une mémoire constante et conserve les données imbriquées comme les variantes et les avis.

Excel — pour les transferts ponctuels vers des analystes :

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

Thunderbit couvre aussi l’export pour les non-développeurs : export en un clic vers Google Sheets, Airtable, Notion, Excel, CSV et JSON — gratuitement sur le plan de base. Pour un suivi récurrent, la fonction de scraper programmé de Thunderbit peut lancer automatiquement des extractions répétées.

Petit avertissement sur la planification : . Les runners GitHub Actions s’appuient sur des plages IP Azure que l’anti-bot de Walmart bloque immédiatement. Utilisez APScheduler sur un VPS, ou faites passer tout le trafic par des proxies résidentiels.

Considérations juridiques et éthiques pour scraper Walmart

Des utilisateurs le disent clairement sur les forums : « Ça ne me dérange pas de jouer au chat et à la souris avec les développeurs, mais je me méfie davantage du service juridique. »

Les conditions d’utilisation de Walmart l’usage de « tout robot, spider… ou autre dispositif manuel ou automatique pour récupérer, indexer, “scraper”, “data miner” ou collecter d’une autre manière des contenus » sans « consentement écrit préalable exprès ».

Le robots.txt de Walmart /search, /account, /api/ et des dizaines d’endpoints internes. Les pages produit (/ip/...) et les avis (/reviews/product/) ne sont pas interdits.

Le précédent hiQ c. LinkedIn (9e circuit, ) a établi que le scraping de données publiques ne viole probablement pas le CFAA fédéral. Mais cette même juridiction a ensuite estimé que et a prononcé un contre elle. Des décisions plus récentes en 2024 (, ) ont encore réduit la portée du CFAA et créé des défenses fondées sur la préemption du copyright, mais ces décisions dépendaient d’un libellé très précis des conditions d’utilisation qui ne se transpose pas proprement à Walmart.

Conseils pratiques : ne surchargez pas les serveurs. Respectez les limites de débit. Ne scrapez pas de données personnelles ou utilisateur. Utilisez les données de façon responsable. Extraire à un rythme modéré des pages publiques Walmart pour de la recherche perso n’expose pas au même niveau de risque qu’un scraping commercial à grande échelle en violation des conditions de Walmart. Si vous construisez un produit basé sur les données Walmart, parlez-en à un avocat et renseignez-vous sur les .

Avertissement : ceci est une information à visée éducative, et non un conseil juridique.

Conclusion et points clés à retenir

Extraire Walmart avec Python est un défi de à cause de sa double pile anti-bot Akamai + PerimeterX. Ce n’est pas impossible — mais il faut les bons outils et les bons patterns.

Points clés :

• L’extraction JSON via __NEXT_DATA__ est le choix pragmatique pour la plupart des cas d’usage. C’est ce qu’utilise tout scraper Walmart open source sérieux de 2024 à 2026. Le chemin de base est props.pageProps.initialData.data.product pour les PDP, et searchResult.itemStacks pour la recherche/navigation.
• curl_cffi avec impersonate="chrome124" est indispensable. requests ou httpx classiques ne peuvent pas franchir le fingerprinting TLS d’Akamai, quels que soient les en-têtes.
• Les blocages silencieux sont le vrai danger. Walmart renvoie du 200 OK avec des corps CAPTCHA. Vérifiez le contenu de la réponse, pas seulement les codes de statut.
• Un scraper de prod a besoin de plus qu’un code happy path. Backoff exponentiel avec jitter, détection de blocage sur quatre signaux, limitation à 3–6 secondes par requête, validation des données et suivi de la santé de session sont essentiels.
• L’interception des API internes via /orchestra/* est puissante mais fragile. Utilisez-la comme exercice DevTools pour des besoins ponctuels, pas comme méthode principale.
• Walmart limite la recherche à 25 pages. Pour aller plus loin, jouez sur l’ordre de tri et le découpage par plages de prix.
• Choisissez honnêtement votre approche : Python DIY pour les devs avec des besoins sur mesure et de gros volumes. Les API de scraping pour les équipes de taille intermédiaire sans ingénieur scraping. pour les utilisateurs métier qui veulent leurs données dans Google Sheets cet après-midi.

Si vous voulez tester l’approche no-code, dispose d’un plan gratuit — vous pouvez extraire quelques pages Walmart et voir le résultat par vous-même. Si vous partez sur Python, les patterns de code de cet article ont été testés en production. Dans tous les cas, vous avez maintenant une carte des défenses de Walmart et trois chemins pour les contourner.

Pour aller plus loin sur les techniques de scraping web, consultez nos guides sur , et . Vous pouvez aussi regarder des tutoriels sur .

FAQ

Est-il légal de scraper des données produit Walmart ?

Les conditions d’utilisation de Walmart interdisent le scraping automatisé sans consentement écrit. L’arrêt hiQ c. LinkedIn de la 9e Cour d’appel (2022) a établi que le CFAA fédéral ne s’applique probablement pas au scraping de pages publiques, mais cette même affaire s’est terminée par un contre le scraper. Extraire des pages produit publiques à un rythme modéré pour de la recherche personnelle n’a pas le même niveau de risque qu’une extraction commerciale à grande échelle. Consultez un avocat si vous construisez une activité sur les données Walmart.

Pourquoi mon scraper Walmart est-il constamment bloqué ?

Les causes les plus fréquentes sont : l’utilisation de requests ou httpx classiques (qui émettent une empreinte TLS spécifique à Python que Akamai détecte immédiatement), des en-têtes manquants ou incorrects, aucune rotation de proxy, des requêtes plus rapides que 3 à 6 secondes par page, et des cookies de session manquants (_px3, _abck, locDataV3). Passez à curl_cffi avec impersonate="chrome124", utilisez des proxies résidentiels et mettez en place les patterns de détection et de retry décrits dans cet article.

Quelles données puis-je extraire de Walmart avec Python ?

Noms de produits, prix (actuels et remisés), images, descriptions courtes et longues, notes, nombre d’avis, disponibilité du stock, noms des vendeurs, informations fabricant, options de variantes (taille, couleur) et positionnement dans les catégories. Avec la méthode __NEXT_DATA__, toutes ces données sont disponibles sous forme de JSON structuré. L’interception des API internes peut en plus fournir le prix par variante, les stocks en temps réel et les avis paginés.

Ai-je besoin de proxies pour scraper Walmart ?

Oui, pour tout usage en production ou répété. — même avec des en-têtes parfaits, une IP non résidentielle sera repérée par le système de réputation d’Akamai. Des proxies résidentiels ou mobiles sont nécessaires. Les IP de datacenter sont grillées presque immédiatement. Prévoyez environ 3 à 17 $ pour 1 000 pages selon votre fournisseur de proxy et le niveau de service.

Puis-je scraper Walmart sans écrire de code ?

Oui. est une extension Chrome alimentée par l’IA qui scrape Walmart en deux clics : « AI Suggest Fields » pour détecter automatiquement les colonnes de données produit, puis « Scrape » pour extraire les données. Elle gère les défis anti-bot dans le cloud et exporte directement vers Excel, Google Sheets, Airtable ou Notion — gratuitement. C’est idéal pour les analystes, PM et utilisateurs métier qui ont besoin de données vite, sans construire de pipeline personnalisé. Pour du scraping très volumineux ou très personnalisé, Python ou une API de scraping reste plus adapté.

En savoir plus