Apprenez à extraire des produits Amazon avec Python

Si vous avez suivi un tutoriel sur l’extraction de données Amazon pour vous retrouver face à une pluie de CAPTCHA, d’erreurs 503 ou de résultats complètement vides — bienvenue au club. La plupart des guides Python sur le scraping Amazon qui traînent sur Internet ont été publiés en 2022 ou 2023, avec des sélecteurs et des techniques qu’Amazon a corrigés depuis longtemps.

Cela fait des années que je construis des outils d’extraction de données chez Thunderbit, et une chose que je peux vous dire par expérience : Amazon est l’un des sites les plus compliqués à scraper de façon fiable. La plateforme change sans arrêt sa structure HTML, déploie une défense anti-bot à six couches et sert même des mises en page différentes selon les utilisateurs via des tests A/B. Dans ce guide, je vais vous montrer un scraper Amazon en Python qui fonctionne vraiment en 2025 — avec des sélecteurs CSS vérifiés, une stratégie anti-blocage en couches, et des conseils de planification et d’export que la plupart des tutoriels passent totalement sous silence. Et pour celles et ceux qui veulent récupérer les données sans se battre avec Python, je vous montrerai aussi comment peut faire le même boulot en deux clics environ.

Qu’est-ce que le scraping de produits Amazon ?

Le scraping de produits Amazon consiste à extraire automatiquement des données publiquement accessibles — noms de produits, prix, notes, nombre d’avis, images, disponibilité, etc. — depuis les pages produit et les pages de résultats de recherche d’Amazon. Au lieu de copier à la main des infos sur des centaines de fiches, un scraper visite chaque page, lit le HTML et récupère les données que vous avez définies dans un format structuré comme CSV, Excel ou une base de données.

Voyez ça comme embaucher un stagiaire infatigable capable de parcourir mille pages produit pendant que vous finissez votre café du matin. Sauf que ce stagiaire ne fait jamais de fautes de frappe et n’a pas besoin de pause déjeuner.

Pourquoi extraire des produits Amazon avec Python ?

Amazon héberge environ réparties dans plus de 30 catégories, alimentées par environ . Les vendeurs tiers représentent désormais 69 % du GMV total. Surveiller manuellement même une petite partie de ce catalogue est impossible. Voici pourquoi les équipes extraient des données Amazon :

L’échelle des prix sur Amazon, à elle seule, rend l’automatisation indispensable : Amazon modifie ses prix , le prix moyen d’un produit étant mis à jour environ toutes les 10 minutes. À l’inverse, des concurrents comme Best Buy et Walmart ne changent leurs prix qu’environ 50 000 fois par mois. Aucune équipe humaine ne peut suivre un tel rythme.

Python vous donne un contrôle total sur le processus d’extraction — vous décidez quoi collecter, comment gérer les erreurs et où stocker les données. Mais cela signifie aussi que vous êtes responsable de la maintenance, de l’anti-blocage et du suivi des changements HTML fréquents d’Amazon.

Ce que vous pouvez extraire d’Amazon (et ce que vous ne pouvez pas)

Depuis les pages produit accessibles publiquement, vous pouvez généralement extraire :

• Titre du produit (nom, marque)
• Prix (actuel, d’origine, prix promo)
• Note (moyenne en étoiles)
• Nombre d’avis
• Images produit (URL de l’image principale)
• Disponibilité / statut du stock
• ASIN (Amazon Standard Identification Number)
• Description du produit et puces
• Informations sur le vendeur
• Variantes du produit (taille, couleur, etc.)

Ce qu’il faut éviter :

• Les données derrière une connexion : pages d’avis étendues, données de compte personnel, historique de commandes
• Les informations personnelles : noms d’acheteurs, adresses, informations de paiement
• Le contenu protégé par copyright à republier : les descriptions et images produit sont acceptables pour l’analyse, mais ne les republiez pas comme si elles vous appartenaient

Le d’Amazon bloque plus de 50 bots nommés (dont GPTBot, Scrapy et ClaudeBot) et interdit des chemins comme les comptes utilisateurs, le panier et les listes de souhaits. Les pages de détail produit ne sont pas explicitement interdites, mais les conditions d’utilisation d’Amazon interdisent l’accès automatisé. Les tribunaux distinguent généralement les violations des CGU (affaire civile) des violations pénales au titre du CFAA — nous revenons sur la légalité à la fin de ce guide.

Outils et bibliothèques nécessaires

Voici la stack Python utilisée dans ce tutoriel :

Optionnel (pour le contenu rendu en JavaScript) :

• selenium ou playwright — automatisation de navigateur sans interface

Configurer votre environnement Python

Ouvrez votre terminal et lancez :

1mkdir amazon-scraper && cd amazon-scraper
2python -m venv venv
3source venv/bin/activate  # Sous Windows : venv\Scripts\activate
4pip install requests beautifulsoup4 lxml curl_cffi pandas

Vérifiez que tout est installé :

1import requests, bs4, curl_cffi, pandas
2print("Tout est bon !")

Si vous voyez « Tout est bon ! » sans erreur, vous êtes prêt.

Pourquoi la plupart des tutoriels sur le scraping Amazon cassent (et pourquoi celui-ci est différent)

C’est la partie que la plupart des guides sautent, et c’est probablement pour cela que vous lisez cet article.

Amazon met souvent à jour sa structure HTML, ses noms de classes et ses identifiants d’éléments. La communauté du scraping estime que à cause des changements du DOM et de l’empreinte de détection. La victime la plus connue ? Le sélecteur #priceblock_ourprice, présent dans des centaines de tutoriels de 2018 à 2023. Cet identifiant n’existe plus sur les pages produit Amazon.

Voici une comparaison rapide entre ce qui est cassé et ce qui marche aujourd’hui :

Chaque extrait de code de ce guide a été testé sur de vraies pages Amazon en 2025. Je vais vous montrer les vrais sélecteurs CSS avec le résultat attendu — pas des copier-coller datés de 2022.

Avant de commencer

• Niveau : intermédiaire (bases de Python supposées)
• Temps nécessaire : environ 30 à 45 minutes pour le tutoriel complet ; environ 10 minutes pour le scraper de base
• Ce qu’il vous faut : Python 3.9+, navigateur Chrome (pour inspecter les pages Amazon), un terminal, et éventuellement l’ si vous voulez comparer avec une approche sans code

Étape 1 : envoyer votre première requête à Amazon

Ouvrez n’importe quelle page produit Amazon dans votre navigateur et copiez l’URL. Nous allons commencer avec un simple requests.get() :

1import requests
2url = "https://www.amazon.com/dp/B0DGNFM9YJ"
3response = requests.get(url)
4print(response.status_code)
5print(response.text[:500])

Exécutez ce code, et vous obtiendrez presque certainement un code 503 ou une page indiquant « To discuss automated access to Amazon data please contact… ». C’est le WAF d’Amazon (Web Application Firewall) qui détecte votre script Python. Un simple requests.get() sans bons en-têtes atteint environ sur Amazon.

Vous devriez voir quelque chose comme : 503 et une page de blocage dans le HTML. C’est normal — nous corrigerons ça à l’étape suivante.

Étape 2 : configurer des en-têtes personnalisés et l’usurpation TLS

Ajouter simplement un en-tête User-Agent ne suffit plus. Amazon compare vos en-têtes HTTP à votre empreinte TLS. Si vous prétendez être Chrome 120 mais que votre handshake TLS révèle la bibliothèque Python requests, vous êtes .

L’approche la plus fiable en 2025 consiste à utiliser curl_cffi avec une usurpation de navigateur :

1from curl_cffi import requests as cfreq
2headers = {
3    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
4    "Accept-Language": "en-US,en;q=0.9",
5    "Accept-Encoding": "gzip, deflate, br",
6    "Referer": "https://www.google.com/",
7    "DNT": "1",
8    "Connection": "keep-alive",
9    "Upgrade-Insecure-Requests": "1",
10}
11url = "https://www.amazon.com/dp/B0DGNFM9YJ"
12response = cfreq.get(url, headers=headers, impersonate="chrome124")
13print(response.status_code)
14print(len(response.text))

Avec curl_cffi en mode Chrome 124, les taux de réussite montent à environ — soit une amélioration de 47x par rapport à requests seul. Vous devriez maintenant obtenir un code 200 et une réponse HTML bien plus longue (plus de 100 000 caractères).

Si vous obtenez toujours un 503, essayez une autre valeur impersonate (par exemple "chrome131") ou ajoutez une courte pause avant de réessayer.

Étape 3 : analyser le HTML et extraire les données produit

Maintenant que nous avons le HTML complet, extrayons les données avec BeautifulSoup et les sélecteurs 2025 vérifiés :

1from bs4 import BeautifulSoup
2soup = BeautifulSoup(response.text, "lxml")
3# Titre du produit
4title_el = soup.select_one("span#productTitle")
5title = title_el.get_text(strip=True) if title_el else None
6# Prix
7price_el = soup.select_one(
8    "div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen"
9)
10if not price_el:
11    price_el = soup.select_one("span.priceToPay .a-offscreen")
12if not price_el:
13    price_el = soup.select_one(".apexPriceToPay .a-offscreen")
14price = price_el.get_text(strip=True) if price_el else None
15# Note
16rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17rating = rating_el.get_text(strip=True) if rating_el else None
18# Nombre d’avis
19reviews_el = soup.select_one("span#acrCustomerReviewText")
20reviews = reviews_el.get_text(strip=True) if reviews_el else None
21# Disponibilité
22avail_el = soup.select_one("div#availability span")
23availability = avail_el.get_text(strip=True) if avail_el else None
24# URL de l’image principale
25img_el = soup.select_one("#landingImage")
26image_url = img_el.get("src") if img_el else None
27print(f"Titre : {title}")
28print(f"Prix : {price}")
29print(f"Note : {rating}")
30print(f"Avis : {reviews}")
31print(f"Disponibilité : {availability}")
32print(f"Image : {image_url}")

Résultat attendu (exemple) :

1Titre : Apple AirPods Pro (2e génération) avec USB-C
2Prix : 189,99 $
3Note : 4,7 sur 5 étoiles
4Avis : 98 432 évaluations
5Disponibilité : En stock
6Image : https://m.media-amazon.com/images/I/61SUj2...

Notez les sélecteurs de secours multiples pour le prix — Amazon utilise différents conteneurs selon le type de produit, le statut promotionnel et la variante de test A/B. En enveloppant chaque extraction dans une vérification conditionnelle, vous évitez que votre scraper ne plante lorsqu’un sélecteur ne correspond pas.

Étape 4 : extraire plusieurs produits depuis les résultats de recherche

Pour construire un vrai jeu de données, commencez par une page de résultats de recherche Amazon, récupérez les ASIN, puis scrappez chaque page de détail produit.

1import time
2import random
3def get_search_asins(keyword, max_pages=1):
4    """Collecte les ASIN depuis les résultats de recherche Amazon."""
5    asins = []
6    for page in range(1, max_pages + 1):
7        search_url = f"https://www.amazon.com/s?k={keyword}&page={page}"
8        resp = cfreq.get(search_url, headers=headers, impersonate="chrome124")
9        if resp.status_code != 200:
10            print(f"La page de recherche {page} a renvoyé {resp.status_code}")
11            break
12        search_soup = BeautifulSoup(resp.text, "lxml")
13        results = search_soup.select('div[data-component-type="s-search-result"]')
14        for r in results:
15            asin = r.get("data-asin")
16            if asin:
17                asins.append(asin)
18        print(f"Page {page} : {len(results)} produits trouvés")
19        time.sleep(random.uniform(2, 5))  # Pause polie
20    return asins
21asins = get_search_asins("wireless+earbuds", max_pages=2)
22print(f"{len(asins)} ASIN collectés")

Chaque ASIN correspond à une URL produit propre : https://www.amazon.com/dp/{ASIN}. C’est plus fiable que d’utiliser les URL complètes des résultats de recherche, qui peuvent contenir des paramètres spécifiques à la session.

Étape 5 : gérer la pagination et extraire à grande échelle

Combinons maintenant la collecte depuis la recherche et l’extraction des pages de détail dans un pipeline complet :

1import pandas as pd
2def scrape_product(asin):
3    """Scrape une page de détail d’un produit Amazon."""
4    url = f"https://www.amazon.com/dp/{asin}"
5    try:
6        resp = cfreq.get(url, headers=headers, impersonate="chrome124")
7        if resp.status_code != 200:
8            return None
9        soup = BeautifulSoup(resp.text, "lxml")
10        title_el = soup.select_one("span#productTitle")
11        price_el = (
12            soup.select_one("div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen")
13            or soup.select_one("span.priceToPay .a-offscreen")
14            or soup.select_one(".apexPriceToPay .a-offscreen")
15        )
16        rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17        reviews_el = soup.select_one("span#acrCustomerReviewText")
18        avail_el = soup.select_one("div#availability span")
19        img_el = soup.select_one("#landingImage")
20        return {
21            "asin": asin,
22            "title": title_el.get_text(strip=True) if title_el else None,
23            "price": price_el.get_text(strip=True) if price_el else None,
24            "rating": rating_el.get_text(strip=True) if rating_el else None,
25            "reviews": reviews_el.get_text(strip=True) if reviews_el else None,
26            "availability": avail_el.get_text(strip=True) if avail_el else None,
27            "image_url": img_el.get("src") if img_el else None,
28            "url": url,
29        }
30    except Exception as e:
31        print(f"Erreur lors du scraping de {asin} : {e}")
32        return None
33# Scraper tous les ASIN collectés
34products = []
35for i, asin in enumerate(asins):
36    print(f"Scraping {i+1}/{len(asins)} : {asin}")
37    product = scrape_product(asin)
38    if product:
39        products.append(product)
40    time.sleep(random.uniform(2, 5))  # Délai aléatoire entre les requêtes
41df = pd.DataFrame(products)
42print(f"\n{len(df)} produits extraits avec succès")
43print(df.head())

Le délai aléatoire entre 2 et 5 secondes est essentiel. Un rythme parfaitement régulier (par exemple exactement 3 secondes à chaque fois) paraît suspect aux analyses comportementales d’Amazon. Des intervalles aléatoires imitent mieux une navigation humaine.

Étape 6 : enregistrer les données Amazon extraites en CSV

1df.to_csv("amazon_products.csv", index=False, encoding="utf-8-sig")
2print("Enregistré dans amazon_products.csv")

Vous devriez maintenant avoir un CSV propre avec des colonnes pour l’ASIN, le titre, le prix, la note, les avis, la disponibilité, l’URL de l’image et l’URL du produit. C’est là que la plupart des tutoriels s’arrêtent — mais si vous construisez un vrai flux de travail, le CSV n’est que le début.

Décryptage de l’anti-blocage : comment faire durer votre scraper

Le blocage est pour toute personne qui essaie de scraper des produits Amazon avec Python. La défense à six couches d’Amazon comprend l’analyse de la réputation IP, l’empreinte TLS, la vérification de l’environnement navigateur, la biométrie comportementale, les CAPTCHA et la détection d’anomalies pilotée par ML. Voici une stratégie en couches pour répondre à chacun de ces niveaux.

Faire tourner les User-Agents et les en-têtes complets

Un seul User-Agent statique est vite repéré. Faites tourner une liste de chaînes de navigateur récentes :

1import random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
4    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
6    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
7]
8def get_headers():
9    return {
10        "User-Agent": random.choice(USER_AGENTS),
11        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
12        "Accept-Language": "en-US,en;q=0.9",
13        "Accept-Encoding": "gzip, deflate, br",
14        "Referer": "https://www.google.com/",
15        "DNT": "1",
16        "Connection": "keep-alive",
17    }

Un détail qui piège souvent les gens : votre Accept-Language doit correspondre à la localisation géographique supposée par votre IP. Envoyer Accept-Language: en-US depuis une IP allemande est un signal d’alerte.

Usurpation d’empreinte TLS avec curl_cffi

Nous l’avons déjà vu à l’étape 2, mais cela mérite d’être souligné : cette seule technique apporte le plus gros gain de réussite. requests standard atteint environ 2 % de réussite sur Amazon. Avec l’usurpation via curl_cffi, vous êtes autour de 94 %. C’est la différence entre un scraper fonctionnel et un scraper cassé.

1from curl_cffi import requests as cfreq
2# Faites aussi varier les navigateurs usurpés
3BROWSERS = ["chrome120", "chrome124", "chrome131"]
4response = cfreq.get(
5    url,
6    headers=get_headers(),
7    impersonate=random.choice(BROWSERS),
8)

Rotation des proxies

Pour scraper plus que quelques pages, vous aurez besoin d’une rotation de proxies. Amazon suit les adresses IP et bloque toute IP unique qui envoie trop de requêtes.

1PROXIES = [
2    "http://user:pass@proxy1.example.com:8080",
3    "http://user:pass@proxy2.example.com:8080",
4    "http://user:pass@proxy3.example.com:8080",
5]
6proxy = random.choice(PROXIES)
7response = cfreq.get(
8    url,
9    headers=get_headers(),
10    impersonate="chrome124",
11    proxies={"http": proxy, "https": proxy},
12)

Les proxies résidentiels sont plus efficaces que les proxies de datacenter (Amazon bloque de manière proactive les plages IP des datacenters), mais ils sont aussi plus chers. Pour un petit projet, vous pouvez commencer avec un puis monter en charge selon vos besoins.

Limitation du débit et backoff exponentiel

Aucun article concurrent que j’ai trouvé ne couvre cela, et pourtant c’est indispensable. Lorsqu’une réponse 503 ou CAPTCHA apparaît, ne réessayez pas immédiatement — c’est le chemin le plus court vers un bannissement permanent.

1import time
2import random
3def fetch_with_backoff(url, max_retries=3):
4    """Récupère une URL avec backoff exponentiel en cas d’échec."""
5    for attempt in range(max_retries):
6        response = cfreq.get(
7            url,
8            headers=get_headers(),
9            impersonate=random.choice(BROWSERS),
10        )
11        if response.status_code == 200:
12            return response
13        # Backoff exponentiel avec jitter
14        wait = min(2 ** attempt + random.uniform(0, 1), 30)
15        print(f"Tentative {attempt+1} échouée ({response.status_code}). Attente {wait:.1f}s...")
16        time.sleep(wait)
17    return None  # Toutes les tentatives ont échoué

La formule wait = min(2^attempt + jitter, max_delay) garantit que vos délais augmentent (2 s, 4 s, 8 s...) sans jamais dépasser un plafond raisonnable. Le jitter aléatoire empêche votre schéma de réessai d’être repéré par empreinte.

Solution de secours Selenium ou Playwright pour le contenu rendu en JavaScript

Certaines pages Amazon (surtout celles avec des widgets de prix dynamiques ou des sélecteurs de variantes) nécessitent JavaScript pour s’afficher complètement. Lorsque curl_cffi renvoie un HTML incomplet, un navigateur sans interface devient votre solution de secours :

1from playwright.sync_api import sync_playwright
2def scrape_with_browser(url):
3    with sync_playwright() as p:
4        browser = p.chromium.launch(headless=True)
5        page = browser.new_page()
6        page.goto(url, wait_until="domcontentloaded")
7        page.wait_for_timeout(3000)  # Laisser le JS se charger
8        html = page.content()
9        browser.close()
10        return html

C’est plus lent — 3 à 5 secondes par page contre moins d’une seconde avec curl_cffi. Utilisez-le seulement si nécessaire.

D’après mon expérience, curl_cffi traite plus de 90 % des pages produit Amazon sans navigateur.

Résumé anti-blocage

Au-delà du CSV : exporter les données Amazon vers Google Sheets, Airtable, et plus encore

Chaque tutoriel que j’ai consulté s’arrête à l’export CSV. Mais les vrais workflows métier ont besoin de données dans Google Sheets, des bases de données ou des outils comme Airtable et Notion.

Exporter vers Google Sheets avec gspread

Commencez par configurer un compte de service Google (configuration unique) :

1. Allez dans → APIs & Services → Credentials
2. Créez un compte de service et téléchargez le fichier clé JSON
3. Enregistrez-le dans ~/.config/gspread/service_account.json
4. Partagez votre feuille cible avec l’adresse client_email du fichier JSON

Puis :

1import gspread
2from gspread_dataframe import set_with_dataframe
3gc = gspread.service_account()
4sh = gc.open("Amazon Scrape Data")
5worksheet = sh.sheet1
6set_with_dataframe(worksheet, df)
7print("Données exportées vers Google Sheets !")

Cela écrit tout votre DataFrame directement dans une feuille Google — en direct, partageable et prête pour les tableaux de bord.

Stocker dans SQLite pour une analyse locale

Pour de plus grands volumes de données ou un suivi historique, SQLite est idéal — aucune configuration serveur, juste un fichier unique :

1import sqlite3
2conn = sqlite3.connect("amazon_products.db")
3df.to_sql("products", conn, if_exists="append", index=False)
4print(f"{len(df)} produits stockés dans SQLite")
5# Requête ultérieure :
6historical = pd.read_sql_query(
7    "SELECT * FROM products WHERE price IS NOT NULL ORDER BY rowid DESC LIMIT 100",
8    conn,
9)

L’alternative sans code

Si vous ne voulez pas maintenir de scripts Python d’export, propose un export gratuit vers Google Sheets, Airtable, Notion, Excel, CSV et JSON — y compris des champs image qui s’affichent directement dans Airtable et Notion. Pas de configuration gspread, pas d’identifiants API, aucun code. Pour les équipes qui ont besoin d’alimenter leurs outils existants en données, c’est un énorme gain de temps.

Planifier des extractions Amazon automatisées — le chapitre manquant

Le suivi des prix et des stocks exige des extractions récurrentes, pas des exécutions ponctuelles. Pourtant, je n’ai trouvé aucun article concurrent qui aborde la planification. Voici comment automatiser votre scraper Python.

Cron jobs (Linux/macOS)

Ouvrez votre crontab :

1crontab -e

Ajoutez une ligne pour exécuter votre scraper tous les jours à 6 h :

10 6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

Ou toutes les 6 heures :

10 */6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

Planificateur de tâches Windows

Créez un fichier batch run_scraper.bat :

1@echo off
2cd /d "C:\path\to\amazon-scraper"
3call venv\Scripts\activate
4python scraper.py
5deactivate

Ensuite ouvrez le Planificateur de tâches → Créer une tâche de base → définissez le déclencheur (quotidien, horaire) → Action : « Démarrer un programme » → sélectionnez run_scraper.bat.

GitHub Actions (gratuit)

Pour une planification cloud sans infrastructure :

1name: Amazon Scraper
2on:
3  schedule:
4    - cron: "0 6 * * *"  # Tous les jours à 6 h UTC
5  workflow_dispatch:       # Déclenchement manuel
6jobs:
7  scrape:
8    runs-on: ubuntu-latest
9    steps:
10      - uses: actions/checkout@v3
11      - name: Set up Python
12        uses: actions/setup-python@v4
13        with:
14          python-version: "3.11"
15      - name: Install dependencies
16        run: pip install -r requirements.txt
17      - name: Run scraper
18        run: python scraper.py
19      - name: Commit results
20        run: |
21          git config user.name 'GitHub Actions'
22          git config user.email 'actions@github.com'
23          git add data/
24          git diff --staged --quiet || git commit -m "Update scraped data"
25          git push

Stockez les identifiants proxy dans GitHub Secrets, et vous obtenez un pipeline de scraping automatisé gratuit.

Alternative sans code : le Scheduled Scraper de Thunderbit

Pour les équipes qui ne veulent pas gérer la syntaxe cron ou une infrastructure cloud, Thunderbit propose un intégré. Vous décrivez la fréquence en langage naturel (par exemple « tous les jours à 8 h » ou « tous les lundis »), vous ajoutez vos URL Amazon et vous cliquez sur « Planifier ». Pas de terminal, pas de fichier YAML, pas de pipeline de déploiement. C’est particulièrement utile pour les équipes e-commerce qui surveillent en continu les prix ou les stocks.

Python maison, Scraper API ou sans code : quelle approche choisir ?

C’est une question que je vois tout le temps sur les forums, et aucun article bien classé ne fournit de réponse structurée. Voici donc mon avis honnête :

Python est le bon choix si vous voulez apprendre, personnaliser chaque détail et ne pas craindre une maintenance continue. Les Scraper APIs gèrent l’anti-blocage pour vous, mais nécessitent toujours du code. Thunderbit est la voie la plus rapide pour les équipes commerciales, e-commerce ou toute personne qui a juste besoin des données — sans sélecteurs, sans code, sans maintenance quand Amazon modifie son HTML.

Comment Thunderbit extrait des produits Amazon en 2 clics

Je suis évidemment partial — mon équipe a construit cet outil. Mais le flux de travail est vraiment aussi simple :

1. Installez l’
2. Ouvrez une page de résultats de recherche ou une page produit Amazon
3. Cliquez sur « AI Suggest Fields » (ou utilisez le modèle d’extraction Amazon instantané)
4. Cliquez sur « Scrape »

L’IA de Thunderbit lit la page, comprend la structure des données et extrait tout dans un tableau propre. Vous pouvez exporter gratuitement vers Excel, Google Sheets, Airtable ou Notion. Le vrai avantage : quand Amazon modifie son HTML la semaine prochaine (et ce sera le cas), l’IA de Thunderbit s’adapte automatiquement. Pas de script cassé, pas de sélecteurs à mettre à jour.

Pour enrichir des listes de produits avec des données de page détail, la fonction Subpage Scraping de Thunderbit suit automatiquement les liens vers les pages produit et ajoute des champs comme les images, descriptions et variantes — ce qui demande beaucoup de code supplémentaire en Python.

Conseils pour faire durer votre scraper Amazon Python sur le long terme

Si vous choisissez Python, voici comment réduire les soucis de maintenance :

• Vérifiez régulièrement les sélecteurs. Amazon les modifie souvent. Mettez cet article en favori — je mettrai à jour le tableau des sélecteurs au fil des changements.
• Surveillez votre taux de réussite. Suivez le ratio de réponses 200 par rapport aux 503/CAPTCHA. Mettez en place une alerte (même simple par e-mail) lorsque votre taux passe sous 80 %.
• Stockez le HTML brut. Sauvegardez la réponse HTML complète avec vos données analysées. Si les sélecteurs changent, vous pourrez retraiter les données historiques sans refaire le scraping.
• Faites tourner fréquemment les proxies et les User-Agents. Les empreintes statiques sont repérées en quelques heures à grande échelle.
• Utilisez le backoff exponentiel. Ne réessayez jamais immédiatement après un blocage.
• Conteneurisez avec Docker. Emballez votre scraper dans un conteneur Docker pour un déploiement et une portabilité faciles.
• Ajoutez une validation des données. Vérifiez que les prix sont numériques, que les notes sont entre 1 et 5 et que les titres ne sont pas vides. Une équipe a signalé une après avoir ajouté des couches de validation.

Ou, si tout cela vous semble demander plus de travail que prévu, demandez-vous si un outil sans code comme Thunderbit ne conviendrait pas mieux à votre cas d’usage. Il n’y a aucune honte à choisir la voie la plus rapide — j’ai passé suffisamment d’années à déboguer des scrapers pour savoir que parfois, le meilleur code est celui qu’on n’a pas à écrire.

Considérations juridiques et éthiques lors du scraping Amazon

Comme cette question revient à chaque discussion sur Amazon scraping, voici un rappel rapide sur le cadre juridique :

• L’extraction de données publiquement accessibles est généralement légale aux États-Unis. L’arrêt historique (2022) a établi que l’accès à des données publiques ne viole pas le CFAA. Plus récemment, (2024) et (2024) ont renforcé ce principe.
• Les CGU d’Amazon interdisent l’accès automatisé. Il s’agit d’une question civile (rupture de contrat), pas pénale. Les tribunaux distinguent généralement les deux.
• Amazon v. Perplexity (2025) est une affaire en cours impliquant le scraping par IA des pages Amazon. Une injonction préliminaire a été rendue en mars 2026. Cela vaut la peine d’être suivi.
• Restez sur les pages publiques. Ne scrapez pas de contenu protégé par connexion, de données personnelles ou tout contenu nécessitant une authentification.
• Respectez les limites de débit. Ne martèlez pas les serveurs d’Amazon. Un délai de 2 à 5 secondes entre les requêtes est raisonnable.
• Utilisez les données de manière responsable. Scrapez pour analyser, pas pour republier du contenu protégé.
• Consultez un juriste pour un usage commercial à grande échelle, surtout si vous êtes dans l’UE (le RGPD s’applique aux données personnelles).

Pour aller plus loin, consultez notre guide sur les .

Conclusion

Vous avez maintenant un scraper Amazon Python fonctionnel avec des sélecteurs 2025 vérifiés, une stratégie anti-blocage en couches qui va bien au-delà de « rajouter un User-Agent », des options pratiques de planification pour la surveillance continue, et des méthodes d’export qui envoient vos données vers Google Sheets, des bases de données ou n’importe quel autre outil utilisé par votre équipe.

Résumé rapide :

• Python + curl_cffi + BeautifulSoup vous donne un contrôle total et un taux de réussite d’environ 94 % lorsqu’il est combiné à l’usurpation TLS
• L’anti-blocage exige plusieurs couches : rotation des en-têtes, usurpation TLS, rotation des proxies, limitation du débit et backoff exponentiel
• La planification transforme un script ponctuel en pipeline de surveillance continue (cron, GitHub Actions ou planificateur intégré de Thunderbit)
• Exporter au-delà du CSV — Google Sheets, SQLite, Airtable, Notion — est là où se trouve la vraie valeur métier
• Thunderbit offre une alternative en 2 clics pour les non-développeurs ou toute personne préférant analyser les données plutôt que déboguer des sélecteurs

Si vous voulez tester le code, tout ce guide est prêt à être copié et exécuté. Et si vous préférez éviter complètement le codage, l’ vous permet d’essayer immédiatement l’approche sans code sur Amazon.

Pour aller plus loin, consultez nos guides sur , et . Vous pouvez aussi regarder des tutoriels pas à pas sur la .

Bon scraping — et que vos sélecteurs tiennent jusqu’à la prochaine mise à jour d’Amazon.

FAQ

1. Pourquoi mon scraper Amazon Python est-il bloqué après quelques requêtes ?

Amazon utilise un système de défense à six couches : analyse de réputation IP, empreinte TLS (JA3/JA4), détection de l’environnement navigateur, biométrie comportementale, défis CAPTCHA et détection d’anomalies pilotée par ML. Un script requests basique avec seulement un en-tête User-Agent n’obtient qu’environ de réussite. Vous avez besoin d’une usurpation TLS (curl_cffi), d’une rotation complète des en-têtes, d’une rotation des proxies et d’une limitation du débit avec jitter aléatoire pour garder un accès fiable.

2. Quelles bibliothèques Python sont les meilleures pour extraire des produits Amazon en 2025 ?

curl_cffi pour les requêtes HTTP avec usurpation TLS (le plus gros gain individuel), BeautifulSoup4 avec lxml pour l’analyse HTML, pandas pour la structuration et l’export des données, et Selenium ou Playwright en solution de secours pour le contenu rendu en JavaScript. Python est utilisé par des développeurs en scraping.

3. Est-il légal de scraper des données produit Amazon ?

L’extraction de données publiquement accessibles est généralement légale aux États-Unis, comme l’illustrent hiQ v. LinkedIn et Meta v. Bright Data. Les conditions d’utilisation d’Amazon interdisent l’accès automatisé, mais les tribunaux distinguent les violations des CGU (civiles) des infractions pénales. Évitez toujours le contenu protégé par connexion, respectez les limites de débit et consultez un avocat pour un usage commercial à grande échelle.

4. Puis-je scraper Amazon sans écrire de code ?

Oui. Des outils comme vous permettent d’extraire des produits Amazon en 2 clics avec une extension Chrome. Sa détection de champs par IA structure automatiquement les données, et vous pouvez exporter gratuitement vers Excel, Google Sheets, Airtable ou Notion. Quand Amazon modifie son HTML, l’IA de Thunderbit s’adapte sans mise à jour manuelle.

5. À quelle fréquence Amazon change-t-il ses sélecteurs HTML, et comment garder mon scraper à jour ?

Fréquemment et sans préavis. La communauté du scraping estime que des crawlers nécessitent des corrections hebdomadaires à cause des changements du DOM. Pour garder une longueur d’avance, surveillez le taux de réussite de votre scraper, stockez le HTML brut pour le retraitement et vérifiez régulièrement les sélecteurs sur les pages réelles. Sinon, les outils dopés à l’IA comme Thunderbit s’adaptent automatiquement et suppriment cette charge de maintenance.

En savoir plus