Keepa API: The Complete Guide for Amazon Sellers and Developers (2026)

Q: What Is Keepa?

Keepa is an Amazon price tracking service founded in Germany. It monitors product prices, sales rank (BSR), offer counts, review counts, and rating history across all major Amazon marketplaces — including the US, UK, Germany, France, Italy, Spain, and Japan. Most Amazon sellers first encounter Keepa through its browser extension, which embeds interactive price history charts directly onto Amazon product pages. These charts show how a product's price, BSR, and buy box have changed over days, week

Q: What Is the Keepa API?

The Keepa API is a RESTful HTTP interface that exposes virtually everything Keepa tracks about Amazon products. Instead of manually browsing Keepa's website or extension, you can programmatically query product data, category trees, seller profiles, deals, and best-seller lists. The API returns JSON responses and uses a token-based authentication system. You pass your API access key as a query parameter, and Keepa deducts tokens from your balance based on what data you request. Key capabilities i

Q: What Does a Token Buy?

- 1 token — standard product query (price history, BSR, basic metadata) - ~2 tokens — product query with offer data - ~5 tokens — product query with buy box statistics - 1 token — category lookup or best seller list - 1 token — seller profile All plans are monthly, prepaid, and can be cancelled anytime. You can stack multiple plans on one account, and upgrades take effect immediately. Downgrades are limited to once per month.

Q: Is the Keepa API free?

The Keepa API is not free. You need at minimum a paid Keepa subscription (€19/month) which gives you basic API access at 1 token per minute. For practical usage, dedicated API plans start at €49/month for 20 tokens per minute. There is no free trial for the API specifically.

Q: How many products can I query per day with the Keepa API?

It depends on your plan and query options. With the €49/month plan (20 tokens/minute), you can query roughly 28,800 products per day using standard requests (1 token each). The €459/month plan (250 tokens/minute) allows approximately 360,000 standard product queries per day. Enabling options like buy box data reduces throughput proportionally.

By AgentXray

2026-04-23T11:11:18.773449+00:00

## Table of Contents

1. [What Is Keepa?](#what-is-keepa)
2. [What Is the Keepa API?](#what-is-the-keepa-api)
3. [Keepa API Pricing Breakdown](#keepa-api-pricing-breakdown)
4. [Core API Endpoints](#core-api-endpoints)
5. [Getting Started with Python](#getting-started-with-python)
6. [Real-World Use Cases](#real-world-use-cases)
7. [Rate Limits, Tokens, and Quirks](#rate-limits-tokens-and-quirks)
8. [Keepa API Alternatives](#keepa-api-alternatives)
9. [Frequently Asked Questions](#frequently-asked-questions)

---

If you sell on Amazon — or build tools for people who do — you have probably heard of Keepa. The browser extension that shows price history charts on Amazon product pages has become the default research companion for millions of sellers worldwide. But Keepa is more than a browser extension. Under the hood sits a powerful API that tracks pricing, sales rank, offers, and category data across every major Amazon marketplace.

This guide covers everything you need to know about the Keepa API in 2026: what it costs, what endpoints are available, how to write your first Python integration, and where the API falls short. Whether you are an Amazon FBA seller automating your research workflow or a developer building the next product research tool, this is your starting point.

## What Is Keepa?

Keepa is an Amazon price tracking service founded in Germany. It monitors product prices, sales rank (BSR), offer counts, review counts, and rating history across all major Amazon marketplaces — including the US, UK, Germany, France, Italy, Spain, and Japan.

Most Amazon sellers first encounter Keepa through its browser extension, which embeds interactive price history charts directly onto Amazon product pages. These charts show how a product's price, BSR, and buy box have changed over days, weeks, months, or years.

Beyond the extension, Keepa offers a web-based suite of tools:

- **Product Finder** — filter Amazon's catalog by price, BSR, category, review count, and dozens of other criteria
- **Product Viewer** — bulk import ASINs and retrieve current data
- **Best Seller lists** — track category leaders in real time
- **Tracking and alerts** — get notified when a product hits your target price

These tools are useful on their own, but the real power unlock for automation-minded sellers and developers is the **Keepa API**.

## What Is the Keepa API?

The Keepa API is a RESTful HTTP interface that exposes virtually everything Keepa tracks about Amazon products. Instead of manually browsing Keepa's website or extension, you can programmatically query product data, category trees, seller profiles, deals, and best-seller lists.

The API returns JSON responses and uses a token-based authentication system. You pass your API access key as a query parameter, and Keepa deducts tokens from your balance based on what data you request.

Key capabilities include:

- **Product data** — current price, BSR, offer count, rating, review count, dimensions, weight, and full price/BSR history going back years
- **Buy box analysis** — who holds the buy box, for how long, and at what price
- **Offer tracking** — live third-party offers with pricing, condition, and seller information
- **Category browsing** — Amazon's full category tree with node IDs
- **Best sellers** — real-time top-selling products per category
- **Seller lookup** — seller details, storefront ASINs, and inventory data
- **Product search** — keyword-based search across Amazon's catalog
- **Deals** — products with recent price drops matching configurable criteria
- **Tracking** — programmatic price alerts with webhook support

If Amazon has data on it, Keepa probably tracks it — and the API lets you access it at scale.

## Keepa API Pricing Breakdown

Keepa uses a token-based pricing system. Each API subscription tier generates a certain number of tokens per minute. Each token lets you request data for one product, one seller, or one category. Unused tokens expire after 60 minutes.

### Prerequisite: Keepa Subscription

Before you can use the API at all, you need a base Keepa subscription:

- **Free** — €0/month. Browser extension and basic tracking only. No API access.
- **Paid** — €19/month (or €189/year). Unlocks Product Finder, Product Viewer, Best Sellers, and basic API access at 1 token/minute.

The €19/month plan gives you API access, but at 1 token per minute you can only query about 60 products per hour — useful for testing, but not for production workloads.

### API Add-On Plans

For serious usage, you purchase an API plan on top of your base subscription:

| Tokens/Minute | Monthly Cost | Products/Hour (approx.) |
|---------------|-------------|------------------------|
| 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 |

The "Products/Hour" column assumes 1 token per product request. In practice, enabling features like buy box data (5 tokens per request) or offer history reduces throughput proportionally.

### What Does a Token Buy?

- **1 token** — standard product query (price history, BSR, basic metadata)
- **~2 tokens** — product query with offer data
- **~5 tokens** — product query with buy box statistics
- **1 token** — category lookup or best seller list
- **1 token** — seller profile

All plans are monthly, prepaid, and can be cancelled anytime. You can stack multiple plans on one account, and upgrades take effect immediately. Downgrades are limited to once per month.

## Core API Endpoints

The Keepa API exposes 16+ endpoints. Here are the ones most relevant to Amazon sellers and tool builders:

### Product Request

The most-used endpoint. Retrieve detailed product data for up to 100 ASINs per request.

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

Returns: current price (Amazon, marketplace, used), sales rank, review count, rating, dimensions, weight, category, and full price/BSR history arrays. Add `&buybox=1` for buy box statistics (costs 5 tokens instead of 1).

### Best Sellers

Retrieve top-selling ASINs for any Amazon category.

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

Returns an ASIN list ranked by current sales rank. You need the category node ID, which you can find via the Category Search endpoint.

### Category Search and Lookup

Find Amazon category node IDs by keyword, or walk the category tree.

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

### Seller

Retrieve seller details and optionally their full storefront (all listed ASINs).

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

### Product Finder

The API equivalent of Keepa's Product Finder tool. Filter Amazon's catalog by dozens of criteria: price range, BSR range, review count, rating, category, and more.

### Tracking

Programmatically add products to your tracking list and configure alerts. Supports webhook delivery — Keepa sends an HTTP POST to your URL when a tracked product's price crosses your threshold.

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

### Deals

Find products with recent price drops, BSR changes, or other deal-qualifying criteria. Useful for arbitrage and wholesale sellers scanning for opportunities.

## Getting Started with Python

The easiest way to interact with the Keepa API from Python is the `keepa` package, maintained by Alex Kaszynski.

### Installation

```bash
pip install keepa
```

Requires Python 3.10+. Dependencies include `numpy`, `aiohttp`, and `matplotlib`.

### Example 1: Query a Single Product

```python
import keepa

api = keepa.Keepa("YOUR_API_KEY")

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

print(f"Title: {product['title']}")
print(f"Sales Rank: {product['salesRankReference']}")
print(f"Rating: {product['csv'][16][-1] / 10 if product['csv'][16] else 'N/A'}")
print(f"Number of Offers: {product['csv'][11][-1] if product['csv'][11] else 'N/A'}")

# Price history is in product['csv'] arrays
# Index 0 = Amazon price, 1 = Marketplace New, 2 = Used, etc.
amazon_prices = product['csv'][0]  # [time, price, time, price, ...]
if amazon_prices is not None:
    latest_price = amazon_prices[-1] / 100  # Prices in cents
    print(f"Current Amazon Price: €{latest_price:.2f}")
```

### Example 2: Find Best Sellers in a Category

```python
import keepa

api = keepa.Keepa("YOUR_API_KEY")

# First, find the category ID for "Kitchen" on Amazon.de
categories = api.search_for_categories("kitchen", domain="DE")
for cat_id, cat_data in list(categories.items())[:3]:
    print(f"Category: {cat_data['name']} (ID: {cat_id})")

# Get best sellers for a specific category
best_sellers = api.best_sellers_query(domain="DE", category="340846031")
print(f"\nTop 5 ASINs in category:")
for asin in best_sellers[:5]:
    print(f"  {asin}")

# Now bulk-query those ASINs for details
products = api.query(best_sellers[:5], domain="DE")
for p in products:
    print(f"  {p['asin']}: {p['title'][:60]}...")
```

### Example 3: Async Bulk Query with Rate Limiting

For production workloads querying thousands of products, use the async API:

```python
import asyncio
import keepa

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

    # The library handles token rate limiting automatically
    # Query in batches of 100 (Keepa's max per request)
    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"Queried {len(all_products)}/{len(asin_list)} products")

    # Analyze results
    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

# Run with a list of ASINs
asins = ["B0088PUEPK", "B07XJ8C8F5", "B09V3KXJPB"]
results = asyncio.run(analyze_asins(asins))
```

The `keepa` Python library handles token management internally — it will pause requests automatically when your token balance is low and resume when tokens regenerate.

## Real-World Use Cases

### BSR Tracking for Product Research

The most common use case. Query products daily and store BSR history in your own database. Plotting BSR over time reveals seasonality, launch trajectories, and competitive dynamics that a single snapshot never shows. Sellers doing product research for private label use this to validate demand before committing to a supplier.

### Price Monitoring and Repricing

Track competitor prices across marketplaces. When a competitor drops their price, your system gets notified (via tracking webhooks or polling) and can adjust your own pricing through Amazon's SP-API. Wholesale and arbitrage sellers rely on this to maintain competitive positioning.

### Competitor Intelligence

Use the Seller endpoint to monitor a competitor's storefront. Track how many ASINs they list, what categories they expand into, and how their pricing strategy shifts over time. Combine this with product queries to build a full competitive landscape.

### Automated Deal Scanning

The Deals endpoint surfaces products with recent price drops or BSR improvements. Arbitrage sellers build scripts that scan for deals matching specific criteria — category, price range, ROI threshold — and push alerts to Slack, Telegram, or email within minutes of a deal appearing.

### Category Analysis

Query best sellers across multiple categories to identify market gaps. Compare average prices, review counts, and BSR distributions across categories to find niches where demand is high but competition is manageable.

## Rate Limits, Tokens, and Quirks

### Token Expiration

Tokens expire 60 minutes after generation, whether you use them or not. You cannot stockpile tokens. If your application is bursty — for example, running a daily batch job — you are paying for tokens generated during the 23 hours your system is idle. For bursty workloads, consider queuing requests and spreading them across your token generation window.

### Buy Box Data Is Expensive

Enabling `buybox=True` on a product query costs 5 tokens instead of 1. If you need buy box data for 10,000 products, that is 50,000 tokens — which at the 250 tokens/minute plan takes over 3 hours. Plan your data pipeline accordingly.

### Price Data Format

Keepa stores prices in cents (integers) and timestamps in "Keepa time" — minutes since January 1, 2011. You need to convert both to standard formats. The Python library handles most of this, but if you use the raw HTTP API, be aware of these conversions:

```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 means "not available"
    return price_cents / 100
```

### Data Freshness

Keepa does not crawl every product continuously. Popular products (low BSR) get updated more frequently — sometimes hourly. Long-tail products might only update every few days. If you need guaranteed freshness, you can pass the `update` parameter in your query to trigger a live crawl, but this costs additional tokens.

### EU Marketplace Coverage

Keepa covers Amazon.de, .fr, .it, .es, .co.uk, .nl, .pl, .se, and .be. Coverage depth varies — Germany and UK have the most historical data, while newer marketplaces like Sweden and Belgium have shorter histories. For EU-focused sellers, Keepa is currently the best single source for cross-marketplace price data.

## Keepa API Alternatives

Keepa is the market leader for Amazon price tracking, but it is not the only option. Here are alternatives worth considering depending on your needs:

### Rainforest API

A broader Amazon data API that covers product details, search results, reviews, and more. Rainforest scrapes Amazon directly rather than maintaining its own historical database, so it gives you real-time snapshots but lacks the deep price history that Keepa offers. Pricing starts at $75/month for 500 requests.

### Pangolin API

Designed as a direct Keepa competitor with a focus on flexible pricing. Offers per-request billing instead of token-per-minute plans, which can be more cost-effective for bursty or low-volume workloads. Coverage is narrower than Keepa's.

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

Amazon's own API for sellers. Gives you access to your own sales data, inventory, orders, and catalog information. It does not provide competitor pricing or BSR history — you can only see data related to your own seller account. Free to use but complex to set up and limited in scope.

### AgentXray

If you are an Amazon EU seller who wants the insights that Keepa data provides but does not want to build and maintain your own data pipeline, [AgentXray](https://agentxray.ai) takes a different approach. It ingests Keepa data alongside other sources and uses AI agents to surface product opportunities, generate market reports, and automate research workflows — so you get the analysis without writing code. Worth exploring if your goal is actionable intelligence rather than raw API access.

### Building Your Own Scraper

Some developers skip third-party APIs entirely and build their own Amazon scrapers. This gives you maximum control and zero ongoing API costs, but Amazon actively blocks scrapers, and maintaining one is a significant engineering investment. For most teams, the Keepa API is more cost-effective than maintaining a scraping infrastructure.

## Frequently Asked Questions

### Is the Keepa API free?

The Keepa API is not free. You need at minimum a paid Keepa subscription (€19/month) which gives you basic API access at 1 token per minute. For practical usage, dedicated API plans start at €49/month for 20 tokens per minute. There is no free trial for the API specifically.

### How many products can I query per day with the Keepa API?

It depends on your plan and query options. With the €49/month plan (20 tokens/minute), you can query roughly 28,800 products per day using standard requests (1 token each). The €459/month plan (250 tokens/minute) allows approximately 360,000 standard product queries per day. Enabling options like buy box data reduces throughput proportionally.

### Does Keepa API support all Amazon marketplaces?

Keepa supports 13 Amazon marketplaces: US, UK, Germany, France, Italy, Spain, Canada, Japan, India, Mexico, Brazil, Australia, and the Netherlands. Additional EU marketplaces including Poland, Sweden, and Belgium are also covered. Each marketplace is identified by a numeric domain ID in API requests.

### Can I use the Keepa API for commercial projects?

Yes. Keepa's API terms allow commercial usage. Many SaaS tools, repricing services, and product research platforms are built on top of the Keepa API. You should review Keepa's current terms of service for any specific restrictions on data redistribution.

### What is the difference between Keepa API and keepa Python library?

The Keepa API is the HTTP REST interface provided by Keepa.com. The `keepa` Python library (installable via `pip install keepa`) is a community-maintained open-source wrapper that simplifies interacting with the API from Python. The library handles authentication, rate limiting, data parsing, and Keepa time conversion automatically. You still need a Keepa API key to use the Python library.

---

*This guide is based on Keepa API documentation and pricing as of early 2026. Keepa may update their pricing tiers or endpoint specifications — always check [keepa.com](https://keepa.com) for the latest information.*