Comment scraper les avis Amazonnotes, texte et sentiment

Les avis produit Amazon sont l'un des signaux publics les plus riches du web ouvert. La note en étoiles, le titre, le corps du texte et la date de chaque avis constituent un enregistrement continu de ce que les vrais acheteurs pensent d'un produit. Ces données alimentent l'analyse de sentiment, la recherche produit et la comparaison concurrentielle, ce qui explique pourquoi les équipes veulent un flux propre et structuré plutôt que de faire défiler la page à la main.

Ce guide vous montre comment scraper les avis Amazon avec Python. Vous construisez un scraper léger et fonctionnel qui récupère la page d'avis d'un produit via la Crawling API, parse chaque avis avec BeautifulSoup, parcourt la pagination, et exporte les résultats en JSON et CSV. L'ensemble du tutoriel reste limité au texte d'avis public qu'Amazon montre à tout visiteur, et la section légalité vers la fin n'est pas du remplissage, lisez-la avant de pointer ce code sur un volume réel.

Ce que vous allez construire

Un script Python qui prend l'URL de la page d'avis d'un produit Amazon, récupère la page rendue via la Crawling API, et extrait un enregistrement structuré par avis. Nous utiliserons le Meta Quest Pro comme exemple fil conducteur et extrairons ces champs de chaque bloc d'avis :

• Nom du critique le nom d'affichage public affiché sur l'avis.
• Note le score en étoiles, par exemple "4.0 out of 5 stars".
• Titre le court titre que le critique a donné à l'avis.
• Corps du texte le texte complet de l'avis rédigé.
• Date la ligne "Reviewed in the United States on ...".

Le script collecte ces enregistrements sur toutes les pages d'avis et les écrit dans amazon_reviews.json et amazon_reviews.csv, prêts pour un modèle de sentiment, un tableur ou une base de données.

Pourquoi une simple requête échoue sur Amazon

Si vous pointez un client HTTP basique sur une URL d'avis Amazon, vous obtenez rarement les avis. Amazon est l'un des sites les plus fortement défendus du web contre le trafic automatisé. Une IP de datacenter, ou une requête qui ne ressemble pas à un vrai navigateur, se heurte à un CAPTCHA, une page interstitielle "Robot Check", ou un blocage pur avant d'atteindre les blocs d'avis. Même quand une requête passe, certaines parties de la page se rendent via JavaScript, de sorte qu'une simple requête peut renvoyer une coquille plutôt qu'un markup fini.

Un scraper d'avis Amazon fonctionnel a donc besoin de deux choses en une seule requête : un navigateur qui rende vraiment la page, et une IP que la plateforme lit comme un vrai acheteur. Vous pouvez assembler cela vous-même avec un navigateur headless plus un pool de proxies résidentiels rotatifs, mais les assembler et les maintenir en état représente l'essentiel du travail. La Crawling API regroupe les deux en un seul appel : vous lui envoyez l'URL, elle rend la page derrière une IP résidentielle de confiance, fait pivoter les adresses pour vous, et renvoie le HTML fini pour BeautifulSoup.

Prérequis

Vous avez besoin de quelques éléments en place avant d'écrire du code. Aucun ne prend longtemps.

Python de base. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des packages avec pip. Si vous êtes nouveau dans le langage, l'introduction à scraper un site web avec Python et tout cours pour débutants vous amèneront au niveau que ce tutoriel suppose.

Python 3.8 ou ultérieur. Confirmez votre version avec python --version. Si vous ne l'avez pas, installez-le depuis python.org ou via une distribution comme Anaconda.

Un compte Crawlbase et un token. Inscrivez-vous, ouvrez votre tableau de bord, et copiez votre token depuis la page docs du compte. Crawlbase vous offre jusqu'à 20 000 requêtes gratuites pour commencer sans carte, et vous ne payez que les requêtes réussies. Traitez le token comme un mot de passe : il authentifie vos requêtes, donc gardez-le hors du contrôle de version.

Configurer le projet

Créez un environnement virtuel pour que les dépendances du projet restent isolées, puis installez les deux bibliothèques dont le scraper a besoin.

python --version

python -m venv amazon_env
source amazon_env/bin/activate

pip install crawlbase beautifulsoup4

Sur Windows, activez l'environnement avec amazon_env\Scripts\activate plutôt que la ligne source. Deux dépendances font le travail : crawlbase est le client officiel de la Crawling API, et beautifulsoup4 parse le HTML renvoyé pour que vous puissiez extraire chaque champ d'un bloc d'avis par sélecteur CSS.

Comprendre la page d'avis Amazon

Avant d'écrire des sélecteurs, ouvrez la page d'avis d'un produit dans votre navigateur, faites un clic droit sur un seul avis, et choisissez Inspecter. Amazon enveloppe chaque avis dans un conteneur marqué avec data-hook="review", et expose les champs individuels via des attributs data-hook stables à l'intérieur de ce conteneur. Ces hooks sont bien plus durables que les noms de classe utilitaires d'Amazon, donc ciblez-les chaque fois que possible.

Les champs qui vous intéressent correspondent à ces hooks dans chaque bloc d'avis :

• Nom du critique l'élément span.a-profile-name.
• Note [data-hook="review-star-rating"] (ou review-star-rating-view-point sur certaines mises en page).
• Titre [data-hook="review-title"].
• Corps du texte [data-hook="review-body"].
• Date [data-hook="review-date"].

Étape 1 : Récupérer la page d'avis rendue

Commencez par obtenir la page finie. Importez la classe CrawlingAPI, initialisez-la avec votre token, pointez-la sur l'URL d'avis d'un produit, et demandez-la. Vérifier le code de statut avant de parser garde les erreurs visibles plutôt que silencieuses.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

REVIEWS_URL = (
    "https://www.amazon.com/Meta-Quest-Pro-Oculus/product-reviews/"
    "B09Z7KGTVW/?reviewerType=all_reviews"
)

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 3000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("latin1")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    html = crawl(REVIEWS_URL)
    print(html[:500] if html else "No HTML returned")

Les deux options d'attente aident quand certaines parties de la page se chargent de façon asynchrone. ajax_wait indique à l'API d'attendre que le contenu asynchrone ait fini, et page_wait maintient un nombre fixe de millisecondes après le chargement pour que les blocs d'avis à rendu tardif apparaissent avant la capture de la page. Le body est décodé en latin1 car les pages Amazon mélangent des caractères sur lesquels le décodage strict UTF-8 peut échouer. Lancez le script et vous devriez voir un vrai markup d'avis, pas une page Robot Check. Cela confirme que la requête passe avant d'écrire un seul sélecteur.

Étape 2 : Parser les avis avec BeautifulSoup

Avec le HTML rendu en main, chargez-le dans BeautifulSoup, trouvez chaque bloc d'avis, et extrayez chaque champ par son sélecteur data-hook. Enveloppez chaque bloc dans un try/except pour qu'un avis malformé ne fasse pas planter l'exécution.

from bs4 import BeautifulSoup

def text_of(block, selector):
    el = block.select_one(selector)
    return el.get_text(strip=True) if el else None

def parse_reviews(html):
    soup = BeautifulSoup(html, "html.parser")
    blocks = soup.select('div[data-hook="review"]')
    reviews = []
    for block in blocks:
        try:
            reviews.append({
                "reviewer_name": text_of(block, "span.a-profile-name"),
                "rating": text_of(block, '[data-hook="review-star-rating"]'),
                "title": text_of(block, '[data-hook="review-title"]'),
                "text": text_of(block, '[data-hook="review-body"]'),
                "date": text_of(block, '[data-hook="review-date"]'),
            })
        except Exception as e:
            print(f"Skipped a review: {e}")
    return reviews

Le helper text_of interroge un seul élément dans un bloc d'avis et renvoie None quand l'élément est absent, au lieu de lever une exception sur un appel .get_text() sur rien. Cela garde l'extraction résiliente quand un champ est absent. Le sélecteur de note en étoiles se rabat gracieusement : si review-star-rating ne renvoie rien sur une mise en page particulière, utilisez review-star-rating-view-point, qu'Amazon utilise sur certaines pages. La note arrive comme une chaîne du type "4.0 out of 5 stars" ; divisez sur " out of" ensuite si vous voulez un score numérique brut pour un modèle.

Étape 3 : Parcourir la pagination des avis

Une page est une démo ; un vrai travail couvre toutes les pages d'avis d'un produit. Amazon pagine les avis avec un paramètre de requête pageNumber, vous parcourez donc les pages en l'incrémentant et vous arrêtez quand une page ne renvoie aucun bloc d'avis. Cela évite de coder en dur un nombre de pages et gère naturellement les produits avec seulement quelques avis.

Pour voir le schéma, comparez les URLs qu'Amazon utilise :

• Page 1 .../product-reviews/B09Z7KGTVW/?reviewerType=all_reviews
• Page 2 .../product-reviews/B09Z7KGTVW/?reviewerType=all_reviews&pageNumber=2
• Page 3 .../product-reviews/B09Z7KGTVW/?reviewerType=all_reviews&pageNumber=3

import time

def scrape_all_reviews(base_url, max_pages=10):
    all_reviews = []
    for page in range(1, max_pages + 1):
        page_url = f"{base_url}&pageNumber={page}"
        html = crawl(page_url)
        if not html:
            break
        reviews = parse_reviews(html)
        if not reviews:
            print(f"No reviews on page {page}; stopping.")
            break
        all_reviews.extend(reviews)
        print(f"Page {page}: {len(reviews)} reviews")
        time.sleep(2)
    return all_reviews

La limite max_pages garde une exécution bornée pour qu'un produit avec des milliers d'avis ne tourne pas indéfiniment, et l'arrêt sur résultats vides vous arrête tôt quand Amazon n'a plus de pages. Le time.sleep(2) entre les pages rythme les requêtes pour ne pas marteler le site dans une boucle serrée, ce qui est la façon la plus rapide d'être throttlé. Ajustez les deux selon votre volume et les limites de débit ci-dessous.

Étape 4 : Assembler et stocker les données

Câblez maintenant le fetch, le parse et la pagination en un seul script exécutable, puis écrivez les avis collectés en JSON et CSV. Le JSON conserve la structure imbriquée pour un pipeline ; le CSV s'insère directement dans un tableur ou un DataFrame pandas pour le travail de sentiment.

import csv
import json
import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

REVIEWS_URL = (
    "https://www.amazon.com/Meta-Quest-Pro-Oculus/product-reviews/"
    "B09Z7KGTVW/?reviewerType=all_reviews"
)

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 3000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("latin1")
    print(f"Request failed: {response['status_code']}")
    return None

def text_of(block, selector):
    el = block.select_one(selector)
    return el.get_text(strip=True) if el else None

def parse_reviews(html):
    soup = BeautifulSoup(html, "html.parser")
    blocks = soup.select('div[data-hook="review"]')
    reviews = []
    for block in blocks:
        try:
            reviews.append({
                "reviewer_name": text_of(block, "span.a-profile-name"),
                "rating": text_of(block, '[data-hook="review-star-rating"]'),
                "title": text_of(block, '[data-hook="review-title"]'),
                "text": text_of(block, '[data-hook="review-body"]'),
                "date": text_of(block, '[data-hook="review-date"]'),
            })
        except Exception as e:
            print(f"Skipped a review: {e}")
    return reviews

def scrape_all_reviews(base_url, max_pages=10):
    all_reviews = []
    for page in range(1, max_pages + 1):
        page_url = f"{base_url}&pageNumber={page}"
        html = crawl(page_url)
        if not html:
            break
        reviews = parse_reviews(html)
        if not reviews:
            break
        all_reviews.extend(reviews)
        print(f"Page {page}: {len(reviews)} reviews")
        time.sleep(2)
    return all_reviews

def save(reviews):
    with open("amazon_reviews.json", "w", encoding="utf-8") as f:
        json.dump(reviews, f, indent=2, ensure_ascii=False)
    if reviews:
        with open("amazon_reviews.csv", "w", newline="", encoding="utf-8") as f:
            writer = csv.DictWriter(f, fieldnames=reviews[0].keys())
            writer.writeheader()
            writer.writerows(reviews)
    print(f"Saved {len(reviews)} reviews to JSON and CSV")

def main():
    reviews = scrape_all_reviews(REVIEWS_URL)
    save(reviews)

if __name__ == "__main__":
    main()

Lancez-le avec python scraper.py. Le script parcourt les pages d'avis, affiche un compte par page, et écrit amazon_reviews.json et amazon_reviews.csv dans le même répertoire. De là, les enregistrements alimentent un modèle de sentiment, un graphique de tendance des notes, ou une comparaison avec le produit d'un concurrent. Avant tout cela, il vaut la peine de faire passer les données par une étape de structuration et nettoyage des données scrapées pour l'IA et le ML pour que les notes et les dates arrivent dans des types cohérents.

À quoi ressemble la sortie

Chaque enregistrement est un objet plat avec les cinq champs. Le fichier JSON ressemble à ceci :

[
  {
    "reviewer_name": "Grrgoyl",
    "rating": "4.0 out of 5 stars",
    "title": "No regret",
    "text": "My 256 gb Quest 2 is in danger of running out of space, so the Pro was an easy call.",
    "date": "Reviewed in the United States on August 2, 2023"
  },
  {
    "reviewer_name": "Damian",
    "rating": "3.0 out of 5 stars",
    "title": "Excellent comfort, poor display",
    "text": "I purchased this to upgrade from my first gen Rift and the comfort is great, the display less so.",
    "date": "Reviewed in the United States on November 1, 2022"
  }
]

Le CSV porte les mêmes cinq colonnes : reviewer_name, rating, title, text et date. Si vous préférez sauter entièrement le parsing, la Crawling API renvoie ces champs pré-parsés en JSON via son parser amazon-product-reviews, qui expose aussi des extras comme l'ID de l'avis et le drapeau d'achat vérifié.

Rester non bloqué

Même avec le rendu et la rotation gérés pour vous, Amazon surveille le trafic à l'allure d'un scraper. Quelques habitudes maintiennent une exécution en bonne santé, et elles s'appliquent à toute cible commerciale exigeante.

• Rythmez vos requêtes. Répartissez les requêtes avec un délai entre les pages plutôt que de crawler à pleine vitesse. Le time.sleep dans la boucle de pagination est le plancher, pas le plafond.
• Appuyez-vous sur la rotation. Un pool d'IPs résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels pour qu'aucune ne déclenche une limite de débit. La Crawling API gère cela pour vous ; si vous montez votre propre stack, c'est la partie à soigner.
• Lisez les codes de statut. Une exécution qui commence à renvoyer des défis ou des erreurs vous dit que le taux actuel ou le niveau d'IP n'est plus suffisant. Traitez ça comme un signal de recul, pas du bruit à ignorer.

Pour le guide complet, consultez comment scraper des sites sans être bloqué. Si votre intérêt est la vue complète des avis sur plus d'un détaillant, le guide général comment scraper les avis clients couvre les schémas multi-sites, et scraper les données produit Amazon s'associe bien quand vous voulez les détails de l'annonce en parallèle des avis.

Est-il légal de scraper les avis Amazon ?

La légitimité du scraping des avis Amazon dépend des conditions d'utilisation d'Amazon, de votre juridiction, et de ce que vous faites des données. Les conditions d'utilisation d'Amazon restreignent l'accès automatisé, de sorte que le scraping peut contrevenir à ces conditions quelle que soit la qualité de vos outils. Aucun code ici ne change cela ; il rend simplement la partie technique fonctionnelle. Lisez les conditions d'utilisation d'Amazon et son robots.txt, et traitez les deux comme la limite de ce que vous collectez. Amazon lance également des défis CAPTCHA pour confirmer qu'un humain navigue, ce qui fait partie de la même posture défensive.

Quelques lignes à respecter. Collectez uniquement le texte d'avis public : la note, le titre, le corps et la date que tout visiteur peut lire sur la page d'avis sans compte. Le nom d'affichage affiché sur un avis est public, mais c'est le maximum que vous devriez conserver. Ne construisez pas de profils d'évaluateurs individuels, ne suivez pas les liens de profil pour assembler l'historique d'avis d'une personne sur plusieurs produits, et ne tentez pas de relier un nom d'affichage à une identité réelle. Respectez la vie privée et traitez chaque avis comme un point de données sur le produit, pas sur une personne.

Ce guide est délibérément limité aux pages d'avis publiques car c'est la ligne qui rend le travail défendable. Il ne couvre rien derrière une connexion, les données de compte ou de commande, ni aucune tentative de contourner l'authentification, et il ne redistribue pas de médias d'avis protégés par des droits d'auteur. Si vous avez besoin d'un accès sous licence ou en volume, Amazon propose des API officielles et des programmes partenaires pour les données produit et d'avis, et c'est le bon outil quand vous avez besoin de grands volumes, d'une structure garantie ou de droits commerciaux. Quand votre projet a besoin de plus que du texte d'avis public, une API officielle ou un accord de données est la bonne voie, pas un scraper plus ingénieux.

Foire aux questions

Pourquoi une simple requête échoue-t-elle sur les avis Amazon ?

Amazon défend fortement contre le trafic automatisé. Une IP de datacenter ou une requête qui ne ressemble pas à un vrai navigateur se heurte à un CAPTCHA, une page interstitielle Robot Check, ou un blocage avant d'atteindre les blocs d'avis, et certaines parties de la page se rendent via JavaScript en plus. La Crawling API rend la page derrière une IP résidentielle de confiance, de sorte que les avis sont présents quand BeautifulSoup les parse.

Quels champs puis-je extraire d'un avis Amazon ?

Ce scraper extrait le nom d'affichage public du critique, la note en étoiles, le titre de l'avis, le corps du texte et la date. Chacun correspond à un attribut data-hook dans le bloc d'avis : review-star-rating, review-title, review-body et review-date, plus span.a-profile-name pour le nom. Le parser amazon-product-reviews de la Scraper API renvoie les mêmes champs plus des extras comme l'ID de l'avis et un drapeau d'achat vérifié.

Comment scraper toutes les pages d'avis ?

Amazon pagine les avis avec un paramètre de requête pageNumber sur l'URL product-reviews. Incrémentez-le dans une boucle, parsez chaque page avec le même code, et arrêtez quand une page ne renvoie plus de blocs d'avis. Limitez le nombre de pages et ajoutez un court délai entre les requêtes pour rythmer l'exécution et éviter d'être throttlé.

Mes sélecteurs renvoient None. Qu'est-ce qui a changé ?

Presque certainement le markup d'Amazon. Ses noms de classe utilitaires changent sans préavis, ce qui explique pourquoi les sélecteurs ci-dessus ciblent les attributs data-hook à la place. Si la note en étoiles revient vide, essayez review-star-rating-view-point, qu'Amazon utilise sur certaines mises en page. Inspectez à nouveau une page d'avis live dans les outils de développement de votre navigateur et mettez à jour le sélecteur ; la maintenance périodique est normale pour tout scraper en production.

Puis-je utiliser les avis scrapés pour l'analyse de sentiment ?

Oui, c'est l'une des raisons les plus courantes de les collecter. Exportez en CSV, chargez dans pandas, et faites passer le corps du texte dans un modèle de sentiment ou une analyse de tendance des notes. Nettoyez d'abord la note en une valeur numérique et parsez la date en un vrai type date pour que les champs soient prêts pour le modèle.

Est-il sûr de stocker les noms des évaluateurs ?

Gardez-le minimal. Le nom d'affichage sur un avis public est public, mais c'est le maximum que vous devriez conserver, et vous ne devriez jamais l'utiliser pour construire un profil d'un évaluateur individuel ou relier un nom à une identité réelle. Traitez chaque avis comme un point de données sur le produit, respectez la vie privée, et vérifiez les conditions d'Amazon et vos règles locales de protection des données avant de stocker un champ personnel.

MA

Muhammad Atif

Développeur full stack senior · Crawlbase

Développeur full stack senior chez Crawlbase, il construit la plateforme et écrit sur l'architecture de scraping, les proxys et les pipelines de données.

IK

Ian Kalvin

Ingénieur support technique · Crawlbase

Ingénieur support technique chez Crawlbase, il écrit depuis la première ligne de ce qui casse réellement en production, sur les configurations de scraping et de proxys.