Comment extraire les pages de recherche Amazon avec Pythonproduits issus de n'importe quelle requête

Les résultats de recherche Amazon constituent l'un des ensembles de données publics les plus denses de la vente au détail. Chaque requête retourne une grille classée de produits avec des titres, des prix, des notes en étoiles, des nombres d'avis, des ASINs et des liens vers chaque page de détail produit. Ces données alimentent le suivi des prix concurrentiels, la recherche de catalogues, les signaux de demande et l'analyse d'assortiment. Le problème est qu'Amazon affiche ces produits avec JavaScript et défend agressivement contre le trafic automatisé, de sorte qu'une simple requête HTTP vous donne un coquille presque vide au lieu des produits recherchés.

Ce guide vous montre comment extraire les pages de recherche Amazon avec Python de manière fiable. Vous construisez un scraper simple et fonctionnel qui récupère une page de résultats de recherche rendue via la Crawling API, analyse chaque fiche résultat en un enregistrement propre, gère la pagination sur plusieurs pages de résultats et exporte les données en JSON et CSV. L'ensemble du tutoriel se limite aux données de recherche et de catalogue publiques, et la section sur la légalité vers la fin n'est pas du remplissage, lisez-la avant de cibler un volume réel.

Ce que vous allez construire

Un script Python qui prend une requête de recherche Amazon, récupère la page de résultats rendue via la Crawling API et extrait un enregistrement structuré par produit. Nous utiliserons le terme de recherche "games" comme exemple et extrairons ces champs de chaque fiche résultat :

• Titre le nom du produit tel qu'il apparaît sur la fiche de recherche.
• Prix le prix affiché sur la fiche.
• Note la moyenne des avis clients, par exemple "4.5 out of 5 stars".
• ASIN l'identifiant de produit Amazon à dix caractères pour chaque produit.
• Lien l'URL vers la propre page de détail du produit.

Ce post se concentre sur la page de résultats de recherche (le SERP). Si vous souhaitez approfondir un seul article une fois que vous avez son lien ou son ASIN, les guides complémentaires sur le scraping des données de produits Amazon et le scraping par ASIN prennent le relais là où celui-ci s'arrête.

Pourquoi une requête ordinaire échoue sur Amazon

Si vous demandez une URL de recherche Amazon avec un client HTTP brut, vous obtenez une réponse avec le statut 200 et presque aucune donnée produit dans le corps. Deux facteurs jouent contre vous. Premièrement, Amazon charge une grande partie de sa grille de recherche côté client : le HTML initial est une coquille, et les résultats, filtres et prix ne s'affichent qu'après l'exécution des scripts JavaScript et des appels Ajax de la page dans un navigateur. Deuxièmement, Amazon signale rapidement le trafic automatisé. Les adresses IP de datacenter et les schémas de requêtes qui ne ressemblent pas à un vrai navigateur sont confrontés à un CAPTCHA, limités en débit ou bloqués avant même d'atteindre les produits affichés.

Un scraper Amazon fonctionnel a donc besoin de deux choses en une seule requête : un navigateur qui affiche réellement la page, et une adresse IP que la plateforme considère comme un vrai acheteur. Vous pouvez assembler cela vous-même avec un navigateur sans interface graphique et un pool de proxies résidentiels rotatifs, mais assembler et maintenir ces composants représente l'essentiel du travail. La Crawling API combine les deux en un seul appel : vous lui envoyez l'URL avec un token JavaScript, elle affiche la page depuis une adresse IP résidentielle fiable et retourne les données finales à 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 nouveau dans le langage, le guide du scraping web avec Python couvre les fondamentaux que ce tutoriel suppose.

Python 3.8 ou une version ultérieure. Vérifiez 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 JS. Inscrivez-vous pour un compte gratuit, ouvrez votre tableau de bord et copiez votre token JavaScript (JS). Le niveau gratuit inclut jusqu'à 20 000 requêtes sans carte requise, et vous ne payez que les requêtes réussies après cela. 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 pandas

Sur Windows, activez l'environnement avec amazon_env\Scripts\activate au lieu de la ligne source. Deux dépendances font le travail : crawlbase est le client officiel sans dépendances pour la Crawling API, et pandas organise les enregistrements extraits et les écrit en CSV. Comme nous utilisons le scraper intégré amazon-serp de la Crawling API, les champs analysés reviennent en JSON structuré, vous n'avez donc pas besoin d'un parseur HTML séparé comme BeautifulSoup pour ce post.

Comprendre la page de recherche Amazon

Amazon expose la recherche via un schéma d'URL simple. La requête va dans le paramètre k :

https://www.amazon.com/s?k=games

Chaque page de recherche présente une grille de fiches produit, une par produit. Une fiche contient un titre, un prix, une note en étoiles avec un nombre d'avis, une image, un lien vers la page de détail et l'ASIN du produit. Amazon intègre également des produits sponsorisés en haut et au milieu des résultats, que le parseur signale séparément afin que vous puissiez les conserver ou les supprimer. Sous la grille se trouvent des contrôles de pagination qui vous permettent de parcourir d'autres pages de résultats pour la même requête. Les données sont là, mais elles se chargent dynamiquement, ce qui est exactement la raison pour laquelle l'étape de rendu dans la section suivante est importante.

Étape 1 : Récupérer la page de recherche rendue

Commencez par obtenir la page finale. Importez la classe CrawlingAPI, initialisez-la avec votre token JS, construisez l'URL de recherche à partir d'une requête et demandez-la avec les options d'attente qui permettent au contenu dynamique de se stabiliser. 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 = {"page_wait": 2000, "ajax_wait": "true"}
    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__":
    query = "games"
    search_url = f"https://www.amazon.com/s?k={query}"
    html = crawl(search_url)
    print(html[:500] if html else "No HTML returned")

Les deux options d'attente sont importantes pour une cible affichée côté client comme celle-ci. ajax_wait demande à l'API d'attendre que les requêtes asynchrones se terminent avant de capturer la page, et page_wait attend un nombre fixe de millisecondes après le chargement pour que la grille à affichage tardif apparaisse en premier. Deux secondes est un bon point de départ ; augmentez si des fiches reviennent manquantes. Le corps est décodé en latin1 car les pages Amazon mélangent des caractères que le décodage strict UTF-8 peut faire échouer. Exécutez le script et vous devriez voir du vrai balisage de produit, pas la coquille vide qu'une simple requête retourne. Cela confirme que le rendu fonctionne avant de demander à l'API d'analyser quoi que ce soit.

Étape 2 : Analyser les résultats avec le scraper amazon-serp

Vous pourriez récupérer le HTML rendu et écrire vos propres sélecteurs, mais la Crawling API embarque des scrapers intégrés pour les sites courants, dont Amazon. Passer l'option scraper indique à l'API d'analyser la page côté serveur et de retourner du JSON structuré au lieu du HTML brut. Le scraper conçu pour les pages de résultats de recherche est amazon-serp. Il retourne un tableau de produits, chacun avec des champs comme name, price, customer review, ASIN, image et link, plus un bloc de pagination.

Voici la structure simplifiée d'une entrée produit de amazon-serp, pour savoir quelles clés lire :

{
  "name": "Product Name",
  "price": "$19.99",
  "rawPrice": 19.99,
  "currency": "$",
  "offer": "Offer Details",
  "customerReview": "4.5 out of 5 stars",
  "customerReviewCount": "1,234",
  "asin": "B0XXXXXXXX",
  "image": "Product Image URL",
  "url": "Product URL",
  "isPrime": true,
  "sponsoredAd": false
}

Ajoutez l'option scraper à la requête et le corps de la réponse devient du JSON. La charge utile analysée se trouve sous la clé body, avec les produits sous products et un bloc pagination à côté. La fonction ci-dessous extrait les cinq champs qui nous intéressent par produit, en mappant name sur title, customerReview sur rating, et en lisant asin et url directement.

import json
from crawlbase import CrawlingAPI

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

options = {
    "page_wait": 2000,
    "ajax_wait": "true",
    "scraper": "amazon-serp",
}

def parse_products(scraper_result):
    products = scraper_result.get("products", [])
    results = []
    for product in products:
        results.append({
            "title": product.get("name", ""),
            "price": product.get("price", ""),
            "rating": product.get("customerReview", ""),
            "reviews": product.get("customerReviewCount", ""),
            "asin": product.get("asin", ""),
            "link": product.get("url", ""),
            "isPrime": product.get("isPrime", False),
            "sponsored": product.get("sponsoredAd", False),
        })
    return results

Chaque champ est lu avec .get() et une valeur par défaut, donc un produit sans prix ni note renvoie une chaîne vide plutôt que de faire planter l'exécution, ce qui est courant car tous les résultats ne comportent pas encore d'avis. Nous gardons aussi isPrime et sponsored dans l'enregistrement : le flag sponsored vous permet de filtrer les placements payants de l'analyse organique ultérieurement. Comme le scraper fait l'extraction côté serveur, vous ne courez pas après les noms de classes CSS d'Amazon vous-même, ce qui est la partie qui casse le plus souvent dans un scraper artisanal.

Étape 3 : Assembler et exporter

Connectez maintenant la récupération et l'analyse dans un seul script exécutable. Demandez la page de recherche avec l'option scraper, chargez le corps JSON, extrayez les produits, puis écrivez-les en JSON et CSV afin que les données soient prêtes pour un tableur ou un travail en aval.

import json
import pandas as pd
from crawlbase import CrawlingAPI

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

options = {
    "page_wait": 2000,
    "ajax_wait": "true",
    "scraper": "amazon-serp",
}

def scrape_search(page_url):
    response = api.get(page_url, options)
    if response["status_code"] != 200:
        print(f"Request failed: {response['status_code']}")
        return [], None
    payload = json.loads(response["body"].decode("latin1"))
    scraper_result = payload["body"]
    return parse_products(scraper_result), scraper_result.get("pagination")

def parse_products(scraper_result):
    products = scraper_result.get("products", [])
    results = []
    for product in products:
        results.append({
            "title": product.get("name", ""),
            "price": product.get("price", ""),
            "rating": product.get("customerReview", ""),
            "reviews": product.get("customerReviewCount", ""),
            "asin": product.get("asin", ""),
            "link": product.get("url", ""),
            "isPrime": product.get("isPrime", False),
            "sponsored": product.get("sponsoredAd", False),
        })
    return results

def main():
    query = "games"
    search_url = f"https://www.amazon.com/s?k={query}"
    products, _ = scrape_search(search_url)
    print(f"Found {len(products)} products")

    with open("amazon_products.json", "w") as f:
        json.dump(products, f, indent=2)

    pd.DataFrame(products).to_csv("amazon_products.csv", index=False)

if __name__ == "__main__":
    main()

L'assistant scrape_search retourne deux choses : la liste de produits analysée et le bloc de pagination, que la section suivante utilise pour parcourir chaque page. Écrire à la fois en JSON et CSV couvre les deux besoins en aval courants : JSON permet de réinjecter facilement les enregistrements dans un autre script, et l'appel pandas to_csv vous donne un tableau prêt pour tableur en une ligne.

À quoi ressemble la sortie

Exécutez le script complet avec python scraper.py et vous obtenez une liste propre d'enregistrements, un par résultat, prête à écrire n'importe où.

[
  {
    "title": "Catan Board Game (Base Game)",
    "price": "$43.99",
    "rating": "4.8 out of 5 stars",
    "reviews": "32,114",
    "asin": "B00U26V4VQ",
    "link": "https://www.amazon.com/dp/B00U26V4VQ",
    "isPrime": true,
    "sponsored": false
  },
  {
    "title": "Ticket to Ride Board Game",
    "price": "$34.99",
    "rating": "4.8 out of 5 stars",
    "reviews": "28,907",
    "asin": "B0001WN5LE",
    "link": "https://www.amazon.com/dp/B0001WN5LE",
    "isPrime": true,
    "sponsored": false
  }
]

La version CSV des mêmes données comporte une colonne par champ (title, price, rating, reviews, asin, link, isPrime, sponsored) et une ligne par produit, ce qui est idéal pour un coup d'oeil rapide dans un tableur ou une feuille de comparaison de prix.

Gérer la pagination sur plusieurs pages de résultats

Une page est une démo ; un vrai travail parcourt toutes les pages de résultats pour une requête. Le scraper amazon-serp retourne un bloc de pagination avec la page actuelle, la page suivante et le nombre total de pages :

"pagination": {
  "currentPage": 1,
  "nextPage": 2,
  "totalPages": 20
}

Amazon pagine la recherche avec un paramètre &page=, exactement comme le site le fait dans le navigateur : ?k=games&page=1, ?k=games&page=2, et ainsi de suite. Lisez totalPages dans la première réponse, puis parcourez en boucle de la page deux jusqu'à la dernière, en collectant les produits au fur et à mesure.

import time

def scrape_all_pages(query, max_pages=5):
    base = f"https://www.amazon.com/s?k={query}"
    all_results, pagination = scrape_search(base)
    if not pagination:
        return all_results

    total_pages = min(pagination.get("totalPages", 1), max_pages)
    for page in range(2, total_pages + 1):
        page_url = f"{base}&page={page}"
        products, _ = scrape_search(page_url)
        if not products:
            break
        all_results.extend(products)
        print(f"Page {page}: {len(products)} products")
        time.sleep(2)
    return all_results

La limite max_pages garde une exécution bornée pour qu'une requête large comme "games" ne parcoure pas accidentellement les vingt pages, et l'interruption sur résultats vides s'arrête tôt lorsqu'une requête n'a que quelques pages. Le time.sleep(2) entre les pages cadence les requêtes pour ne pas marteler la recherche dans une boucle serrée, ce qui est le moyen le plus rapide d'être limité en débit. Remplacez l'appel de page unique dans main par scrape_all_pages(query) et le même export JSON et CSV gère le jeu de données combiné.

Choisir le scraper ou construire le sien

L'option scraper est ce qui rend cela court. Supprimez-la et l'API retourne le HTML rendu complet, que vous analyseriez vous-même avec une bibliothèque comme BeautifulSoup, en ciblant manuellement les sélecteurs des fiches de résultat Amazon. Ce chemin vous donne un contrôle total mais transfère la charge de maintenance sur vous : les noms de classes CSS d'Amazon dérivent, un parseur artisanal a donc besoin d'une maintenance périodique. Le scraper amazon-serp absorbe ce travail, ce qui en fait l'approche par défaut ici. Si vous voulez la route manuelle pour un champ personnalisé que le scraper n'expose pas, le guide BeautifulSoup couvre la technique d'analyse, et la Crawling API d'auto-analyse expose les mêmes scrapers Amazon via un point de terminaison dédié si vous préférez l'appeler de cette façon.

Rester non bloqué

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

• Cadencez vos requêtes. Espacez les requêtes avec un délai entre les pages et variez vos requêtes au lieu de crawler un terme à pleine vitesse. Le time.sleep dans la boucle de pagination est le plancher, pas le plafond.
• Misez sur la rotation. Un pool d'adresses 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 stack, c'est la partie à bien faire.
• Lisez les codes de statut. Une exécution qui commence à retourner des défis ou des erreurs vous indique que le débit actuel ou le niveau d'adresses IP n'est plus suffisant. Traitez cela comme un signal pour ralentir, pas du bruit à ignorer.

Pour le guide plus complet sur le maintien d'un scraper en vie face à des sites défendus, voir comment scraper des sites web sans être bloqué.

Est-il légal de scraper Amazon ?

La question de savoir si le scraping d'Amazon est autorisé 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é et l'extraction de données, 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 rend seulement 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.

Quelques lignes à retenir. Collectez uniquement des données publiques : les titres de produits, les prix, les notes, les nombres d'avis, les ASINs et les liens de produits que tout le monde peut voir sur une page de résultats de recherche sans compte. Respectez les attentes de débit déclarées d'Amazon et gardez votre volume de requêtes suffisamment bas pour ne pas surcharger ses serveurs. Évitez les données personnelles, y compris tout ce qui est lié à des acheteurs, évaluateurs ou vendeurs tiers identifiables au-delà de ce qui est listé publiquement sur une page de résultats. Ne redistribuez pas de médias protégés par le droit d'auteur tels que des images de produits ou du texte d'avis comme s'ils vous appartenaient. Si vous prévoyez de réutiliser les données commercialement, obtenez une autorisation ou un accord officiel plutôt que de supposer que le silence vaut consentement.

Ce guide est délibérément limité aux pages de recherche et de catalogue 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, les informations personnelles, les flux de paiement ou de passage en caisse, ou toute tentative de contourner l'authentification. Pour un accès sous licence ou en masse, Amazon propose la Product Advertising API et d'autres programmes officiels, ce sont les bons outils lorsque vous avez besoin de grands volumes, d'une structure garantie ou de droits commerciaux. Si votre projet a besoin de plus que des produits publics, une API officielle ou un accord de données est le bon chemin, pas un scraper plus sophistiqué.

Foire aux questions

Pourquoi une requête ordinaire ne retourne-t-elle aucun produit d'Amazon ?

Parce qu'Amazon charge une grande partie de sa grille de recherche côté client avec JavaScript et Ajax. Le HTML initial est une coquille qui ne se remplit qu'après l'exécution des scripts de la page dans un navigateur, de sorte qu'une requête HTTP brute retourne le statut 200 avec les produits vides. Pour obtenir de vraies données, vous devez d'abord afficher la page, ce que gère le token JS de la Crawling API pour vous.

Ai-je besoin du token normal ou du token JS pour Amazon ?

Le token JS. Le token normal récupère le HTML statique, qui sur Amazon est la même coquille vide qu'une simple requête retourne. Le token JS affiche la page dans un vrai navigateur avant l'analyse, de sorte que les fiches produit sont présentes lorsque le scraper amazon-serp les extrait.

Que retourne le scraper amazon-serp ?

Il retourne un objet JSON avec un tableau products et un bloc pagination. Chaque produit comporte des champs comme name, price, rawPrice, currency, customerReview, customerReviewCount, asin, image, url, isPrime et sponsoredAd. Ce post mappe une poignée de ceux-ci sur un enregistrement propre de title, price, rating, ASIN et link.

Comment scraper toutes les pages d'une recherche Amazon ?

Lisez totalPages dans le bloc de pagination de la première réponse, puis parcourez l'URL de recherche en boucle avec un paramètre &page= incrémental à partir de la page deux. Scrapez chaque page avec la même fonction, limitez le nombre de pages pour qu'une requête large reste bornée, et ajoutez un délai court entre les requêtes pour cadencer l'exécution et ne pas être limité en débit.

Puis-je scraper les données de commande, de compte ou de paiement d'Amazon ?

Non, et ce guide ne le couvre pas. L'historique des commandes, les détails de compte et les flux de paiement sont derrière une connexion, ils ne constituent donc pas des données publiques. Le scraping de contenu protégé par une connexion, ou le contournement de l'authentification pour l'atteindre, est hors de portée ici et va à l'encontre des conditions d'Amazon. Pour un accès sanctionné à des données plus riches, le bon chemin est la Product Advertising API officielle ou un accord partenaire.

Comment éviter d'être bloqué lors du scraping d'Amazon ?

Gardez votre taux de requêtes par adresse IP bas, ajoutez un délai entre les pages, variez vos requêtes au lieu de boucler sur un terme, et routez via des adresses IP résidentielles rotatives afin qu'aucune adresse unique ne déclenche une limite de débit. La Crawling API gère la rotation et un pool d'adresses IP fiables pour vous ; si vous construisez votre propre stack, c'est la partie sur laquelle investir. Surveillez les codes de statut et ralentissez lorsque vous commencez à voir des défis.

HR

Hassan Rehan

Ingénieur logiciel · Crawlbase

Ingénieur logiciel chez Crawlbase, il rédige des guides pratiques sur les proxys rotatifs, le scraping et les détails concrets de l'intégration de proxys dans du vrai code.