Comment utiliser l'API Amazon Scraper : guide de démarrage rapide

L'API Amazon de WebScrapingAPI est un point de terminaison GET qui prend en paramètre un type de requête (par exemple, produit, recherche ou best-sellers), ainsi qu'un ASIN, un mot-clé, une catégorie ou un identifiant de vendeur, et renvoie la page Amazon correspondante sous forme de JSON structuré. WebScrapingAPI se charge de l'accès, de l'extraction et de la maintenance de l'analyseur syntaxique. Votre code sélectionne les pages, les marchés et les champs, puis stocke les résultats.

Vous nommez la page via type et ses paramètres d’entrée, et chaque réponse est structurée de la même manière : ce que vous avez demandé, ce qu’Amazon a affiché et les enregistrements présents sur cette page. Vous n’avez pas à écrire de sélecteurs, ni à les réécrire lorsque Amazon modifie son balisage.

Voici qui fait quoi :

• WebScrapingAPI gère : l’accès à la source, l’extraction des données, les mises à jour de l’analyseur et le contrôle qualité.
• Votre équipe est responsable : du choix des pages et des marchés à collecter, des champs à conserver, des calendriers de mise à jour et de livraison, ainsi que de l’analyse qui en découle.

L’API couvre les résultats de recherche et par catégorie, les pages de produits et de variantes, ainsi que les listes d’offres des vendeurs. Les équipes les utilisent pour analyser la « Buy Box » et les offres, les parts de marché en recherche et par catégorie, ainsi que les variantes et les signaux issus des avis. Amazon est l’une des sources du catalogue plus large de l’API de données.

Chaque réponse correspond à une observation d’une page, sur un marché donné, à un moment précis. Un prix, un classement ou un nombre d’avis n’a de sens qu’en fonction des paramètres et du moment qui l’ont généré.

Créez un compte WebScrapingAPI, abonnez-vous à l’API Amazon dans le tableau de bord, puis enregistrez votre clé dans une variable d’environnement. Envoyez ensuite une requête GET à https://ecom.webscrapingapi.com/v1 en indiquant api_key, engine=amazon, type=search et q avec votre mot-clé. Laissez votre client HTTP s’occuper de l’encodage des paramètres et conservez la clé sur votre serveur.

1. Créez un compte avec une adresse e-mail et un mot de passe, via GitHub ou Google.
2. Abonnez-vous à l’API Amazon dans le tableau de bord. La version d’essai comprend 100 requêtes Amazon pour 0 $.
3. Enregistrez la clé dans une variable d’environnement, par exemple WSA_API_KEY, ou dans un gestionnaire de secrets.
4. Envoyez la requête depuis un terminal, en Python ou en Node.js.

Conservez la clé dans les secrets côté serveur, jamais dans le code front-end, un dépôt public, une ligne de journal ou une capture d’écran. Elle est liée à votre compte et à votre quota ; ainsi, toute personne qui la détient utilise vos requêtes.

# Paste your key from the dashboard, or load it from your secrets manager. Never commit it.
export WSA_API_KEY="..."

curl --get "https://ecom.webscrapingapi.com/v1" \
  --max-time 130 \
  --data-urlencode "engine=amazon" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "type=search" \
  --data-urlencode "q=memory card"

La suite de ce guide s’appuie sur le client Python ci-dessous. Il lit la clé dans l’environnement, effectue des tentatives de réessai selon les règles de gestion des erreurs abordées plus loin, et renvoie le JSON analysé ainsi que l’en-tête de crédit de l’appel. Installez Requests avec pip install requests.

# amazon_client.py
import os
import random
import time
from urllib.parse import urlencode

import requests

SCRAPER_URL = "https://ecom.webscrapingapi.com/v1"
RETRYABLE = {429, 500, 502, 503}


def redacted_url(params):
    """The request URL with the key hidden. Log this, never the real URL."""
    return f"{SCRAPER_URL}?{urlencode({'engine': 'amazon', 'api_key': '***', **params}, safe='*')}"


def amazon_get(params, retries=3, timeout=130):
    query = {"engine": "amazon", "api_key": os.environ["WSA_API_KEY"], **params}
    for attempt in range(retries + 1):
        resp = requests.get(SCRAPER_URL, params=query, timeout=timeout)
        if resp.status_code == 200:
            return resp.json(), resp.headers.get("Searchdata-Call-Credit-Usage")
        retry_422 = resp.status_code == 422 and attempt == 0  # retry a website error once
        if (resp.status_code not in RETRYABLE and not retry_422) or attempt == retries:
            raise RuntimeError(f"{resp.status_code} on {redacted_url(params)}: {resp.text[:200]}")
        wait = resp.headers.get("Retry-After", "")
        delay = int(wait) if wait.isdigit() else 2 ** attempt
        time.sleep(delay + random.random())  # exponential backoff with jitter

# first_request.py
from amazon_client import amazon_get

data, credits = amazon_get({"type": "search", "q": "memory card"})
results = data.get("search_results", {}).get("product_results", [])
print(len(results), "products; credits for this call:", credits)

La même requête dans Node.js 18 ou une version ultérieure ne nécessite aucune dépendance :

// amazon_request.mjs — run with: node amazon_request.mjs
const params = new URLSearchParams({
  engine: "amazon",
  api_key: process.env.WSA_API_KEY,
  type: "search",
  q: "memory card",
});

const res = await fetch(`https://ecom.webscrapingapi.com/v1?${params}`, {
  signal: AbortSignal.timeout(130_000),
});
if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);

const data = await res.json();
console.log("credits for this call:", res.headers.get("searchdata-call-credit-usage"));
console.log(data.search_results?.product_results?.length, "products");

Un mot-clé suivi d’un espace, &, ou + doit respecter les règles d’encodage en pourcentage. Un & lance silencieusement un nouveau paramètre, que l’API rejette avec le message « Paramètre '<nom>' non autorisé ». Les options --data-urlencode et URLSearchParams de curl, ainsi que l’argument params de Requests, effectuent tous l’encodage à votre place. Chaque exemple définit également un délai d'expiration de 130 secondes, afin qu'une page lente ne puisse pas bloquer un worker.

Exemple de réponse (extrait de la documentation de l’API, raccourci) :

{
  "search_parameters": {
    "amazon_url": "https://www.amazon.com/s?k=memory+card",
    "engine": "amazon",
    "amazon_domain": "amazon.com",
    "type": "search",
    "q": "memory card"
  },
  "search_information": {
    "organic_results_state": "Results for exact spelling",
    "total_results": "5,000",
    "query_displayed": "memory card"
  },
  "search_results": {
    "product_results": [
      {
        "position": 1,
        "product_id": "B08TJRVWV1",
        "title": "Amazon Basics microSDXC Memory Card with Full Size Adapter",
        "link": "https://www.amazon.com/dp/B08TJRVWV1",
        "price": "$12.42",
        "rating": { "rating": "4.7 out of 5 stars", "total_ratings": 33500 }
      }
    ]
  }
}

Documentation : Accéder à l’API

Définissez le type sur l’une des neuf valeurs suivantes : « product » pour un ASIN, « search » pour un mot-clé, « category », « bestsellers », « new-releases » ou « todays-deals » pour un ID de catégorie, et « seller_products », « seller_profile » ou « seller_feedback » pour un ID de vendeur. « seller_feedback » correspond à la requête relative aux avis. Chaque type nécessite ses propres paramètres d’entrée et renvoie des lignes à un emplacement qui lui est propre.

Les emplacements des réponses suivent les exemples de la documentation. Lisez-les avec attention. L'analyseur ci-dessous montre comment procéder.

Trois détails posent souvent problème. La valeur des offres est todays-deals, avec le trait d’union et le « s ». L’API accepte seller comme alias de seller_products, mais écrivez la valeur complète pour que vos journaux restent lisibles. De plus, parent_alias cela ne s’applique qu’aux best-sellers et aux nouveautés, où il renvoie à une sous-catégorie.

Pour les avis, utilisez seller_feedback pour récupérer les lignes d’avis et product pour la note et le nombre de notes d’un ASIN.

Documentation : Types de recherche sur Amazon

Envoyez type=product en définissant product_id sur l’ASIN, l’identifiant à dix caractères situé après /dp/ dans n’importe quelle URL de produit Amazon. L’objet product_results de la réponse contient le titre, le prix, la note, le nombre total de notes, les catégories, les images et les attributs, ainsi que les points forts de l’article lorsque Amazon les affiche. Ajoutez amazon_domain pour récupérer le même ASIN sur une autre place de marché Amazon.

Dans https://www.amazon.com/dp/B098RNZGNW, l’ASIN est B098RNZGNW. Un même ASIN existant généralement sur plusieurs places de marché, un seul identifiant associé à amazon_domain vous permet de comparer un produit d’un pays à l’autre.

curl --get "https://ecom.webscrapingapi.com/v1" \
  --max-time 130 \
  --data-urlencode "engine=amazon" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "type=product" \
  --data-urlencode "product_id=B098RNZGNW" \
  --data-urlencode "amazon_domain=amazon.co.uk"

import re
from amazon_client import amazon_get

url = "https://www.amazon.com/dp/B098RNZGNW"
asin = re.search(r"/dp/([A-Z0-9]{10})", url).group(1)

data, _ = amazon_get({"type": "product", "product_id": asin})
item = data.get("product_results", {})
rating = item.get("rating", {})
print(item.get("title"), item.get("price"), rating.get("rating"), rating.get("total_ratings"))

Exemple de réponse (extrait de la documentation de l'API, raccourci) :

{
  "product_results": {
    "product_id": "B098RNZGNW",
    "title": "Example Amazon Product",
    "item_highlights": "Foldable card table for board games, dining, and extra seating",
    "price": "$59.99",
    "rating": { "rating": "4.6 out of 5 stars", "total_ratings": 12438 },
    "categories": ["Electronics", "Headphones"],
    "images": ["https://m.media-amazon.com/images/I/example-1.jpg"],
    "attributes": { "Brand": "Example", "Color": "Black" }
  }
}

price est une chaîne d'affichage telle que "$59.99"; conservez-la donc telle quelle avec son domaine et analysez le nombre dans une étape distincte. rating.rating est du texte, tandis que rating.total_ratings est un entier que vous pouvez comparer au fil du temps. Il s’agit de l’indicateur d’évaluation au niveau du produit qui s’associe aux avis des acheteurs sur le vendeur. item_highlights est omis lorsqu’Amazon n’en affiche aucun. Définissez wait_for_offers=true lorsque les modules d’offre sont pertinents, et wait_for_video=true pour les modules vidéo.

La couverture des champs varie selon les pages. Les détails relatifs à la Buy Box, au vendeur, aux variantes et à la disponibilité dépendent de ce qui s’affiche sur chaque page produit ; vérifiez donc un échantillon représentatif de vos propres ASIN avant de concevoir un schéma. C’est également à partir de cet échantillon que commence le suivi des prix et de la Buy Box.

Documentation : Produit Amazon

Envoyez type=search avec q défini sur le mot-clé. Les produits apparaissent dans search_results.product_results, chacun avec une position, un ASIN, un titre, un lien, un prix et une note, tandis que related_searches répertorie les suggestions d’Amazon. Demandez « page=2 », « 3 » et ainsi de suite pour obtenir davantage de résultats, et utilisez « sort_by » ou « filter_by=prime » lorsque vous avez besoin du tri propre à Amazon ou du filtre Prime.

Les résultats de recherche Amazon (la SERP d’Amazon) indiquent quels sites apparaissent pour une requête, et dans quel ordre. position Il s’agit du classement dans la liste renvoyée pour ce mot-clé, ce domaine, cette page et ce moment précis. Enregistrez-le avec q, amazon_domain, page, sort_byet l’heure de capture ; sinon, les comparaisons de classement perdent tout leur sens.

curl --get "https://ecom.webscrapingapi.com/v1" \
  --max-time 130 \
  --data-urlencode "engine=amazon" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "type=search" \
  --data-urlencode "q=memory card" \
  --data-urlencode "page=2" \
  --data-urlencode "filter_by=prime"

Pour paginer, conservez q, le domaine et les paramètres de tri identiques, puis augmentez page. Chaque page correspondant à une requête distincte, limitez le nombre de pages par mot-clé :

from datetime import datetime, timezone
from amazon_client import amazon_get

rows = []
for page in range(1, 4):  # page cap: three pages per keyword
    params = {"type": "search", "q": "memory card", "page": page, "amazon_domain": "amazon.com"}
    data, _ = amazon_get(params)
    found = data.get("search_results", {}).get("product_results", [])
    if not found:
        break
    captured_at = datetime.now(timezone.utc).isoformat()
    rows += [{**params, "captured_at": captured_at, "position": r.get("position"),
              "product_id": r.get("product_id"), "price_text": r.get("price")} for r in found]
print(len(rows), "rows")

Exemple de réponse (copié depuis la documentation de l'API, raccourci) :

{
  "related_searches": [
    { "query": "micro sd card", "link": "https://www.amazon.com/s?k=micro+sd+card" }
  ]
}

sort_by accepte featured, price-asc-rank, price-desc-rank, review-rank, date-desc-rank, et relevancerank. filter_by accepte prime et climate-friendly. Conservez ces deux paramètres fixes d'une exécution à l'autre si vous suivez les positions. Les pages de recherche peuvent également inclure top_sponsored, video_sponsored, pagination, et amazon_pagination. Lisez-les lorsqu’elles sont présentes, et ne les présumez jamais.

Si vous suivez l'évolution des positions de recherche au fil du temps, comparez ces lignes avec les résultats Google pour le même mot-clé.

Documentation : Recherche sur Amazon

Envoyez type=bestsellers avec un category_id, qui peut être un alias tel que « electronics » ou un identifiant de nœud numérique, et ajoutez parent_alias pour accéder à une sous-catégorie. L'assistant « keyless categories » recherche ces deux valeurs à partir d’un mot-clé. Les produits classés apparaissent dans « category_results.product_results », chacun avec sa position affichée sur Amazon, son ASIN, son titre, son lien et son prix.

Trois étapes suffisent pour obtenir un classement :

1. Recherchez la catégorie à l’aide de l’assistant « categories », qui ne nécessite aucune clé API.
2. Transmettez son category_id, ainsi que parent_alias pour une sous-catégorie.
3. Lisez la category_results.product_results.

curl "https://amazon-helpers.webscrapingapi.com/categories?q=electronics&limit=3"

Réponse de l’assistant (abrégée) :

[
  { "title": "Amazon Launchpad Top Electronics", "href": "/gp/new-releases/boost/23602499011", "parent_alias": "boost", "category_id": "23602499011" },
  { "title": "Electronics", "href": "/gp/new-releases/boost/21179674011", "parent_alias": "boost", "category_id": "21179674011" },
  { "title": "Electronics", "href": "/gp/new-releases/automotive/3248690011", "parent_alias": "automotive", "category_id": "3248690011" }
]

Lisez les champs de l’assistant par clé, car les noms peuvent différer de ceux du tableau de la documentation. Les alias de premier niveau tels que electronics fonctionnent sans recherche :

curl --get "https://ecom.webscrapingapi.com/v1" \
  --max-time 130 \
  --data-urlencode "engine=amazon" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "type=bestsellers" \
  --data-urlencode "category_id=electronics"

Exemple de réponse (copiée depuis la documentation de l'API, abrégée) :

{
  "category_results": {
    "product_results": [
      { "position": 1, "product_id": "B08C1W5N87", "title": "Fire TV Stick with Alexa Voice Remote",
        "link": "/fire-tv-stick-with-3rd-gen-alexa-voice-remote/dp/B08C1W5N87", "price": "$19.99",
        "rating": { "rating": "4.7 out of 5 stars", "total_ratings": 141438 } }
    ]
  }
}

position correspond au classement affiché par Amazon pour cette catégorie à ce moment-là ; enregistrez donc l’heure de capture et comparez les exécutions effectuées selon le même calendrier. Notez le link: faites précéder ces chemins du domaine avant de les stocker, ce que absolute_link() est ce que fait la section « analyseur ».

Documentation : Meilleures ventes Amazon

Envoyez type=new-releases avec un category_id, tel que « fashion », et ajoutez parent_alias pour une sous-catégorie, exactement comme pour les meilleures ventes. La réponse répertorie les nouveautés phares d’Amazon pour cette catégorie dans `category_results.product_results`, avec la position, l’ASIN, le titre, le lien et le prix. Exécutez cette requête de manière programmée pour voir quels produits font leur entrée ou sortent de la liste.

curl --get "https://ecom.webscrapingapi.com/v1" \
  --max-time 130 \
  --data-urlencode "engine=amazon" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "type=new-releases" \
  --data-urlencode "category_id=fashion"

Exemple de réponse (copié depuis la documentation de l’API ; l’ASIN est un espace réservé de la documentation) :

{
  "category_results": {
    "product_results": [
      { "position": 1, "product_id": "B09EXAMPLE", "title": "New release product",
        "link": "https://www.amazon.com/dp/B09EXAMPLE", "price": "$29.99" }
    ]
  }
}

Recherchez les identifiants de sous-catégories et leurs parent_alias à l’aide de l’assistant « categories » de la section des meilleures ventes. Utilisez cette requête pour le suivi des lancements : une catégorie et un marché par exécution, selon le même calendrier à chaque fois.

Documentation : Nouveautés Amazon

Envoyez type=category avec un category_id, soit un alias tel que amazon-devices, soit un identifiant de nœud numérique. Ajoutez page pour obtenir des résultats plus détaillés et sort_by pour modifier l'ordre d'affichage. Les produits sont renvoyés dans `category_results.product_results` avec la position, l’ASIN, le titre, le lien, le prix et la note, ce qui vous permet de suivre l’ensemble d’un nœud de navigation plutôt qu’un seul mot-clé.

curl --get "https://ecom.webscrapingapi.com/v1" \
  --max-time 130 \
  --data-urlencode "engine=amazon" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "type=category" \
  --data-urlencode "category_id=amazon-devices" \
  --data-urlencode "page=2"

Exemple de réponse (copié depuis la documentation de l’API, abrégé) :

{
  "category_results": {
    "product_results": [
      { "position": 1, "product_id": "B08C1W5N87", "title": "Fire TV Stick with Alexa Voice Remote",
        "link": "/fire-tv-stick-with-3rd-gen-alexa-voice-remote/dp/B08C1W5N87", "price": "$19.99",
        "rating": { "rating": "4.7 out of 5 stars", "total_ratings": 141438 } }
    ]
  }
}

Une requête de catégorie renvoie la liste de navigation selon le tri choisi par Amazon, tandis que la requête « bestsellers » renvoie la liste des meilleures ventes classées. page et sort_by s'appliquent ici, mais parent_alias pas ici. Les liens peuvent être relatifs, comme dans le cas des meilleures ventes.

Documentation : Catégorie Amazon

Envoyez type=todays-deals, et non deals, avec un category_id tel que 15684181. Les produits en promotion apparaissent dans category_results.product_results, et chaque ligne contient le prix (price), le prix promotionnel actuel, ainsi que le prix brut (price_raw), c'est-à-dire le prix avant la promotion. Enregistrez ces deux informations avec l'heure de capture, car les promotions changent au cours de la journée et une requête ultérieure peut renvoyer une liste différente.

curl --get "https://ecom.webscrapingapi.com/v1" \
  --max-time 130 \
  --data-urlencode "engine=amazon" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "type=todays-deals" \
  --data-urlencode "category_id=15684181"

Exemple de réponse (extrait de la documentation de l’API, raccourci) :

{
  "category_results": {
    "product_results": [
      { "position": 1, "product_id": "B081T7N948", "title": "Cleaning Gel for Car",
        "link": "/Cleaning-Universal-Detailing-Automotive-Interior/dp/B081T7N948",
        "price": "$5.94", "currency": "$", "price_raw": "$9.99" }
    ]
  }
}

Calculez la remise uniquement sur les nombres analysés, après avoir supprimé le symbole monétaire de ce domaine, et conservez également les chaînes brutes :

deal, before = float(row["price"].lstrip("$")), float(row["price_raw"].lstrip("$"))
discount_pct = round((before - deal) / before * 100, 1)  # 40.5 for the sample row

Les liens vers les offres peuvent être relatifs ; il faut donc les traiter via absolute_link().

Docs : Offres Amazon

Envoyez type=seller_products avec l'identifiant du vendeur dans seller_id. La réponse répertorie les produits de la boutique de ce vendeur dans search_results.product_results, avec la position, l'ASIN, le titre, le lien et le prix, sous la même forme que search. Ajoutez « page » pour obtenir davantage de résultats. L’alias plus court « seller » fonctionne également, mais utilisez « seller_products » pour que votre code reste lisible.

Utilisez l’identifiant du vendeur indiqué dans l’URL de sa boutique.

curl --get "https://ecom.webscrapingapi.com/v1" \
  --max-time 130 \
  --data-urlencode "engine=amazon" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "type=seller_products" \
  --data-urlencode "seller_id=AAZRLVTNON75Z"

Exemple de réponse (copié depuis la documentation de l’API, raccourci) :

{
  "search_results": {
    "product_results": [
      { "position": 1, "product_id": "B01NGTV4J5", "title": "Cascade Platinum Dishwasher Pods",
        "link": "https://www.amazon.com/dp/B01NGTV4J5", "price": "$38.88", "currency": "$" }
    ]
  }
}

Comme les lignes correspondent aux résultats de recherche, le même code de parsing et de stockage fonctionne ici. Enregistrez-les à chaque exécution pour voir quels ASIN un commerçant propose et à quels prix affichés.

Documentation : Produits des vendeurs Amazon

Envoyez type=seller_profile avec le seller_id. L'objet seller_profile renvoie seller_details avec le nom de la boutique, le lien vers la boutique, la note par étoiles, le nombre total d'évaluations et le pourcentage d'évaluations positives, ainsi qu'une courte liste des commentaires récents et un résumé des commentaires avec les pourcentages de commentaires positifs, neutres et négatifs. Il s’agit d’une requête par vendeur, sans liste de produits ni pagination.

curl --get "https://ecom.webscrapingapi.com/v1" \
  --max-time 130 \
  --data-urlencode "engine=amazon" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "type=seller_profile" \
  --data-urlencode "seller_id=AAZRLVTNON75Z"

Exemple de réponse (extrait de la documentation de l’API, raccourci) :

{
  "seller_profile": {
    "seller_details": { "name": "Triplenet Pricing INC", "store_link": "https://www.amazon.com/s?me=AAZRLVTNON75Z",
      "rating": 4, "ratings_total": 4078, "ratings_positive_percentage": 74 },
    "feedback": [ { "rating": 5, "body": "Great service", "rater": "By Sarah M. on July 24, 2023." } ],
    "feedback_summary": [ { "positive_percent": 75, "neutral_percent": 1, "negative_percent": 24, "count": 366 } ]
  }
}

Utilisez un profil pour évaluer les vendeurs tiers en concurrence pour une « Buy Box » ou une boutique ratings_total et ratings_positive_percentage par exécution pour suivre l’évolution de la position d’un vendeur. La feedback liste ci-dessous en est un bref échantillon récent. Pour chaque ligne d’évaluation, parcourez la requête d’avis sur le vendeur ci-dessous.

Documentation : Profil du vendeur Amazon

Envoyez type=seller_feedback avec un seller_id. Il s'agit de la requête « avis » de l'API Amazon : chaque ligne correspond à un avis d'acheteur sur ce vendeur, avec le nom de l'évaluateur, la note en étoiles, le texte de l'avis, la date et l'indication si le vendeur a répondu. Les résultats s’affichent par lots de cinq par page ; suivez donc les paramètres pagination.has_next_page et next_page jusqu’à ce que vous atteigniez la limite de pages que vous avez définie.

curl --get "https://ecom.webscrapingapi.com/v1" \
  --max-time 130 \
  --data-urlencode "engine=amazon" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "type=seller_feedback" \
  --data-urlencode "seller_id=AAZRLVTNON75Z" \
  --data-urlencode "page=2"

Exemple de réponse (copié depuis la documentation de l’API, raccourci) :

{
  "seller_feedback": [
    { "rater": "Sarah M.", "rating": 5, "has_response": false, "body": "Great service",
      "date": { "raw": "July 24, 2023", "utc": "2023-07-24T04:00:00.000Z" }, "position": 1 }
  ],
  "pagination": { "current_page": 1, "has_next_page": true, "next_page": 2 }
}

Chaque page correspond à une requête distincte ; un historique d’avis volumineux génère donc plusieurs requêtes. Ce paginateur s’arrête lorsqu’il n’y a plus de page suivante ou lorsqu’il atteint max_pages:

# seller_feedback_pages.py
from amazon_client import amazon_get


def all_feedback(seller_id, max_pages=3):
    page, rows = 1, []
    while page and page <= max_pages:
        data, _ = amazon_get({"type": "seller_feedback", "seller_id": seller_id, "page": page})
        rows += data.get("seller_feedback", [])
        pagination = data.get("pagination", {})
        page = pagination.get("next_page") if pagination.get("has_next_page") else None
    return rows


reviews = all_feedback("AAZRLVTNON75Z")
print(len(reviews), "reviews")

Store seller_id et date.utc et effectue une déduplication de ces avis entre chaque exécution. date.raw Il suit le format d’affichage d’Amazon. Associez-le aux données produit : type=product fournit la note et le nombre total de notes pour chaque ASIN ; ainsi, ces deux requêtes couvrent ensemble le volume d’avis, les notes par étoiles et le texte des avis sur le vendeur.

Documentation : Avis sur les vendeurs Amazon

Définissez amazon_domain sur l’une des vingt places de marché prises en charge, telles que amazon.de ou amazon.co.jp. La valeur par défaut est amazon.com. Ajoutez delivery_location avec un code pays tel que de ou gb pour définir le pays de livraison par défaut, ou zip_code pour une adresse locale aux États-Unis. Utilisez hl et gl pour la langue et le pays, et enregistrez chaque paramètre avec ses résultats.

Le prix, la disponibilité et les délais de livraison sur Amazon dépendent de la place de marché et de l’adresse de livraison ; deux appels avec des paramètres différents ne sont donc pas comparables. Définissez une petite grille de marché (chaque ASIN ou mot-clé × chaque domaine × chaque lieu de livraison) et conservez-la inchangée d’un test à l’autre.

Tous ces paramètres généraux sont facultatifs :

delivery_location n'accepte que les douze codes répertoriés ; tous les domaines ne disposent donc pas d'une valeur correspondante. Il n'y a pas de it ni nl, par exemple. Lorsque vous n'avez pas besoin de modules en bas de page, définissez scroll_to_bottom=false et wait_bottom_carousel=false pour des réponses plus rapides. Utilisez lazy_loading lorsqu’une page nécessite davantage de temps après son chargement.

Dans Node.js, les paramètres de marché correspondent à d’autres clés dans URLSearchParams:

const params = new URLSearchParams({
  engine: "amazon",
  api_key: process.env.WSA_API_KEY,
  type: "search",
  q: "memory card",
  amazon_domain: "amazon.de",
  delivery_location: "de",
});

Docs : Domaines pris en charge

Commencez par search_parameters, qui renvoie votre requête et l’URL Amazon récupérée, ainsi que search_information. Lisez ensuite les lignes de search_results, category_results, de l’objet unique product_results, de seller_profile ou de seller_feedback, selon le type. Considérez tous les autres modules comme facultatifs, conservez les chaînes de prix brutes avec leur domaine, et stockez chaque ligne avec ses paramètres de requête.

Les descriptions et exemples de la documentation placent parfois les produits sous des clés différentes. Le texte de la page de catégorie indique product_results, tandis que son exemple l’imbrique sous category_results, et le texte de la page des produits du vendeur mentionne seller_results, alors que son exemple utilise search_results. Le parseur vérifie donc tous les emplacements documentés et renvoie une liste vide au lieu de planter. Ajoutez-le à amazon_client.py:

def product_rows(data):
    """Return the product list wherever this request type puts it."""
    for container in ("search_results", "category_results"):
        rows = (data.get(container) or {}).get("product_results")
        if isinstance(rows, list):
            return rows
    single = data.get("product_results")
    return [single] if isinstance(single, dict) else []


def absolute_link(link, amazon_domain="amazon.com"):
    """Category-style responses can return relative links such as /Item/dp/ASIN."""
    if not link or link.startswith("http"):
        return link
    return f"https://www.{amazon_domain}{link}"

product_rows() renvoie des lignes pour les sept types comportant des produits. Lire seller_profile et seller_feedback par leurs propres clés, comme indiqué dans leurs sections respectives. Aplatissez ensuite chaque produit en une seule ligne de stockage :

# store.py
from datetime import datetime, timezone
from amazon_client import absolute_link, product_rows


def to_records(data, request):
    """One flat row per product, with the request settings that produced it."""
    captured_at = datetime.now(timezone.utc).isoformat()
    domain = request.get("amazon_domain", "amazon.com")
    amazon_url = (data.get("search_parameters") or {}).get("amazon_url")
    for row in product_rows(data):
        rating = row.get("rating") or {}
        yield {
            "captured_at": captured_at,
            "type": request["type"],
            "input": request.get("q") or request.get("category_id")
                     or request.get("seller_id") or request.get("product_id"),
            "amazon_domain": domain,
            "delivery_location": request.get("delivery_location"),
            "page": request.get("page", 1),
            "position": row.get("position"),
            "product_id": row.get("product_id"),
            "title": row.get("title"),
            "price_text": row.get("price"),
            "rating_text": rating.get("rating"),
            "total_ratings": rating.get("total_ratings"),
            "link": absolute_link(row.get("link"), domain),
            "amazon_url": amazon_url,
        }

Conservez également la réponse brute, afin de pouvoir la retraiter lorsque vous ajoutez des champs. Distinguez une requête qui a échoué (une erreur HTTP) de celle qui a abouti sans module (une liste vide). Le second cas est une observation, pas un bug. Pour plus de modèles, consultez l’analyse des réponses JSON en Python.

La page des tarifs répertorie les formats de sortie JSON, CSV et HTML pour chaque formule. La documentation d’Amazon décrit les réponses JSON ; ce guide utilise donc le format JSON tout au long de ce document.

Ne réessayez pas en cas d’erreurs 401 ou de validation. Corrigez la clé, l’abonnement ou les paramètres. Réessayez plusieurs fois en cas de codes 429, 500, 502 et 503 en appliquant un recul exponentiel et une variation de délai, et réduisez la concurrence en cas de code 429. Un code 422 signifie qu’Amazon a renvoyé une erreur, un défi ou un délai d’expiration ; ne réessayez donc qu’une seule fois si l’échec semble temporaire.

Une requête sans clé renvoie ce corps avec un code HTTP 401 :

{ "error": "Access denied. No key `api_key` provided." }

Parmi les autres messages de validation, on trouve Parameter '<name>' is required., must be a boolean, must be in range, et cannot be used with. Ils indiquent que la requête elle-même est incorrecte ; une nouvelle tentative n’y changera donc rien. Si une /v1 requête renvoie la réponse « Ce point de terminaison est obsolète. Veuillez utiliser /v2. », cela signifie que votre clé n’est pas abonnée à l’API Amazon. Abonnez-vous via le tableau de bord plutôt que de changer de point de terminaison.

amazon_get() met en œuvre cette politique. Il effectue des tentatives de réessai pour les réponses HTTP 429 et 5xx avec un délai d’attente exponentiel et une variation aléatoire, respecte un en-tête Retry-After numérique lorsqu’il est présent, effectue une seule tentative de réessai pour une erreur 422, et déclenche une exception pour tout le reste en masquant la clé. En cas de 429 répétées, réduisez également le nombre de workers parallèles.

Enregistrez deux en-têtes à chaque appel : Searchdata-Call-Credit-Usage (crédits facturés pour cet appel) et Searchdata-Current-Credit-Usage (l’utilisation actuelle de votre compte). Une semaine de ce journal indique quels types de services et quels marchés utilisent votre quota.

Documentation : Erreurs et en-têtes

En octobre 2026, la version d'essai est gratuite pour 100 requêtes Amazon. Les formules payantes sont mensuelles : Starter à 59 $ pour 10 000 requêtes, Grow à 375 $ pour 250 000, Business à 1 000 $ pour 1 000 000 et Pro à 2 200 $ pour 2 500 000. Chaque formule couvre l’ensemble des domaines Amazon, les API produits et avis, les résultats de recherche et par catégorie, ainsi que les meilleures ventes.

Chaque forfait inclut l’ensemble des domaines Amazon, les API Produits et Avis, les résultats de recherche et par catégorie, l’API Meilleures ventes, les formats de sortie JSON, CSV et HTML, ainsi que le traitement en masse. Les prix sont indiqués en dollars américains. Dans ce guide, les API Produits et Avis sont les product et seller_feedback requêtes.

Choisissez un forfait en fonction de vos données d’entrée, et non au hasard :

nombre de requêtes par mois = données d’entrée (ASIN, mots-clés, catégories, vendeurs) × domaines × lieux de livraison × nombre de pages par donnée d’entrée × nombre d’exécutions par mois, plus une marge pour les tests et les nouvelles tentatives

Par exemple, 400 ASIN × 2 domaines × 1 page × 4 exécutions hebdomadaires correspondent à 3 200 requêtes, ce qui correspond au forfait Starter. Ajoutez 50 mots-clés × 2 domaines × 3 pages × 30 exécutions quotidiennes, soit 9 000 requêtes supplémentaires, et le total de 12 200 dépasse la limite de la formule Starter ; il faut donc passer à la formule Grow. Les tarifs et les quotas évoluent ; la page dédiée aux tarifs fait donc autorité. Vous êtes encore en train de choisir un fournisseur ? Consultez notre guide comparatif des API de scraping Amazon.

L’API Amazon couvre les neuf types de pages mentionnés dans sa documentation, et uniquement ceux-là. Il n’y a pas de tâche asynchrone Amazon, la couverture des champs varie selon les pages, et chaque résultat décrit un domaine, un emplacement et un instant précis. Pour d’autres pages, d’autres places de marché ou des ensembles de données prêts à l’emploi, utilisez l’API Scraper, une autre source de l’API Data ou un flux géré.

• Pages ne faisant pas partie des neuf types. Demandez un échantillon pour celles-ci, ou récupérez les pages au format HTML. Découvrez comment utiliser l’API Scraper.
• Vous préférez créer votre propre outil. Pour exécuter et gérer vous-même le scraper, suivez ce guide pratique sur la création d'un scraper Amazon en Python.
• Vous souhaitez des enregistrements, et non des requêtes. Pour des données Amazon prêtes à l’emploi et récurrentes, consultez l’ensemble de données sur les produits Amazon.
• Vous avez besoin d’une autre place de marché. L’API Data couvre également d’autres détaillants, tels que les données sur les produits Walmart.
• Pas de tâches asynchrones pour Amazon. Chaque appel est synchrone ; vous devez donc gérer votre propre file d’attente de tâches en appliquant la politique de réessai décrite ci-dessus.
• Les champs varient selon les pages. Vérifiez un échantillon représentatif avant de vous engager sur un schéma.
• L’utilisation est réglementée. Collectez uniquement les pages publiques, conformément au contrat de service de WebScrapingAPI et aux exigences qui s’appliquent à vous.

Oui. À compter d'octobre 2026, la formule d'essai de l'API Amazon de WebScrapingAPI coûte 0 $ et comprend 100 requêtes Amazon, ce qui est suffisant pour tester les requêtes relatives aux produits, à la recherche, aux meilleures ventes et aux vendeurs à partir de vos propres données. Créez un compte, abonnez-vous à l’API Amazon dans le tableau de bord et conservez la clé dans une variable d’environnement pendant que vous évaluez le service.

Un ASIN est l’identifiant de produit à dix caractères d’Amazon, et l’API Amazon l’utilise comme « product_id ». Vous le trouverez dans l’URL d’un produit après « /dp/ », ou dans la section « Informations sur le produit » ou « Informations supplémentaires » de la page du produit. Un même ASIN peut afficher des prix et des disponibilités différents selon les domaines Amazon.

Envoyez type=bestsellers avec un category_id, tel que « electronics », et ajoutez parent_alias lorsque vous souhaitez une sous-catégorie. L'assistant de catégories sans clé trouve ces deux valeurs à partir d'un mot-clé. Les résultats sont renvoyés dans category_results.product_results avec la position affichée par Amazon, l'ASIN, le titre, le lien, le prix et la note ; veillez donc à enregistrer l'heure de capture avec chaque ligne.

Elle prend en charge vingt domaines Amazon : États-Unis, Canada, Mexique, Brésil, Royaume-Uni, Allemagne, France, Italie, Espagne, Pays-Bas, Pologne, Suède, Turquie, Émirats arabes unis, Arabie saoudite, Égypte, Japon, Inde, Singapour et Australie. Définissez amazon_domain pour en sélectionner un, et utilisez delivery_location ou zip_code lorsque le contexte de livraison modifie les informations affichées par Amazon.

Non. Une requête depuis un navigateur exposerait votre clé API à toute personne ouvrant les outils de développement, et cette clé contrôle votre quota. Appelez l’API depuis un serveur, une fonction sans serveur ou une tâche planifiée, lisez la clé à partir d’une variable d’environnement ou d’un gestionnaire de secrets, et n’envoyez que les résultats analysés vers le front-end.

Ajoutez « page=2 », « page=3 », etc. à une requête de type « type=search » avec les mêmes paramètres « q », « domain » et « sort ». Chaque page correspond à une requête distincte décomptée de votre quota ; définissez donc une limite de pages par mot-clé. Enregistrez le numéro de page avec chaque ligne afin de pouvoir reconstituer ultérieurement le classement complet pour ce mot-clé.

Oui. Envoyez « type=seller_feedback » avec un « seller_id » pour collecter les avis des acheteurs sur un vendeur, à raison de cinq par page, chacun comprenant l’auteur, la note en étoiles, le texte de l’avis, la date et l’indication si le vendeur a répondu ou non. Pour les signaux d’avis au niveau du produit, « type=product » renvoie la note et le nombre total de notes pour chaque ASIN. Suivez pagination.has_next_page pour lire toutes les pages.

L’API valide chaque paramètre par rapport au moteur Amazon et rejette les noms qu’elle n’accepte pas. Les causes courantes sont un nom de paramètre mal orthographié ou mal capitalisé, un paramètre provenant d’un autre moteur, ou un « & » non encodé dans votre mot-clé qui le divise en un nouveau paramètre. Corrigez la requête au lieu de la réessayer.

Consultez l’en-tête de réponse « Searchdata-Call-Credit-Usage », qui indique les crédits facturés pour cet appel, ainsi que l’en-tête « Searchdata-Current-Credit-Usage », qui indique l’utilisation actuelle de votre compte. Enregistrez ces deux informations avec le type de requête, les données d’entrée et le domaine. Sur une semaine, ce journal vous permettra de voir quels types de requêtes et quels marchés consomment votre quota, et si votre forfait reste adapté.

Oui, si un flux prêt à l’emploi répond à vos besoins. WebScrapingAPI peut fournir des enregistrements Amazon sous forme d’ensemble de données ou de collection gérée selon un calendrier défini, après que vous ayez examiné des exemples de données pour vos pages, vos champs et vos marchés. L’API convient aux équipes qui souhaitent choisir elles-mêmes les données d’entrée et la fréquence, tandis qu’un flux géré convient aux analystes qui ont simplement besoin de fichiers récurrents.

L’API Amazon Scraper renvoie les pages de produits, de recherche, de catégories, de best-sellers, d’offres, de vendeurs et d’avis sur les vendeurs provenant de 20 places de marché Amazon sous forme de JSON structuré, la gestion du parseur étant prise en charge pour vous. Une fois que vous connaissez vos ASIN, vos mots-clés, vos marchés et votre fréquence de rafraîchissement, comparez les forfaits de l’API Amazon et choisissez le quota qui vous convient.