Le week-end dernier, j’ai vidé une cafetière entière en essayant d’extraire la page Amazon Best Sellers de quatre manières différentes. Deux méthodes ont super bien marché, une a failli faire bloquer mon IP, et une autre a été faite en un seul clic. Voici tout ce que j’ai retenu.
Amazon est un mastodonte du e-commerce — 600 millions de fiches produits, plus de 310 millions de comptes clients actifs et un système de classement Best Sellers Rank (BSR) mis à jour toutes les heures. Si tu fais de la recherche produit pour le FBA, de l’analyse concurrentielle des prix ou que tu veux simplement repérer les tendances avant tes concurrents, les données Best Sellers valent de l’or.
Mais récupérer ces données depuis Amazon pour les mettre dans un tableur ? Là, les choses se corsent. J’ai testé requests + BeautifulSoup, Selenium, une API de scraping et Thunderbit (notre extracteur web IA sans code) pour voir quelle approche donne vraiment des résultats — et lesquelles te laissent face à une page CAPTCHA.
Que sont les Amazon Best Sellers, et pourquoi s’y intéresser ?
Le Best Sellers Rank (BSR) d’Amazon est un classement en temps réel des produits selon leur volume de ventes dans chaque catégorie. Vois-le comme un concours de popularité, mis à jour toutes les heures, basé sur les ventes récentes et historiques. Amazon le décrit ainsi :
« Le calcul du classement Amazon Best Sellers est basé sur les ventes Amazon et est mis à jour toutes les heures afin de refléter les ventes récentes et historiques de chaque article vendu sur Amazon. » — Amazon Seller Central
La page Best Sellers affiche les 100 meilleurs produits par catégorie, répartis sur deux pages de 50 produits chacune. La page 1 couvre les rangs #1 à #50, la page 2 les rangs #51 à #100. Amazon a confirmé que les pages vues et les avis clients n’influencent PAS le BSR — ce classement repose uniquement sur les ventes.
Qui a besoin de ces données ? Les vendeurs e-commerce qui cherchent des produits pour le FBA, les équipes commerciales qui construisent leur veille concurrentielle, les équipes opérations qui suivent l’évolution des prix et les analystes marché qui surveillent la croissance des catégories. D’après mon expérience, toute personne qui vend sur Amazon ou qui y est en concurrence finit tôt ou tard par avoir besoin de ces données dans un tableur.
Pourquoi extraire Amazon Best Sellers avec Python ?
La recherche produit manuelle est un gouffre à temps. Une étude McKinsey a montré que les employés passent 9,3 heures par semaine rien qu’à chercher et rassembler de l’information. Pour les équipes e-commerce, ça veut dire des heures passées à cliquer sur les pages Amazon, copier des noms de produits et des prix, puis tout coller dans des feuilles de calcul — avant de recommencer la semaine suivante.
Voici un aperçu rapide des usages qui rendent l’extraction des Best Sellers intéressante :
| Cas d’usage | Ce que vous obtenez | Qui en profite |
|---|---|---|
| Recherche produit FBA | Identifier les produits à forte demande et faible concurrence grâce au BSR et au nombre d’avis | Vendeurs Amazon, dropshippers |
| Suivi des prix concurrents | Suivre l’évolution des prix sur les produits phares de votre catégorie | Équipes e-commerce, analystes pricing |
| Veille des tendances marché | Repérer les catégories en hausse et les variations saisonnières | Chefs de produit, analystes marché |
| Génération de leads | Constituer des listes de marques les plus vendues et de leurs gammes | Équipes commerciales, prospection B2B |
| Analyse concurrentielle | Comparer vos produits aux leaders de la catégorie | Responsables de marque, équipes stratégie |
Le retour sur investissement est bien réel : une enquête Salesforce menée auprès de 2 700 professionnels du commerce a montré que les outils IA font gagner en moyenne 6,4 heures par semaine aux équipes e-commerce. Et les vendeurs qui utilisent un suivi automatisé des prix remportent la Buy Box 67 % du temps, contre 42 % pour les outils manuels — soit une hausse des ventes de 37 % grâce à des réactions plus rapides aux variations de prix.
4 façons d’extraire Amazon Best Sellers avec Python : comparatif rapide
Avant d’entrer dans les tutoriels pas à pas, voici le comparatif côte à côte que j’aurais aimé avoir avant de commencer mes tests. Ce tableau devrait t’aider à choisir la bonne méthode selon ta situation :
| Critère | requests + BS4 | Selenium | API de scraping (ex. Scrape.do) | Thunderbit (sans code) |
|---|---|---|---|---|
| Difficulté de mise en place | Moyenne | Élevée (driver, navigateur) | Faible (clé API) | Très faible (extension Chrome) |
| Gère le chargement progressif | Non | Oui (simulation du scroll) | Oui (HTML rendu) | Oui (l’IA gère le rendu) |
| Résistance anti-bot | Faible (blocages IP) | Moyenne (détectable) | Élevée (proxies rotatifs) | Élevée (mode cloud + navigateur) |
| Charge de maintenance | Élevée (sélecteurs qui cassent) | Élevée (mises à jour driver + sélecteurs) | Faible | Très faible (l’IA s’adapte aux changements de mise en page) |
| Coût | Gratuit | Gratuit | Payant (par requête) | Offre gratuite + abonnements payants |
| Idéal pour | Extractions ponctuelles, apprentissage | Pages lourdes en JS, connexion requise | Usage à grande échelle / production | Non-développeurs, recherche rapide, suivi récurrent |
Si tu veux apprendre les bases du scraping Python, commence par la méthode 1 ou 2. Si tu as besoin d’une fiabilité de niveau production, choisis la méthode 3. Si tu veux obtenir un résultat en un clic sans écrire de code, passe directement à la méthode 4.
Avant de commencer
- Niveau de difficulté : débutant à intermédiaire (selon la méthode)
- Temps nécessaire : environ 15 minutes pour Thunderbit, environ 45 minutes pour les méthodes Python
- Ce qu’il te faut : Python 3.8+ (pour les méthodes 1 à 3), navigateur Chrome, extension Thunderbit Chrome (pour la méthode 4) et l’URL d’une catégorie Amazon Best Sellers
Méthode 1 : extraire Amazon Best Sellers avec requests + BeautifulSoup
C’est l’approche légère et adaptée aux débutants — pas d’automatisation de navigateur, juste des requêtes HTTP et du parsing HTML. Et c’est aussi celle qui m’a le plus appris sur les défenses anti-scraping d’Amazon.
Étape 1 : préparer l’environnement
Installe les paquets nécessaires :
pip install requests beautifulsoup4 pandas
Puis configure tes imports :
import requests
from bs4 import BeautifulSoup
import pandas as pd
import random
import time
Étape 2 : envoyer une requête avec des en-têtes réalistes
Amazon bloque les requêtes qui ressemblent à celles d’un bot. La défense la plus basique consiste à utiliser un en-tête User-Agent qui imite un vrai navigateur. Voici un extrait avec une liste de chaînes User-Agent récentes et réalistes (source : Geekflare, mars 2026) :
USER_AGENTS = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; rv:149.0) Gecko/20100101 Firefox/149.0",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
]
headers = {"User-Agent": random.choice(USER_AGENTS)}
url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
response = requests.get(url, headers=headers)
print(response.status_code) # Doit afficher 200
Si tu vois un code 200, c’est bon. Si tu vois un 503 ou si tu es redirigé vers une page CAPTCHA, Amazon a détecté ta requête.
Étape 3 : parser les données produit avec BeautifulSoup
Inspecte le HTML de la page Amazon avec les outils de développement de ton navigateur (clic droit → Inspecter). Les conteneurs produit utilisent l’ID gridItemRoot. À l’intérieur de chaque conteneur, tu trouveras le nom du produit, le prix, la note et l’URL.
soup = BeautifulSoup(response.text, "html.parser")
products = []
for item in soup.find_all("div", id="gridItemRoot"):
title_tag = item.find("div", class_="_cDEzb_p13n-sc-css-line-clamp-3_g3dy1")
price_tag = item.find("span", class_="_cDEzb_p13n-sc-price_3mJ9Z")
link_tag = item.find("a", class_="a-link-normal")
title = title_tag.get_text(strip=True) if title_tag else "N/A"
price = price_tag.get_text(strip=True) if price_tag else "N/A"
url = "https://www.amazon.com" + link_tag["href"] if link_tag else "N/A"
products.append({"Title": title, "Price": price, "URL": url})
Attention : les noms de classes avec le préfixe
_cDEzb_sont des hash CSS modules qu’Amazon régénère régulièrement. L’IDgridItemRootet la classea-link-normalsont plus stables, mais vérifie toujours les sélecteurs dans DevTools avant d’exécuter ton scraper.
Étape 4 : exporter en CSV
df = pd.DataFrame(products)
df.to_csv("amazon_best_sellers.csv", index=False)
print(f"{len(products)} produits extraits")
Ce à quoi s’attendre — et ce qui bloque
Lors de mon test, cette méthode a récupéré environ 30 produits au lieu de 50. Ce n’est pas un bug du code — c’est le chargement progressif d’Amazon. Seuls environ 30 produits s’affichent au chargement initial ; les autres apparaissent après défilement, ce que requests ne sait pas gérer car il n’exécute pas JavaScript.
Autres limites :
- Les blocages IP arrivent vite sans rotation de proxy (j’ai été bloqué après environ 15 requêtes en rafale)
- Les sélecteurs CSS cassent dès qu’Amazon modifie la mise en page — et cela arrive régulièrement
- Pas de gestion de la pagination intégrée
Pour apprendre le scraping Python, cette approche est excellente. Pour un usage en production, elle reste fragile.
Méthode 2 : extraire Amazon Best Sellers avec Selenium
Selenium règle le problème du chargement progressif en exécutant un vrai navigateur — plus lourd à configurer, mais il récupère bien les 50 produits par page.
Étape 1 : installer Selenium
pip install selenium pandas
Bonne nouvelle : depuis Selenium 4.6+, tu n’as plus besoin de webdriver-manager. Selenium Manager gère automatiquement le téléchargement des drivers.
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
import time
import pandas as pd
options = Options()
options.add_argument("--headless=new")
options.add_argument("--window-size=1920,1080")
options.add_argument("--disable-blink-features=AutomationControlled")
driver = webdriver.Chrome(options=options)
L’option --headless=new (introduite avec Chrome 109+) utilise le même moteur de rendu que Chrome avec interface, ce qui rend la détection par Amazon plus difficile.
Étape 2 : faire défiler la page pour charger le contenu
C’est cette étape qui justifie l’usage de Selenium. Amazon Best Sellers charge seulement une trentaine de produits au départ — les autres apparaissent après le scroll.
def scroll_page(driver, scrolls=5, delay=2):
for _ in range(scrolls):
driver.find_element(By.TAG_NAME, "body").send_keys(Keys.PAGE_DOWN)
time.sleep(delay)
driver.get("https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/")
time.sleep(3)
scroll_page(driver)
Après le défilement, les 50 produits devraient être présents dans le DOM. J’ai constaté que 5 pages vers le bas avec un délai de 2 secondes suffisaient, mais tu devras peut-être ajuster selon la vitesse de ta connexion.
Étape 3 : extraire les données produit
items = driver.find_elements(By.ID, "gridItemRoot")
products = []
for item in items:
try:
title = item.find_element(By.CSS_SELECTOR, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1").text
except:
title = "N/A"
try:
price = item.find_element(By.CSS_SELECTOR, "span._cDEzb_p13n-sc-price_3mJ9Z").text
except:
price = "N/A"
try:
url = item.find_element(By.CSS_SELECTOR, "a.a-link-normal").get_attribute("href")
except:
url = "N/A"
products.append({"Title": title, "Price": price, "URL": url})
Envelopper chaque extraction dans un bloc try/except est important — certains produits peuvent être en rupture de stock ou présenter des champs manquants, et tu ne veux pas qu’un seul élément défectueux fasse planter tout le scraping.
Étape 4 : gérer la pagination
Amazon répartit les 100 Best Sellers sur deux pages avec des structures d’URL différentes :
urls = [
"https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
"https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/ref=zg_bs_pg_2_electronics?_encoding=UTF8&pg=2"
]
all_products = []
for url in urls:
driver.get(url)
time.sleep(3)
scroll_page(driver)
# ... extraire les produits comme ci-dessus ...
all_products.extend(products)
driver.quit()
Ce à quoi s’attendre
Lors de mon test, Selenium a capturé les 50 produits par page — une nette amélioration par rapport à requests + BS4. L’inconvénient : environ 45 secondes par page (défilement inclus), et j’ai quand même été détecté après de trop nombreuses exécutions sans rotation de proxy. Selenium reste également détectable par les systèmes anti-bot d’Amazon malgré les options anti-détection — pour un usage intensif, il faudra prévoir des protections supplémentaires (voir la section anti-bannissement ci-dessous).
Autres points pénibles :
- Les versions du WebDriver peuvent encore parfois ne pas correspondre, même si Selenium Manager a beaucoup réduit ce problème
- Les sélecteurs CSS doivent être mis à jour dès qu’Amazon modifie son DOM
- La consommation mémoire est élevée — chaque instance de navigateur consomme 200 à 400 Mo de RAM
Méthode 3 : extraire Amazon Best Sellers avec une API de scraping
Les API de scraping, c’est l’approche « laisse quelqu’un d’autre gérer les parties difficiles ». Des services comme Scrape.do, Oxylabs et ScrapingBee prennent en charge la rotation de proxies, le rendu JavaScript et les protections anti-bot — tu envoies simplement une URL et tu reçois du HTML ou du JSON en retour.
Comment ça fonctionne
Tu envoies ton URL cible à l’endpoint de l’API. L’API rend la page avec un vrai navigateur sur sa propre infrastructure, fait tourner les proxies, gère les CAPTCHA et renvoie un HTML propre. Il ne te reste plus qu’à parser ce HTML avec BeautifulSoup comme d’habitude.
Étape 1 : envoyer une requête via l’API
Voici un exemple avec Scrape.do (les prix commencent à 29 $/mois pour 150 000 crédits, 1 crédit = 1 requête, indépendamment du rendu) :
import requests
from bs4 import BeautifulSoup
api_token = "YOUR_API_TOKEN"
target_url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
api_url = f"https://api.scrape.do?token={api_token}&url={target_url}&render=true&geoCode=us"
response = requests.get(api_url)
soup = BeautifulSoup(response.text, "html.parser")
À partir de là, l’analyse est identique à la méthode 1 — mêmes sélecteurs, même logique d’extraction.
Réalité des prix
Voici ce que facturent les principales API par 1 000 requêtes Amazon au meilleur tarif disponible :
| Fournisseur | Coût pour 1 000 requêtes | Remarques |
|---|---|---|
| Scrape.do | ~0,19 $ | Tarif fixe, pas de multiplicateur de crédits |
| Oxylabs | ~1,80 $ | Multiplicateur x5 pour le rendu JS |
| ScrapingBee | ~4,90 $ | Multiplicateurs x5 à x25 pour les fonctionnalités premium |
| Bright Data | 5,00 $+ | Données les plus complètes (686 champs/produit) mais le plus lent (~66 s/requête) |
Avantages et inconvénients
Avantages : grande fiabilité (~99 % de taux de réussite sur Amazon chez les principaux fournisseurs), aucune maintenance de driver, gestion automatique de l’anti-bot, bonne montée en charge.
Inconvénients : paiement à la requête (les coûts grimpent vite à grande échelle), il faut quand même écrire du code de parsing, et les sélecteurs CSS restent sensibles aux changements de structure. Pour 100 000 pages/mois, la comparaison devient très parlante : développer en interne coûte environ 1,98 M$ sur trois ans contre 332 k$ avec un fournisseur API — soit 71 % d’économies.
Le point d’équilibre se situe généralement entre 500 000 et 1 million de requêtes par mois. En dessous, le gain de temps des API compense largement leur coût.
Méthode 4 : extraire Amazon Best Sellers avec Thunderbit (sans Python)
Transparence totale : je travaille chez Thunderbit, donc prends cette section avec ce contexte. Cela dit, j’ai vraiment testé les quatre méthodes l’une après l’autre, et la différence en temps d’obtention des données est frappante.
Thunderbit est un extracteur web IA qui fonctionne comme extension Chrome. L’idée principale : au lieu d’écrire des sélecteurs CSS ou du code Python, l’IA lit la page et détermine elle-même quelles données extraire. Pour Amazon Best Sellers en particulier, Thunderbit propose des modèles prêts à l’emploi qui fonctionnent en un clic.
Étape 1 : installer l’extension Chrome Thunderbit
Rends-toi sur le Chrome Web Store et clique sur « Ajouter à Chrome ». Crée ensuite un compte gratuit — l’offre gratuite fournit assez de crédits pour tester.
Étape 2 : ouvrir la page Amazon Best Sellers
Ouvre n’importe quelle page de catégorie Amazon Best Sellers dans Chrome. Par exemple :
https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/
Étape 3 : cliquer sur « One Click Extract »
Ouvre la barre latérale Thunderbit et clique sur « One Click Extract ». L’IA analyse la structure de la page et identifie les colonnes : nom du produit, prix, note, URL de l’image, vendeur, URL du produit et rang. Lors de mon test, elle a correctement détecté tous les champs pertinents en environ 3 secondes.
Tu peux renommer, supprimer ou ajouter des colonnes. Tu peux même ajouter des consignes IA personnalisées par champ — par exemple, « classer en Electronics/Apparel/Home » pour ajouter un tag de catégorie à chaque produit.
Étape 4 : cliquer sur « Scrape »
Appuie sur le bouton « Scrape ». Thunderbit remplit un tableau structuré avec toutes les données produit de la page. En mode cloud, l’outil traite jusqu’à 50 pages en parallèle, en gérant automatiquement le chargement progressif et la pagination.
Étape 5 : exporter gratuitement
Clique sur « Export » et choisis ta destination : Excel, Google Sheets, Airtable ou Notion. Tous les exports sont gratuits, quel que soit le plan — sans frais cachés.
L’ensemble du processus m’a pris environ 90 secondes entre l’ouverture de la page et l’obtention d’un tableur complet. À titre de comparaison, la méthode 1 m’a pris environ 20 minutes (en comptant le débogage du chargement progressif), la méthode 2 environ 35 minutes (configuration de Selenium incluse) et la méthode 3 environ 15 minutes (création du compte API incluse).
Pourquoi Thunderbit gère bien Amazon
Comme l’IA relit la page à chaque exécution, elle s’adapte automatiquement aux changements de mise en page — aucun sélecteur CSS à maintenir. Ça répond directement à la plainte la plus fréquente sur les forums de scraping : « Un scraper web basique ne suffit pas, il faut ajouter trop de gestion des changements d’éléments. » Quand Amazon modifie son DOM (ce qui arrive régulièrement), tu n’as rien à mettre à jour.
Le mode de scraping cloud prend en charge la rotation des proxies, le rendu et les protections anti-bot de manière transparente. Pour les utilisateurs qui veulent une solution qui « marche tout de suite », ça supprime complètement le casse-tête anti-bannissement.
Fini la maintenance des sélecteurs Quand Amazon modifie son code HTML, vos sélecteurs BeautifulSoup cassent. L’IA de Thunderbit relit la page à chaque exécution et redétermine les champs. Get Started Free
Le plan anti-bannissement : comment éviter d’être bloqué par Amazon
La détection de bots d’Amazon est agressive. J’ai été temporairement bloqué pendant mes tests, et les utilisateurs de forums rapportent la même chose : « des erreurs partout, Amazon a même commencé à me rediriger vers la page d’accueil ». Si tu passes par Python (méthodes 1 à 3), cette section est essentielle.
Voici une stratégie en plusieurs couches, de la plus simple à la plus avancée :
1. Faire tourner les chaînes User-Agent
Envoyer toujours le même User-Agent est un signal d’alerte. Utilise le pool de 5 chaînes ou plus de l’exemple de la méthode 1 et sélectionne-en une aléatoirement à chaque requête :
headers = {"User-Agent": random.choice(USER_AGENTS)}
2. Ajouter des délais aléatoires entre les requêtes
Les délais fixes sont détectables (ils créent des motifs). Les délais aléatoires sont plus sûrs :
time.sleep(random.uniform(2, 5))
J’ai constaté que des pauses de 2 à 5 secondes entre les requêtes me permettaient de passer sous les radars pour de petits lots (moins de 50 requêtes). Pour des exécutions plus importantes, passe plutôt à 3 à 7 secondes.
3. Utiliser la rotation de proxies
C’est le point clé. Les benchmarks de Proxyway montrent que les proxies résidentiels obtiennent en moyenne ~94 % de réussite sur Amazon contre ~59 % pour les proxies datacenter — soit un écart de 35 points. La pile de détection d’Amazon inclut l’empreinte TLS, l’analyse comportementale et le rate limiting par IP, donc les IP datacenter classiques sont repérées en quelques secondes.
Les proxies résidentiels coûtent plus cher (2 à 12 $ par Go selon le fournisseur), mais ils sont nettement plus fiables. Exemple de code :
proxies = {
"http": "http://user:pass@residential-proxy.example.com:8080",
"https": "http://user:pass@residential-proxy.example.com:8080"
}
response = requests.get(url, headers=headers, proxies=proxies)
4. Renforcer l’empreinte navigateur (Selenium)
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option('useAutomationExtension', False)
# Après l'initialisation du driver, supprimer le flag navigator.webdriver
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
})
5. Gérer les sessions et les cookies
Conserver les cookies d’une requête à l’autre donne à ton scraper l’apparence d’une vraie session utilisateur :
session = requests.Session()
# Visitez d'abord la page d'accueil pour obtenir des cookies réalistes
session.get("https://www.amazon.com", headers=headers)
time.sleep(2)
# Puis extrayez la page cible
response = session.get(target_url, headers=headers)
6. Quand éviter de se compliquer la vie
Pour ceux qui ne veulent rien gérer de tout ça, le scraping cloud de Thunderbit prend en charge la rotation des proxies, le rendu et l’anti-bot de manière transparente. Les API de scraping couvrent également la plupart de ces aspects par défaut. D’après mon expérience, le temps passé à déboguer les problèmes anti-bannissement dépasse souvent le temps passé à écrire le code de scraping lui-même — l’approche « ça marche tout de suite » a donc un vrai ROI.
Enrichissement via les sous-pages : extraire les pages produit pour des données plus riches
La page de listing Best Sellers n’affiche que les informations de base — titre, prix, note, rang. Mais la vraie valeur pour la recherche FBA se trouve sur les pages détail produit individuelles. Voici ce que tu rates si tu n’extrais que la liste :
| Champ | Page de listing | Page détail produit |
|---|---|---|
| Nom du produit | ✅ | ✅ |
| Prix | ✅ | ✅ |
| Note | ✅ | ✅ |
| Rang BSR | ✅ | ✅ (avec les rangs par sous-catégorie) |
| Marque | ❌ | ✅ |
| ASIN | ❌ | ✅ |
| Date de première disponibilité | ❌ | ✅ |
| Dimensions/poids | ❌ | ✅ |
| Nombre de vendeurs | ❌ | ✅ |
| Caractéristiques en puces | ❌ | ✅ |
| Propriétaire de la Buy Box | ❌ | ✅ |
Le champ « Date de première disponibilité » est particulièrement utile — il indique depuis combien de temps un produit est sur le marché, un signal clé pour l’analyse de la concurrence. Et connaître le nombre de vendeurs ainsi que le propriétaire de la Buy Box permet d’évaluer si un créneau produit vaut la peine d’être attaqué (si Amazon détient lui-même plus de 30 % de part de Buy Box, la concurrence est extrêmement difficile).
Approche Python : parcourir les URL des produits
Après avoir collecté les URL produits depuis la page de listing, parcours-les une à une avec un délai :
for product in products:
time.sleep(random.uniform(3, 6))
detail_response = session.get(product["URL"], headers={"User-Agent": random.choice(USER_AGENTS)})
detail_soup = BeautifulSoup(detail_response.text, "html.parser")
# Extraire la marque
brand_tag = detail_soup.find("a", id="bylineInfo")
product["Brand"] = brand_tag.get_text(strip=True) if brand_tag else "N/A"
# Extraire l'ASIN depuis le code source ou l'URL
# Extraire la date de première disponibilité depuis le tableau des détails produit
# ... autres champs ...
Attention : accéder à 100 pages produit individuelles augmente fortement le risque de blocage. Prévois une rotation de proxies et des délais plus longs.
Approche Thunderbit : scraping des sous-pages en un clic
Après avoir extrait la page de listing dans un tableau, clique sur « Scrape Subpages » dans Thunderbit. L’IA visite chaque URL produit et enrichit automatiquement le tableau avec des colonnes supplémentaires — marque, ASIN, spécifications, caractéristiques, etc. Aucun code supplémentaire, aucun sélecteur, aucune configuration. C’est particulièrement utile pour les équipes e-commerce qui ont besoin d’une vue complète pour leurs décisions d’approvisionnement sans vouloir écrire ni maintenir un parseur de page détail.
Automatiser les extractions récurrentes : surveiller les Best Sellers dans le temps
Une extraction ponctuelle, c’est utile. Mais le vrai avantage concurrentiel vient du suivi continu. Suivre les produits qui montent et descendent, repérer les tendances tôt et surveiller les variations de prix sur plusieurs semaines ou plusieurs mois — voilà ce qui distingue une recherche ponctuelle d’une prise de décision fondée sur les données.
Approche Python : planification avec cron
Sous Linux/Mac, tu peux planifier ton script Python avec cron. Voici l’entrée crontab pour une extraction quotidienne à 8h :
0 8 * * * /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1
Pour une extraction hebdomadaire le lundi à 9h :
0 9 * * 1 /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1
Sous Windows, utilise le Planificateur de tâches pour obtenir le même résultat. Pour une planification en continu sans laisser ton ordinateur allumé, déploie sur un VPS ou AWS Lambda — mais ça ajoute de la complexité d’infrastructure.
Ajoute de la journalisation et des notifications d’erreur pour repérer les exécutions ratées. Il n’y a rien de pire que de découvrir deux semaines plus tard que ton scraper est cassé en silence.
Approche Thunderbit : Scheduled Scraper en langage naturel
Le Scheduled Scraper de Thunderbit te permet de décrire l’intervalle en langage naturel — tape « tous les lundis à 9 h » ou « tous les jours à 8 h » et l’IA interprète la planification. Les extractions s’exécutent sur les serveurs cloud de Thunderbit (aucun navigateur ni ordinateur n’a besoin de rester allumé), et les données s’exportent automatiquement vers Google Sheets ou Airtable. Tu obtiens ainsi un tableau de bord de suivi en temps réel sans gestion serveur — idéal pour les équipes opérations qui veulent une visibilité continue sans la charge DevOps.
Considérations légales et éthiques lors du scraping d’Amazon
Je ne suis pas avocat, et ceci ne constitue pas un conseil juridique. Mais ignorer l’aspect légal dans un tutoriel de scraping serait irresponsable — les utilisateurs de forums soulèvent explicitement les questions liées aux CGU, et pour de bonnes raisons.
robots.txt d’Amazon : en 2026, le fichier robots.txt d’Amazon contient plus de 80 chemins Disallow spécifiques, mais /gp/bestsellers/ n’est PAS explicitement bloqué pour les user agents standards. En revanche, plus de 35 user agents dédiés à l’IA (ClaudeBot, GPTBot, Scrapy, etc.) reçoivent un Disallow: / global. L’absence d’interdiction spécifique ne signifie pas qu’Amazon approuve le scraping.
Conditions d’utilisation d’Amazon : les Conditions d’utilisation d’Amazon (mises à jour en mai 2025) interdisent explicitement « l’utilisation de tout processus ou technologie automatisé pour accéder, obtenir, copier ou surveiller toute partie du site Amazon » sans autorisation écrite. Ce n’est pas théorique — Amazon a poursuivi Perplexity AI en novembre 2025 pour accès automatisé non autorisé et a obtenu une injonction préliminaire.
Le précédent hiQ v. LinkedIn : dans hiQ Labs v. LinkedIn (9e circuit, 2022), la cour a jugé que l’extraction de données publiquement accessibles ne viole probablement pas le Computer Fraud and Abuse Act. Mais hiQ a finalement conclu un accord et accepté d’arrêter le scraping — gagner sur le CFAA ne protège pas contre les actions pour rupture de contrat.
Bonnes pratiques :
- Extraire uniquement des données publiques (prix, BSR, titres produits — pas de données personnelles)
- Respecter les limites de fréquence et ne pas surcharger les serveurs
- Utiliser les données pour une veille concurrentielle légitime
- Consulter votre conseil juridique avant de scraper à grande échelle
- Garder à l’esprit que plus de 20 États américains disposent désormais de lois complètes sur la protection de la vie privée
Le scraping cloud de Thunderbit utilise des schémas de requêtes proches de ceux d’un navigateur standard, mais tu dois toujours vérifier ta conformité avec ton propre conseil juridique.
Pas besoin de Python pour celui-ci Si votre objectif est un tableur plutôt qu’un pipeline, un seul clic suffit. Exportez directement vers Excel, Google Sheets, Airtable ou Notion. Get Started Free
Quelle méthode choisir ? Guide de décision rapide
Version courte :
- « J’apprends Python et je veux un projet pour le week-end. » → Méthode 1 (requests + BeautifulSoup). Tu apprendras énormément sur les requêtes HTTP, le parsing HTML et les défenses anti-bot d’Amazon.
- « Je dois extraire des pages lourdes en JavaScript ou des sessions connectées. » → Méthode 2 (Selenium). Plus lourd, mais adapté au contenu dynamique.
- « Je lance des extractions en production à grande échelle. » → Méthode 3 (API de scraping). Laisse quelqu’un d’autre gérer les proxies et le rendu. Le coût total de possession penche en faveur des API en dessous de 500 000 requêtes par mois.
- « Je ne suis pas développeur et je veux des données en 2 minutes. » → Méthode 4 (Thunderbit). Pas de code, pas de sélecteurs, pas de maintenance.
- « J’ai besoin d’un suivi continu sans gérer de serveur. » → Thunderbit Scheduled Scraper. Configure-le une fois, puis laisse-le tourner.
Essayez Thunderbit pour Amazon Best Sellers Get Started Free
Conclusion et points clés à retenir
Après un week-end de tests, voici ce qui ressort vraiment :
requests + BeautifulSoup est excellent pour apprendre, mais la limitation liée au chargement progressif (seulement ~30 produits sur 50) et la fragilité des sélecteurs CSS le rendent peu pratique en production.
Selenium résout le problème du chargement progressif et capture bien les 50 produits par page, mais il est lent, gourmand en mémoire et reste détectable par les défenses anti-bot d’Amazon.
Les API de scraping offrent la meilleure fiabilité pour du scraping à l’échelle de la production — ~99 % de taux de réussite sur Amazon — mais les coûts montent vite et tu dois quand même écrire du code de parsing.
Thunderbit a livré, de loin, le temps d’obtention des données le plus court. L’IA gère les changements de mise en page, le chargement progressif, la pagination et les protections anti-bot sans configuration. Pour les utilisateurs non techniques ou les équipes qui ont besoin de données récurrentes sans charge DevOps, c’est l’option la plus pratique.
La plus grande leçon ? Les défenses anti-bot d’Amazon et les changements fréquents de mise en page font que les solutions sans maintenance font gagner le plus de temps sur la durée. Chaque heure passée à déboguer des sélecteurs cassés et à faire tourner des proxies est une heure que tu ne passes pas sur l’analyse réelle.
Envie d’essayer l’approche sans code ? L’offre gratuite de Thunderbit te donne assez de crédits pour extraire quelques catégories Best Sellers et voir le résultat par toi-même. Tu préfères Python ? Les exemples de code ci-dessus devraient t’aider à démarrer. Dans tous les cas, tu obtiendras les données Amazon Best Sellers dans un tableur, au lieu de fixer un onglet de navigateur.
Pour aller plus loin sur les approches de scraping web, consulte nos guides sur l’extraction des produits et avis Amazon, l’extraction de données depuis un site vers Excel et les meilleurs extracteurs web IA. Tu peux aussi suivre des démonstrations pas à pas sur la chaîne YouTube Thunderbit.
En savoir plus
