API Keepa : Guide Complet pour Vendeurs et Développeurs Amazon (2026)

# Table des matières

1. [Qu'est-ce que Keepa ?](#quest-ce-que-keepa)  
2. [Qu'est-ce que l'API Keepa ?](#quest-ce-que-lapi-keepa)  
3. [Tarification de l'API Keepa](#tarification-de-lapi-keepa)  
4. [Endpoints clés de l'API](#endpoints-cles-de-lapi)  
5. [Premiers pas avec Python](#premiers-pas-avec-python)  
6. [Cas d'usage concrets](#cas-dusage-concrets)  
7. [Limites de débit, jetons et particularités](#limites-de-debit-jetons-et-particularites)  
8. [Alternatives à l'API Keepa](#alternatives-a-lapi-keepa)  
9. [Questions fréquentes](#questions-frequentes)  

---

Si vous vendez sur Amazon — ou développez des outils pour ceux qui le font — vous avez probablement entendu parler de Keepa. Cette extension navigateur affichant l'historique des prix sur les fiches produits Amazon est devenue l'outil de recherche incontournable pour des millions de vendeurs. Mais Keepa va bien au-delà : son API puissante traque les prix, le classement des ventes (BSR), les offres et les données catégorielles sur toutes les marketplaces Amazon majeures.

Ce guide couvre tout ce que vous devez savoir sur l'API Keepa en 2026 : coûts, endpoints disponibles, intégration Python et limites. Que vous soyez un vendeur FBA automatisant votre veille ou un développeur créant un outil d'analyse, voici votre point de départ.

## Qu'est-ce que Keepa ?

Keepa est un service allemand de suivi des prix Amazon. Il surveille les prix, le BSR, le nombre d'offres, les avis et les notes sur toutes les marketplaces majeures (États-Unis, Royaume-Uni, Allemagne, France, Italie, Espagne, Japon, etc.).

La plupart des vendeurs découvrent Keepa via son extension navigateur, qui intègre des graphiques d'historique directement sur les pages produits Amazon. Ces courbes montrent l'évolution des prix, du BSR et du Buy Box sur des périodes variables.

Au-delà de l'extension, Keepa propose :

- **Product Finder** — filtrer le catalogue Amazon par prix, BSR, catégorie, etc.  
- **Product Viewer** — importer des ASINs en masse  
- **Listes de best-sellers** — suivre les leaders par catégorie  
- **Alertes** — notifications lorsque des produits atteignent un prix cible  

Mais la vraie puissance pour l'automatisation réside dans **l'API Keepa**.

## Qu'est-ce que l'API Keepa ?

L'API Keepa est une interface REST HTTP donnant accès à toutes les données suivies par Keepa. Au lieu d'utiliser manuellement l'extension, vous pouvez interroger programmatiquement :

- Données produits (prix, BSR, offres, dimensions)  
- Arborescence des catégories  
- Profils vendeurs  
- Promotions  
- Listes de best-sellers  

Les réponses sont en JSON, avec une authentification par jeton. Votre clé API est passée en paramètre, et Keepa déduit des jetons selon la requête.

Principales fonctionnalités :

- Historique complet des prix et du BSR  
- Analyse du Buy Box (qui le détient, à quel prix)  
- Suivi des offres concurrentes  
- Arborescence des catégories Amazon  
- Best-sellers en temps réel  
- Recherche par mot-clé dans le catalogue  

Si Amazon le tracke, Keepa le suit — et l'API vous l'offre à l'échelle.

## Tarification de l'API Keepa

Keepa utilise un système de jetons. Chaque abonnement API génère un nombre défini de jetons par minute. Un jeton permet de requêter un produit, un vendeur ou une catégorie. Les jetons inutilisés expirent après 60 minutes.

### Prérequis : Abonnement Keepa

Avant d'utiliser l'API, un abonnement Keepa est nécessaire :

- **Gratuit** — 0€/mois. Extension seule, sans API.  
- **Payant** — 19€/mois (ou 189€/an). API basique à 1 jeton/minute.  

Le plan à 19€/mois permet de tester l'API, mais avec seulement ~60 requêtes/heure, il est insuffisant pour un usage intensif.

### Plans API complémentaires

Pour un usage professionnel, des plans dédiés existent :

| Jetons/Minute | Coût Mensuel | Requêtes/Heure (env.) |  
|---------------|-------------|-----------------------|  
| 20 | 49€ | ~1 200 |  
| 60 | 129€ | ~3 600 |  
| 250 | 459€ | ~15 000 |  
| 500 | 879€ | ~30 000 |  
| 1 000 | 1 499€ | ~60 000 |  
| 2 000 | 2 499€ | ~120 000 |  
| 3 000 | 3 499€ | ~180 000 |  
| 4 000 | 4 499€ | ~240 000 |  

Les "Requêtes/Heure" supposent 1 jeton par produit. Les options comme les stats Buy Box (5 jetons) réduisent proportionnellement le débit.

### Coût par requête

- **1 jeton** — requête produit standard (prix, BSR)  
- **~2 jetons** — données d'offres incluses  
- **~5 jetons** — statistiques Buy Box  
- **1 jeton** — catégorie ou liste de best-sellers  
- **1 jeton** — profil vendeur  

Tous les plans sont mensuels, prépayés et résiliables à tout moment. Les montées en gamme sont immédiates, les réductions limitées à une fois/mois.

## Endpoints clés de l'API

L'API Keepa expose 16+ endpoints. Voici les plus utiles pour les vendeurs :

### Requête Produit

Le plus utilisé. Données détaillées pour jusqu'à 100 ASINs par requête.

```
GET https://api.keepa.com/product?key=YOUR_KEY&domain=1&asin=B0088PUEPK
```

Retourne : prix actuel, BSR, avis, notes, dimensions, historique complet. Ajoutez `&buybox=1` pour les stats Buy Box (5 jetons).

### Best-sellers

Top ASINs par catégorie.

```
GET https://api.keepa.com/bestsellers?key=YOUR_KEY&domain=3&category=340846031
```

### Catégories

Trouvez des IDs de catégorie par mot-clé.

```
GET https://api.keepa.com/search?key=YOUR_KEY&domain=3&type=category&term=cuisine
```

### Vendeurs

Détails d'un vendeur et ses ASINs.

```
GET https://api.keepa.com/seller?key=YOUR_KEY&domain=1&seller=A2R2RITDJNW1Q6
```

### Product Finder

Version API de l'outil Product Finder. Filtrez le catalogue par prix, BSR, etc.

### Suivi

Ajoutez des produits à suivre avec alertes configurables (webhooks possibles).

```
POST https://api.keepa.com/tracking?key=YOUR_KEY&type=add
```

### Promotions

Produits avec baisses de prix récentes. Idéal pour l'arbitrage.

## Premiers pas avec Python

Le moyen le plus simple d'utiliser l'API Keepa en Python est le package `keepa` d'Alex Kaszynski.

### Installation

```bash
pip install keepa
```

Nécessite Python 3.10+. Dépendances : `numpy`, `aiohttp`, `matplotlib`.

### Exemple 1 : Requêter un produit

```python
import keepa

api = keepa.Keepa("VOTRE_CLE_API")

# Requête sur Amazon.de (domain=3)
products = api.query("B0088PUEPK", domain="DE")
product = products[0]

print(f"Titre : {product['title']}")
print(f"BSR : {product['salesRankReference']}")
print(f"Note : {product['csv'][16][-1] / 10 if product['csv'][16] else 'N/A'}")
print(f"Nombre d'offres : {product['csv'][11][-1] if product['csv'][11] else 'N/A'}")

# Historique des prix dans product['csv']
prix_amazon = product['csv'][0]  # [temps, prix, temps, prix...]
if prix_amazon:
    dernier_prix = prix_amazon[-1] / 100  # Prix en centimes
    print(f"Prix actuel : {dernier_prix:.2f}€")
```

### Exemple 2 : Best-sellers par catégorie

```python
import keepa

api = keepa.Keepa("VOTRE_CLE_API")

# Trouver l'ID catégorie "Cuisine" sur Amazon.de
categories = api.search_for_categories("cuisine", domain="DE")
for cat_id, cat_data in list(categories.items())[:3]:
    print(f"Catégorie : {cat_data['name']} (ID : {cat_id})")

# Best-sellers d'une catégorie
best_sellers = api.best_sellers_query(domain="DE", category="340846031")
print("\nTop 5 ASINs :")
for asin in best_sellers[:5]:
    print(f"  {asin}")

# Détails des produits
products = api.query(best_sellers[:5], domain="DE")
for p in products:
    print(f"  {p['asin']} : {p['title'][:60]}...")
```

### Exemple 3 : Requêtes asynchrones

Pour des volumes importants :

```python
import asyncio
import keepa

async def analyser_asins(liste_asins):
    api = await keepa.AsyncKeepa().create("VOTRE_CLE_API")
    
    # Le gère le rate limiting
    tous_produits = []
    for i in range(0, len(liste_asins), 100):
        lot = liste_asins[i:i+100]
        produits = await api.query(lot, domain="DE")
        tous_produits.extend(produits)
        print(f"Requêtés {len(tous_produits)}/{len(liste_asins)} produits")
    
    # Analyse
    for p in tous_produits:
        print(f"{p['asin']} | BSR : {p.get('salesRankReference', -1):>8} | {p.get('title', 'N/A')[:50]}")
    
    return tous_produits

asins = ["B0088PUEPK", "B07XJ8C8F5", "B09V3KXJPB"]
resultats = asyncio.run(analyser_asins(asins))
```

La bibliothèque `keepa` gère automatiquement les jetons — elle pause les requêtes si nécessaire.

## Cas d'usage concrets

### Analyse du BSR

Requêtez quotidiennement des produits et stockez leur BSR. Visualiser l'évolution révèle des tendances invisibles sur un instantané. Indispensable pour valider la demande avant de lancer un produit.

### Veille tarifaire

Surveillez les prix concurrents. Lorsqu'un concurrent baisse son prix, ajustez le vôtre via l'API SP-API d'Amazon. Clé pour les stratégies de réassort et d'arbitrage.

### Intelligence concurrentielle

Surveillez les ASINs et stratégies tarifaires des concurrents via l'endpoint Seller. Combinez avec des requêtes produits pour une analyse complète.

### Détection de promotions

L'endpoint Deals identifie les baisses de prix récentes. Les scripts peuvent scanner ces deals selon vos critères (catégorie, ROI minimum) et alerter via Slack/Telegram.

### Analyse de catégories

Comparez les prix moyens, BSR et nombre d'avis entre catégories pour identifier des niches portantes mais peu concurrentielles.

## Limites de débit, jetons et particularités

### Expiration des jetons

Les jetons expirent après 60 minutes, utilisés ou non. Impossible de les stocker. Pour des besoins ponctuels (traitement quotidien), cela peut entraîner un gaspillage de jetons payés mais inutilisés.

### Données Buy Box coûteuses

Activer `buybox=True` coûte 5 jetons au lieu de 1. 10 000 requêtes Buy Box = 50 000 jetons — soit plus de 3h au plan 250 jetons/minute. Planifiez bien vos besoins.

### Format des données

Keepa stocke les prix en centimes (entiers) et les dates en "temps Keepa" (minutes depuis le 1er janvier 2011). La bibliothèque Python convertit automatiquement, mais pour l'API brute :

```python
from datetime import datetime, timedelta

KEEPA_EPOCH = datetime(2011, 1, 1)

def keepa_time_to_datetime(minutes_keepa):
    return KEEPA_EPOCH + timedelta(minutes=minutes_keepa)

def keepa_price_to_float(centimes):
    return centimes / 100 if centimes >= 0 else None
```

### Fraîcheur des données

Keepa ne met pas à jour tous les produits en continu. Les best-sellers (BSR faible) sont actualisés fréquemment (parfois toutes les heures), les produits de niche moins souvent (quelques jours). Le paramètre `update` force une actualisation, mais coûte plus de jetons.

### Couverture des marketplaces EU

Keepa couvre Amazon.de, .fr, .it, .es, .co.uk, .nl, .pl, .se et .be. La profondeur des données varie — Allemagne et Royaume-Uni sont les plus complètes. Pour les vendeurs européens, Keepa reste la meilleure source unifiée.

## Alternatives à l'API Keepa

Keepa domine le suivi des prix Amazon, mais d'autres options existent selon vos besoins :

### Rainforest API

Une API plus large couvrant produits, recherches, avis. Rainforest scrape Amazon directement plutôt que de maintenir une base historique. Données en temps réel mais sans l'historique de Keepa. À partir de 75$/mois pour 500 requêtes.

### Pangolin API

Concurrent direct de Keepa avec une tarification flexible (facturation à la requête plutôt qu'abonnement). Couverture plus limitée.

### SP-API (API Partenaires de Vente Amazon)

L'API officielle d'Amazon pour les vendeurs. Donne accès à vos ventes, stocks et commandes, mais pas aux données concurrentes (prix, BSR). Gratuite mais complexe à mettre en œuvre.

### AgentXray

Pour les vendeurs Amazon EU qui veulent exploiter les données Keepa sans développer leur propre pipeline, [AgentXray](https://agentxray.ai/fr) propose une approche différente : il agrège Keepa avec d'autres sources et utilise des IA pour générer des rapports et automatiser la recherche de produits. Une solution clé en main si vous cherchez des insights actionnables sans coder.

### Développer votre propre scraper

Certains développeurs créent leurs propres scrapers Amazon pour éviter les APIs tierces. Cela offre un contrôle total et aucun coût récurrent, mais Amazon bloque activement les scrapers, et leur maintenance demande un effort technique important. Pour la plupart, l'API Keepa reste plus rentable.

## Questions fréquentes

### L'API Keepa est-elle gratuite ?

Non. Il faut au minimum un abonnement Keepa payant (19€/mois) donnant un accès API basique à 1 jeton/minute. Pour un usage professionnel, les plans dédiés commencent à 49€/mois. Aucun essai gratuit spécifique à l'API n'est disponible.

### Combien de produits puis-je requêter par jour ?

Cela dépend de votre plan. Avec le plan 49€/mois (20 jetons/minute), environ 28 800 requêtes standard/jour sont possibles. Le plan 459€/mois (250 jetons/minute) permet ~360 000 requêtes/jour. Les options comme Buy Box réduisent ce nombre.

### L'API couvre-t-elle toutes les marketplaces Amazon ?

Keepa supporte 13 marketplaces : États-Unis, Royaume-Uni, Allemagne, France, Italie, Espagne, Canada, Japon, Inde, Mexique, Brésil, Australie et Pays-Bas. Les marchés émergents comme la Pologne ou la Suède sont aussi inclus. Chaque marketplace a un ID numérique dans l'API.

### Puis-je utiliser l'API Keepa commercialement ?

Oui. Les conditions de Keepa autorisent un usage commercial. De nombreuses solutions SaaS et outils de repricing utilisent cette API. Consultez les CGV pour les restrictions éventuelles sur la redistribution des données.

### Différence entre l'API Keepa et la librairie Python `keepa` ?

L'API Keepa est l'interface HTTP fournie par keepa.com. La librairie Python `keepa` (installable via pip) est un wrapper open source qui simplifie son utilisation en Python. Elle gère l'authentification, le rate limiting et les conversions de données. Une clé API Keepa reste nécessaire.

---

*Ce guide est basé sur la documentation et tarifs de l'API Keepa début 2026. Keepa peut mettre à jour ses offres — vérifiez [keepa.com](https://keepa.com) pour les dernières informations.*

## Pour aller plus loin

- [Explication des données Keepa](https://agentxray.ai/fr/blog/keepa-data-explained-eu-sellers)