Keepa API: De Complete Gids voor Amazon-verkopers en Ontwikkelaars (2026)

## Inhoudsopgave

1. [Wat is Keepa?](#wat-is-keepa)
2. [Wat is de Keepa API?](#wat-is-de-keepa-api)
3. [Keepa API Prijsopbouw](#keepa-api-prijsopbouw)
4. [Kern API Endpoints](#kern-api-endpoints)
5. [Aan de slag met Python](#aan-de-slag-met-python)
6. [Praktijkvoorbeelden](#praktijkvoorbeelden)
7. [Snelheidslimieten, Tokens en Eigenaardigheden](#snelheidslimieten-tokens-en-eigenaardigheden)
8. [Alternatieven voor de Keepa API](#alternatieven-voor-de-keepa-api)
9. [Veelgestelde Vragen](#veelgestelde-vragen)

---

Als je verkoopt op Amazon — of tools bouwt voor mensen die dat doen — heb je waarschijnlijk wel eens van Keepa gehoord. De browserextensie die prijshistoriekgrafieken toont op Amazon-productpagina's is uitgegroeid tot de standaard onderzoekspartner voor miljoenen verkopers wereldwijd. Maar Keepa is meer dan een browserextensie. Onder de motorkap zit een krachtige API die prijzen, verkooprang (BSR), aanbiedingen en categoriegegevens volgt in elke grote Amazon-marktplaats.

Deze gids behandelt alles wat je moet weten over de Keepa API in 2026: wat het kost, welke endpoints beschikbaar zijn, hoe je je eerste Python-integratie schrijft en waar de API tekortschiet. Of je nu een Amazon FBA-verkoper bent die je onderzoeksworkflow automatiseert of een ontwikkelaar die de volgende productonderzoektool bouwt, dit is je startpunt.

## Wat is Keepa?

Keepa is een Amazon-prijstrackingservice die in Duitsland is opgericht. Het houdt productprijzen, verkooprang (BSR), aanbiedingsaantallen, beoordelingsaantallen en waarderingsgeschiedenis bij in alle grote Amazon-marktplaatsen — inclusief de VS, het VK, Duitsland, Frankrijk, Italië, Spanje en Japan.

De meeste Amazon-verkopers komen Keepa voor het eerst tegen via de browserextensie, die interactieve prijshistoriekgrafieken direct in Amazon-productpagina's integreert. Deze grafieken laten zien hoe de prijs, BSR en Buy Box van een product zijn veranderd over dagen, weken, maanden of jaren.

Naast de extensie biedt Keepa een webgebaseerde suite van tools:

- **Product Finder** — filter de catalogus van Amazon op prijs, BSR, categorie, beoordelingsaantal en tientallen andere criteria
- **Product Viewer** — importeer ASIN's in bulk en haal actuele gegevens op
- **Best Seller-lijsten** — volg categorieleiders in realtime
- **Tracking en meldingen** — krijg een melding wanneer een product jouw doelprijs bereikt

Deze tools zijn op zichzelf nuttig, maar de echte kracht voor verkopers en ontwikkelaars die gericht zijn op automatisering is de **Keepa API**.

## Wat is de Keepa API?

De Keepa API is een RESTful HTTP-interface die vrijwel alles blootlegt wat Keepa bijhoudt over Amazon-producten. In plaats van handmatig door de website of extensie van Keepa te browsen, kun je programmatisch productgegevens, categoriebomen, verkopersprofielen, deals en best-sellerlijsten opvragen.

De API retourneert JSON-reacties en gebruikt een tokengebaseerd authenticatiesysteem. Je geeft je API-toegangssleutel door als een queryparameter, en Keepa trekt tokens af van je saldo op basis van welke gegevens je aanvraagt.

Belangrijke mogelijkheden zijn:

- **Productgegevens** — huidige prijs, BSR, aanbiedingsaantal, waardering, beoordelingsaantal, afmetingen, gewicht en volledige prijs/BSR-geschiedenis die jaren teruggaat
- **Buy Box-analyse** — wie de Buy Box heeft, voor hoe lang en tegen welke prijs
- **Aanbiedingstracking** — live aanbiedingen van derden met prijzen, conditie en verkopersinformatie
- **Categoriebrowsing** — de volledige categorieboom van Amazon met node-ID's
- **Best sellers** — realtime bestverkopende producten per categorie
- **Verkopersopzoeken** — verkopersdetails, winkel-ASIN's en voorraadgegevens
- **Productzoeken** — zoeken op trefwoord in de catalogus van Amazon
- **Deals** — producten met recente prijsdalingen die aan configureerbare criteria voldoen
- **Tracking** — programmatische prijsmeldingen met webhook-ondersteuning

Als Amazon er gegevens over heeft, houdt Keepa het waarschijnlijk bij — en de API geeft je toegang op schaal.

## Keepa API Prijsopbouw

Keepa gebruikt een tokengebaseerd prijssysteem. Elk API-abonnement genereert een bepaald aantal tokens per minuut. Elk token stelt je in staat om gegevens op te vragen voor één product, één verkoper of één categorie. Ongebruikte tokens vervallen na 60 minuten.

### Voorwaarde: Keepa-abonnement

Voordat je de API kunt gebruiken, heb je een basisabonnement van Keepa nodig:

- **Gratis** — €0/maand. Alleen browserextensie en basistracking. Geen API-toegang.
- **Betaald** — €19/maand (of €189/jaar). Ontgrendelt Product Finder, Product Viewer, Best Sellers en basis-API-toegang met 1 token/minuut.

Het abonnement van €19/maand geeft je API-toegang, maar met 1 token per minuut kun je slechts ongeveer 60 producten per uur opvragen — handig voor testen, maar niet voor productieworkloads.

### API Add-On-abonnementen

Voor serieus gebruik koop je een API-abonnement bovenop je basisabonnement:

| Tokens/Minute | Maandelijkse Kosten | Producten/Uur (ongeveer) |
|---------------|-------------|------------------------|
| 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 |

De kolom "Producten/Uur" gaat uit van 1 token per productaanvraag. In de praktijk vermindert het inschakelen van functies zoals Buy Box-gegevens (5 tokens per aanvraag) of aanbiedingsgeschiedenis de doorvoer proportioneel.

### Wat koop je met een token?

- **1 token** — standaard productquery (prijshistorie, BSR, basis metadata)
- **~2 tokens** — productquery met aanbiedingsgegevens
- **~5 tokens** — productquery met Buy Box-statistieken
- **1 token** — categorieopzoeken of best seller-lijst
- **1 token** — verkopersprofiel

Alle abonnementen zijn maandelijks, vooraf betaald en kunnen op elk moment worden opgezegd. Je kunt meerdere abonnementen op één account stapelen, en upgrades zijn direct van kracht. Downgrades zijn beperkt tot één keer per maand.

## Kern API Endpoints

De Keepa API biedt 16+ endpoints. Hier zijn de meest relevante voor Amazon-verkopers en toolbouwers:

### Productaanvraag

Het meest gebruikte endpoint. Haal gedetailleerde productgegevens op voor maximaal 100 ASIN's per aanvraag.

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

Retourneert: huidige prijs (Amazon, marktplaats, gebruikt), verkooprang, beoordelingsaantal, waardering, afmetingen, gewicht, categorie en volledige prijs/BSR-geschiedenis arrays. Voeg `&buybox=1` toe voor Buy Box-statistieken (kost 5 tokens in plaats van 1).

### Best Sellers

Haal bestverkopende ASIN's op voor elke Amazon-categorie.

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

Retourneert een ASIN-lijst gerangschikt op huidige verkooprang. Je hebt de categorie-node-ID nodig, die je kunt vinden via het Category Search-endpoint.

### Categoriezoeken en opzoeken

Vind Amazon-categorie-node-ID's op trefwoord, of doorloop de categorieboom.

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

### Verkoper

Haal verkopersdetails op en optioneel hun volledige winkel (alle gelijste ASIN's).

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

### Product Finder

De API-equivalent van Keepa's Product Finder-tool. Filter de catalogus van Amazon op tientallen criteria: prijsbereik, BSR-bereik, beoordelingsaantal, waardering, categorie en meer.

### Tracking

Voeg programmatisch producten toe aan je trackinglijst en configureer meldingen. Ondersteunt webhook-levering — Keepa stuurt een HTTP POST naar je URL wanneer de prijs van een gevolgd product je drempel overschrijdt.

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

### Deals

Vind producten met recente prijsdalingen, BSR-wijzigingen of andere deal-kwalificerende criteria. Handig voor arbitrage- en wholesale-verkopers die op zoek zijn naar kansen.

## Aan de slag met Python

De eenvoudigste manier om met de Keepa API vanuit Python te werken is het `keepa`-pakket, onderhouden door Alex Kaszynski.

### Installatie

```bash
pip install keepa
```

Vereist Python 3.10+. Afhankelijkheden zijn onder andere `numpy`, `aiohttp` en `matplotlib`.

### Voorbeeld 1: Query één product

```python
import keepa

api = keepa.Keepa("YOUR_API_KEY")

# Query een product op Amazon.de (domain=3)
products = api.query("B0088PUEPK", domain="DE")
product = products[0]

print(f"Titel: {product['title']}")
print(f"Verkooprang: {product['salesRankReference']}")
print(f"Waardering: {product['csv'][16][-1] / 10 if product['csv'][16] else 'N/A'}")
print(f"Aantal aanbiedingen: {product['csv'][11][-1] if product['csv'][11] else 'N/A'}")

# Prijshistorie zit in product['csv'] arrays
# Index 0 = Amazon prijs, 1 = Marketplace Nieuw, 2 = Gebruikt, etc.
amazon_prices = product['csv'][0]  # [tijd, prijs, tijd, prijs, ...]
if amazon_prices is not None:
    laatste_prijs = amazon_prices[-1] / 100  # Prijzen in centen
    print(f"Huidige Amazon Prijs: €{laatste_prijs:.2f}")
```

### Voorbeeld 2: Vind best sellers in een categorie

```python
import keepa

api = keepa.Keepa("YOUR_API_KEY")

# Vind eerst de categorie-ID voor "Keuken" op Amazon.de
categories = api.search_for_categories("keuken", domain="DE")
for cat_id, cat_data in list(categories.items())[:3]:
    print(f"Categorie: {cat_data['name']} (ID: {cat_id})")

# Haal best sellers op voor een specifieke categorie
best_sellers = api.best_sellers_query(domain="DE", category="340846031")
print(f"\nTop 5 ASIN's in categorie:")
for asin in best_sellers[:5]:
    print(f"  {asin}")

# Query nu die ASIN's in bulk voor details
products = api.query(best_sellers[:5], domain="DE")
for p in products:
    print(f"  {p['asin']}: {p['title'][:60]}...")
```

### Voorbeeld 3: Async bulkquery met snelheidslimieten

Voor productieworkloads die duizenden producten opvragen, gebruik de async API:

```python
import asyncio
import keepa

async def analyze_asins(asin_list: list[str]):
    api = await keepa.AsyncKeepa().create("YOUR_API_KEY")

    # De bibliotheek regelt token snelheidslimieten automatisch
    # Query in batches van 100 (Keepa's max per aanvraag)
    all_products = []
    for i in range(0, len(asin_list), 100):
        batch = asin_list[i:i+100]
        products = await api.query(batch, domain="DE")
        all_products.extend(products)
        print(f"Gequeryd {len(all_products)}/{len(asin_list)} producten")

    # Analyseer resultaten
    for p in all_products:
        title = p.get("title", "N/A")
        bsr = p.get("salesRankReference", -1)
        print(f"{p['asin']} | BSR: {bsr:>8} | {title[:50]}")

    return all_products

# Voer uit met een lijst van ASIN's
asins = ["B0088PUEPK", "B07XJ8C8F5", "B09V3KXJPB"]
results = asyncio.run(analyze_asins(asins))
```

De `keepa` Python-bibliotheek regelt tokenbeheer intern — het pauzeert aanvragen automatisch wanneer je tokenbalans laag is en hervat wanneer tokens worden gegenereerd.

## Praktijkvoorbeelden

### BSR-tracking voor productonderzoek

Het meest voorkomende gebruik. Query producten dagelijks en sla BSR-geschiedenis op in je eigen database. Het plotten van BSR over tijd onthult seizoensgebondenheid, lanceringstrajecten en competitieve dynamiek die een enkele momentopname nooit laat zien. Verkopers die productonderzoek doen voor private label gebruiken dit om de vraag te valideren voordat ze zich vastleggen op een leverancier.

### Prijsmonitoring en herprijzing

Volg concurrentieprijzen over marktplaatsen. Wanneer een concurrent zijn prijs verlaagt, krijgt je systeem een melding (via tracking webhooks of polling) en kan het je eigen prijzen aanpassen via Amazon's SP-API. Wholesale- en arbitrageverkopers vertrouwen hierop om concurrerend te blijven.

### Concurrentie-informatie

Gebruik het Seller-endpoint om de winkel van een concurrent te monitoren. Volg hoeveel ASIN's ze aanbieden, in welke categorieën ze uitbreiden en hoe hun prijsstrategie in de loop van de tijd verschuift. Combineer dit met productqueries om een volledig concurrentielandschap op te bouwen.

### Geautomatiseerde deal-scanning

Het Deals-endpoint brengt producten met recente prijsdalingen of BSR-verbeteringen aan het licht. Arbitrageverkopers bouwen scripts die scannen op deals die aan specifieke criteria voldoen — categorie, prijsbereik, ROI-drempel — en sturen binnen enkele minuten na het verschijnen van een deal meldingen naar Slack, Telegram of e-mail.

### Categorieanalyse

Query best sellers over meerdere categorieën om markthiaten te identificeren. Vergelijk gemiddelde prijzen, beoordelingsaantallen en BSR-distributies over categorieën om niches te vinden waar de vraag hoog is maar de concurrentie beheersbaar.

## Snelheidslimieten, Tokens en Eigenaardigheden

### Tokenverval

Tokens vervallen 60 minuten na generatie, of je ze nu gebruikt of niet. Je kunt geen tokens opslaan. Als je applicatie bursty is — bijvoorbeeld een dagelijkse batchjob — betaal je voor tokens die worden gegenereerd tijdens de 23 uur dat je systeem inactief is. Voor bursty workloads kun je overwegen om aanvragen in een wachtrij te plaatsen en ze te spreiden over je token-generatievenster.

### Buy Box-gegevens zijn duur

Het inschakelen van `buybox=True` bij een productquery kost 5 tokens in plaats van 1. Als je Buy Box-gegevens nodig hebt voor 10.000 producten, is dat 50.000 tokens — wat bij het abonnement van 250 tokens per minuut meer dan 3 uur kost. Plan je datapijplijn dienovereenkomstig.

### Prijsgegevensformaat

Keepa slaat prijzen op in centen (integers) en tijdstempels in "Keepa-tijd" — minuten sinds 1 januari 2011. Je moet beide converteren naar standaardformaten. De Python-bibliotheek regelt het meeste hiervan, maar als je de raw HTTP API gebruikt, wees je bewust van deze conversies:

```python
from datetime import datetime, timedelta

KEEPA_EPOCH = datetime(2011, 1, 1)

def keepa_time_to_datetime(keepa_minutes: int) -> datetime:
    return KEEPA_EPOCH + timedelta(minutes=keepa_minutes)

def keepa_price_to_float(price_cents: int) -> float:
    if price_cents < 0:
        return None  # -1 betekent "niet beschikbaar"
    return price_cents / 100
```

### Dataversheid

Keepa crawlt niet elk product continu. Populaire producten (lage BSR) worden vaker bijgewerkt — soms elk uur. Producten in de lange staart worden mogelijk slechts om de paar dagen bijgewerkt. Als je gegarandeerde versheid nodig hebt, kun je de `update`-parameter in je query doorgeven om een live crawl te activeren, maar dit kost extra tokens.

### EU-marktplaatsdekking

Keepa dekt Amazon.de, .fr, .it, .es, .co.uk, .nl, .pl, .se en .be. De dekking varieert — Duitsland en het VK hebben de meeste historische gegevens, terwijl nieuwere marktplaatsen zoals Zweden en België kortere geschiedenissen hebben. Voor EU-verkopers is Keepa momenteel de beste bron voor prijsgegevens over meerdere marktplaatsen.

## Alternatieven voor de Keepa API

Keepa is de marktleider voor Amazon-prijstracking, maar het is niet de enige optie. Hier zijn alternatieven die het overwegen waard zijn, afhankelijk van je behoeften:

### Rainforest API

Een bredere Amazon-data-API die productdetails, zoekresultaten, reviews en meer dekt. Rainforest scrapet Amazon rechtstreeks in plaats van een eigen historische database bij te houden, dus het geeft je realtime momentopnamen maar mist de diepe prijshistorie die Keepa biedt. Prijzen beginnen bij $75/maand voor 500 aanvragen.

### Pangolin API

Ontworpen als een directe concurrent van Keepa met een focus op flexibele prijzen. Biedt per-aanvraagfacturering in plaats van token-per-minuut-abonnementen, wat kosteneffectiever kan zijn voor bursty of low-volume workloads. De dekking is smaller dan die van Keepa.

### SP-API (Amazon Selling Partner API)

Amazon's eigen API voor verkopers. Geeft je toegang tot je eigen verkoopgegevens, voorraad, bestellingen en catalogusinformatie. Het biedt geen concurrentieprijzen of BSR-geschiedenis — je kunt alleen gegevens zien die betrekking hebben op je eigen verkopersaccount. Gratis te gebruiken maar complex om op te zetten en beperkt in scope.

### AgentXray

Als je een Amazon EU-verkoper bent die de inzichten wil die Keepa-gegevens bieden, maar niet je eigen datapijplijn wilt bouwen en onderhouden, neemt [AgentXray](https://agentxray.ai) een andere aanpak. Het verwerkt Keepa-gegevens naast andere bronnen en gebruikt AI-agents om productkansen te ontdekken, marktrapporten te genereren en onderzoeksworkflows te automatiseren — zodat je de analyse krijgt zonder code te schrijven. Het is het verkennen waard als je doel actiegerichte intelligentie is in plaats van ruwe API-toegang.

### Je eigen scraper bouwen

Sommige ontwikkelaars slaan third-party API's helemaal over en bouwen hun eigen Amazon-scrapers. Dit geeft je maximale controle en geen doorlopende API-kosten, maar Amazon blokkeert actief scrapers, en het onderhouden ervan is een aanzienlijke technische investering. Voor de meeste teams is de Keepa API kosteneffectiever dan het onderhouden van een scraping-infrastructuur.

## Veelgestelde Vragen

### Is de Keepa API gratis?

De Keepa API is niet gratis. Je hebt minimaal een betaald Keepa-abonnement nodig (€19/maand) dat je basis-API-toegang geeft met 1 token per minuut. Voor praktisch gebruik beginnen toegewijde API-abonnementen bij €49/maand voor 20 tokens per minuut. Er is geen gratis proefperiode voor de API specifiek.

### Hoeveel producten kan ik per dag opvragen met de Keepa API?

Het hangt af van je abonnement en query-opties. Met het abonnement van €49/maand (20 tokens/minuut) kun je ongeveer 28.800 producten per dag opvragen met standaardaanvragen (1 token elk). Het abonnement van €459/maand (250 tokens/minuut) staat ongeveer 360.000 standaard productqueries per dag toe. Het inschakelen van opties zoals Buy Box-gegevens vermindert de doorvoer proportioneel.

### Ondersteunt de Keepa API alle Amazon-marktplaatsen?

Keepa ondersteunt 13 Amazon-marktplaatsen: VS, VK, Duitsland, Frankrijk, Italië, Spanje, Canada, Japan, India, Mexico, Brazilië, Australië en Nederland. Extra EU-marktplaatsen zoals Polen, Zweden en België zijn ook gedekt. Elke marktplaats wordt geïdentificeerd door een numerieke domein-ID in API-aanvragen.

### Kan ik de Keepa API gebruiken voor commerciële projecten?

Ja. De API-voorwaarden van Keepa staan commercieel gebruik toe. Veel SaaS-tools, repricingservices en productonderzoeksplatforms zijn gebouwd op de Keepa API. Je moet de huidige servicevoorwaarden van Keepa bekijken voor eventuele specifieke beperkingen op gegevensherdistributie.

### Wat is het verschil tussen de Keepa API en de keepa Python-bibliotheek?

De Keepa API is de HTTP REST-interface die door Keepa.com wordt aangeboden. De `keepa` Python-bibliotheek (installeerbaar via `pip install keepa`) is een door de community onderhouden open-source wrapper die het werken met de API vanuit Python vereenvoudigt. De bibliotheek regelt authenticatie, snelheidslimieten, gegevensparsing en Keepa-tijdconversie automatisch. Je hebt nog steeds een Keepa API-sleutel nodig om de Python-bibliotheek te gebruiken.

---

*Deze gids is gebaseerd op Keepa API-documentatie en prijzen vanaf begin 2026. Keepa kan hun prijstiers of endpointspecificaties bijwerken — controleer altijd [keepa.com](https://keepa.com) voor de laatste informatie.*

## Gerelateerde lectuur

- [keepa data uitgelegd](https://agentxray.ai/nl/blog/keepa-data-explained-eu-sellers)