Mon extracteur d’avis Amazon marchait nickel depuis six semaines — puis, un matin, il m’a renvoyé 200 OK avec une page totalement vide. Pas d’erreur, pas de CAPTCHA, juste du HTML vide à l’endroit où il y avait encore, la veille, des centaines d’avis.
Si ça vous dit quelque chose, vous n’êtes pas seul. Fin 2025, Amazon a commencé à bloquer l’accès aux pages d’avis complètes derrière une connexion, et un paquet de scripts Python de scraping ont cassé du jour au lendemain. J’ai passé les derniers mois chez Thunderbit à bosser sur le sujet des deux côtés — en construisant notre extracteur IA et en gardant aussi mon propre pipeline Python d’avis en état de marche — alors je me suis dit qu’il était temps d’écrire le guide que j’aurais aimé avoir quand mon script a lâché. Cet article couvre l’approche qui fonctionne : l’authentification par cookies, des sélecteurs stables qui tiennent bon malgré l’obfuscation CSS d’Amazon, des contournements pour la limite de pagination de 10 pages, les défenses anti-bot, et un bonus d’analyse de sentiment pour transformer du texte brut en vrais insights business. Et si, en cours de route, vous vous dites : « Franchement, je n’ai pas envie de maintenir tout ce code », je vous montrerai comment Thunderbit fait le même boulot en environ deux minutes, sans écrire une seule ligne de Python.
Qu’est-ce que le scraping d’avis Amazon, et pourquoi est-ce important ?
Le scraping d’avis Amazon, c’est le fait d’extraire automatiquement les données d’avis clients — notes étoilées, texte de l’avis, nom de l’auteur, date, badge d’achat vérifié — depuis les pages produits Amazon. Comme Amazon a supprimé le contenu des avis de son Product Advertising API en 2010 (et ne l’a jamais remis), le web scraping reste la seule voie programmatique pour accéder à ces données.
Les chiffres parlent d’eux-mêmes. 95 % des acheteurs lisent les avis avant d’acheter, et 94 % citent Amazon comme leur première source d’avis produits. Afficher seulement 5 avis sur une fiche produit peut augmenter la conversion de 270 %. Les entreprises qui analysent régulièrement le sentiment des avis voient jusqu’à 15 % de rétention client en plus. Ce n’est pas de la science des données abstraite — c’est du renseignement concurrentiel, des signaux d’amélioration produit et du langage marketing, le tout écrit noir sur blanc sur les serveurs d’Amazon.
Pourquoi scraper les avis Amazon avec Python
Python reste le langage de référence pour ce genre de boulot. C’est le langage le plus désiré n°1 dans l’enquête Stack Overflow 2024, et son écosystème — requests, BeautifulSoup, pandas, Scrapy — rend le scraping accessible même à ceux qui ne sont pas développeurs à plein temps.
Chaque équipe exploite ces données à sa façon :
| Équipe | Cas d’usage | Ce qu’elle extrait |
|---|---|---|
| Produit / R&D | Repérer les plaintes qui reviennent tout le temps, prioriser les correctifs | Texte des avis 1–2 étoiles, fréquence des mots-clés |
| Ventes | Suivre le sentiment sur les produits concurrents | Notes, évolution du volume d’avis |
| Marketing | Réutiliser le vocabulaire client pour les annonces | Phrases positives, mentions de fonctionnalités |
| E-commerce / Ops | Suivre l’évolution du ressenti sur ses propres produits | Répartition des notes, taux d’achats vérifiés |
| Études de marché | Comparer les leaders de la catégorie sur plusieurs critères | Jeux de données d’avis multi-ASIN |
Une marque d’ustensiles de cuisine a analysé les avis négatifs, découvert que 22 % mentionnaient « le revêtement antiadhésif s’use », retravaillé son produit et repris la place de n°1 Best Seller en 60 jours. Une société de trackers d’activité a repéré des mentions de « gêne au poignet » dans les avis, identifié un problème d’allergie au latex, lancé une version hypoallergénique et réduit les retours de 40 %. C’est le genre de ROI qui rend l’effort d’ingénierie très rentable.
Mur de connexion : pourquoi votre extracteur d’avis Amazon a cessé de fonctionner
Le 14 novembre 2024, Amazon a commencé à exiger une connexion pour afficher la page complète des avis produit. Le changement a été confirmé sur des forums communautaires et dans des blogs de fournisseurs de scraping. Si vous ouvrez /product-reviews/{ASIN}/ en navigation privée, vous serez redirigé vers une page de connexion au lieu d’obtenir les avis.
Les symptômes sont piégeux : votre script reçoit bien une réponse 200 OK, mais le corps HTML contient un formulaire de connexion (name="email", id="ap_password") au lieu des avis. Pas de code d’erreur. Pas de CAPTCHA. Juste… rien d’exploitable.
Amazon a mis ça en place pour lutter contre les bots et pour des raisons de conformité régionale. L’application est irrégulière — parfois, une fenêtre de navigateur fraîche affiche quelques avis avant que le mur ne se déclenche, surtout sur la première page — mais pour tout scraper qui tourne à grande échelle, il faut considérer que ce mur est toujours actif.
Les différents domaines pays d’Amazon (.de, .co.uk, .co.jp) appliquent ce mur de façon indépendante. Comme l’a résumé un utilisateur de forum : « une connexion par pays est requise ». Vos cookies .com ne fonctionneront pas sur .co.uk.
Avis mis en avant vs avis complets : ce qui reste accessible sans connexion
Les pages produits Amazon (l’URL /dp/{ASIN}/) affichent encore environ 8 « avis mis en avant » sans authentification. Ils sont choisis par l’algorithme d’Amazon et servent bien pour un aperçu rapide du sentiment, mais ils ne sont ni triables, ni filtrables, ni paginés.
Les pages d’avis complètes (/product-reviews/{ASIN}/) — avec tri par nouveauté, filtre par note et pagination sur des centaines d’avis — exigent une connexion.
Si vous n’avez besoin que de quelques avis pour prendre la température, scrapez la page produit. Pour des centaines ou des milliers, il faudra gérer l’authentification.
Ce qu’il vous faut avant de commencer : configuration Python et bibliothèques
Avant d’écrire du code, voici la config :
- Niveau requis : intermédiaire (à l’aise avec Python, notions de base en HTML)
- Temps nécessaire : ~45 minutes pour le pipeline complet ; ~10 minutes pour un scraping simple
- Ce qu’il vous faut : Python 3.8+, navigateur Chrome, compte Amazon valide
Installez les bibliothèques principales :
pip install requests beautifulsoup4 lxml pandas textblob
Optionnel (pour l’analyse de sentiment avancée) :
pip install transformers torch
Qu’est-ce qu’un ASIN ? C’est l’identifiant produit Amazon à 10 caractères. Vous le trouverez dans n’importe quelle URL produit — par exemple, dans amazon.com/dp/B0BCNKKZ91, l’ASIN est B0BCNKKZ91. C’est la clé que vous utiliserez dans l’URL des avis.
Étape 1 : franchir le mur de connexion grâce à l’authentification par cookies
L’approche la plus fiable consiste à vous connecter à Amazon dans votre navigateur, copier vos cookies de session, puis les injecter dans votre requests.Session() Python. Ça évite de déclencher les CAPTCHA et la double authentification par SMS qui compliquent l’automatisation de la connexion avec Selenium.
Vous avez besoin de ces sept cookies :
| Nom du cookie | Rôle |
|---|---|
session-id | Identifiant de session tournant |
session-id-time | Horodatage de session |
session-token | Jeton de session tournant |
ubid-main | Identifiant de navigation utilisateur |
at-main | Jeton d’authentification principal |
sess-at-main | Authentification limitée à la session |
x-main | Identifiant lié à l’adresse e-mail de l’utilisateur |
Comment extraire les cookies depuis Chrome DevTools
- Connectez-vous à amazon.com dans Chrome
- Ouvrez DevTools (F12 ou clic droit → Inspecter)
- Allez dans Application → Storage → Cookies →
https://www.amazon.com - Repérez chaque cookie du tableau et copiez sa valeur
- Mettez-les au format chaîne séparée par des points-virgules pour Python
Configurez votre session comme ceci :
import requests
session = requests.Session()
# Collez ici vos valeurs de cookies
cookies = {
"session-id": "YOUR_SESSION_ID",
"session-id-time": "YOUR_SESSION_ID_TIME",
"session-token": "YOUR_SESSION_TOKEN",
"ubid-main": "YOUR_UBID_MAIN",
"at-main": "YOUR_AT_MAIN",
"sess-at-main": "YOUR_SESS_AT_MAIN",
"x-main": "YOUR_X_MAIN",
}
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.5",
}
session.cookies.update(cookies)
session.headers.update(headers)
Important : réutilisez le même objet session pour toutes vos requêtes. Ça garde des cookies cohérents et reproduit un vrai parcours navigateur. Les cookies durent généralement de quelques jours à quelques semaines sous charge de scraping ; si vous retombez sur des redirections vers la connexion, rafraîchissez-les depuis votre navigateur.
Pour les marketplaces autres que .com, les noms de cookies changent légèrement — amazon.de utilise at-acbde au lieu de at-main, amazon.co.uk utilise at-acbuk, etc. Chaque marketplace nécessite sa propre session indépendante.
Étape 2 : construire la requête et parser le HTML des avis avec BeautifulSoup
L’URL des avis Amazon suit ce format :
https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1
La fonction centrale :
from bs4 import BeautifulSoup
import time, random
def get_soup(session, url):
time.sleep(random.uniform(2, 5)) # Pause polie
response = session.get(url, timeout=15)
# Détection du mur de connexion
if "ap_email" in response.text or "Amazon Sign-In" in response.text:
raise Exception("Mur de connexion détecté — rafraîchissez vos cookies")
if response.status_code != 200:
raise Exception(f"HTTP {response.status_code}")
return BeautifulSoup(response.text, "lxml")
Une petite astuce utile : avant d’ouvrir la page des avis, visitez d’abord la page produit. Ça installe un schéma de navigation naturel dans votre session.
# Visitez d’abord la page produit (simule une navigation réelle)
product_url = f"https://www.amazon.com/dp/{asin}"
session.get(product_url, timeout=15)
time.sleep(random.uniform(1, 3))
# Puis ouvrez la page des avis
reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
soup = get_soup(session, reviews_url)
Étape 3 : utiliser des sélecteurs stables pour extraire les avis (arrêtez de vous fier aux classes CSS)
C’est là que la plupart des tutoriels de 2022–2023 se plantent. Amazon obfusque les noms de classes CSS — ils changent régulièrement, et comme l’a dit un développeur agacé sur un forum : « aucun d’entre eux n’avait un seul schéma pour les noms des classes des balises span ».
La solution : Amazon utilise des attributs data-hook sur les éléments d’avis, et ils sont étonnamment stables. Ce sont des identifiants sémantiques sur lesquels repose le frontend d’Amazon, donc ils ne sont pas randomisés.
| Champ de l’avis | Sélecteur stable (data-hook) | Sélecteur fragile (classe) |
|---|---|---|
| Texte de l’avis | [data-hook="review-body"] | .review-text-content (change) |
| Note étoilée | [data-hook="review-star-rating"] | .a-icon-alt (ambigu) |
| Titre de l’avis | [data-hook="review-title"] | .review-title (parfois) |
| Nom de l’auteur | span.a-profile-name | Relativement stable |
| Date de l’avis | [data-hook="review-date"] | .review-date (selon la région) |
| Achat vérifié | [data-hook="avp-badge"] | span.a-size-mini |
Le code d’extraction avec les sélecteurs data-hook :
import re
def extract_reviews(soup):
reviews = []
review_divs = soup.select('[data-hook="review"]')
for div in review_divs:
# Note étoilée
rating_el = div.select_one('[data-hook="review-star-rating"]')
rating = None
if rating_el:
rating_text = rating_el.get_text(strip=True)
match = re.search(r'(\d\.?\d?)', rating_text)
if match:
rating = float(match.group(1))
# Titre
title_el = div.select_one('[data-hook="review-title"]')
title = title_el.get_text(strip=True) if title_el else ""
# Corps
body_el = div.select_one('[data-hook="review-body"]')
body = body_el.get_text(strip=True) if body_el else ""
# Auteur
author_el = div.select_one('span.a-profile-name')
author = author_el.get_text(strip=True) if author_el else ""
# Date et pays
date_el = div.select_one('[data-hook="review-date"]')
date_text = date_el.get_text(strip=True) if date_el else ""
# Format : "Reviewed in the United States on January 15, 2025"
country_match = re.search(r'Reviewed in (.+?) on', date_text)
date_match = re.search(r'on (.+)$', date_text)
country = country_match.group(1) if country_match else ""
date = date_match.group(1) if date_match else ""
# Achat vérifié
verified_el = div.select_one('[data-hook="avp-badge"]')
verified = bool(verified_el)
reviews.append({
"author": author,
"rating": rating,
"title": title,
"content": body,
"date": date,
"country": country,
"verified": verified,
})
return reviews
J’utilise cet ensemble de sélecteurs sur plusieurs ASIN depuis des mois, et les attributs data-hook n’ont pas bougé une seule fois. Les classes CSS, en revanche, ont changé au moins deux fois pendant la même période.
Étape 4 : gérer la pagination et la limite de 10 pages d’Amazon
Amazon limite le paramètre pageNumber à 10 pages de 10 avis chacune — un plafond dur d’environ 100 avis par combinaison de filtres. Le bouton « Page suivante » disparaît simplement après la page 10.
Boucle de pagination basique :
all_reviews = []
for page in range(1, 11):
url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break # Plus d’avis sur cette page
all_reviews.extend(page_reviews)
print(f"Page {page} : {len(page_reviews)} avis")
Comment obtenir plus de 10 pages d’avis Amazon
Le contournement consiste à utiliser le bucketing par filtres. Chaque combinaison de filterByStar et sortBy obtient sa propre fenêtre indépendante de 10 pages.
Valeurs de filtre par étoile : one_star, two_star, three_star, four_star, five_star
Valeurs de tri : recent, helpful (par défaut)
En combinant les 5 filtres d’étoiles × 2 ordres de tri, vous pouvez accéder à jusqu’à 100 pages, soit 1 000 avis par produit — et pour les produits dont la répartition des notes est déséquilibrée, vous vous approcherez souvent de l’ensemble complet des avis.
star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
sort_orders = ["recent", "helpful"]
all_reviews = []
seen_titles = set() # Déduplication simple
for star in star_filters:
for sort in sort_orders:
for page in range(1, 11):
url = (
f"https://www.amazon.com/product-reviews/{asin}"
f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
)
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break
for review in page_reviews:
# Déduplication par combinaison titre + auteur
key = (review["title"], review["author"])
if key not in seen_titles:
seen_titles.add(key)
all_reviews.append(review)
print(f"[{star}/{sort}] Page {page} : {len(page_reviews)} avis")
print(f"Nombre total d’avis uniques : {len(all_reviews)}")
Il y aura des recoupements entre les buckets, donc la déduplication est indispensable. J’utilise une combinaison titre d’avis + nom d’auteur comme clé rapide — ce n’est pas parfait, mais ça élimine la grande majorité des doublons.
Étape 5 : contourner les défenses anti-bot (rotation, limitation, retries)
Amazon utilise AWS WAF Bot Control, et le système est devenu franchement plus agressif. Les contre-mesures à un seul niveau (rotation de User-Agent seulement, ou ajout de délais seulement) ne suffisent plus.
| Technique | Mise en œuvre |
|---|---|
| Rotation des User-Agents | Choix aléatoire parmi 10+ chaînes réelles de navigateurs |
| Backoff exponentiel | Délais de relance de 2s → 4s → 8s sur les 503 |
| Limitation du débit | random.uniform(2, 5) secondes entre les pages |
| Rotation de proxy | Rotation via proxies résidentiels |
| Empreinte de session | Cookies + en-têtes cohérents par session |
| Impersonation TLS | Utiliser curl_cffi au lieu de requests en production |
Un wrapper de retry prêt pour la production :
import time, random
USER_AGENTS = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
]
def scrape_with_retries(session, url, max_retries=3):
for attempt in range(max_retries):
try:
session.headers["User-Agent"] = random.choice(USER_AGENTS)
time.sleep(random.uniform(2, 5))
response = session.get(url, timeout=15)
# Détection des blocages
if "validateCaptcha" in response.url or "Robot Check" in response.text:
wait = (2 ** attempt) * 5
print(f"CAPTCHA détecté. Attente {wait}s...")
time.sleep(wait)
continue
if response.status_code in (429, 503):
wait = (2 ** attempt) * 2
print(f"Limite atteinte ({response.status_code}). Attente {wait}s...")
time.sleep(wait)
continue
if "ap_email" in response.text:
raise Exception("Mur de connexion — cookies expirés")
return BeautifulSoup(response.text, "lxml")
except Exception as e:
if attempt == max_retries - 1:
raise
print(f"Tentative {attempt + 1} échouée : {e}")
return None
À propos des proxies : Amazon blackliste les plages d’adresses IP des datacenters (AWS, GCP, Azure, DigitalOcean) au niveau réseau. Si vous scrapez plus que quelques centaines de pages, les proxies résidentiels deviennent pratiquement obligatoires — comptez 50 à 200 $/mois et plus selon le volume. Pour les petits projets (moins de 100 requêtes/jour), une limitation prudente depuis votre IP perso fonctionne souvent sans souci.
Amazon inspecte aussi les empreintes TLS. La bibliothèque requests standard de Python a un JA3 bien connu que les WAF bloquent à l’avance. Pour les scrapers de production, envisagez curl_cffi, qui imite les vraies piles TLS des navigateurs. Pour un scraping de niveau tutoriel (quelques centaines de pages), requests avec de bons en-têtes suffit généralement.
Étape 6 : exporter vos avis Amazon vers CSV ou Excel
Une fois vos avis récupérés, les mettre dans un format exploitable est simple avec pandas :
import pandas as pd
df = pd.DataFrame(all_reviews)
df.to_csv("amazon_reviews.csv", index=False)
print(f"{len(df)} avis exportés vers amazon_reviews.csv")
Exemple de sortie :
| author | rating | title | content | date | country | verified |
|---|---|---|---|---|---|---|
| Sarah M. | 5.0 | Meilleur achat de l’année | La batterie tient toute la journée, l’écran est superbe... | January 15, 2025 | the United States | True |
| Mike T. | 2.0 | Déçu au bout de 2 semaines | Le port de charge a cessé de fonctionner... | February 3, 2025 | the United States | True |
| Priya K. | 4.0 | Excellent rapport qualité-prix | Fait tout ce dont j’ai besoin, léger ralentissement sur les applis lourdes... | March 10, 2025 | the United States | False |
Pour exporter vers Excel : df.to_excel("amazon_reviews.xlsx", index=False) (nécessite openpyxl).
Pour Google Sheets, la bibliothèque gspread fonctionne, mais elle demande 8 étapes ou plus de configuration Google Cloud — création d’un projet, activation de deux API, génération d’identifiants de compte de service, partage de la feuille. Si ça vous semble plus long que le scraping lui-même, ce n’est pas faux. (C’est justement le genre de moment où un outil comme Thunderbit qui exporte vers Google Sheets en un clic devient très tentant.)
Bonus : ajouter une analyse de sentiment à vos avis en 5 lignes de Python
La plupart des tutos de scraping s’arrêtent à l’export CSV. Mais scorer le sentiment, c’est ce qui transforme des données brutes en décisions business.
L’approche la plus rapide utilise TextBlob :
from textblob import TextBlob
df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)
Vous obtenez ainsi un score de polarité allant de -1.0 (très négatif) à +1.0 (très positif) pour chaque avis. Exemple de sortie :
| content (tronqué) | rating | sentiment |
|---|---|---|
| "La batterie tient toute la journée, l’écran est superbe..." | 5.0 | 0.65 |
| "Le port de charge a cessé de fonctionner après..." | 2.0 | -0.40 |
| "Fait tout ce dont j’ai besoin, léger ralentissement sur..." | 4.0 | 0.25 |
| "Catastrophique. Renvoyé immédiatement." | 1.0 | -0.75 |
| "C’est correct. Rien de spécial, mais ça fonctionne." | 3.0 | 0.10 |
Les lignes les plus intéressantes sont celles qui ne collent pas — un avis 3 étoiles avec un texte positif, ou un avis 5 étoiles avec un langage négatif. Ces écarts révèlent souvent des opinions clients nuancées que la note seule ne montre pas.
Pour une précision de niveau production, la recommandation est d’utiliser Hugging Face Transformers. VADER a été entraîné sur des tweets, pas sur des avis produits, et les modèles transformer atteignent plus de 98 % de précision sur la classification d’avis par rapport aux outils lexicaux. Le modèle nlptown/bert-base-multilingual-uncased-sentiment prédit même directement des notes de 1 à 5 étoiles :
from transformers import pipeline
clf = pipeline("sentiment-analysis",
model="nlptown/bert-base-multilingual-uncased-sentiment")
df["predicted_stars"] = df["content"].apply(
lambda x: int(clf(str(x)[:512])[0]["label"][0])
)
Les avis Amazon suivent une distribution en J — un gros pic à 5 étoiles, un plus petit pic à 1 étoile, et un creux au milieu. Ça veut dire que la note moyenne est souvent un mauvais proxy de la vraie qualité du produit. Segmentez le cluster 1 étoile et cherchez les thèmes récurrents — c’est souvent là qu’un défaut corrigeable se cache.
Le compromis honnête : Python en DIY vs API de scraping payantes vs Thunderbit
J’ai maintenu des scrapers Python pour Amazon, et je vais être franc : ils cassent. Les sélecteurs changent, les cookies expirent, Amazon ajoute une nouvelle couche de détection de bots, et d’un coup votre samedi matin se transforme en débogage de scraper au lieu d’analyse de données. Les gens sur les forums racontent la même galère — des scripts maison qui « marchaient le mois dernier » demandent maintenant des correctifs en continu.
Voici comment les trois approches principales se comparent :
| Critère | Python DIY (BS4/Selenium) | API de scraping payante | Thunderbit (sans code) |
|---|---|---|---|
| Temps de mise en place | 1–3 heures | 30 min (clé API) | 2 minutes |
| Coût | Gratuit (+ coût des proxies) | 50–200 $/mois et plus | Offre gratuite disponible |
| Gestion du mur de connexion | Gestion manuelle des cookies | Généralement gérée | Gérée automatiquement |
| Maintenance | Élevée (les sélecteurs cassent) | Faible (le fournisseur maintient) | Zéro (l’IA s’adapte) |
| Pagination | Code personnalisé requis | Intégrée | Intégrée |
| Support multi-pays | Sessions séparées par domaine | Généralement pris en charge | Basé navigateur = votre locale |
| Analyse de sentiment | Votre propre code | Parfois incluse | Export vers Sheets, analyse partout |
| Idéal pour | Apprentissage, contrôle total | Pipelines de production / grande échelle | Extraction rapide, équipes non techniques |
Python vous donne un contrôle total et reste la meilleure manière de comprendre le scraping en profondeur. Les API payantes (ScrapingBee, Oxylabs, Bright Data) sont pertinentes pour les pipelines de production où la disponibilité compte plus que le coût. Et pour les équipes qui ont besoin de données d’avis sans surcharge de dev — ops e-commerce qui surveillent des concurrents chaque semaine, équipes marketing qui extraient le langage client pour les accroches pub — il existe une troisième voie.
Comment scraper les avis Amazon avec Thunderbit (sans code, sans maintenance)
Nous avons conçu Thunderbit pour gérer précisément les cas où maintenir un scraper Python ressemble à du surdimensionnement. Le flux de travail ressemble à ça :
- Installez l’extension Chrome Thunderbit
- Accédez à la page d’avis du produit Amazon dans votre navigateur (vous êtes déjà connecté, donc le mur de connexion n’est pas un souci)
- Cliquez sur "AI Suggest Fields" — Thunderbit lit la page et propose des colonnes comme Auteur, Note, Titre, Texte de l’avis, Date, Achat vérifié
- Cliquez sur "Scrape" — les données sont extraites instantanément, avec pagination intégrée
- Exportez vers Excel, Google Sheets, Airtable ou Notion
Le gros avantage, c’est que l’IA de Thunderbit relit la structure de la page à chaque fois. Pas de sélecteurs CSS à maintenir, pas de gestion des cookies, pas de code anti-bot. Quand Amazon modifie son HTML, l’IA s’adapte. Pour ceux qui veulent un accès programmatique sans tout faire eux-mêmes, Thunderbit propose aussi une Extract API — extraction structurée via API avec détection de champs par IA, sans maintenance de sélecteurs.
Pour aller plus loin sur les données Amazon, consultez nos guides sur comment scraper les produits et avis Amazon et l’extraction et l’analyse des ventes Amazon.
Conseils pour scraper les avis Amazon à grande échelle avec Python
Si vous scrapez des avis sur beaucoup d’ASIN, quelques bonnes pratiques vous éviteront pas mal de galères :
- Traitez les ASIN par lots avec des pauses entre les produits, pas seulement entre les pages. J’utilise des pauses de 10 à 15 secondes entre les ASIN.
- Dédupliquez agressivement. En combinant plusieurs filtres par étoile et ordres de tri, vous allez récupérer des avis qui se recoupent. Utilisez un ensemble de tuples
(title, author, date)comme clé de déduplication. - Journalisez les échecs. Suivez les combinaisons ASIN + page + filtre qui ont échoué pour pouvoir les relancer sans tout rescaper.
- Stockez dans une base de données pour les gros projets. Une base SQLite simple évolue bien mieux que des fichiers CSV qui grossissent sans fin :
import sqlite3
conn = sqlite3.connect("reviews.db")
df.to_sql("reviews", conn, if_exists="append", index=False)
- Programmez les extractions récurrentes. Pour un suivi continu, configurez une tâche cron ou utilisez la fonction Scheduled Scraper de Thunderbit — décrivez l’URL et la fréquence, et le reste est géré sans serveur.
Pour d’autres approches, nos articles sur les meilleurs outils de web scraping automatisé et l’extraction de données de sites vers Excel présentent d’autres options.
Un mot rapide sur les aspects juridiques et éthiques
Les conditions d’utilisation d’Amazon interdisent explicitement « l’utilisation de tout robot, spider, scraper ou autre moyen automatisé pour accéder aux services Amazon ». Cela dit, la jurisprudence récente aux États-Unis a été favorable aux scrapers de données publiques. Dans Meta Platforms v. Bright Data (janvier 2024), un tribunal fédéral a jugé que le scraping de données accessibles publiquement ne viole pas les conditions d’utilisation lorsque le scraper n’est pas un « utilisateur » connecté.
La nuance : scraper derrière une connexion (ce que couvre ce tutoriel) vous fait entrer dans le champ du droit des contrats, puisque vous avez accepté les CGU d’Amazon en créant votre compte. Scraper les avis mis en avant visibles publiquement présente moins de risques juridiques que scraper derrière le mur de connexion.
Quelques règles pratiques : ne redistribuez pas commercialement les données scrapées, ne collectez pas de données personnelles au-delà de ce qui est affiché publiquement, respectez robots.txt et consultez un conseiller juridique pour un usage à grande échelle ou commercial. Ceci ne constitue pas un conseil juridique. Pour aller plus loin sur le cadre légal, consultez notre synthèse sur les implications juridiques du web scraping.
Conclusion : scraper les avis Amazon avec Python, ou s’épargner le code complètement
Récapitulatif rapide de ce que ce guide a couvert :
- Le mur de connexion est bien réel, mais on peut le contourner avec une authentification par cookies — copiez 7 cookies depuis votre navigateur et injectez-les dans une
requests.Session() - Utilisez les sélecteurs
data-hook, pas les classes CSS, pour une extraction qui ne casse pas toutes les quelques semaines - Combinez filtres par étoile et ordres de tri pour dépasser la limite de pagination de 10 pages et accéder à plus de 500 avis par produit
- Ajoutez une analyse de sentiment avec TextBlob pour une base rapide, ou Hugging Face Transformers pour une précision de niveau production
- Gardez vos défenses anti-bot à jour : limitation du débit, rotation des User-Agents, backoff exponentiel et proxies résidentiels à grande échelle
Python vous donne un contrôle total et reste la meilleure façon de comprendre ce qui se passe sous le capot. Mais si votre besoin ressemble plutôt à « j’ai besoin des avis des concurrents dans un tableur avant vendredi » qu’à « je veux construire un pipeline de données en production », le coût de maintenance d’un scraper personnalisé n’en vaut peut-être pas la peine.
Thunderbit gère l’authentification, les sélecteurs, la pagination et l’export en quelques clics — essayez la version gratuite et voyez si ça colle à votre flux de travail. À mesure qu’Amazon renforce ses défenses anti-bot, les outils alimentés par l’IA qui s’adaptent en temps réel vont passer du statut de confort à celui de nécessité.
Vous pouvez aussi consulter notre chaîne YouTube Thunderbit pour des tutos vidéo sur les workflows de scraping.
FAQ
1. Peut-on scraper les avis Amazon sans se connecter ?
Oui, mais seulement les ~8 « avis mis en avant » affichés sur la page produit (/dp/{ASIN}/). Les pages d’avis complètes avec tri, filtres et pagination exigent une authentification depuis fin 2024. Pour la plupart des cas d’usage business, il faudra gérer le mur de connexion.
2. Est-il légal de scraper les avis Amazon ?
Les conditions d’utilisation d’Amazon interdisent le scraping automatisé. Cependant, la jurisprudence récente aux États-Unis (Meta v. Bright Data, 2024 ; hiQ v. LinkedIn) soutient le scraping de données publiquement accessibles. Le scraping derrière une connexion comporte un risque juridique plus élevé, puisque vous avez accepté les CGU d’Amazon. Consultez un conseiller juridique pour un usage commercial.
3. Combien d’avis Amazon puis-je scraper par produit ?
Amazon limite les pages d’avis à 10 par combinaison ordre de tri + filtre par étoile. En utilisant les 5 filtres par étoile × 2 ordres de tri, vous pouvez accéder à jusqu’à 100 pages (environ 1 000 avis) par produit. Avec des filtres par mots-clés, le plafond théorique est bien plus haut, mais avec beaucoup de doublons.
4. Quelle est la meilleure bibliothèque Python pour scraper les avis Amazon ?
requests + BeautifulSoup pour l’analyse HTML statique est la combinaison la plus courante et la plus fiable. Selenium est utile quand le rendu JavaScript est nécessaire. Pour une alternative sans code qui gère automatiquement le mur de connexion et la pagination, essayez Thunderbit.
5. Comment éviter d’être bloqué en scrapant Amazon ?
Faites tourner les chaînes User-Agent parmi au moins 10 navigateurs réels, ajoutez des délais aléatoires de 2 à 5 secondes entre les requêtes, implémentez un backoff exponentiel sur les erreurs 503/429, utilisez des proxies résidentiels à grande échelle (les IP de datacenter sont pré-bloquées) et gardez des cookies de session cohérents entre les requêtes. Pour une approche sans maintenance, Thunderbit gère automatiquement les défenses anti-bot via votre session navigateur.
En savoir plus
