Comment je récupère les avis Amazon avec Python (même derrière la page de connexion)

Mon extracteur d’avis Amazon tournait nickel depuis six semaines — puis, un matin, il m’a renvoyé un 200 OK avec une page vide. Pas d’erreur, pas de CAPTCHA, juste du HTML vide là où il y avait des centaines d’avis.

Si ça vous parle, vous n’êtes pas seul. Fin 2025, Amazon a commencé à bloquer l’accès à ses pages d’avis complètes derrière une page de connexion, et une grosse partie des scripts Python de scraping a cessé de fonctionner du jour au lendemain. Ces derniers mois, chez , j’ai bossé sur le sujet des deux côtés — en développant notre extracteur IA et en gardant aussi mon propre pipeline Python d’avis — alors je me suis dit qu’il était temps d’écrire le guide que j’aurais aimé avoir quand mon script a arrêté de répondre. Cet article couvre l’approche qui marche : authentification par cookies, sélecteurs stables qui tiennent bon malgré l’obfuscation CSS d’Amazon, contournement de la limite de pagination à 10 pages, protections anti-bot, et en bonus une partie analyse de sentiment qui transforme le texte brut des avis en vrais insights métier. Et si, au milieu, vous vous dites : « Franchement, je n’ai pas envie de maintenir tout ce code », je vous montrerai comment fait le même boulot en deux minutes environ, sans écrire une ligne de Python.

Qu’est-ce que le scraping des avis Amazon et pourquoi est-ce important ?

Le scraping des avis Amazon consiste à extraire automatiquement des données d’avis clients — notes étoiles, texte de l’avis, nom de l’auteur, date, badge d’achat vérifié — depuis les pages produits Amazon. Depuis qu’Amazon a (sans jamais le remettre), le scraping web reste la seule voie programmatique pour accéder à ces données.

Les chiffres parlent d’eux-mêmes. , et . Afficher seulement 5 avis sur une page produit peut . Les entreprises qui analysent systématiquement le sentiment des avis constatent . Ici, on ne parle pas de science des données abstraite : ce sont des signaux concrets pour améliorer un produit, surveiller la concurrence et affiner son marketing, tous disponibles en clair sur les serveurs d’Amazon.

Pourquoi extraire les avis Amazon avec Python

Python reste le langage de référence pour ce type de tâche. C’est le , et son écosystème — requests, BeautifulSoup, pandas, Scrapy — rend le scraping web accessible même à celles et ceux qui ne sont pas développeurs à plein temps.

Les équipes exploitent ces données de différentes manières :

Une marque d’ustensiles de cuisine , a retravaillé son produit, puis a repris la place de n°1 des meilleures ventes en 60 jours. Une entreprise de traqueurs d’activité , a identifié un problème d’allergie au latex, a lancé une version hypoallergénique et a réduit les retours de 40 %. C’est ce genre de ROI qui justifie l’effort d’ingénierie.

Page de connexion : pourquoi votre extracteur d’avis Amazon a cessé de fonctionner

Le 14 novembre 2024, . Ce changement a été confirmé dans et sur . Si vous ouvrez /product-reviews/{ASIN}/ dans une fenêtre de navigation privée, vous serez redirigé vers une page de connexion au lieu d’obtenir les avis.

Les symptômes sont subtils : votre script reçoit bien une réponse 200 OK, mais le HTML contient un formulaire de connexion (name="email", id="ap_password") à la place des avis. Aucun code d’erreur. Aucun 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 du blocage n’est pas toujours uniforme — parfois, une fenêtre de navigateur neuve affiche quelques avis avant que la barrière ne s’active, surtout sur la première page — mais pour tout extracteur à l’échelle, il faut partir du principe que la barrière est toujours là.

Les différents domaines pays d’Amazon (.de, .co.uk, .co.jp) appliquent cette barrière séparément. Comme l’a dit un utilisateur sur un forum : « une connexion par pays est requise ». Vos cookies .com ne marcheront pas sur .co.uk.

Avis mis en avant vs avis complets : ce que vous pouvez encore voir sans connexion

Les pages produit Amazon (l’URL /dp/{ASIN}/) affichent encore environ sans authentification. Ces avis sont choisis par l’algorithme d’Amazon et sont utiles pour un diagnostic 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 — demandent une connexion.

Si vous n’avez besoin que de quelques avis pour un aperçu rapide, scrapez la page produit. Pour des centaines ou des milliers d’avis, il faudra gérer l’authentification.

Ce qu’il vous faut avant de commencer : environnement Python et bibliothèques

Avant d’écrire une seule ligne de code, voici la configuration :

• Niveau : intermédiaire (à l’aise avec Python, notions de HTML)
• Temps nécessaire : environ 45 minutes pour le pipeline complet ; ~10 minutes pour un scraping basique
• Prérequis : Python 3.8+, navigateur Chrome, compte Amazon valide

Installez les bibliothèques principales :

1pip install requests beautifulsoup4 lxml pandas textblob

Optionnel (pour une analyse de sentiment plus poussée) :

1pip 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 cette clé que vous utiliserez dans l’URL des avis.

Étape 1 : franchir la page de connexion avec une 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 connexion avec Selenium.

Vous avez besoin de ces sept cookies :

Comment extraire les cookies depuis Chrome DevTools

1. Connectez-vous à amazon.com dans Chrome
2. Ouvrez DevTools (F12 ou clic droit → Inspecter)
3. Allez dans Application → Storage → Cookies → https://www.amazon.com
4. Repérez chaque nom de cookie dans le tableau et copiez sa valeur
5. Formatez-les en chaîne séparée par des points-virgules pour Python

Configurez votre session comme suit :

1import requests
2session = requests.Session()
3# Collez vos valeurs de cookies ici
4cookies = {
5    "session-id": "YOUR_SESSION_ID",
6    "session-id-time": "YOUR_SESSION_ID_TIME",
7    "session-token": "YOUR_SESSION_TOKEN",
8    "ubid-main": "YOUR_UBID_MAIN",
9    "at-main": "YOUR_AT_MAIN",
10    "sess-at-main": "YOUR_SESS_AT_MAIN",
11    "x-main": "YOUR_X_MAIN",
12}
13headers = {
14    "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",
15    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
16    "Accept-Language": "en-US,en;q=0.5",
17}
18session.cookies.update(cookies)
19session.headers.update(headers)

Important : réutilisez le même objet session pour toutes vos requêtes. Ça garde les cookies cohérents et imite une vraie session de navigateur. En général, les cookies durent de quelques jours à quelques semaines sous charge de scraping, mais si vous retombez sur des redirections vers la connexion, rafraîchissez-les depuis votre navigateur.

Pour les places de marché hors .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 analyser le HTML des avis avec BeautifulSoup

L’URL des avis Amazon suit ce format :

1https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1

La fonction principale :

1from bs4 import BeautifulSoup
2import time, random
3def get_soup(session, url):
4    time.sleep(random.uniform(2, 5))  # Pause polie
5    response = session.get(url, timeout=15)
6    # Détection de la page de connexion
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("Page de connexion détectée — rafraîchissez vos cookies")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    return BeautifulSoup(response.text, "lxml")

Petite astuce utile : avant d’ouvrir la page d’avis, visitez d’abord la page produit. Ça crée un schéma de navigation plus naturel dans la session.

1# Visiter d’abord la page produit (imite une navigation réelle)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# Puis accéder à la page des avis
6reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
7soup = get_soup(session, reviews_url)

Étape 3 : utiliser des sélecteurs stables pour extraire les avis (ne vous fiez plus aux classes CSS)

C’est ici 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 frustré sur un forum : « aucun n’avait un seul schéma cohérent 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 dont dépend le frontend d’Amazon, donc ils ne sont pas randomisés.

Le code d’extraction avec les sélecteurs data-hook :

1import re
2def extract_reviews(soup):
3    reviews = []
4    review_divs = soup.select('[data-hook="review"]')
5    for div in review_divs:
6        # Note étoilée
7        rating_el = div.select_one('[data-hook="review-star-rating"]')
8        rating = None
9        if rating_el:
10            rating_text = rating_el.get_text(strip=True)
11            match = re.search(r'(\d\.?\d?)', rating_text)
12            if match:
13                rating = float(match.group(1))
14        # Titre
15        title_el = div.select_one('[data-hook="review-title"]')
16        title = title_el.get_text(strip=True) if title_el else ""
17        # Contenu
18        body_el = div.select_one('[data-hook="review-body"]')
19        body = body_el.get_text(strip=True) if body_el else ""
20        # Auteur
21        author_el = div.select_one('span.a-profile-name')
22        author = author_el.get_text(strip=True) if author_el else ""
23        # Date et pays
24        date_el = div.select_one('[data-hook="review-date"]')
25        date_text = date_el.get_text(strip=True) if date_el else ""
26        # Format : "Reviewed in the United States on January 15, 2025"
27        country_match = re.search(r'Reviewed in (.+?) on', date_text)
28        date_match = re.search(r'on (.+)$', date_text)
29        country = country_match.group(1) if country_match else ""
30        date = date_match.group(1) if date_match else ""
31        # Achat vérifié
32        verified_el = div.select_one('[data-hook="avp-badge"]')
33        verified = bool(verified_el)
34        reviews.append({
35            "author": author,
36            "rating": rating,
37            "title": title,
38            "content": body,
39            "date": date,
40            "country": country,
41            "verified": verified,
42        })
43    return reviews

J’utilise cet ensemble de sélecteurs sur plusieurs ASIN depuis des mois, et les attributs data-hook n’ont pas changé une seule fois. Les classes CSS, elles, ont déjà changé au moins deux fois sur la même période.

Étape 4 : gérer la pagination et la limite Amazon de 10 pages

Amazon limite le paramètre pageNumber à 10 pages de 10 avis chacune — un plafond strict d’environ 100 avis par combinaison de filtres. Le bouton « Page suivante » disparaît tout simplement après la page 10.

Boucle de pagination de base :

1all_reviews = []
2for page in range(1, 11):
3    url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
4    soup = get_soup(session, url)
5    page_reviews = extract_reviews(soup)
6    if not page_reviews:
7        break  # Plus d'avis sur cette page
8    all_reviews.extend(page_reviews)
9    print(f"Page {page}: {len(page_reviews)} avis")

Comment récupérer plus de 10 pages d’avis Amazon

Le contournement consiste à segmenter par filtres. Chaque combinaison de filterByStar et sortBy a 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 approcherez souvent l’ensemble des avis.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # Déduplication simple
5for star in star_filters:
6    for sort in sort_orders:
7        for page in range(1, 11):
8            url = (
9                f"https://www.amazon.com/product-reviews/{asin}"
10                f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
11            )
12            soup = get_soup(session, url)
13            page_reviews = extract_reviews(soup)
14            if not page_reviews:
15                break
16            for review in page_reviews:
17                # Déduplication par combinaison titre + auteur
18                key = (review["title"], review["author"])
19                if key not in seen_titles:
20                    seen_titles.add(key)
21                    all_reviews.append(review)
22            print(f"[{star}/{sort}] Page {page}: {len(page_reviews)} avis")
23print(f"Total d'avis uniques : {len(all_reviews)}")

Il y aura des chevauchements entre les segments, donc la déduplication est indispensable. J’utilise une combinaison titre de l’avis + nom de l’auteur comme clé rapide — ce n’est pas parfait, mais ça enlève la grande majorité des doublons.

Étape 5 : contourner les protections anti-bot (rotation, ralentissement, retries)

Amazon utilise AWS WAF Bot Control, et c’est devenu nettement plus agressif. Les contre-mesures simples (seulement tourner les User-Agents, seulement ajouter des délais) ne suffisent plus.

Un wrapper de retry prêt pour la prod :

1import time, random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
4    "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",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
6    "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",
7    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
8]
9def scrape_with_retries(session, url, max_retries=3):
10    for attempt in range(max_retries):
11        try:
12            session.headers["User-Agent"] = random.choice(USER_AGENTS)
13            time.sleep(random.uniform(2, 5))
14            response = session.get(url, timeout=15)
15            # Détection des blocages
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"CAPTCHA détecté. Attente {wait}s...")
19                time.sleep(wait)
20                continue
21            if response.status_code in (429, 503):
22                wait = (2 ** attempt) * 2
23                print(f"Limitation détectée ({response.status_code}). Attente {wait}s...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("Page de connexion — cookies expirés")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"Échec de la tentative {attempt + 1} : {e}")
33    return None

Pour les proxies : Amazon (AWS, GCP, Azure, DigitalOcean) au niveau réseau. Si vous scrapez plus de quelques centaines de pages, les proxies résidentiels deviennent quasiment indispensables — comptez 50 à 200 $/mois ou plus selon le volume. Pour les petits projets (moins de 100 requêtes/jour), un throttling propre depuis votre IP domestique fonctionne souvent très bien.

Amazon inspecte aussi les empreintes TLS. La bibliothèque requests de Python a une . Pour les scrapers de production, envisagez curl_cffi, qui imite les stacks TLS de vrais navigateurs. Pour un scraping à l’échelle d’un 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 les avis collectés, les mettre dans un format exploitable est simple avec pandas :

1import pandas as pd
2df = pd.DataFrame(all_reviews)
3df.to_csv("amazon_reviews.csv", index=False)
4print(f"Exporté {len(df)} avis vers amazon_reviews.csv")

Exemple de sortie :

Pour l’export Excel : df.to_excel("amazon_reviews.xlsx", index=False) (nécessite openpyxl).

Pour Google Sheets, la bibliothèque gspread fonctionne, mais demande — créer un projet, activer deux API, générer des identifiants de service, partager la feuille. Si ça vous semble plus long que le scraping lui-même, vous n’avez pas tort. (C’est exactement le genre de moment où un outil comme 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 c’est l’analyse de sentiment qui transforme des données brutes en décisions métier.

Le baseline le plus rapide utilise TextBlob :

1from textblob import TextBlob
2df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)

Vous obtenez pour chaque avis un score de polarité compris entre -1.0 (très négatif) et +1.0 (très positif). Exemple de sortie :

Les lignes les plus intéressantes sont les écarts — un avis 3 étoiles avec un texte positif, ou un avis 5 étoiles avec un langage négatif. Ces différences révèlent souvent des avis clients nuancés que la seule note étoilée ne montre pas.

Pour une précision de niveau production, la recommandation est Hugging Face Transformers. , et par rapport aux outils lexicaux. Le modèle nlptown/bert-base-multilingual-uncased-sentiment peut même prédire directement des notes de 1 à 5 étoiles :

1from transformers import pipeline
2clf = pipeline("sentiment-analysis",
3               model="nlptown/bert-base-multilingual-uncased-sentiment")
4df["predicted_stars"] = df["content"].apply(
5    lambda x: int(clf(str(x)[:512])[0]["label"][0])
6)

Les avis Amazon suivent une — un gros pic à 5 étoiles, un pic plus petit à 1 étoile, et un creux au milieu. Ça veut dire que la note moyenne est souvent un mauvais indicateur de la vraie qualité du produit. Segmentez le groupe 1 étoile et cherchez les thèmes récurrents — c’est souvent là qu’est caché un défaut corrigeable.

Le compromis honnête : Python maison vs API de scraping payante vs Thunderbit

J’ai gardé des scrapers Python pour Amazon, et soyons francs : ils cassent. Les sélecteurs changent, les cookies expirent, Amazon déploie une nouvelle couche de détection des bots, et d’un coup votre samedi matin se transforme en débogage de scraper au lieu d’analyse de données. Les utilisateurs des forums racontent la même galère — les scripts maison qui « marchaient le mois dernier » demandent maintenant des correctifs en permanence.

Voici la comparaison des trois approches principales :

Python vous donne un contrôle total et reste la meilleure façon de comprendre le scraping web en profondeur. Les API payantes (ScrapingBee, Oxylabs, Bright Data) ont du sens 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 la surcharge de développement — opérations e-commerce qui surveillent les produits concurrents chaque semaine, équipes marketing qui récupèrent le langage client pour les annonces — il existe une troisième voie.

Comment extraire les avis Amazon avec Thunderbit (sans code, sans maintenance)

Nous avons conçu pour les cas où maintenir un scraper Python ressemble clairement à du surdimensionnement. Le workflow est le suivant :

1. Installez l’
2. Rendez-vous sur la page d’avis du produit Amazon dans votre navigateur (vous êtes déjà connecté, donc la barrière de connexion ne pose plus problème)
3. 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é
4. Cliquez sur "Scrape" — les données sont extraites instantanément, avec pagination intégrée
5. Exportez vers Excel, Google Sheets, Airtable ou Notion

Le principal avantage 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 celles et ceux qui veulent un accès programmatique sans tout faire eux-mêmes, Thunderbit propose aussi une — extraction structurée via API avec détection de champs alimentée par l’IA, sans maintenance des sélecteurs.

Pour aller plus loin sur les données Amazon, consultez nos guides sur et .

Conseils pour extraire des avis Amazon à grande échelle avec Python

Si vous scrapez des avis sur de nombreux ASIN, quelques bonnes pratiques vous éviteront pas mal d’ennuis :

• Traitez vos 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 d’étoiles 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 les relancer sans tout rescraper.
• Stockez dans une base de données pour les gros projets. Une simple base SQLite évolue bien mieux que des fichiers CSV qui grossissent sans cesse :

1import sqlite3
2conn = sqlite3.connect("reviews.db")
3df.to_sql("reviews", conn, if_exists="append", index=False)

• Planifiez des extractions récurrentes. Pour un suivi continu, configurez une tâche cron ou utilisez la fonctionnalité Scheduled Scraper de Thunderbit — décrivez l’URL et le planning, et le reste est géré sans serveur.

Pour d’autres approches, nos articles sur et présentent d’autres options.

Petite note sur les aspects juridiques et éthiques

Les 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 américaine récente a été favorable aux scrapers de données publiques. Dans , 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 est importante : scraper derrière une connexion (ce qui est le sujet de 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. Le scraping d’avis visibles publiquement comporte moins de risques juridiques que le scraping derrière la page de connexion.

Règles de bon sens : ne redistribuez pas commercialement les données extraites, ne récupérez pas de données personnelles au-delà de ce qui est affiché publiquement, respectez robots.txt, et consultez un juriste pour un usage commercial ou à grande échelle. Ceci ne constitue pas un avis juridique. Pour aller plus loin sur le cadre légal, consultez notre synthèse sur .

Conclusion : extraire les avis Amazon avec Python ou s’éviter le code

Récapitulatif rapide de ce que ce guide a couvert :

• La page de connexion est bien réelle, mais elle peut être contournée avec une authentification par cookies — copiez 7 cookies depuis votre navigateur et injectez-les dans une requests.Session()
• Utilisez des sélecteurs data-hook, pas des classes CSS, pour une extraction qui ne casse pas toutes les deux semaines
• Combinez les filtres d’étoiles et les ordres de tri pour dépasser la limite de 10 pages et accéder à 500+ avis par produit
• Ajoutez une analyse de sentiment avec TextBlob pour une approche rapide, ou Hugging Face Transformers pour une précision de niveau production
• Mettez en place des protections anti-bot : throttling, rotation des User-Agents, backoff exponentiel et proxies résidentiels pour passer à l’é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 à « j’ai besoin des avis concurrents dans un tableur avant vendredi » plutôt qu’à « je veux construire un pipeline de données de production », la maintenance d’un scraper sur mesure n’en vaut peut-être pas la peine.

gère l’authentification, les sélecteurs, la pagination et l’export en quelques clics — essayez l’ et voyez si ça colle à votre workflow. À mesure qu’Amazon renforce ses protections anti-bot, les outils IA capables de s’adapter en temps réel vont passer du statut de confort à celui de nécessité.

Vous pouvez aussi consulter notre pour des démonstrations vidéo de workflows de scraping.

FAQ

1. Peut-on extraire 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, filtrage et pagination nécessitent une authentification depuis fin 2024. Pour la plupart des usages pro, vous devrez gérer la page 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 américaine récente (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 juriste pour un usage commercial.

3. Combien d’avis Amazon puis-je extraire par produit ?

Amazon limite les pages d’avis à 10 par combinaison d’ordre de tri et de filtre d’étoiles. En utilisant les 5 filtres d’étoiles × 2 ordres de tri, vous pouvez accéder jusqu’à 100 pages, soit environ 1 000 avis par produit. Avec les filtres par mots-clés, le plafond théorique est bien plus élevé, 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 les pages de connexion et la pagination, essayez .

5. Comment éviter d’être bloqué lors du scraping Amazon ?

Faites tourner les chaînes User-Agent à partir d’un pool de plus de 10 vrais navigateurs, ajoutez des délais aléatoires de 2 à 5 secondes entre les requêtes, mettez en place un backoff exponentiel sur les erreurs 503/429, utilisez des proxies résidentiels à grande échelle (les IP de datacenter sont bloquées en amont), et gardez des cookies de session cohérents entre les requêtes. Pour une approche sans maintenance, Thunderbit gère automatiquement les protections anti-bot via votre session navigateur.

En savoir plus