J’ai testé 4 façons d’extraire les Best Sellers Amazon avec Python et ...

Le week-end dernier, j’ai vidé une cafetière entière en essayant d’extraire la page Amazon Best Sellers de quatre façons différentes. Deux méthodes ont super bien marché, une a failli me faire bannir mon IP, et une m’a demandé littéralement deux clics. Voici tout ce que j’ai appris.

Amazon, c’est un mastodonte du e-commerce : , , et un classement Best Sellers Rank (BSR) mis à jour toutes les heures. Si tu fais de la recherche produit pour Amazon 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 vraiment de l’or.

Mais sortir ces données d’Amazon pour les mettre dans un tableur ? C’est là que ça devient intéressant. J’ai testé requests + BeautifulSoup, Selenium, une API de scraping, et (notre extracteur Web IA no-code) pour voir quelle approche fait vraiment le job — et lesquelles vont te laisser devant une page CAPTCHA.

Que sont les Amazon Best Sellers, et pourquoi s’y intéresser ?

Le Amazon Best Sellers Rank (BSR) est le classement en temps réel d’Amazon, qui trie les produits selon leur volume de ventes dans chaque catégorie. Imagine ça comme un concours de popularité, mis à jour chaque heure, basé sur les ventes récentes et historiques. Amazon l’explique comme ça :

« Le calcul des Amazon Best Sellers est basé sur les ventes Amazon et est mis à jour chaque heure afin de refléter les ventes récentes et passées de chaque article vendu sur Amazon. » —

La page Best Sellers affiche les 100 meilleurs produits par catégorie, répartis sur deux pages de 50. La page 1 couvre les rangs #1 à #50, et la page 2 les rangs #51 à #100. Amazon a confirmé que les pages vues et les avis clients n’influencent PAS le BSR — tout repose uniquement sur les ventes.

Qui a besoin de ces données ? Les vendeurs e-commerce à la recherche de produits pour FBA, les équipes commerciales qui construisent leur veille concurrentielle, les équipes opérationnelles qui suivent les tendances de 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 se retrouve face à Amazon — finit tôt ou tard par avoir besoin de ces données dans un tableur.

Pourquoi extraire les Best Sellers Amazon avec Python ?

La recherche produit manuelle fait perdre un temps fou. Une étude a montré que les employés passent 9,3 heures par semaine rien qu’à chercher et rassembler des informations. Pour les équipes e-commerce, ça se traduit par des heures passées à cliquer dans Amazon, copier les noms et les prix, puis les coller dans des tableurs — avant de recommencer la semaine suivante.

Voici un aperçu rapide des cas d’usage qui rendent l’extraction des Best Sellers utile :

Le retour sur investissement est bien réel : une enquête menée auprès de 2 700 professionnels du commerce a montré que les outils IA font gagner en moyenne aux pros de l’e-commerce. Et les vendeurs qui utilisent un suivi automatisé des prix gardent la Buy Box , contre 42 % pour ceux qui suivent manuellement — soit une hausse de ventes de 37 % grâce à des réactions plus rapides aux changements de prix.

4 façons d’extraire les Best Sellers Amazon avec Python : comparaison rapide

Avant d’entrer dans les tutos pas à pas, voici la comparaison côte à côte que j’aurais aimé avoir sous la main avant de lancer mes tests. Ce tableau devrait t’aider à choisir la méthode qui colle à ton besoin :

Si tu veux apprendre les bases du scraping en 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 un résultat en deux clics sans écrire de code, passe directement à la méthode 4.

Avant de commencer

• Niveau : Débutant à intermédiaire (selon la méthode)
• Temps nécessaire : ~15 minutes pour Thunderbit, ~45 minutes pour les méthodes Python
• Ce qu’il te faut : Python 3.8+ (pour les méthodes 1 à 3), navigateur 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 simple pour démarrer : pas d’automatisation du navigateur, juste des requêtes HTTP et l’analyse du 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 dépendances nécessaires :

1pip install requests beautifulsoup4 pandas

Puis configure tes imports :

1import requests
2from bs4 import BeautifulSoup
3import pandas as pd
4import random
5import time

Étape 2 : envoyer une requête avec des en-têtes réalistes

Amazon bloque les requêtes qui ressemblent à des robots. La défense la plus basique consiste à utiliser un en-tête User-Agent qui imite un vrai navigateur. Voici un extrait avec une sélection de chaînes User-Agent récentes et réalistes (source : , mars 2026) :

1USER_AGENTS = [
2    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
3    "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",
4    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
5    "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; rv:149.0) Gecko/20100101 Firefox/149.0",
6    "Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
7]
8headers = {"User-Agent": random.choice(USER_AGENTS)}
9url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
10response = requests.get(url, headers=headers)
11print(response.status_code)  # devrait afficher 200

Si tu obtiens un code 200, c’est bon. Si tu vois un 503 ou une redirection vers une page CAPTCHA, Amazon a repéré ta requête.

Étape 3 : parser les données produits avec BeautifulSoup

Inspecte le HTML de la page Amazon dans les DevTools de ton navigateur (clic droit → Inspecter). Les conteneurs produits utilisent l’ID gridItemRoot. À l’intérieur de chaque conteneur, tu trouveras le nom du produit, le prix, la note et l’URL.

1soup = BeautifulSoup(response.text, "html.parser")
2products = []
3for item in soup.find_all("div", id="gridItemRoot"):
4    title_tag = item.find("div", class_="_cDEzb_p13n-sc-css-line-clamp-3_g3dy1")
5    price_tag = item.find("span", class_="_cDEzb_p13n-sc-price_3mJ9Z")
6    link_tag = item.find("a", class_="a-link-normal")
7    title = title_tag.get_text(strip=True) if title_tag else "N/A"
8    price = price_tag.get_text(strip=True) if price_tag else "N/A"
9    url = "https://www.amazon.com" + link_tag["href"] if link_tag else "N/A"
10    products.append({"Title": title, "Price": price, "URL": url})

Attention : les noms de classes préfixés par _cDEzb_ sont des hash CSS modules qu’Amazon régénère régulièrement. L’ID gridItemRoot et la classe a-link-normal sont plus stables, mais vérifie toujours tes sélecteurs dans les DevTools avant d’exécuter le scraper.

Étape 4 : exporter en CSV

1df = pd.DataFrame(products)
2df.to_csv("amazon_best_sellers.csv", index=False)
3print(f"{len(products)} produits extraits")

Ce qu’il faut attendre — et ce qui casse

Lors de mon test, cette méthode a renvoyé environ 30 produits au lieu de 50. Ce n’est pas un bug du code : c’est le lazy loading d’Amazon. Seuls ~30 produits s’affichent au chargement initial ; les autres apparaissent après défilement, ce que requests ne peut pas gérer puisqu’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 structure de la page — et ça arrive régulièrement
• Pas de gestion native de la pagination

Pour apprendre le scraping en Python, c’est une excellente méthode. Pour un usage en production, elle reste fragile.

Méthode 2 : extraire Amazon Best Sellers avec Selenium

Selenium règle le problème du lazy loading en lançant un vrai navigateur — c’est plus lourd à configurer, mais ça permet de récupérer les 50 produits de chaque page.

Étape 1 : installer Selenium

1pip install selenium pandas

Bonne nouvelle : depuis Selenium 4.6+, tu n’as plus besoin de webdriver-manager. Selenium Manager s’occupe automatiquement du téléchargement des drivers.

1from selenium import webdriver
2from selenium.webdriver.chrome.options import Options
3from selenium.webdriver.common.by import By
4from selenium.webdriver.common.keys import Keys
5import time
6import pandas as pd
7options = Options()
8options.add_argument("--headless=new")
9options.add_argument("--window-size=1920,1080")
10options.add_argument("--disable-blink-features=AutomationControlled")
11driver = webdriver.Chrome(options=options)

L’option --headless=new (introduite avec Chrome 109+) utilise le même pipeline de rendu que Chrome avec interface, ce qui rend la détection par Amazon plus difficile.

Étape 2 : défiler pour dépasser le lazy loading

C’est cette étape qui justifie l’usage de Selenium. La page Amazon Best Sellers charge seulement ~30 produits au départ ; le reste apparaît après défilement.

1def scroll_page(driver, scrolls=5, delay=2):
2    for _ in range(scrolls):
3        driver.find_element(By.TAG_NAME, "body").send_keys(Keys.PAGE_DOWN)
4        time.sleep(delay)
5driver.get("https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/")
6time.sleep(3)
7scroll_page(driver)

Après le défilement, les 50 produits devraient être présents dans le DOM. J’ai trouvé que 5 défilements avec 2 secondes de pause suffisaient, mais tu devras peut-être ajuster selon la vitesse de ta connexion.

Étape 3 : extraire les données produits

1items = driver.find_elements(By.ID, "gridItemRoot")
2products = []
3for item in items:
4    try:
5        title = item.find_element(By.CSS_SELECTOR, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1").text
6    except:
7        title = "N/A"
8    try:
9        price = item.find_element(By.CSS_SELECTOR, "span._cDEzb_p13n-sc-price_3mJ9Z").text
10    except:
11        price = "N/A"
12    try:
13        url = item.find_element(By.CSS_SELECTOR, "a.a-link-normal").get_attribute("href")
14    except:
15        url = "N/A"
16    products.append({"Title": title, "Price": price, "URL": url})

Entourer chaque extraction d’un try/except est important : certains produits peuvent être en rupture de stock ou avoir des champs manquants, et tu ne veux pas qu’un seul élément cassé fasse planter toute l’extraction.

Étape 4 : gérer la pagination

Amazon répartit les 100 Best Sellers sur deux pages avec des structures d’URL différentes :

1urls = [
2    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
3    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/ref=zg_bs_pg_2_electronics?_encoding=UTF8&pg=2"
4]
5all_products = []
6for url in urls:
7    driver.get(url)
8    time.sleep(3)
9    scroll_page(driver)
10    # ... extraire les produits comme ci-dessus ...
11    all_products.extend(products)
12driver.quit()

Ce qu’il faut attendre

Dans mon test, Selenium a bien récupéré les 50 produits par page — une vraie victoire face à requests + BS4. Le revers : environ 45 secondes par page (défilement compris), et j’ai quand même fini signalé après trop d’exécutions sans rotation de proxy. Selenium reste détectable par les systèmes anti-bot d’Amazon, même avec les options anti-détection — pour du volume sérieux, il faut ajouter d’autres protections (voir le playbook anti-bannissement plus bas).

Autres points pénibles :

• Les incompatibilités de version WebDriver arrivent encore parfois, même si Selenium Manager les a beaucoup réduites
• Les sélecteurs CSS doivent être mis à jour dès qu’Amazon modifie son DOM
• La consommation mémoire est élevée : chaque instance du navigateur engloutit 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 pénibles ». Des services comme Scrape.do, Oxylabs et ScrapingBee gèrent la rotation des proxies, le rendu JavaScript et les mesures anti-bot : tu envoies juste une URL et tu récupères du HTML ou du JSON.

Principe de fonctionnement

Tu envoies l’URL cible à l’endpoint de l’API. L’API rend la page à l’aide d’un vrai navigateur sur sa propre infrastructure, fait tourner les proxies, gère les CAPTCHA, puis renvoie un HTML propre. Tu peux ensuite analyser ce HTML avec BeautifulSoup comme d’habitude.

Étape 1 : envoyer une requête via l’API

Voici un exemple avec Scrape.do (tarifs à partir de 29 $/mois pour 150 000 crédits, 1 crédit = 1 requête quel que soit le rendu) :

1import requests
2from bs4 import BeautifulSoup
3api_token = "YOUR_API_TOKEN"
4target_url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
5api_url = f"https://api.scrape.do?token={api_token}&url={target_url}&render=true&geoCode=us"
6response = requests.get(api_url)
7soup = BeautifulSoup(response.text, "html.parser")

À partir de là, le parsing est identique à la méthode 1 — mêmes sélecteurs, même logique d’extraction.

Point sur les prix

Voici ce que facturent les principales APIs pour 1 000 requêtes Amazon au meilleur tarif disponible :

Avantages et inconvénients

Avantages : fiabilité élevée ( sur Amazon pour les meilleurs fournisseurs), pas de maintenance de driver, gestion automatique des anti-bots, bonne montée en charge.

Inconvénients : paiement à la requête (les coûts montent vite à grande échelle), il faut quand même écrire le code d’analyse, et les changements de sélecteurs CSS restent un risque. Pour 100 000 pages par mois, la comparaison des coûts totaux est parlante : construire en interne revient à environ — soit 71 % d’économies.

Le seuil de rentabilité se situe généralement entre 500 000 et 1 million de requêtes par mois. En dessous, le gain de temps d’une API compense largement le 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 l’écart de temps pour obtenir les données était énorme.

est un extracteur Web IA qui fonctionne comme extension Chrome. L’idée centrale : au lieu d’écrire des sélecteurs CSS ou du code Python, l’IA lit la page et comprend quelles données extraire. Pour Amazon Best Sellers, Thunderbit propose des modèles prêts à l’emploi qui marchent en un clic.

Étape 1 : installer l’extension Chrome Thunderbit

Va sur le et clique sur « Ajouter à Chrome ». Crée un compte gratuit : l’offre gratuite inclut assez de crédits pour faire tes tests.

É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 « AI Suggest Fields »

Ouvre la barre latérale Thunderbit et clique sur « AI Suggest Fields ». L’IA analyse la structure de la page et propose des colonnes : nom du produit, prix, note, URL de l’image, vendeur, URL produit et rang. Pendant mon test, elle a repéré tous les champs pertinents en environ 3 secondes.

Tu peux renommer, supprimer ou ajouter des colonnes. Tu peux même ajouter des prompts IA personnalisés par champ — par exemple, « classer en Electronics/Apparel/Home » pour ajouter une étiquette de catégorie à chaque produit.

Étape 4 : cliquer sur « Scrape »

Clique sur le bouton « Scrape ». Thunderbit remplit un tableau structuré avec toutes les données produit de la page. En mode cloud, il traite jusqu’à 50 pages en parallèle, en gérant automatiquement le lazy loading et la pagination.

Étape 5 : exporter gratuitement

Clique sur « Export » et choisis ta destination : Excel, Google Sheets, Airtable ou Notion. Les exports sont gratuits sur tous les forfaits — sans frais cachés.

Le processus complet 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 (correction du lazy loading comprise), la méthode 2 environ 35 minutes (configuration Selenium comprise), et la méthode 3 environ 15 minutes (configuration du compte API comprise).

Pourquoi Thunderbit gère bien Amazon

Comme l’IA relit la page à neuf à chaque fois, elle s’adapte automatiquement aux changements de structure — sans sélecteurs CSS à maintenir. Ça répond directement à la plainte la plus fréquente dans les forums de scraping : « Un scraper Web basique ne suffit pas, il faut ajouter énormément de garde-fous pour les 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 gère sans friction la rotation des proxies, le rendu et les mesures anti-bot. Pour les utilisateurs qui veulent une solution qui “marche tout simplement”, ça enlève toute la galère du bannissement.

Le playbook anti-bannissement : comment éviter d’être bloqué par Amazon

La détection des robots par Amazon est agressive. Mon IP a été temporairement bloquée pendant les 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 pars sur l’approche Python (méthodes 1 à 3), cette section est essentielle.

Voici une stratégie en plusieurs couches, du plus basique au plus avancé :

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 :

1headers = {"User-Agent": random.choice(USER_AGENTS)}

2. Ajouter des délais aléatoires entre les requêtes

Les délais fixes sont détectables. Les délais aléatoires sont plus sûrs :

1time.sleep(random.uniform(2, 5))

J’ai constaté que 2 à 5 secondes entre les requêtes me permettaient de rester sous le radar pour de petits lots (moins de 50 requêtes). Pour des exécutions plus longues, passe plutôt à 3 à 7 secondes.

3. Utiliser la rotation de proxies

C’est le gros morceau. Les montrent que les proxies résidentiels atteignent en moyenne ~94 % de réussite sur Amazon, contre ~59 % pour les proxies de datacenter — soit un écart de 35 points. La pile de détection d’Amazon inclut le fingerprint TLS, l’analyse comportementale et le rate limiting par IP, donc les IP de datacenter classiques sont repérées en quelques secondes.

Les proxies résidentiels sont plus chers (2 à 12 $ par Go selon le fournisseur), mais beaucoup plus fiables. Exemple de code :

1proxies = {
2    "http": "http://user:pass@residential-proxy.example.com:8080",
3    "https": "http://user:pass@residential-proxy.example.com:8080"
4}
5response = requests.get(url, headers=headers, proxies=proxies)

4. Renforcer l’empreinte navigateur (Selenium)

1options.add_argument('--disable-blink-features=AutomationControlled')
2options.add_experimental_option("excludeSwitches", ["enable-automation"])
3options.add_experimental_option('useAutomationExtension', False)
4# Après l’initialisation du driver, supprimer le drapeau navigator.webdriver
5driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
6    'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
7})

5. Gérer les sessions et les cookies

Conserver les cookies entre les requêtes rend ton scraper plus proche d’une vraie session utilisateur :

1session = requests.Session()
2# Visiter d’abord la page d’accueil pour obtenir des cookies réalistes
3session.get("https://www.amazon.com", headers=headers)
4time.sleep(2)
5# Puis extraire la page cible
6response = session.get(target_url, headers=headers)

6. Quand éviter complètement la prise de tête

Pour les utilisateurs qui ne veulent rien gérer de tout ça, le scraping cloud de Thunderbit prend en charge la rotation des proxies, le rendu et les mesures anti-bot de façon transparente. Les APIs de scraping gèrent aussi la plupart de ces points automatiquement. D’après mon expérience, le temps passé à déboguer les soucis anti-bannissement dépasse souvent le temps nécessaire pour écrire le code de scraping lui-même — donc l’approche “ça marche, point” a un vrai ROI.

Enrichissement des sous-pages : extraire les pages de détail produit pour des données plus riches

La page Best Sellers ne montre que les infos de base : titre, prix, note, rang. Mais la vraie valeur pour la recherche FBA se trouve sur les pages de détail produit. Voici ce que tu rates si tu ne récupères que la liste :

Le champ « Date de première disponibilité » est particulièrement précieux : il indique depuis combien de temps un produit est sur le marché, un signal clé pour analyser la concurrence. Et connaître le nombre de vendeurs ainsi que le propriétaire de la Buy Box aide à évaluer si une niche vaut la peine d’être attaquée (si Amazon détient lui-même plus de 30 % de la Buy Box, la concurrence devient extrêmement difficile).

Approche Python : parcourir les URL produits

Après avoir collecté les URL produits depuis la page de liste, parcours chacune d’elles avec un délai :

1for product in products:
2    time.sleep(random.uniform(3, 6))
3    detail_response = session.get(product["URL"], headers={"User-Agent": random.choice(USER_AGENTS)})
4    detail_soup = BeautifulSoup(detail_response.text, "html.parser")
5    # Extraire la marque
6    brand_tag = detail_soup.find("a", id="bylineInfo")
7    product["Brand"] = brand_tag.get_text(strip=True) if brand_tag else "N/A"
8    # Extraire l’ASIN depuis le code source ou l’URL
9    # Extraire la date de première disponibilité depuis le tableau de détails produit
10    # ... champs supplémentaires ...

Petit avertissement : accéder à 100 pages produit individuelles augmente nettement le risque de blocage. Prévois de la 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 liste 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. Aucun code supplémentaire, aucun sélecteur, aucune configuration. C’est particulièrement utile pour les équipes e-commerce qui ont besoin d’une vision complète pour leurs décisions d’approvisionnement, sans vouloir écrire et maintenir un parseur de pages détail.

Automatiser les extractions récurrentes : suivre les Best Sellers dans le temps

Une extraction ponctuelle peut être utile, mais le vrai avantage concurrentiel vient du suivi continu. Surveiller les produits qui montent et qui descendent, repérer les tendances tôt, et suivre les variations de prix sur plusieurs semaines ou mois : c’est ce qui distingue une simple recherche d’une décision pilotée par 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 :

10 8 * * * /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1

Pour une extraction hebdomadaire le lundi à 9h :

10 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 faire pareil. Pour une planification en continu sans laisser tourner ton ordinateur portable, 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 échecs. Rien de pire que de découvrir deux semaines plus tard que ton scraper s’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 à 9h » ou « tous les jours à 8h » et l’IA comprend le planning. Les extractions s’exécutent sur les serveurs cloud de Thunderbit (pas besoin de navigateur ni d’ordinateur allumé), et les données sont exportées automatiquement vers Google Sheets ou Airtable. Tu obtiens ainsi un tableau de bord de suivi en direct sans gérer de serveur — idéal pour les équipes opérationnelles qui veulent une visibilité continue sans la charge DevOps.

Considérations juridiques et éthiques pour scraper Amazon

Je ne suis pas avocat, et ceci ne constitue pas un conseil juridique. Mais ignorer le cadre légal dans un tutoriel de scraping serait irresponsable — les utilisateurs de forums soulèvent clairement les questions de CGU, et pour de bonnes raisons.

robots.txt d’Amazon : en 2026, le robots.txt d’Amazon contient plus de 80 chemins Disallow spécifiques, mais /gp/bestsellers/ n’est PAS explicitement bloqué pour les agents utilisateurs standards. En revanche, plus de 35 agents utilisateurs spécifiques à l’IA (ClaudeBot, GPTBot, Scrapy, etc.) reçoivent un Disallow: / global. L’absence de blocage explicite ne veut pas dire qu’Amazon approuve le scraping.

Conditions d’utilisation d’Amazon : les d’Amazon (mises à jour en mai 2025) interdisent explicitement « l’utilisation de tout processus ou technologie automatisés pour accéder, acquérir, copier ou surveiller une partie quelconque du site Web Amazon » sans autorisation écrite. Ce n’est pas théorique : Amazon a en novembre 2025 pour un accès automatisé non autorisé et a obtenu une injonction préliminaire.

Le précédent hiQ contre LinkedIn : dans l’affaire (9e circuit, 2022), le tribunal a jugé que le scraping de données publiquement accessibles ne violait 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 plaintes pour rupture de contrat.

Recommandations pratiques :

• Ne récupère que des données publiques (prix, BSR, titres produits — pas de données personnelles)
• Respecte les limites de débit et ne surcharge pas les serveurs
• Utilise les données pour une veille concurrentielle légitime
• Consulte ton conseil juridique avant de scraper à grande échelle
• Garde à l’esprit que disposent désormais d’une législation complète sur la protection des données

Le scraping cloud de Thunderbit utilise des schémas de requêtes standards proches d’un navigateur, mais tu dois toujours vérifier la conformité avec ton propre conseil juridique.

Quelle méthode choisir ? Guide rapide de décision

En résumé :

• « J’apprends Python et je veux un projet de 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.
• « J’ai besoin de scraper des pages très riches en JavaScript ou des sessions connectées. » → Méthode 2 (Selenium). C’est plus lourd, mais ça gère le 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 favorise les APIs sous les 500 000 requêtes/mois.
• « Je ne suis pas développeur et je veux les données en 2 minutes. » → Méthode 4 (). Pas de code, pas de sélecteurs, pas de maintenance.
• « J’ai besoin d’un suivi récurrent sans gérer de serveur. » → Thunderbit Scheduled Scraper. Tu le configures une fois, puis tu l’oublies.

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 limite du lazy loading (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 lazy loading 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 APIs de scraping offrent la meilleure fiabilité pour un scraping à l’échelle de la production — sur Amazon — mais les coûts augmentent et il faut quand même écrire le code d’analyse.

Thunderbit a livré le temps d’obtention des données le plus rapide, et de loin. L’IA gère les changements de structure, le lazy loading, 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 ses changements fréquents de structure 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 de moins consacrée à la vraie analyse.

Tu veux essayer l’approche no-code ? 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 la voie Python ? Les exemples de code ci-dessus devraient t’aider à démarrer. Dans tous les cas, tu auras 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 web scraping, consulte nos guides sur , , et . Tu peux aussi suivre des tutoriels pas à pas sur la .

En savoir plus