Suivi du classement de mots-clés Amazon avec proxies : guide développeur

Avertissement juridique : Le scraping de données publiques de recherche Amazon doit respecter les Conditions d'Utilisation d'Amazon, le Computer Fraud and Abuse Act (CFAA) aux États-Unis et le RGPD dans l'UE. Ce guide couvre uniquement la collecte de données de recherche publiques (résultats visibles sans connexion) et le suivi de vos propres listings. Pour des volumes importants ou des données commerciales, privilégiez l'API SP d'Amazon (SP-API) qui fournit des rapports de recherche et de catalogue de manière contractuelle.

Le suivi du classement de mots-clés Amazon avec proxies est une discipline incontournable pour les vendeurs marketplace et les développeurs SEO. Contrairement à Google, Amazon est un moteur de recherche commercial : chaque requête génère un classement influencé par les ventes, la conversion et l'historique du produit. Suivre manuellement la position d'un ASIN pour 50 mots-clés sur 5 marketplaces devient rapidement ingérable. Ce guide vous montre comment automatiser ce suivi en Python avec des proxies résidentiels géo-ciblés.

Pourquoi Amazon est un SERP à part entière

Le classement organique d'Amazon repose sur un algorithme nommé A9, qui combine pertinence textuelle (titre, bullet points, description, backend keywords) et performance commerciale (taux de conversion, ventes récentes, stock disponible, reviews). Une page qui convertit bien grimpe ; un produit en rupture coule. C'est pourquoi un vendeur doit connaître sa position organique par mot-clé, par marketplace et par ASIN — pas seulement son trafic global.

Les outils tiers comme Helium 10 ou Jungle Scout facturent souvent 30 à 100 $/mois pour ce suivi. En construisant votre propre amazon keyword rank tracker, vous gardez le contrôle des données, des fréquences et des marketplaces surveillées, sans dépendre d'un SaaS opaque.

Organique vs Sponsorisé

Sur la page de résultats Amazon, les emplacements Sponsored (Publicité Produits Sponsorisés) sont mélangés avec les résultats organiques. Pour mesurer le vrai référencement naturel, il faut détecter le libellé Sponsored et exclure ces blocs du comptage. Nous verrons comment faire avec le sélecteur [data-component-type="s-search-result"] et l'attribut data-asin.

Anatomie de la page de résultats Amazon

Amazon utilise des composants React/NodeJS rendus côté serveur. Chaque résultat organique est encapsulé dans une div avec l'attribut data-component-type="s-search-result" et un attribut data-asin contenant l'identifiant produit (10 caractères alphanumériques, ex. B0CHX1W1XY). Les placements sponsorisés portent la classe s-sponsored-label-info-icon ou un texte Sponsored visible.

La position organique se calcule en itérant sur les blocs s-search-result dans l'ordre du DOM et en incrémentant un compteur uniquement pour les blocs non sponsorisés. La page (1, 2, 3…) correspond au paramètre d'URL &page=N ou au défilement (sur certaines vues mobiles).

Pourquoi les proxies résidentiels sont indispensables

Amazon applique une localisation par marketplace : amazon.com renvoie des résultats US, amazon.de des résultats allemands, amazon.co.jp des résultats japonais. Un proxy datacenter situé à Francfort interrogeant amazon.com peut recevoir des résultats dégradés, des captchas ou des redirections vers amazon.de. Les proxies résidentiels avec géo-ciblage pays simulent un utilisateur local et évitent ces biais.

De plus, Amazon dispose d'un système anti-bot agressif : détection de TLS fingerprint, rate limiting par IP, challenges CAPTCHA. Un proxy résidentiel rotatif répartit la charge, tandis qu'une session sticky permet de paginer sans changer d'IP en plein milieu d'une série de requêtes (ce qui perturberait la cohérence des résultats).

Avec ProxyHat, le géo-ciblage se fait via le nom d'utilisateur :

• user-country-US pour amazon.com
• user-country-DE pour amazon.de
• user-country-FR pour amazon.fr
• user-session-abc123 pour une session stable de 10 à 30 minutes

Consultez la liste complète des emplacements ProxyHat pour couvrir les 17 marketplaces Amazon.

Mise en œuvre : scraper les résultats Amazon en Python

1. Requête brute avec curl

Avant d'écrire du Python, vérifions la connexion proxy avec un simple curl :

curl -x http://user-country-US:pass@gate.proxyhat.com:8080 \
  -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" \
  -H "Accept-Language: en-US,en;q=0.9" \
  "https://www.amazon.com/s?k=bluetooth+earbuds&page=1" \
  -o amazon_page1.html

Si le fichier contient des data-asin, le proxy fonctionne. Si vous obtenez une page CAPTCHA, changez de session ou ajoutez un délai.

2. curl_cffi avec TLS fingerprint Chrome

curl_cffi reproduit l'empreinte TLS de Chrome, ce qui réduit les blocages. Voici un client réutilisable avec retry et gestion de session sticky :

import time
import random
from curl_cffi import requests

PROXY = "http://user-country-US-session-rank01:pass@gate.proxyhat.com:8080"

def fetch_amazon_search(keyword: str, page: int = 1, marketplace: str = "www.amazon.com") -> str:
    """Récupère le HTML d'une page de recherche Amazon avec retry et backoff."""
    url = f"https://{marketplace}/s?k={requests.utils.quote(keyword)}&page={page}"
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    }
    for attempt in range(4):
        try:
            r = requests.get(url, headers=headers, proxies={"http": PROXY, "https": PROXY},
                             impersonate="chrome120", timeout=20)
            if r.status_code == 200 and "data-asin" in r.text:
                return r.text
            if "captcha" in r.text.lower():
                print(f"CAPTCHA détecté (page {page}, tentative {attempt+1})")
                time.sleep(15 + random.uniform(0, 10))
                continue
            r.raise_for_status()
        except Exception as e:
            print(f"Erreur page {page} tentative {attempt+1}: {e}")
            time.sleep(2 ** attempt + random.uniform(0, 2))
    raise RuntimeError(f"Échec après retries pour page {page}")

Le paramètre impersonate="chrome120" est crucial : il configure JA3/JA4, l'ordre des ciphers et les extensions TLS pour imiter Chrome 120, ce qui passe la plupart des filtres anti-bot d'Amazon.

3. Parsing des résultats avec BeautifulSoup

from bs4 import BeautifulSoup
from dataclasses import dataclass

@dataclass
class AmazonResult:
    asin: str
    organic_position: int
    page: int
    is_sponsored: bool

def parse_search_results(html: str, page: int) -> list[AmazonResult]:
    """Extrait les ASIN et positions organiques depuis le HTML Amazon."""
    soup = BeautifulSoup(html, "html.parser")
    results = []
    organic_counter = 0
    for div in soup.select('[data-component-type="s-search-result"]'):
        asin = div.get("data-asin", "")
        if not asin:
            continue
        # Détection des placements sponsorisés
        sponsored = div.select_one(".s-sponsored-label-info-icon, span.s-sponsored-label")
        is_sponsored = sponsored is not None or "Sponsored" in div.get_text()
        if not is_sponsored:
            organic_counter += 1
        results.append(AmazonResult(
            asin=asin,
            organic_position=organic_counter,
            page=page,
            is_sponsored=is_sponsored,
        ))
    return results

Cette fonction renvoie une liste ordonnée. La organic_position n'incrémente que pour les blocs non sponsorisés, ce qui isole le vrai classement naturel.

4. Orchestration : suivre un ASIN sur 5 pages

import csv
from datetime import datetime

def track_asin_rank(keyword: str, target_asin: str, max_pages: int = 5,
                    marketplace: str = "www.amazon.com") -> dict | None:
    """Parcourt les pages 1..N et renvoie la position de target_asin."""
    for page in range(1, max_pages + 1):
        html = fetch_amazon_search(keyword, page=page, marketplace=marketplace)
        results = parse_search_results(html, page)
        for res in results:
            if res.asin == target_asin and not res.is_sponsored:
                return {
                    "keyword": keyword,
                    "asin": target_asin,
                    "marketplace": marketplace,
                    "page": page,
                    "organic_position": res.organic_position,
                    "absolute_position": (page - 1) * 60 + res.organic_position,
                    "timestamp": datetime.utcnow().isoformat(),
                }
        time.sleep(2 + random.uniform(0, 3))  # throttle entre pages
    return {"keyword": keyword, "asin": target_asin, "found": False,
            "timestamp": datetime.utcnow().isoformat()}

# Exemple d'usage
record = track_asin_rank("bluetooth earbuds", "B0CHX1W1XY", max_pages=5,
                          marketplace="www.amazon.com")
print(record)

# Persistance CSV pour historique
with open("rank_history.csv", "a", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=record.keys())
    writer.writerow(record)

La session -session-rank01 dans l'URL proxy garantit que toutes les pages d'une même recherche proviennent de la même IP résidentielle, ce qui évite les incohérences de localisation entre pages.

5. Alternative Playwright pour pages dynamiques

Sur certaines marketplaces, Amazon charge les résultats en lazy-load. Playwright gère le rendu JavaScript et le scroll :

from playwright.sync_api import sync_playwright

def fetch_with_playwright(keyword: str, page: int, marketplace: str = "www.amazon.com") -> str:
    url = f"https://{marketplace}/s?k={keyword.replace(' ', '+')}&page={page}"
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=True,
            proxy={"server": "http://gate.proxyhat.com:8080",
                   "username": "user-country-US-session-pw01", "password": "pass"}
        )
        ctx = browser.new_context(user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                                  "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
                                  locale="en-US")
        pg = ctx.new_page()
        pg.goto(url, wait_until="domcontentloaded", timeout=25000)
        pg.wait_for_selector('[data-component-type="s-search-result"]', timeout=10000)
        html = pg.content()
        browser.close()
        return html

Playwright est plus lent (≈ 3-5 s par page) mais plus robuste face aux lazy-loads. Réservez-le aux cas où curl_cffi échoue.

Production : planification, retries, détection CAPTCHA

Planification quotidienne

Un suivi sérieux tourne une fois par jour par mot-clé/marketplace. Pour 100 mots-clés × 5 marketplaces = 500 requêtes/jour, un seul proxy résidentiel suffit si vous throttlez à 1 requête toutes les 3-5 secondes. Pour 1000 mots-clés, prévoyez 5-10 sessions concurrentes.

import schedule
import threading
from queue import Queue

def job_daily():
    keywords = load_keywords()  # liste de (keyword, asin, marketplace)
    q = Queue()
    for kw in keywords:
        q.put(kw)
    def worker():
        while not q.empty():
            keyword, asin, marketplace = q.get()
            try:
                rec = track_asin_rank(keyword, asin, max_pages=5, marketplace=marketplace)
                save_to_db(rec)
            except Exception as e:
                log_error(keyword, marketplace, e)
            finally:
                q.task_done()
    threads = [threading.Thread(target=worker) for _ in range(5)]
    for t in threads: t.start()
    for t in threads: t.join()

schedule.every().day.at("06:00").do(job_daily)
while True:
    schedule.run_pending()
    time.sleep(60)

Détection CAPTCHA et circuit breaker

Amazon renvoie un challenge CAPTCHA quand il détecte un comportement automatisé. Signes typiques : présence de captcha dans l'URL ou le HTML, code 503, ou page contenant api-services-support@amazon.com. Implémentez un circuit breaker qui suspend 30 minutes après 3 CAPTCHAs consécutifs :

class CircuitBreaker:
    def __init__(self, threshold=3, cooldown=1800):
        self.failures = 0
        self.threshold = threshold
        self.cooldown = cooldown
        self.tripped_until = 0
    def record_failure(self):
        self.failures += 1
        if self.failures >= self.threshold:
            self.tripped_until = time.time() + self.cooldown
            self.failures = 0
    def is_open(self) -> bool:
        return time.time() < self.tripped_until
    def record_success(self):
        self.failures = 0

breaker = CircuitBreaker()

def safe_fetch(keyword, page, marketplace):
    if breaker.is_open():
        raise RuntimeError("Circuit breaker ouvert — pause 30 min")
    html = fetch_amazon_search(keyword, page, marketplace)
    if "captcha" in html.lower() or "api-services-support@amazon.com" in html:
        breaker.record_failure()
        raise RuntimeError("CAPTCHA détecté")
    breaker.record_success()
    return html

Vérification d'indexation

Avant de suivre un mot-clé, vérifiez que l'ASIN est indexé pour ce terme. Si l'ASIN n'apparaît pas dans les 5 premières pages, il peut être non indexé ou pénalisé. Une méthode simple : recherchez le mot-clé + filtre de marque, ou comparez le nombre total de résultats avec/sans le mot-clé. Un ASIN non indexé pour un mot-clé stratégique signale un problème de backend keywords ou de contenu.

Comparaison des approches de scraping Amazon

Pour des volumes importants, combinez : SP-API pour les rapports de catalogue, scraping pour le classement organique par mot-clé (que SP-API ne fournit pas directement).

Éthique et bonnes pratiques

• Throttlez : 1 requête toutes les 3-5 secondes par session, 5-10 sessions max en parallèle.
• Suivez vos propres listings et/ou des données publiquement visibles sans connexion.
• Respectez robots.txt d'Amazon (disponible sur https://www.amazon.com/robots.txt).
• Privilégiez SP-API quand il offre la donnée dont vous avez besoin — c'est contractuel et sans risque de blocage.
• Stockez l'historique pour détecter les baisses de position liées à des modifications de listing ou à des pénalités.

Pour aller plus loin sur la configuration des proxies et les bonnes pratiques de scraping, consultez notre guide de web scraping, notre page de suivi SERP, la tarification ProxyHat et la documentation officielle.

Points clés à retenir

• Amazon est un SERP commercial : le classement dépend de pertinence et de ventes, d'où l'importance de suivre la position organique par mot-clé.
• Utilisez [data-component-type="s-search-result"] et data-asin pour parser ; détectez le label Sponsored pour exclure les placements payants.
• Les proxies résidentiels géo-ciblés (-country-US, -country-DE) sont indispensables pour des résultats locaux cohérents.
• Les sessions sticky (-session-abc123) garantissent une pagination stable sans changement d'IP.
• curl_cffi avec impersonate="chrome120" réduit les blocages ; Playwright gère le lazy-load.
• En production : throttlez, ajoutez retries/backoff, un circuit breaker anti-CAPTCHA, et vérifiez l'indexation des ASIN.
• Pour des volumes élevés, évaluez l'API SP d'Amazon qui est contractuelle et sans risque de blocage.

FAQ

Qu'est-ce que le suivi du classement de mots-clés Amazon avec proxies ?

C'est l'automatisation de la collecte de la position organique d'un ASIN pour un mot-clé donné sur une marketplace Amazon, en utilisant des proxies résidentiels pour simuler une connexion locale et éviter les blocages anti-bot. On récupère le HTML de la page de recherche, on parse les blocs s-search-result et on calcule la position de l'ASIN cible.

Pourquoi le suivi du classement Amazon nécessite-t-il des proxies ?

Amazon localise les résultats par marketplace et applique un filtrage anti-bot agressif (TLS fingerprint, rate limiting, CAPTCHA). Sans proxy résidentiel géo-ciblé, un scraper datacenter reçoit des résultats dégradés ou des blocages. Les proxies résidentiels simulent un utilisateur local, garantissant des classements représentatifs et fiables.

Quel type de proxy fonctionne le mieux pour le suivi Amazon ?

Les proxies résidentiels avec géo-ciblage pays et sessions sticky sont recommandés. Les proxies datacenter sont rapidement détectés et bloqués par Amazon. Les proxies mobiles fonctionnent aussi mais sont plus coûteux et plus lents. ProxyHat propose des résidentiels avec géo-ciblage via le nom d'utilisateur (-country-US, -country-DE) et sessions sticky via -session-abc123.

Comment éviter les blocages lors du scraping Amazon ?

Utilisez curl_cffi avec impersonate="chrome120" pour reproduire l'empreinte TLS de Chrome, throttlez à 1 requête toutes les 3-5 secondes par session, utilisez des sessions sticky pour la pagination, implémentez un circuit breaker qui suspend 30 minutes après 3 CAPTCHAs, et variez les User-Agents. Pour les volumes importants, évaluez l'API SP d'Amazon qui est contractuelle et sans risque de blocage.

Peut-on suivre le classement Amazon sans scraping ?

Partiellement. L'API SP d'Amazon fournit des rapports de catalogue, de ventes et de performance publicitaire, mais ne fournit pas directement le classement organique par mot-clé. Pour le classement organique, le scraping reste la méthode la plus courante. Combiner SP-API (données contractuelles) et scraping (classement) offre une solution hybride robuste.