Yes, there is a free tier: new SellerMagnet API accounts get 150 free credits once the e-mail address is verified, and every endpoint costs exactly 1 credit per request after that, whether the answer is a hit or a miss. The one exception is a server-side 500 error, which is refunded automatically. There is no per-endpoint pricing difference and no batch discount: a lookup, a search and a full statistics history call all cost the same single credit.
Key Takeaways
- 150 free credits on signup after e-mail verification; 1 credit per request after that.
- A 404 (product not found) is billed the same as a 200; a 500 is refunded automatically.
- Gate errors (missing parameter, unknown marketplaceId, bad key, rate limit) are never billed.
- Endpoint errors raised after validation (bad count, invalid category ID) ARE billed.
- Current plan tiers and pay-as-you-go pricing are listed live on /pricing.
What does the Amazon Product API cost?
| Plan | What you get | Good for |
|---|---|---|
| Free | 150 credits (after e-mail verification) | test the endpoints, small scripts |
| Paid plans | see /pricing for current tiers | recurring credit allowance, scales with usage |
| Pay-as-you-go top-up | buy credits directly | no recurring commitment |
Which errors are billed and which are free?
The order inside the API matters: the API key is checked, then the request parameters are validated, then a per-key concurrency slot is claimed, then the credit is deducted atomically, and only then does the real fetch happen. Anything rejected before that deduction step is free; anything that gets past it is billed, even if the end result is an error.
| Response | Billed? | Why |
|---|---|---|
| 200 success | Yes | the thing you asked for |
| 404 not found | Yes | Amazon answered; the page just isn't there |
| Endpoint 400 (bad count, bad category ID, malformed ASIN on statistics/estimate) | Yes | validated inside the view, after the credit is taken |
| Gate 400 (missing/blank parameter, unknown marketplaceId) | No | rejected before billing |
| 401 (bad key, or 0 credits left) | No | never reaches the view |
| 403 (credits hit 0 mid-request) | No | race during a burst, refused |
| 429 (per-key concurrency cap) | No | retry after the Retry-After header |
| 500 (server error) | Refunded | credits_used = 0 in the usage log |
| 502 / 503 (upstream/circuit breaker) | Yes | retryable, but still billed per attempt |
How do I estimate a monthly credit budget?
Multiply the number of tracked ASINs by how many times a day you refresh them and by 30, then add a small margin for retries on 502/503 and billed 404s. A credit budget that ignores retries runs out mid-month on any plan with real traffic.
Two calls, one free and one billed
# Gate 400: missing marketplaceId -> free, no credit spent
curl -s "https://sellermagnet-api.com/api/amazon-product-lookup?asin=B0CLTBHXWQ&api_key=$SELLERMAGNET_API_KEY"
# Endpoint 400: count above 50 on bestsellers -> billed, credit spent
curl -s "https://sellermagnet-api.com/api/amazon-bestsellers?category_id=electronics&marketplaceId=ATVPDKIKX0DER&count=200&api_key=$SELLERMAGNET_API_KEY"cost_estimate.py - price a monitoring plan before building it
"""Estimate the monthly credit cost of a product-tracking plan on the SellerMagnet API.
1 credit = 1 request, billed on every call that reaches the view (free-gate 400s,
401 and 429 are not billed; 500 is refunded). This script prices a plan: N ASINs,
refreshed with /amazon-product-lookup K times per day, with retries on 5xx.
"""
import os
import time
import requests
BASE = "https://sellermagnet-api.com/api"
RETRYABLE = {500, 502, 503}
def get_with_retry(endpoint, params, max_attempts=4):
"""Billed attempts: every try except a free 401/429 counts. 500 is refunded."""
session = requests.Session()
session.headers["X-Api-Key"] = os.environ["SELLERMAGNET_API_KEY"]
billed = 0
for attempt in range(1, max_attempts + 1):
resp = session.get(f"{BASE}/{endpoint}", params=params, timeout=120)
if resp.status_code in (401, 429):
return None, billed # not billed, don't retry a bad key or a rate limit
if resp.status_code == 500:
time.sleep(min(2 ** attempt, 20))
continue # refunded, so it does not add to billed
billed += 1
if resp.status_code in (502, 503) and attempt < max_attempts:
time.sleep(min(2 ** attempt, 20))
continue
body = resp.json() if resp.headers.get("content-type", "").startswith("application/json") else {}
return body, billed
return None, billed
def monthly_credits(num_asins: int, checks_per_day: int, retry_rate: float) -> dict:
"""retry_rate = fraction of calls that need one extra billed retry (502/503/404)."""
base_calls = num_asins * checks_per_day * 30
extra_from_retries = round(base_calls * retry_rate)
total = base_calls + extra_from_retries
return {"base_calls": base_calls, "extra_from_retries": extra_from_retries, "total_credits": total}
if __name__ == "__main__":
plans = [
("50 ASINs, daily", 50, 1),
("50 ASINs, every 6h", 50, 4),
("500 ASINs, daily", 500, 1),
("500 ASINs, every 6h", 500, 4),
]
for name, asins, checks in plans:
result = monthly_credits(asins, checks, retry_rate=0.03)
print(f"{name}: {result}")Output for four example plans
50 ASINs, daily: {'base_calls': 1500, 'extra_from_retries': 45, 'total_credits': 1545}
50 ASINs, every 6h: {'base_calls': 6000, 'extra_from_retries': 180, 'total_credits': 6180}
500 ASINs, daily: {'base_calls': 15000, 'extra_from_retries': 450, 'total_credits': 15450}
500 ASINs, every 6h: {'base_calls': 60000, 'extra_from_retries': 1800, 'total_credits': 61800}| ASINs tracked | Check frequency | Credits / month |
|---|---|---|
| 50 ASINs | daily | 1,545 / month |
| 50 ASINs | every 6 h | 6,180 / month |
| 500 ASINs | daily | 15,450 / month |
| 500 ASINs | every 6 h | 61,800 / month |
Validate before you call
A malformed ASIN on /amazon-product-statistics and /amazon-product-search-estimated-sells is billed, and an unknown category_id on /amazon-bestsellers is billed too. Checking format and known values client-side before the call is free money saved, not just a faster failure.
Frequently Asked Questions
Is the Amazon product API free?
There is a free tier: 150 credits after e-mail verification, enough to test every endpoint. Beyond that each request costs 1 credit; see /pricing for paid tiers and pay-as-you-go top-ups.
Does a failed request still cost a credit?
It depends where it failed. A 404 (not found), a billed endpoint 400, or a 502/503 all cost a credit. A gate 400, 401 or 429 never reaches billing. A 500 is billed then automatically refunded.
Is there a discount for bulk requests?
No. There is no batch endpoint at all: each ASIN, seller or search is its own request at the same flat 1-credit rate, with no bulk discount built into the price per call.
How do I avoid wasting credits on bad requests?
Validate ASIN format, category IDs and count limits locally before calling, since those checks are billed when the API itself rejects them. Caching responses per endpoint TTL also avoids paying twice for the same answer.
Where do I see current plan prices?
Live tier pricing and the pay-as-you-go top-up rate are shown on the site's /pricing page, since prices change independently of this guide.
Bottom line: budget by multiplying tracked ASINs by daily checks by 30, add a small retry margin, and remember that only gate errors and successful refunds are free. Start on the 150 free credits, see the real call volume your use case needs, then pick a plan on /pricing. For the request/response shape itself, see the product data without SP-API guide, and cache responses to avoid paying for the same answer twice.
