Roundup
September 4, 2026 · 21 min read
Best Amazon APIs in 2026: 8 Tested and Compared
Amazon product data without running a scraper. We pulled the published pricing of 8 providers on the same day, ran the same product lookup and the same keyword search through each one, and worked out the cost per 1K requests for every Amazon endpoint each provider offers.

Author
Adam Ben-Ayoun
CTO · OpenWeb Ninja
Amazon API · Amazon Scraper API · Python · API Comparison

Quick Answer: Best Amazon APIs at a Glance
Prices are what each provider published on September 4, 2026, monthly billing. "Per 1K" is the cost of 1,000 Amazon product-page requests on the entry paid plan. Endpoint counts are what each provider documents for Amazon specifically.
| API | Best for | Entry paid plan | Per 1K (entry) | Free tier | Amazon endpoints |
|---|---|---|---|---|---|
| OpenWeb Ninja | Most Amazon endpoints under one flat-rate key | $25 / 10K req | $2.50 | 100/mo | 21 in the OpenAPI spec: search, product, offers, reviews, best sellers, deals, promo codes, seller profile and products, influencer profile and posts, ASIN/GTIN conversion |
| Rainforest API | Deepest Amazon-only schema | $23 / 500 credits | $46.00 | 100 (trial) | 23 request types incl. Q&A, seller feedback, stock estimation |
| Oxylabs | Cheapest parsed pages past 100K/month | $49 / 98K results | $0.50 | 2,000 (trial) | 6: product, search, pricing, sellers, best sellers, generic URL |
| Scrapingdog | Cheapest product pages at any spend | $40 / 200K credits | $0.20 | 200 credits | 6: product, search, offers, best sellers, reviews (non-functional), autocomplete; $0.20 rate is US only |
| Bright Data | Biggest free tier, pay per record | PAYG $1.50 / 1K | $1.50 | 5,000/mo | 14 scrapers incl. reviews, sellers, best sellers, keyword and UPC discovery |
| SerpApi | Teams already on SerpApi | $25 / 1K searches | $25.00 | 250/mo | 3: search, product, autocomplete |
| ScraperAPI | General scraper with Amazon structured endpoints | $49 / 100K credits | $2.45 | 5,000 credits (trial) | 3: product, search, offers (5 credits each) |
| Apify | Community actors, pay per result | $19 + $4 / 1K results | $4.00 | $5 usage/mo | Product and search crawler; separate reviews and best sellers actors |
Two more sources sit outside this table and get their own sections below: Amazon's official Creators API (free, but gated by affiliate sales and missing reviews and third-party offers) and Keepa (the only one with price history, from 49 EUR per month).
How We Evaluated
- What we tested: two requests on every provider. First, a product lookup by ASIN (B07ZPKBL9V, an Amazon Renewed iPhone 11, chosen because it has many third-party offers); what each provider returned for it is summarized in the table below. Second, a keyword search for "wireless earbuds", which is the request shown in each provider's code and response blocks. The latency sample adds four more ASINs (B0CHX3QBCH, B09G9FPHY6, B0BSHF7WHW, B08L5NP6NG) and two more search terms (standing desk, air purifier). We also called each provider's reviews and offers endpoints once to check they exist and respond; those results are in the coverage table. If you want the product-lookup code for these providers, our e-commerce API roundup shows it for seven of them.
- Pricing: every number was read from the provider's public pricing page or docs on September 4, 2026. Where a page contradicted another page on the same site, we say so. Monthly billing unless stated.
- Unit conversion: credits, results, records, tokens, and searches were converted to cost per 1,000 Amazon product-page requests, then to the monthly bill at 10K, 50K, and 200K requests.
- Code and responses: every code block was executed as printed, with only the placeholder key replaced, and every response block is trimmed from the JSON that call returned. Seven providers were tested on free accounts created for this article; SerpApi was tested with an existing OpenWeb Ninja account. The Creators API and Keepa sections use their official documentation, labeled, because both are gated: one by affiliate sales, the other by a paid plan.
- Response time: the same five ASINs and three searches, once each, from one machine in the same session. We report the median. It is a smoke test, not a benchmark.
- Order: by how many readers we expect each to fit, not strictly by price.
We build one of these APIs, so read the OpenWeb Ninja section with that in mind. The competitor sections are as flattering as the published numbers allow.
Same ASIN, Eight Answers
What each provider returned for B07ZPKBL9V (Apple iPhone 11 64GB, Amazon Renewed) on September 4, 2026, all calls within a 15-minute window. Same page, three different buy box winners: Amazon rotates the featured offer by seller, stock, and delivery location, and each API reports the one its request saw.
| API | Price returned | Buy box seller | Rating | Reviews | Price type | Fields |
|---|---|---|---|---|---|---|
| OpenWeb Ninja | 179.99 | Woot (main_buy_box) | 4.2 | 60,049 | string, no symbol | 54 |
| Rainforest API | 179.99 | Edge Cellular (buybox_winner.fulfillment) | 4.2 | 60,049 | object: value, currency, raw | 48 |
| Oxylabs | 179.99 | Woot (buybox[0].seller_name) | 4.2 | 60,049 | number | 51 |
| Scrapingdog | $172.95 | WirelessSource (sold_by) | "4.2" | "60,049" | string with symbol | 39 |
| Bright Data | 179.99 | Woot (seller_name) | 4.2 | 60,049 | number | 99 |
| SerpApi | $179.99 and 179.99 | not in product_results | 4.0 | 60,049 | string and number | 21 in product_results |
| ScraperAPI | $172.95 | WirelessSource (sold_by) | 4.2 | 60,049 | string with symbol | 30 |
| Apify (junglee) | 179.99 | Woot (seller.name) | 4.2 | 60,049 | object: value, currency symbol | 56 |
Three things to take from this. The price differences are Amazon's, not the APIs': Woot, WirelessSource, and Edge Cellular each held the buy box at some point in the window. Only SerpApi read the rating as 4.0 while everyone else read 4.2 from the same page. And the price type matters for your code: three providers hand you a string with a currency symbol, three hand you a number, two hand you both.
OpenWeb Ninja Real-Time Amazon Data
this siteBest for: the widest set of Amazon endpoints at one flat per-request price
The Real-Time Amazon Data API documents 21 endpoints in its OpenAPI spec: search, products by category, product details, product reviews, review details, top reviews, product offers, seller profile, seller reviews, seller products, best sellers, deals, deal products, promo code details, influencer profile, influencer posts, influencer post products, ASIN to GTIN, GTIN to ASIN, category list, and scrape by URL, across 24 Amazon country codes. Every one of them costs one request. A reviews call or a seller lookup is billed exactly like a search page.
The same key also covers Walmart, eBay, Home Depot, and 40+ non-retail APIs. The free plan is 100 requests a month, no card. On reviews, the product page itself notes that Amazon's login wall limits results to 8 per call; our probe returned exactly 8 plus the rating distribution. Plans run from $25 for 10,000 requests to $2,000 for 5,000,000; the unit economics table below has the per-endpoint math.
Python example: keyword search
# openwebninja_amazon_search.py
import requests
response = requests.get(
"https://api.openwebninja.com/realtime-amazon-data/search",
headers={"x-api-key": "YOUR_API_KEY"},
params={"query": "wireless earbuds", "country": "US", "page": 1}
)
data = response.json()["data"]
print(data["total_products"], data["products"][0]["product_title"])
Response (trimmed)
{
"status": "OK",
"data": {
"total_products": 28266,
"country": "US",
"domain": "www.amazon.com",
"products": [{
"asin": "B0HBWW3958",
"product_title": "Wireless Earbuds, Bluetooth 5.3 Headphones HiFi Stereo 50H Playback LED Digital Display Ear Buds with ENC Noise Canceling Headset, IPX7 Waterproof Earphones for Gym/Running/Work(Black)",
"product_price": "$19.97",
"product_original_price": "$249.99",
"currency": "USD",
"product_star_rating": "4.8",
"product_num_ratings": 255,
"is_prime": true,
"is_amazon_choice": false,
"product_url": "https://www.amazon.com/dp/B0HBWW3958"
}, ...]
}
}
28,266 total matches and 16 products on the first page, each with ASIN, price, original price, rating, review count, Prime and badge flags, and delivery text. Median 2.2 seconds across our three search terms; 3.9 seconds for product lookups.
Pros
- +21 Amazon endpoints, including deals, promo codes, seller reviews, influencer pages, and ASIN/GTIN conversion that no one else here documents
- +Flat billing: reviews, offers, and seller lookups cost the same one request as a product page
- +Seller profile returns legal business name and address, and VAT and registration numbers for EU sellers
- +Walmart, eBay, Home Depot, and 40+ other APIs on the same key
Cons
- -Entry price is above the cheapest raw-page scrapers: $2.50/1K at Pro vs $0.50 at Oxylabs and $0.20 at Scrapingdog, narrowing to $0.75/1K at Mega and $0.40/1K on the scale plans
- -Free tier is 100 requests a month, enough to evaluate but smaller than Bright Data's 5,000
- -No Q&A endpoint and no price history
Rainforest API (Traject Data)
Best for: the deepest Amazon-only schema, if your volume justifies the Production tier
Rainforest is the longest-running dedicated Amazon API in this list, now under Traject Data, whose site carries a "Traject Data joins ScraperAPI" banner. It documents 23 request types: product, search, offers, reviews, bestsellers, category, also_bought, seller_profile, seller_feedback, seller_products, questions, question_answers, autocomplete, stock_estimation, sales_estimation, store, charts, and more, across 24 Amazon domains. Every type is 1 credit. Collections schedule batches of up to 15,000 requests with delivery to S3, GCS, or Azure.
Two caveats from our tests. The reviews type returned a 503 with "reviews request type is temporarily unavailable", and pricing is steep at low volume: Hobbyist is $23 for 500 credits, $46 per 1,000. It becomes competitive at Production, $375 for 250,000, $1.50 per 1,000, and reaches $0.45 per 1,000 on the 20,000,000-credit Volume plan.
Python example: keyword search
# rainforest_amazon_search.py
import requests
params = {
'api_key': 'YOUR_API_KEY',
'type': 'search',
'amazon_domain': 'amazon.com',
'search_term': 'wireless earbuds'
}
api_result = requests.get('https://api.rainforestapi.com/request', params)
first = api_result.json()['search_results'][0]
print(first['title'], first['price']['raw'])
Response (trimmed)
{
"request_info": {"success": true, "credits_used_this_request": 1},
"search_information": {"results_text_raw": "1-16 of over 20,000 results for \"wireless earbuds\"", "total_results": 20000},
"search_results": [{
"position": 1,
"title": "Wireless Earbuds, Bluetooth 5.3 Headphones HiFi Stereo 50H Playback LED Digital Display Ear Buds with ENC Noise Canceling Headset, IPX7 Waterproof Earphones for Gym/Running/Work(Black)",
"asin": "B0HBWW3958",
"rating": 4.8,
"ratings_total": 255,
"price": {"symbol": "$", "value": 19.97, "currency": "USD", "raw": "$19.97", "list_price": "$249.99"},
"is_prime": false
}, ...],
"pagination": {...}, "refinements": {...}, "ad_blocks": [...]
}
16 results plus pagination, refinements, and ad blocks in one credit. The structured price object carries symbol, value, currency, raw string, and list price. Median 6.7 seconds for search, 6.2 seconds for product lookups.
Pros
- +23 request types: the only provider here with Q&A, seller feedback, and stock and sales estimation
- +Collections for scheduled bulk jobs with cloud-storage delivery
- +Structured price object with symbol, value, currency, and raw string
Cons
- -$46/1K at Hobbyist and $8.30/1K at Starter; only competitive from $375/month
- -Reviews type returned 503 "temporarily unavailable" in our test
- -Amazon only; Walmart, Target, eBay, and Home Depot are separate Traject products and bills
Oxylabs Web Scraper API
Best for: cheapest parsed Amazon pages once you pass 100K a month
Oxylabs sells one Web Scraper API with per-site sources. For Amazon there are five dedicated sources, plus a generic amazon source for any Amazon URL: amazon_product, amazon_search, amazon_pricing (the offers list), amazon_sellers, and amazon_bestsellers, all with parse: true at no extra charge. There is no reviews source; our amazon_reviews attempt returned 400. Amazon pages are the cheapest bucket in their pricing: $0.50 per 1,000 on the $49 Micro plan down to $0.25 on Corporate.
The pricing page splits plans across a Regular tab (Free trial, Micro, Starter, Advanced) and an Enterprise tab (Venture, Business, Corporate, Custom+); a plain fetch of the page without JavaScript shows only five of them, which is worth knowing if you scrape pricing pages. Billing is per successfully fetched page, and a 2xx or 4xx counts even if the parser returned nothing useful.
Python example: keyword search
# oxylabs_amazon_search.py
import requests
payload = {
"source": "amazon_search",
"domain": "com",
"query": "wireless earbuds",
"parse": True
}
response = requests.post(
"https://realtime.oxylabs.io/v1/queries",
auth=("USERNAME", "PASSWORD"),
json=payload,
)
content = response.json()["results"][0]["content"]
print(content["total_results_count"], content["results"]["organic"][0]["title"])
Response (trimmed)
{
"results": [{
"content": {
"query": "wireless earbuds",
"total_results_count": 20000,
"last_visible_page": 7,
"results": {
"organic": [{
"pos": 3,
"asin": "B0HBWW3958",
"title": "Wireless Earbuds, Bluetooth 5.3 Headphones HiFi Stereo 50H Playback LED Digital Display Ear Buds with ENC Noise Canceling Headset, IPX7 Waterproof Earphones for Gym/Running/Work(Black)",
"price": 19.97,
"price_strikethrough": 249.99,
"currency": "USD",
"rating": 4.8,
"reviews_count": 255,
"is_amazons_choice": true,
"is_sponsored": false
}, ...],
"paid": [...], "amazons_choices": [...], "suggested": [...]
}
}
}]
}
Organic, paid, Amazon's Choice, and suggested results are separated, with 16 organic and 14 paid on this page, and prices are numbers. Median 2.5 seconds for search; 5.3 seconds for product lookups with one 25.8-second outlier.
Pros
- +$0.50/1K Amazon pages at $49, $0.30/1K at Business, $0.25/1K at Corporate, with parsing included
- +Offers (amazon_pricing) and sellers sources worked first time in our probes
- +2,000-result trial, no card, and the same account covers Walmart, Target, Best Buy, and Google
Cons
- -No reviews, deals, or Q&A sources for Amazon
- -Billed on any 2xx or 4xx page even when nothing parsed; one of our five product calls took 25.8 seconds
- -The help-center results table disagrees with the pricing page on per-tier Amazon allowances
Scrapingdog
Best for: the cheapest Amazon product and search pages at any budget
Scrapingdog's Amazon endpoints are product, search, offers, best sellers, reviews, and autocomplete, all on one credit pool. Product and search are 1 credit each for the US marketplace and 5 credits for any other country; on the $40 Lite plan that is 200,000 US pages, or $0.20 per 1,000, the lowest entry rate in this roundup. Best sellers, reviews, and autocomplete are 5 credits; the offers docs page does not state its cost. The search endpoint requires a page parameter; without it you get a 400.
The reviews endpoint is documented but the docs say it "cannot retrieve review data at this time" because of Amazon's login wall; our call returned a 400. Ratings and review counts come back as strings, so budget a parsing step. There is no overage: when credits run out, requests fail until the next cycle.
Python example: keyword search
# scrapingdog_amazon_search.py
import requests
params = {
"api_key": "YOUR_API_KEY",
"query": "wireless earbuds",
"domain": "com",
"country": "us",
"page": "1"
}
response = requests.get("https://api.scrapingdog.com/amazon/search", params=params)
data = response.json()
print(len(data["results"]), data["results"][0]["title"])
Response (trimmed)
{
"location": "Delivering to Sanjose 95101",
"results": [{
"type": "search_product",
"title": "Wireless Earbuds, Bluetooth 5.3 Headphones HiFi Stereo 50H Playback LED Digital Display Ear Buds with ENC Noise Canceling Headset, IPX7 Waterproof Earphones for Gym/Running/Work(Black)",
"optimized_url": "https://www.amazon.com/Fhumsh-Bluetooth-Headphones-Canceling-Waterproof/dp/B0HBWW3958",
"has_prime": false,
"is_amazon_choice": true,
"is_best_seller": false,
"sponsored": false,
"stars": "4.8",
"total_reviews": "255",
"delivery": "Join Prime to get FREE delivery Sat, Sep 5 Or Non-members get FREE delivery Tue, Sep 8 on $35 of items shipped by Amazon"
}, ...],
"sponsored_brands": [...], "pagination": [...]
}
18 results including sponsored placements flagged with a boolean, plus sponsored-brand blocks and pagination URLs. Note there is no ASIN field on search results; you parse it from the URL. Median 2.0 seconds for search, the fastest in our sample; 3.2 seconds for product lookups.
Pros
- +$0.20/1K product pages at $40; fastest search in our sample
- +Simple GET with an API key, flat JSON back; failed requests not charged
- +22 Amazon TLDs and a 200-credit free tier, no card
Cons
- -Reviews endpoint documented but non-functional; best sellers and autocomplete cost 5x, as do non-US marketplaces
- -Prices and ratings arrive as display strings, not numbers
- -No seller profile, deals, or Q&A; hard stop with no overage
Bright Data Web Scraper API
Best for: the largest free tier, and reviews and seller datasets billed per record
Bright Data packages Amazon as 14 scrapers: products by URL or ASIN, by keyword, by category, by UPC, best sellers by category, reviews, seller info, product search, and global variants of each. You pay per delivered record: $1.50 per 1,000 on pay-as-you-go, $499 for 384,000 on Scale, and 5,000 free credits every month, shared across Bright Data's scraping products, no card. Output is JSON, NDJSON, JSON lines, or CSV.
The API is a dataset trigger, not a GET. You POST an array of inputs to a dataset ID; the synchronous endpoint has a one-minute window, after which you get a 202 with a snapshot ID to poll. Keyword search is a discovery dataset that returns one record per product found, so a 16-result page is 16 records, not one request. That is why we show the product scraper here rather than search: it is the only endpoint whose cost maps to one call.
Python example: product by URL
# brightdata_amazon.py
import requests
response = requests.post(
"https://api.brightdata.com/datasets/v3/scrape",
params={"dataset_id": "gd_l7q7dkf244hwjntr0", "format": "json"},
headers={
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json",
},
json=[{"url": "https://www.amazon.com/dp/B07ZPKBL9V"}],
)
print(response.json())
Response (trimmed)
[{
"title": "Apple iPhone 11, 64GB, PRODUCT RED - Unlocked (Renewed)",
"asin": "B07ZPKBL9V",
"brand": "Apple",
"initial_price": 179.99,
"final_price": 179.99,
"currency": "USD",
"rating": 4.2,
"reviews_count": 60049,
"seller_name": "Woot",
"seller_id": "A1KWJVS57NX03I",
"availability": "In Stock",
"bought_past_month": 200,
"department": "Cell Phones & Accessories",
"timestamp": "2026-09-03T21:03:09.972Z",
...
}]
99 fields per record, numeric prices, and a seller ID you can chain into the seller scraper. Median 9.0 seconds for product lookups, the slowest of the eight; in our two days of testing, five of six synchronous calls returned inline and one came back as a snapshot to poll.
Pros
- +5,000 free credits every month (shared across its scraping products), the largest free tier here
- +Dedicated reviews, seller, best sellers, and UPC scrapers, all in the same dataset API
- +Pay-as-you-go with spend limits; only successful records billed
Cons
- -$1.30 to $1.50/1K is 3x to 7x Oxylabs and Scrapingdog for the same page
- -Slowest product lookups in our sample (9.0 s median) and an async snapshot path you must handle
- -Per-record billing makes keyword discovery expensive: one search page can be dozens of records
SerpApi
Best for: teams already paying SerpApi for Google who need occasional Amazon lookups
SerpApi has three Amazon engines: amazon (search), amazon_product, and amazon_autocomplete. Every call is one search credit; cached, failed, and errored searches are free. The parsed output is thorough, with paired string and numeric price fields and separate blocks for related searches, categories, and filters.
The problem is price. Starter is $25 for 1,000 searches, $25 per 1,000; Production is $150 for 15,000, $10 per 1,000. There is no reviews, offers, sellers, or best sellers engine. If your team already has SerpApi for Google, adding a few thousand Amazon lookups on the existing plan is reasonable. Buying it for Amazon alone is not.
Python example: keyword search
# serpapi_amazon_search.py (pip install serpapi)
import serpapi
client = serpapi.Client(api_key="YOUR_API_KEY")
results = client.search({
"engine": "amazon",
"k": "wireless earbuds",
"amazon_domain": "amazon.com"
})
print(results["search_information"]["total_results"], results["organic_results"][0]["title"])
Response (trimmed)
{
"search_information": {"total_results": 28014, "query_displayed": "wireless earbuds", "page": 1},
"organic_results": [{
"position": 1,
"asin": "B0HBWW3958",
"title": "Wireless Earbuds, Bluetooth 5.3 Headphones HiFi Stereo 50H Playback LED Digital Display Ear Buds with ENC Noise Canceling Headset, IPX7 Waterproof Earphones for Gym/Running/Work(Black)",
"rating": 4.8,
"reviews": 255,
"price": "$19.97",
"extracted_price": 19.97,
"delivery": ["Join Prime to get FREE delivery Sat, Sep 5", "Or Non-members get FREE delivery Tue, Sep 8 on $35 of items shipped by Amazon"]
}, ...],
"related_searches": [...], "categories": [...], "filters": [...], "serpapi_pagination": {...}
}
16 organic results with delivery split into an array, plus related searches, categories, and filters. Median 2.3 seconds for search, with one repeat term served from SerpApi's one-hour cache in 0.07 seconds; 5.6 seconds for product lookups.
Pros
- +Best-organized docs in the group; string and numeric price fields side by side
- +Failed and cached searches are free; Legal Shield from the Production plan up
- +Same credit pool as Google, Walmart, eBay, and Home Depot engines
Cons
- -$25/1K at Starter and $10/1K at Production, the most expensive here at every tier
- -Only three Amazon engines; no reviews, offers, sellers, or best sellers
- -Our free-plan sign-up required phone verification before the first call
ScraperAPI
Best for: teams on ScraperAPI for general scraping who want parsed Amazon pages from the same credits
ScraperAPI is a general proxy-and-render scraper with structured-data endpoints layered on top. For Amazon there are three: product, search, and offers, each with an async variant. Any Amazon structured request costs 5 credits, so the $49 Hobby plan's 100,000 credits are 20,000 Amazon pages, $2.45 per 1,000. That drops to $0.745 at Startup and under $0.50 from Business up. Only 200 and 404 responses are charged.
There is no reviews endpoint; our call to a review path returned 404. The offers endpoint worked. ScraperAPI and Rainforest share a parent company but remain separate products with separate pricing.
Python example: keyword search
# scraperapi_amazon_search.py
import requests
response = requests.get(
"https://api.scraperapi.com/structured/amazon/search",
params={"api_key": "YOUR_API_KEY", "query": "wireless earbuds", "country": "us"}
)
data = response.json()
print(len(data["results"]), data["results"][0]["name"])
Response (trimmed)
{
"results": [{
"type": "search_product",
"position": 1,
"asin": "B0HBWW3958",
"name": "Wireless Earbuds, Bluetooth 5.3 Headphones HiFi Stereo 50H Playback LED Digital Display Ear Buds with ENC Noise Canceling Headset, IPX7 Waterproof Earphones for Gym/Running/Work(Black)",
"has_prime": false,
"is_best_seller": false,
"is_amazon_choice": false,
"stars": 4.8,
"total_reviews": 255,
"price_string": "$19.97",
"price": 19.97
}, ...],
"explore_more_items": [...],
"next_pages": [...]
}
18 results with both a price string and a numeric price, plus next-page URLs. Median 3.1 seconds for search with one 14-second outlier; 3.2 seconds for product lookups, tied with Scrapingdog for fastest.
Pros
- +Fastest product lookups in our sample alongside Scrapingdog (3.2 s median)
- +Under $0.50/1K from the $299 Business plan; 22 Amazon TLDs
- +Same credits cover any URL, so Amazon pages without a structured endpoint are still reachable as HTML
Cons
- -Only product, search, and offers; no reviews, best sellers, or seller endpoints
- -5 credits per Amazon request makes the $49 plan $2.45/1K, more than OWN's $2.50 tier buys you in endpoints
- -Prices are display strings; the free plan drops to 1,000 credits (200 Amazon pages) after the trial
Apify
Best for: pay-per-result crawls when you accept container start-up time and a marketplace model
Apify is a marketplace of hosted scrapers called actors. You pay a platform plan ($0 Free with $5 of usage, $19 Starter, $199 Scale, $999 Business) that comes with the same amount of prepaid usage, and each actor bills per result out of it. Apify's own junglee/amazon-crawler handles product and search URLs at $5.00, $4.00, $3.50, and $3.00 per 1,000 results by plan. Its pay-per-event pricing adds paid events on top: offers and seller data at $1.50 to $2.50 per 1,000, and delivery-location targeting at $35 to $60 per 1,000. Reviews and best sellers are separate junglee actors at $3.00 to $6.00 and $3.20 to $5.90 per 1,000.
Every run starts a container. Our 10-item search crawls took 22 to 37 seconds and single-product runs about 8 seconds via the synchronous endpoint. Quality and schema depend on the actor developer, and the older rental pricing model is retired as of October 2026.
Python example: keyword search
# apify_amazon_search.py (pip install apify-client)
from apify_client import ApifyClient
client = ApifyClient("YOUR_API_TOKEN")
run_input = {
"categoryOrProductUrls": [{ "url": "https://www.amazon.com/s?k=wireless+earbuds" }],
"maxItemsPerStartUrl": 10,
"maxSearchPagesPerStartUrl": 1,
"proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
"maxOffers": 0,
}
run = client.actor("junglee/amazon-crawler").call(run_input=run_input)
for item in client.dataset(run.default_dataset_id).iterate_items():
print(item["asin"], item["title"])
Response (trimmed)
{
"title": "ZIHNIC Wireless Bluetooth Earphones Ear Hooks IPX5 iOS Android Black",
"asin": "B0HC6PCLFP",
"url": "https://www.amazon.com/dp/B0HC6PCLFP",
"price": {"value": 33.99, "currency": "$"},
"listPrice": {"value": 35.99, "currency": "$"},
"stars": null,
"reviewsCount": null,
"inStock": true,
"brand": "ZIHNIC",
"breadCrumbs": "Electronics > Headphones, Earbuds & Accessories > Headphones & Earbuds > Open-Ear Headphones"
}
... 9 more items, one per dataset row
The crawler visits each result's product page, so search items carry product-page fields such as list price and breadcrumbs, but the first item's stars and review count came back null and the ordering differs from Amazon's search page. Median 25.2 seconds for a 10-item crawl; 8.3 seconds for a single product.
Pros
- +Richest default item in the group: star breakdown, best-seller ranks, seller ID, breadcrumbs
- +Reviews and best sellers actors exist; $19 entry with pay per result
- +Scheduling, storage, and webhooks are part of the platform
Cons
- -$3 to $5/1K base plus paid add-ons for offers, sellers, and delivery location
- -Slowest in our sample for search (25 s median) because each run boots a container
- -Schema and reliability depend on the actor developer, and pricing versions change
Amazon Unit Economics: Cost per 1,000 Requests by Endpoint
Published pricing on September 4, 2026, converted to cost per 1,000 requests of each Amazon endpoint type. The first figure is the entry paid plan, the second is the cheapest listed self-serve tier. Where a provider bills per record or per result, a search page counts as one request only if the provider bills it that way. Full plan ladders for seven of these providers are in the e-commerce roundup.
| API (entry plan to cheapest tier) | Product page | Search page | Offers list | Reviews | Best sellers | Seller profile | How units are counted |
|---|---|---|---|---|---|---|---|
| OpenWeb Ninja ($25 Pro to $2,000 Mega-Scale) | $2.50 to $0.40 | $2.50 to $0.40 | $2.50 to $0.40 | $2.50 to $0.40 (8 reviews per call) | $2.50 to $0.40 | $2.50 to $0.40 | 1 request per call, any endpoint |
| Rainforest ($23 Hobbyist to $9,000 Volume) | $46.00 to $0.45 | $46.00 to $0.45 | $46.00 to $0.45 | same rate; returned 503 in our test | $46.00 to $0.45 | $46.00 to $0.45 | 1 credit per request, any type |
| Oxylabs ($49 Micro to $2,000 Corporate) | $0.50 to $0.25 | $0.50 to $0.25 | $0.50 to $0.25 (amazon_pricing) | no source | $0.50 to $0.25 | $0.50 to $0.25 (amazon_sellers) | 1 result per fetched page |
| Scrapingdog ($40 Lite to $500 Business) | $0.20 to $0.056 (US); 5x elsewhere | $0.20 to $0.056 (US); 5x elsewhere | cost not published | $1.00 to $0.28; non-functional | $1.00 to $0.28 | no endpoint | 1 credit product/search in the US, 5 credits other countries, best sellers, reviews |
| Bright Data (PAYG to $499 Scale) | $1.50 to $1.30 | $1.50 to $1.30 per product found | fields only | $1.50 to $1.30 per review record | $1.50 to $1.30 per product record | $1.50 to $1.30 per seller record | 1 record per delivered row; discovery returns many rows per query |
| SerpApi ($25 Starter to $2,750 Infrastructure) | $25.00 to $5.50 | $25.00 to $5.50 | no engine | no engine | no engine | no engine | 1 search per call; Cloud tiers reach about $1.96 |
| ScraperAPI ($49 Hobby to $1,975 Advanced) | $2.45 to $0.46 | $2.45 to $0.46 | $2.45 to $0.46 | no endpoint | no endpoint | no endpoint | 5 credits per Amazon structured request |
| Apify junglee ($19 Starter to $999 Business) | $4.00 to $3.00 | $4.00 to $3.00 per result | +$2.00 to $1.50 add-on | $5.00 to $3.00 per 1K reviews (separate actor) | $5.00 to $3.20 per 1K items (separate actor) | +$2.00 to $1.50 add-on | per dataset item plus paid events |
| Keepa (49 EUR Starter) | about 0.05 EUR (1 token) | about 0.55 EUR (10 tokens per page) | about 0.33 EUR per offer page (6 tokens) | rating and review-count history only | about 2.74 EUR per list (50 tokens) | about 0.05 EUR (1 token) | tokens: 20 per minute, 892,800 per month, expire after 60 minutes |
| Creators API (free) | free | free | buy box only | none | sales rank field only | none | 1 request per second, 8,640 per day, grows with referral revenue |
Read across, not down. Scrapingdog is the cheapest product page here and among the most expensive reviews page, because reviews cost five credits and do not currently work. Rainforest and OpenWeb Ninja charge the same for every endpoint, which is why their columns are flat. Bright Data and Apify look cheap per unit until a search returns 40 units. Keepa's per-request figures assume you use the full 892,800 monthly tokens; the plan costs 49 EUR whether you do or not.
Measured Response Time (Same 5 ASINs, Same 3 Searches):
One request to each provider's Amazon product endpoint per ASIN (B07ZPKBL9V, B0CHX3QBCH, B09G9FPHY6, B0BSHF7WHW, B08L5NP6NG), and one request to each provider's Amazon search endpoint per term (wireless earbuds, standing desk, air purifier), on September 4, 2026, from a single machine in Israel. Every call succeeded. Small sample; it tells you the order of magnitude, not the tail.
| API | Product median | Product range | Search median | Search range | Product fields |
|---|---|---|---|---|---|
| OpenWeb Ninja | 3.9 s | 3.8 to 4.8 s | 2.2 s | 1.9 to 2.3 s | 54 |
| Rainforest API | 6.2 s | 4.9 to 10.3 s | 6.7 s | 5.0 to 7.0 s | 48 |
| Oxylabs | 5.3 s | 4.8 to 25.8 s | 2.5 s | 2.5 to 2.9 s | 51 |
| Scrapingdog | 3.2 s | 2.6 to 4.2 s | 2.0 s | 1.8 to 2.4 s | 39 |
| Bright Data | 9.0 s | 5.7 to 9.9 s | not run | billed per product found | 99 |
| SerpApi | 5.6 s | 5.4 to 8.2 s | 2.3 s | 0.07 (cache) to 2.3 s | 21 in product_results |
| ScraperAPI | 3.2 s | 2.5 to 7.2 s | 3.1 s | 3.0 to 14.2 s | 30 |
| Apify (junglee) | 8.3 s | 8.0 to 10.1 s | 25.2 s (10 items) | 21.6 to 37.2 s | 56 |
Field counts are top-level keys in the product object for ASIN B07ZPKBL9V. More fields is not automatically better; check that the ones you need are populated. Apify search returned 10 items per run, so its time covers a crawl, not a single page.
Amazon Endpoint Coverage
What each provider documents for Amazon, with the result of our single probe call where we made one. "Documented" means listed in the provider's docs but not called by us. The Creators API and Keepa are included for reference.
| Endpoint | OpenWeb Ninja | Rainforest | Oxylabs | Scrapingdog | Bright Data | SerpApi | ScraperAPI | Apify | Creators API | Keepa |
|---|---|---|---|---|---|---|---|---|---|---|
| Product by ASIN | ✅ tested | ✅ tested | ✅ tested | ✅ tested | ✅ tested | ✅ tested | ✅ tested | ✅ tested | ✅ getItems | ✅ 1 token |
| Keyword search | ✅ tested | ✅ tested | ✅ tested | ✅ tested | documented, per record | ✅ tested | ✅ tested | ✅ tested | ✅ searchItems | ✅ 10 tokens/page |
| Offers / buy box list | ✅ tested | ✅ tested | ✅ tested (amazon_pricing) | documented, 5 credits | fields only | ❌ | ✅ tested | paid add-on event | buy box only | ✅ 6 tokens/page |
| Reviews | ✅ tested (8 per call) | 503 "temporarily unavailable" | ❌ (400) | documented, non-functional (400) | documented | ❌ | ❌ (404) | separate actor | ❌ | rating history only |
| Best sellers | ✅ | ✅ | ✅ | ✅ 5 credits | ✅ by category | ❌ | ❌ | separate actor | sales rank field only | ✅ 50 tokens/list |
| Seller profile | ✅ tested | ✅ | ✅ amazon_sellers | ❌ | ✅ | ❌ | ❌ | paid add-on event | ❌ | ✅ 1 token |
| Deals | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ 5 tokens/150 |
| Questions & answers | ❌ | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |
| Price history | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ |
| Marketplaces | 24 | 24 | domain param | 22 | URL | amazon_domain | 22 | URL | 22, approved only | 11 |
| Billing unit | request | credit | page | weighted credit | record | search | 5 credits | result + events | free, rate-limited | token |
The Official Route: Amazon's Creators API (PA-API 5 Is Deprecated)
If you search for "Amazon product API" you will find guides to Product Advertising API 5.0. As of September 2026 it is gone. Every PA-API 5 documentation URL we tried redirected to a deprecation notice, which states that calls now return HTTP 403 with AccessDeniedException and the message "Product Advertising API is deprecated. Please migrate to Creators API using the migration guide." The successor is the Creators API: REST, OAuth 2.0 client credentials, lowerCamelCase fields.
Eligibility is the catch. The docs require an approved Amazon Associates account with "at least 10 qualifying sales within the past 30 days", and access is revoked after 30 consecutive days without qualified referring sales. New credentials get 1 request per second and 8,640 per day; limits grow by one request per day for every five cents of shipped revenue you refer, up to 10 requests per second. Amazon's docs list no fee.
What you do not get: customer reviews (no review resource exists), third-party offer listings (OffersV2 "provides only featured listings as shown to retail customers on Amazon Detail Page buybox"), or any history. Items can also come back as "not accessible through the Creators API." That gap is why the eight scraping APIs above exist.
Request (from the Creators API docs, verbatim)
# Step 1: token. Step 2: getItems. Both copied from the "Using cURL" docs page.
curl -X POST https://api.amazon.com/auth/o2/token \
-H "Content-Type: application/json" \
-d '{"grant_type": "client_credentials", "client_id": "YOUR_CLIENT_ID", "client_secret": "YOUR_CLIENT_SECRET", "scope": "creatorsapi::default"}'
curl -X POST https://creatorsapi.amazon/catalog/v1/getItems \
-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
-H "Content-Type: application/json" \
-H "x-marketplace: www.amazon.com" \
-d '{"itemIds": ["B09B2SBHQK", "B09B8V1LZ3"], "itemIdType": "ASIN", "marketplace": "www.amazon.com", "partnerTag": "xyz-20", "resources": ["images.primary.small", "itemInfo.title", "itemInfo.features", "parentASIN"]}'
Response (from the getItems docs page, trimmed)
{
"errors": [{"code": "ItemNotAccessible", "message": "The ItemId B01180YUXS is not accessible through the Creators API."}],
"itemResults": {
"items": [{
"asin": "B0199980K4",
"detailPageURL": "https://www.amazon.com/dp/B0199980K4?tag=xyz-20&linkCode=ogi&language=en_US&th=1&psc=1",
"itemInfo": {"title": {"displayValue": "Genghis: The Legend of the Ten", "label": "Title", "locale": "en_US"}},
"parentASIN": "B07QGKM68X"
}, ...]
}
}
Copied from the getItems reference and the cURL guide. We did not run these calls: the Creators API requires an Associates account with recent qualifying sales, which a research account does not have. Price arrives under an offersV2.listings.price resource as money.amount, currency, and displayAmount.
Price History: Keepa
Every API above returns the page as it is right now. Keepa returns how it got there. Its product object carries history arrays for Amazon, new, used, buy box, list price, sales rank, rating, review count, and offer counts, plus aggregated statistics such as 30-, 90-, 180-, and 365-day averages, out-of-stock percentages, and sales-rank drop counts. It covers 11 marketplaces and, in its own words, "more than 7 billion products."
There is no free API tier. Plans are prepaid monthly and priced by token rate: Starter is 49 EUR per month for 20 tokens per minute (Keepa states this as 892,800 tokens per month), Developer is 459 EUR for 250 per minute, Business is 2,499 EUR for 2,000, Enterprise is 11,099 EUR for 10,000. A product lookup costs 1 token; adding live offers costs 6 tokens per offer page; searches cost 10 per result page. Unused tokens expire after 60 minutes, so the bucket never holds more than an hour of accrual.
Request (from the Keepa docs, verbatim)
# From keepa.com/api-docs/request-basics.html
curl -s --compressed "https://api.keepa.com/product?key=YOUR_API_KEY&domain=1&asin=B0F3GWXLTS"
Response (from the Keepa docs, which label the values illustrative, trimmed)
{
"tokensLeft": 297,
"refillIn": 42000,
"refillRate": 5,
"tokensConsumed": 1,
"processingTimeInMs": 812,
"products": [{
"asin": "B0F3GWXLTS",
"domainId": 1,
"title": "Example Wireless Bluetooth Speaker (Black)",
"brand": "examplebrand",
"lastPriceChange": 7663520,
"csv": [
[7650120, 2999, 7658340, 3199, 7663520, 3099], // AMAZON price history: Keepa-time minutes, cents
[7650120, 2799, 7660100, 2749, 7663520, 2699], // NEW
null, // USED
[7650120, 5310, 7663880, 4874] // SALES rank
]
}]
}
Copied from the Product Request docs. We created a Keepa account but did not subscribe, so this block is Keepa's documented example rather than our own call. Prices are integers in the smallest currency unit and timestamps are "Keepa Time" minutes (Unix minutes minus 21,564,000). The stats object adds buyBoxPrice, averages, and salesRankDrops30 when requested.
How to Choose: 4 Common Scenarios
Product, offers, reviews, and seller data in one pipeline
You go from a search to an ASIN to its offers to the seller behind each offer, and you want each hop to cost the same and come from the same key.
Best choice: OpenWeb Ninja. Twenty-one endpoints at one request each, and the only provider here that returned reviews in our tests without a workaround. Rainforest is the alternative if you also need Q&A or seller feedback and can spend $375 a month.
Bulk product pages, hundreds of thousands a month
Price and availability across a large catalog, several times a day. Cost per million matters more than fields.
Best choice: Scrapingdog for the raw price ($0.09/1K at Standard) or Oxylabs for numeric fields and a stable parser ($0.45/1K at Starter). Both were also the fastest for search in our sample. OpenWeb Ninja's scale plans reach $0.40/1K at 5M requests if you need the other endpoints at the same rate.
Repricing or research that needs history
You need to know what a product sold for last quarter, how often it went out of stock, or how many sales-rank drops it logged.
Best choice: Keepa, from 49 EUR per month. No scraping API here stores history. If you only need history going forward, poll any of the eight on a schedule and store the results yourself.
You are an Amazon Associate with steady sales
You build affiliate content and already clear 10 qualifying sales a month.
Best choice: the Creators API is free and official, with tracked affiliate links in every response. Pair it with one of the scraping APIs for reviews and third-party offers, which it does not return, and watch the 8,640-request daily cap until your revenue raises it.
Pricing Sources
Every price in this article was read from the page below on September 4, 2026. Providers change plans without notice; if a number here disagrees with the live page, the live page wins.
- OpenWeb Ninja: openwebninja.com/api/real-time-amazon-data (Pricing and Scale tabs)
- Rainforest API: trajectdata.com/pricing/rainforest-api (monthly and annual toggle); trial size from app.rainforestapi.com/signup
- Oxylabs: oxylabs.io/products/scraper-api/web/pricing
- Scrapingdog: scrapingdog.com/pricing and the credit table on the same page
- Bright Data: brightdata.com/pricing/web-scraper
- SerpApi: serpapi.com/pricing
- ScraperAPI: scraperapi.com/pricing; credit costs from docs.scraperapi.com
- Apify: apify.com/pricing and the Pricing tab on apify.com/junglee/amazon-crawler
- Keepa: keepa.com/#!api (Pricing Plans tab) and keepa.com/api-docs/plans-tokens.html
- Creators API: API rates, introduction, and the PA-API 5 deprecation notice
FAQ
Most common questions and answers
Is there an official Amazon product data API?
Which Amazon API is cheapest per product page?
Can I get Amazon reviews through an API in 2026?
Which Amazon API returns price history?
How many Amazon marketplaces do these APIs cover?
Why do different Amazon APIs return different prices for the same ASIN?
Are credits the same as requests?
Is scraping Amazon product data legal?
About the author

Adam Ben-Ayoun
CTO @ OpenWeb Ninja
Adam leads engineering at OpenWeb Ninja, building the APIs and infrastructure that make public web data accessible to developers and AI agents.
Connect on LinkedInOne key. 40+ APIs. Start free.
100 free Amazon requests a month, no credit card. Products, search, offers, reviews, best sellers, deals, sellers, and influencers, across 24 marketplaces, plus Walmart, eBay, Home Depot, SERP, Maps, and Jobs on the same key.
Didn't find the API you are looking for? Request an API
