Comment extraire les meilleures ventes Amazonproduits les mieux classés par catégorie

Les pages Meilleures Ventes d'Amazon constituent un classement en direct et public de ce qui se vend réellement dans le catalogue. Chaque catégorie, des Electroniques aux Ordinateurs et Accessoires, possède sa propre liste ordonnée des meilleurs produits, actualisée chaque heure par Amazon, avec le rang, le titre, le prix et la note de chaque article directement sur la page. Ce classement est l'un des signaux de demande les plus propres du web ouvert, ce qui explique pourquoi les chercheurs de produits, les vendeurs et les analystes le suivent pour détecter les tendances, analyser la concurrence et prendre des décisions tarifaires.

Ce guide vous montre comment extraire une liste de Meilleures Ventes Amazon avec Python. Vous construisez un petit scraper fonctionnel qui récupère la page Meilleures Ventes d'une catégorie via la Crawling API, analyse un enregistrement propre pour chaque produit classé et exporte les résultats en JSON et CSV. Le tutoriel reste délibérément limité aux données de classement publiques : les noms, prix, notes et liens que tout le monde peut voir sur une page Meilleures Ventes sans se connecter.

Ce que vous allez construire

Un script Python qui prend une URL de catégorie Meilleures Ventes Amazon, récupère la page rendue via la Crawling API et extrait un enregistrement structuré par produit classé. Nous utilisons la page Meilleures Ventes en Ordinateurs et Accessoires comme exemple fil conducteur, la même catégorie que le tutoriel précédent utilisait, et extrayons ces champs de chaque fiche classée :

• Rang la position du produit dans la liste, par exemple 1 pour le meilleur vendeur.
• Titre le nom du produit affiché sur la fiche de classement.
• Prix le prix affiché, quand le produit en montre un.
• Note la note moyenne en étoiles, par exemple "4.7 sur 5 étoiles".
• Lien l'URL vers la propre page de détail du produit.

Pourquoi une simple requête échoue sur Amazon

Si vous pointez un simple client HTTP vers une URL Meilleures Ventes Amazon, vous obtenez rarement la liste classée souhaitée. Deux facteurs jouent contre vous. Premièrement, une grande partie de la grille de classement se rend côté client : Amazon livre une coquille légère et remplit les fiches au fur et à mesure que le JavaScript de la page s'exécute et que vous faites défiler, de sorte que le HTML initial manque souvent les articles les moins bien classés. Deuxièmement, Amazon détecte rapidement le trafic automatisé. Les plages d'IP de datacenter et les schémas de requêtes qui ne ressemblent pas à un vrai navigateur reçoivent un CAPTCHA, une page interstitielle de "vérification robot" ou un blocage pur avant d'atteindre la liste.

Un scraper Meilleures Ventes fonctionnel a donc besoin de deux choses en une seule requête : un navigateur qui rende la page, et une IP qu'Amazon reconnaît comme un vrai acheteur. Vous pouvez assembler cela vous-même avec un navigateur headless et un pool de proxies résidentiels rotatifs, mais maintenir cette pile en bon état représente l'essentiel du travail. La Crawling API regroupe les deux en un seul appel : vous lui envoyez l'URL de la catégorie, elle rend la page derrière une IP résidentielle de confiance, gère la rotation et la résolution des CAPTCHAs, et retourne le HTML terminé à analyser.

Prérequis

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

Python de base. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des paquets avec pip. Si vous êtes novice dans le langage, la documentation officielle Python ou n'importe quel cours débutant couvre le niveau que ce tutoriel suppose acquis.

Python 3.8 ou ultérieur. Vérifiez votre version avec python --version (ou python3 --version). Si vous ne l'avez pas, installez-le depuis python.org et assurez-vous que Python est dans votre PATH système.

Un compte Crawlbase et un token. Inscrivez-vous pour un compte gratuit, ouvrez votre tableau de bord et copiez votre token depuis la page de documentation du compte. Le niveau gratuit inclut jusqu'à 20 000 requêtes sans carte, ce qui est amplement suffisant pour construire et tester ce scraper. Traitez le token comme un mot de passe et gardez-le hors du contrôle de version.

Configurer le projet

Créez un environnement virtuel pour isoler les dépendances du projet, puis installez les deux bibliothèques dont le scraper a besoin. crawlbase est le client officiel de la Crawling API, et beautifulsoup4 analyse le HTML retourné pour extraire chaque champ des fiches de classement par sélecteur CSS.

python --version

python -m venv amazon_env
source amazon_env/bin/activate

pip install crawlbase beautifulsoup4

Sous Windows, activez l'environnement avec amazon_env\Scripts\activate à la place de la ligne source. Les deux bibliothèques installées, créez le fichier de script que le reste du guide construit :

touch amazon_best_sellers.py

Comprendre la page Meilleures Ventes

Chaque catégorie Meilleures Ventes Amazon se trouve à une URL /zgbs/ stable. La liste Ordinateurs et Accessoires, par exemple, est https://www.amazon.com/Best-Sellers-Computers-Accessories/zgbs/pc, et Electroniques est https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics. La page présente une grille ordonnée de fiches de classement, une par produit, chacune portant les mêmes quelques champs : un badge de rang, un titre, un prix, une note en étoiles et un lien vers la page de détail du produit.

Avant d'écrire des sélecteurs, ouvrez une page Meilleures Ventes dans votre navigateur, faites un clic droit sur une fiche de classement et choisissez Inspecter. Amazon encapsule chaque article classé dans un conteneur marqué avec un attribut id="gridItemRoot", affiche le rang dans un badge numéroté près du haut de la fiche et expose le titre, le prix et la note à l'intérieur de ce conteneur. Ce sont les éléments que vous ciblez. Les noms de classe utilitaires d'Amazon changent souvent, alors là où vous le pouvez, misez sur les attributs structurels plus durables comme id="gridItemRoot" plutôt qu'une chaîne de classes fragile.

Étape 1 : Récupérer la page Meilleures Ventes rendue

Commencez par obtenir la page terminée. Importez la classe CrawlingAPI, initialisez-la avec votre token, définissez l'URL de la catégorie et demandez-la. Vérifier le code de statut avant d'analyser rend les échecs visibles plutôt que silencieux.

from crawlbase import CrawlingAPI

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

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 4000}
    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__":
    bestsellers_url = "https://www.amazon.com/Best-Sellers-Computers-Accessories/zgbs/pc"
    html = crawl(bestsellers_url)
    print(html[:500] if html else "No HTML returned")

Les deux options d'attente sont importantes pour une liste qui se remplit au chargement de la page. ajax_wait indique à l'API d'attendre la fin du chargement du contenu asynchrone, et page_wait maintient une attente fixe en millisecondes après le chargement pour que les fiches à rendu tardif apparaissent avant la capture de la page. Le corps est décodé en latin1 car les pages Amazon mélangent des caractères que le décodage strict UTF-8 peut bloquer. Exécutez le script et vous devriez voir le vrai balisage de classement, pas une coquille de vérification robot. Cela confirme que le rendu fonctionne avant d'écrire un seul sélecteur.

Étape 2 : Analyser les fiches de classement avec BeautifulSoup

HTML rendu en main, chargez-le dans BeautifulSoup, trouvez chaque fiche de classement et extrayez chaque champ par son sélecteur. Amazon encapsule chaque article classé dans un conteneur que vous sélectionnez, affiche le rang dans un badge numéroté et expose le titre, le prix et la note à l'intérieur de la fiche. Lisez le lien produit depuis l'ancre de la fiche. Encapsulez chaque fiche dans un try/except pour qu'une annonce mal formée ne fasse pas planter l'exécution.

from bs4 import BeautifulSoup

BASE = "https://www.amazon.com"

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

def parse_link(card):
    a = card.select_one("a.a-link-normal[href]")
    if not a:
        return None
    href = a["href"]
    return href if href.startswith("http") else BASE + href

def scrape_best_sellers(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("div#gridItemRoot")
    results = []
    for card in cards:
        try:
            rank = text_of(card, "span.zg-bdg-text")
            results.append({
                "rank": rank.lstrip("#") if rank else None,
                "title": text_of(card, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1"),
                "price": text_of(card, "span._cDEzb_p13n-sc-price_3mJ9Z"),
                "rating": text_of(card, "span.a-icon-alt"),
                "link": parse_link(card),
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

L'assistant text_of interroge un élément à l'intérieur d'une fiche et retourne None quand il est absent, au lieu de lever une exception sur un appel .get_text() contre rien. Cela rend l'extraction résistante quand un champ est absent, ce qui est courant puisque tous les articles classés n'affichent pas un prix. Le rang vient du badge numéroté (span.zg-bdg-text), avec le # initial supprimé pour stocker un nombre propre. La chaîne de note réside dans le span.a-icon-alt masqué qui contient le texte "4.7 sur 5 étoiles" qu'Amazon rend derrière le graphique d'étoiles, et le lien est normalisé en URL absolue puisqu'Amazon sert souvent un href relatif.

Étape 3 : Assembler le script et exporter JSON et CSV

Maintenant reliez la récupération et l'analyse en un seul script exécutable, puis écrivez les enregistrements en JSON et CSV pour pouvoir les charger dans un notebook ou un tableur. Récupérez la page de catégorie rendue, transmettez-la au parseur et déversez les lignes structurées.

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

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
BASE = "https://www.amazon.com"
FIELDS = ["rank", "title", "price", "rating", "link"]

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 4000}
    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(card, selector):
    el = card.select_one(selector)
    return el.get_text(strip=True) if el else None

def parse_link(card):
    a = card.select_one("a.a-link-normal[href]")
    if not a:
        return None
    href = a["href"]
    return href if href.startswith("http") else BASE + href

def scrape_best_sellers(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("div#gridItemRoot")
    results = []
    for card in cards:
        try:
            rank = text_of(card, "span.zg-bdg-text")
            results.append({
                "rank": rank.lstrip("#") if rank else None,
                "title": text_of(card, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1"),
                "price": text_of(card, "span._cDEzb_p13n-sc-price_3mJ9Z"),
                "rating": text_of(card, "span.a-icon-alt"),
                "link": parse_link(card),
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

def export(rows, name="amazon_best_sellers"):
    with open(f"{name}.json", "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=2, ensure_ascii=False)
    with open(f"{name}.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS)
        writer.writeheader()
        writer.writerows(rows)
    print(f"Saved {len(rows)} products to {name}.json and {name}.csv")

def main():
    url = "https://www.amazon.com/Best-Sellers-Computers-Accessories/zgbs/pc"
    html = crawl(url)
    if not html:
        return
    rows = scrape_best_sellers(html)
    export(rows)

if __name__ == "__main__":
    main()

Exécutez le script complet avec python amazon_best_sellers.py. Il récupère la page de catégorie rendue, analyse une ligne par produit classé et écrit amazon_best_sellers.json et amazon_best_sellers.csv. La liste partagée FIELDS maintient l'ordre des colonnes CSV en accord avec les clés du dictionnaire, pour que les deux exports ne divergent jamais.

À quoi ressemble la sortie

Vous obtenez une liste propre d'enregistrements classés, dans l'ordre de la liste, prête à écrire en JSON, CSV ou dans une base de données.

[
  {
    "rank": "1",
    "title": "Amazon Basics High-Speed HDMI Cable, 6 Feet",
    "price": "$6.99",
    "rating": "4.7 out of 5 stars",
    "link": "https://www.amazon.com/dp/B014I8SSD0"
  },
  {
    "rank": "2",
    "title": "Apple AirTag",
    "price": "$24.99",
    "rating": "4.7 out of 5 stars",
    "link": "https://www.amazon.com/dp/B0D54JZTHY"
  }
]

Chemin plus rapide : le scraper Meilleures Ventes intégré

Écrire vos propres sélecteurs vous donne un contrôle total, mais cela signifie aussi les maintenir à mesure que le balisage d'Amazon évolue. Si vous préférez ne pas le faire, la Crawling API inclut un scraper amazon-best-sellers intégré qui retourne la liste classée directement en JSON structuré, sans BeautifulSoup. Vous passez une option scraper et lisez le body analysé.

import json
from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics"

response = api.get(url, {"scraper": "amazon-best-sellers"})

if response.get("status_code") == 200:
    data = json.loads(response["body"].decode("latin1"))
    result = data.get("body", {})
    with open("amazon_best_sellers.json", "w", encoding="utf-8") as f:
        json.dump(result, f, indent=4, ensure_ascii=False)
    print("Scraper response saved to amazon_best_sellers.json")
else:
    print(f"Request failed: {response.get('status_code', 0)}")

La réponse analysée inclut un pageTitle, un tableau products (chacun avec title, price, customerReview, customerReviewCount, asin, image, url et position), la liste des categories sœurs et un bloc pagination. C'est le moyen le plus rapide d'obtenir un flux de classement maintenu ; le parseur fait main ci-dessus est le bon choix quand vous avez besoin de champs que le scraper intégré ne retourne pas ou que vous voulez apprendre la structure de la page. La Scraper API documentée dans auto-parse web data pilote le même auto-parsing.

Mise à l'échelle sur plusieurs catégories et pages

Une catégorie est une démonstration ; un vrai travail de recherche en couvre plusieurs. Amazon expose une liste Meilleures Ventes pour presque chaque département et sous-catégorie, chacune à sa propre URL /zgbs/, et chaque liste pagine (généralement le top 50 réparti sur deux pages, avec un paramètre ?pg=2). Parcourez un ensemble d'URLs de catégories et rythmez les requêtes pour ne pas marteler Amazon en boucle serrée.

import time

CATEGORIES = {
    "computers": "https://www.amazon.com/Best-Sellers-Computers-Accessories/zgbs/pc",
    "electronics": "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics",
}

def scrape_categories(categories):
    everything = {}
    for name, url in categories.items():
        rows = []
        for page in (1, 2):
            page_url = url if page == 1 else f"{url}?pg={page}"
            html = crawl(page_url)
            if not html:
                break
            found = scrape_best_sellers(html)
            if not found:
                break
            rows.extend(found)
            print(f"{name} page {page}: {len(found)} products")
            time.sleep(2)
        everything[name] = rows
    return everything

L'interruption sur résultats vides vous arrête tôt quand une catégorie n'a plus de pages, et le time.sleep(2) entre les requêtes rythme l'exécution pour ne pas être signalé pour du trafic en rafale rapide. Clé la sortie par nom de catégorie garde chaque liste séparée, ce qui est ce que vous voulez lors de la comparaison des classements entre départements. Pour suivre les tendances dans le temps, exécutez le travail selon un planning et horodatez chaque export, puis comparez les instantanés successifs pour voir ce qui a monté ou descendu dans la liste.

Rester non bloqué

Même avec le rendu géré, Amazon surveille le trafic à l'allure d'un scraper. Quelques habitudes maintiennent une exécution saine, et elles s'appliquent à toute cible commerciale difficile.

• Espacez vos requêtes. Répartissez les requêtes avec un délai entre les pages et les catégories plutôt que de tout crawler à pleine vitesse. Planifiez les travaux plus lourds aux heures creuses pour alléger la charge sur les serveurs Amazon.
• Misez sur la rotation. Un pool d'IP résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels afin qu'aucune ne déclenche une limite de débit. La Crawling API gère cela pour vous ; si vous construisez votre propre pile, c'est la partie à soigner.
• Conservez uniquement ce dont vous avez besoin. Stockez les champs de classement que votre projet utilise et éliminez le reste. Revérifiez vos sélecteurs périodiquement pour que le scraper suive les changements de balisage.

Pour le guide complet sur l'évitement des blocages, voir comment scraper des sites web sans être bloqué, et pour plus d'informations sur pourquoi le rendu est important ici, comment crawler des sites web JavaScript. Si vous souhaitez approfondir le côté BeautifulSoup, le guide sur l'utilisation de BeautifulSoup en Python couvre la bibliothèque d'analyse en détail.

Est-il légal de scraper Amazon ?

La question de savoir si le scraping Amazon est autorisé dépend des Conditions d'utilisation d'Amazon, de votre juridiction et de l'usage que vous faites des données. Les conditions d'Amazon restreignent l'accès automatisé, de sorte que le scraping peut aller à l'encontre de ces conditions quelle que soit la prudence de vos outils. Aucun code ici ne change cela ; il fait simplement fonctionner la partie technique. Lisez les Conditions d'utilisation d'Amazon et son robots.txt, et traitez les deux comme les limites de ce que vous collectez. Pour un usage commercial ou concurrentiel, le tableau juridique se complique, et consulter un expert juridique sur votre cas spécifique est la démarche prudente.

Quelques lignes à tenir. Collectez uniquement les données publiques : les rangs, titres de produits, prix, notes et liens d'annonces que tout le monde peut voir sur une page Meilleures Ventes sans compte. Gardez votre volume de requêtes suffisamment bas pour ne pas solliciter les serveurs Amazon, et évitez les données personnelles, y compris tout ce lié à des acheteurs, évaluateurs ou vendeurs identifiables au-delà de ce qui est publiquement listé. Si vous comptez réutiliser les données commercialement, obtenez l'autorisation ou un accord officiel plutôt que de supposer que le silence est un consentement.

Ce guide est délibérément limité aux pages de classement Meilleures Ventes publiques car c'est la ligne qui rend le travail défendable. Il ne couvre pas ce qui est derrière une connexion, les données de compte ou de commande, les informations personnelles ou toute tentative de contourner l'authentification ou un CAPTCHA que vous n'êtes pas autorisé à passer. Pour un accès sous licence ou en volume, Amazon propose l'API Publicité Produits et d'autres programmes officiels, et c'est le bon outil quand vous avez besoin de grands volumes, d'une structure garantie ou de droits commerciaux. Si votre projet a besoin de plus que des données de classement public, une API officielle ou un accord de données est la bonne voie, pas un scraper plus sophistiqué.

Foire aux questions

Pourquoi une simple requête ne retourne-t-elle aucune Meilleure Vente d'Amazon ?

Deux raisons. Amazon remplit une grande partie de la grille de classement côté client au chargement et au défilement de la page, de sorte qu'une requête brute obtient souvent une coquille manquant les articles les moins bien classés. De plus, Amazon défie ou bloque le trafic qui ne ressemble pas à un vrai navigateur. Rendre la page via la Crawling API derrière une IP de confiance résout les deux, ce qui explique pourquoi le scraper ici achemine sa requête à travers elle.

Comment extraire les Meilleures Ventes pour une catégorie spécifique ?

Chaque liste Meilleures Ventes a sa propre URL /zgbs/ stable, par exemple /Best-Sellers-Computers-Accessories/zgbs/pc pour Ordinateurs et Accessoires ou /Best-Sellers-Electronics/zgbs/electronics pour Electroniques. Pointez le scraper sur l'URL de catégorie souhaitée. Pour couvrir plusieurs catégories, conservez une carte de noms vers URLs et parcourez-la en rythmant les requêtes avec un court délai.

Puis-je extraire les Meilleures Ventes pour n'importe quelle catégorie de produits ?

Vous pouvez extraire la plupart des catégories, car Amazon publie les Meilleures Ventes pour presque chaque département et beaucoup de sous-catégories, chacune avec sa propre liste. La mise en page de la page est cohérente entre les catégories, donc les mêmes sélecteurs s'appliquent généralement. Gardez le volume raisonnable et respectez les conditions et attentes de débit d'Amazon quand vous vous déployez sur de nombreuses catégories.

Quelle est la différence entre le parseur BeautifulSoup et le scraper intégré ?

Le parseur BeautifulSoup vous donne un contrôle total sur les champs que vous extrayez et comment, au coût de maintenir des sélecteurs à mesure que le balisage d'Amazon change. Le scraper intégré amazon-best-sellers retourne la liste classée directement en JSON structuré, incluant l'ASIN, l'image et la position, sans sélecteurs à maintenir. Utilisez le scraper intégré pour la rapidité et le parseur fait main quand vous avez besoin d'un champ qu'il ne retourne pas.

Comment suivre les tendances Meilleures Ventes dans le temps ?

Exécutez le scraper selon un planning, horodatez chaque export et stockez les instantanés. Comparer des exécutions successives montre quels produits ont grimpé ou chuté dans le classement et comment les prix ont évolué. Cette série temporelle est ce qui transforme une liste ponctuelle en données de tendance utilisables pour la recherche de produits, la tarification et l'analyse concurrentielle.

Comment éviter d'être bloqué en scrapant Amazon ?

Gardez votre débit de requêtes par IP faible, ajoutez un délai entre les pages et les catégories, et routez via des IP résidentielles rotatives pour qu'aucune adresse unique ne déclenche une limite de débit. La Crawling API gère la rotation, un pool d'IP de confiance et la gestion des CAPTCHAs pour vous ; si vous construisez votre propre pile, c'est la partie à soigner. Surveillez les codes de statut et levez le pied quand vous commencez à voir des défis.

HI

Hamza Ikhlaq

Développeur logiciel · Crawlbase

Développeur logiciel chez Crawlbase, il rédige des guides pratiques sur le scraping de sites cibles, les proxys et la Crawling API.