Roundup

September 3, 2026 · 19 min read

Best E-Commerce APIs in 2026: 7 Tested and Compared

Amazon, Walmart, eBay, and Home Depot product data without maintaining a scraper. We pulled the published pricing of 7 providers on the same day, ran the same Amazon product lookup through each one, and worked out the cost per 1K requests.

Adam Ben-Ayoun

Author

Adam Ben-Ayoun

CTO · OpenWeb Ninja

E-Commerce API · Amazon Scraper API · Python · API Comparison

Best e-commerce APIs in 2026, tested and compared

Quick Answer: Best E-Commerce APIs at a Glance

Prices are what each provider published on September 3, 2026, monthly billing. "Per 1K" is the cost of 1,000 Amazon product-page requests on the entry paid plan.

APIBest forEntry paid planPer 1K (entry)Free tierRetailers
OpenWeb NinjaMulti-retailer data under one key$25 / 10K req$2.50100/moAmazon, Walmart, eBay, Home Depot, Costco, Wayfair, Google Shopping
OxylabsLowest per-page price with parsed JSON$49 / 98K results$0.502,000 (trial)Amazon, Walmart, Target, Best Buy, Etsy, Google Shopping, eBay (HTML)
ScrapingdogCheapest Amazon product pages$40 / 200K credits$0.20 (US)200 creditsAmazon, Walmart (5 cr), eBay (5 cr), Google Shopping (10 cr)
Bright DataBiggest free tier, no monthly commitmentPAYG $1.50 / 1K$1.505,000/moAmazon, Walmart, Target, Best Buy, Etsy, Google Shopping
Rainforest APIAmazon-only depth (Collections, zip targeting)$23 / 500 credits$46.00100 (trial)Amazon only
SerpApiTeams already on SerpApi for Google$25 / 1K searches$25.00250/moAmazon, Walmart, eBay, Home Depot, Google Shopping
ApifyLong-tail retailers via community actors$19 + $4 / 1K results$4.00$5 usage/moAnything with an actor; quality varies

Per-1K figures assume you use the full plan allotment. A plan you only half use costs twice as much per request.

How We Evaluated

"E-commerce API" covers two different products. Some providers sell a parsed endpoint per retailer: send an ASIN, get a product object. Others sell a general scraper that happens to have an Amazon parser attached. Both appear here because buyers compare them, but the pricing units are not the same, so we normalized everything to one question: what does it cost to look up 1,000 Amazon product pages, and what else do you get for the same account?

  • What we tested: one thing, on every provider: the Amazon product-page endpoint, looked up by ASIN. The code samples and response blocks all use ASIN B07ZPKBL9V. The latency sample adds four more ASINs (B0CHX3QBCH, B09G9FPHY6, B0BSHF7WHW, B08L5NP6NG). We did not benchmark Walmart, eBay, Home Depot, search, or reviews endpoints; retailer coverage beyond Amazon is compared on documentation, not on calls.
  • Pricing: every number below was read from the provider's public pricing page or documentation on September 3, 2026. Where a page contradicted another page on the same site, we say so. Monthly billing unless stated.
  • Unit conversion: credits, results, records, and searches were converted to cost per 1,000 Amazon product requests, then to the monthly bill at 10K, 50K, and 200K requests.
  • Retailer coverage: only retailers with a documented, dedicated endpoint or scraper count. "Listed on the marketing page" did not.
  • Code and responses: every code block below was executed as printed on September 3, 2026 (only the placeholder key swapped for a real one), all against the same ASIN, B07ZPKBL9V. Every response block is trimmed from the JSON that call returned. Six providers were tested on free accounts created for this article; SerpApi was tested with an existing OpenWeb Ninja account.
  • Response time: we requested the same five ASINs once each from one machine on the same afternoon and report the median. Five calls is a smoke test, not a benchmark; treat the numbers as indicative.
  • Order: providers are ordered by how many readers we expect each to fit, not strictly by price. The cheapest option is not first.

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, and the cons in our own section are real.

#1

OpenWeb Ninja

this site

Best for: Amazon, Walmart, eBay, Home Depot, Costco, and Wayfair data under one key

OpenWeb Ninja sells a parsed endpoint per retailer. The Real-Time Amazon Data API has separate endpoints for product search, product details, offers, reviews, best sellers, deals, seller profiles, and influencer pages, across 24 Amazon marketplaces. The same account and key also cover Walmart (US and Canada), eBay (20 domains), Home Depot, Costco, Wayfair, and Google Shopping.

Billing is one request, one unit, whatever the endpoint. A reviews call costs the same as a product call. That matters when you compare against credit-weighted providers below, where reviews or Walmart pages cost 5x a plain Amazon product page.

Every API here uses the same four plan tiers, so adding Walmart to an Amazon pipeline is a second subscription on the same key at the same prices, not a new vendor. The free plan is 100 requests per month per API, no card required.

Python example

# openwebninja_amazon.py

import requests

 

response = requests.get(

"https://api.openwebninja.com/realtime-amazon-data/product-details",

headers={"x-api-key": "YOUR_API_KEY"},

params={"asin": "B07ZPKBL9V", "country": "US"}

)

product = response.json()["data"]

print(product["product_title"], product["product_price"])

Response (trimmed)

{

"status": "OK",

"data": {

"asin": "B07ZPKBL9V",

"product_title": "Apple iPhone 11, 64GB, PRODUCT RED - Unlocked (Renewed)",

"product_price": "179.99",

"currency": "USD",

"country": "US",

"product_star_rating": "4.2",

"product_num_ratings": 60044,

"product_availability": "In Stock",

"product_num_offers": 17,

"sales_volume": "200+ bought in past month",

"is_prime": false,

"climate_pledge_friendly": false,

"rating_distribution": {"1": 11, "2": 3, "3": 5, "4": 12, "5": 69},

"category_path": [{"name": "Cell Phones & Accessories"}, {"name": "Cell Phones"}],

"about_product": ["This phone is unlocked and compatible with any carrier of choice..."],

"product_information": {"Operating System": "iOS 16", "Memory Storage Capacity": "64 GB", ...}

}

}

The full response is 54 top-level fields, including product_photos, product_variations, coupon_text, deal_badge, and rating_distribution. Across the same five ASINs used for every provider below, product-details returned in a median of 3.7 seconds (3.3 to 4.8); search calls returned in 2.5 to 2.9 seconds.

Pricing (same tiers on every retailer API)

PlanPrice/moRequests/moPer 1K reqOverage
Free$0100-hard limit
Pro$2510,000$2.50$0.003/req
Ultra$7550,000$1.50$0.002/req
Mega$150200,000$0.75$0.001/req
Pay As You Go$0none$5.00$0.005/req

Real-Time Amazon Data also lists scale plans: $300 for 500K ($0.60/1K), $500 for 1M ($0.50/1K), and $2,000 for 5M ($0.40/1K). Custom plans with hard caps are available on request.

Pros

  • +Seven retail sources plus 40+ other APIs (SERP, Maps, Jobs, Finance) on one key
  • +Flat per-request billing: reviews, offers, and sellers cost the same as a product page
  • +Seller Profile returns business_name, business_address, and for EU-registered sellers business_vat_number and business_registration_number (seen live on amazon.de)
  • +A Wayfair endpoint, which none of the other six document; Costco is otherwise only in Oxylabs

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, though the gap narrows to $0.75/1K at Mega and $0.40/1K on the scale plans
  • -Free tier is 100 requests per API per month, enough to evaluate but smaller than Bright Data's 5,000
  • -No Target, Best Buy, or Etsy endpoints yet; each retailer is subscribed separately, on the same key and tiers
#2

Oxylabs Web Scraper API

Best for: the lowest per-page price with parsed JSON at 100K+ pages a month

Oxylabs sells one Web Scraper API with per-site "sources". For Amazon there are amazon_product, amazon_search, amazon_pricing, amazon_sellers, and amazon_bestsellers, all with parse: true at no extra charge. Walmart, Target, Best Buy, Etsy, and Google Shopping have parsed sources too. eBay returns HTML only. Home Depot and Wayfair appear on the marketing page but have no dedicated target in the docs, so they fall to the generic scraper at the higher "other" rate.

You pay per successfully fetched page, and the rate depends on the target: Amazon pages are the cheapest bucket at $0.50 down to $0.25 per 1,000; Google is $1.00 down to $0.50; everything else is $1.15 down to $0.70; JavaScript rendering pushes a page to $1.35 down to $0.95. A 2xx or 4xx counts as billable even if the parser returned nothing useful, which the billing docs state explicitly. Auth is HTTP Basic with an API user, and requests are POSTs to a realtime endpoint rather than GETs.

Python example

# oxylabs_amazon.py - the request we ran on September 3, 2026

import requests

 

payload = {

"source": "amazon_product",

"domain": "com",

"query": "B07ZPKBL9V",

"parse": True

}

response = requests.post(

"https://realtime.oxylabs.io/v1/queries",

auth=("USERNAME", "PASSWORD"),

json=payload,

)

content = response.json()["results"][0]["content"]

print(content["title"], content["price"])

Response (trimmed)

{

"results": [{

"content": {

"url": "https://www.amazon.com/dp/B07ZPKBL9V?language=en_US",

"asin": "B07ZPKBL9V",

"title": "Apple iPhone 11, 64GB, PRODUCT RED - Unlocked (Renewed)",

"brand": "Apple",

"manufacturer": "Amazon Renewed",

"price": 179.99,

"price_buybox": 179.99,

"currency": "USD",

"stock": "In Stock",

"rating": 4.2,

"reviews_count": 60050,

"is_prime_eligible": false,

"parse_status_code": 12000

},

"status_code": 200,

"job_id": "7501257744884731906",

...

}]

}

The parsed product arrives inside results[0].content with 51 keys for this ASIN, and prices are numbers. Across our five test ASINs the median response was 3.3 seconds, the tightest spread of the four providers we measured.

Pricing

PlanPrice/moAmazon results/moAmazon per 1KOther sites per 1K
Free trial$02,000--
Micro$4998,000$0.50$1.15
Starter$99220,000$0.45$1.10
Advanced$249622,500$0.40$0.95
Venture$4991,350,000$0.37$0.85
Business$9993,330,000$0.30$0.75
Corporate$2,0008,000,000$0.25$0.70

No annual discount shown. The pricing page splits these across a Regular tab (through Advanced) and an Enterprise tab (Venture and up, plus a Custom+ tier with custom pricing). Oxylabs' help-center results table gives different Amazon allowances for Starter, Venture, and Corporate than the pricing page; we use the pricing page.

Pros

  • +$0.50/1K Amazon pages at $49, and $0.25/1K at scale, with parsing included
  • +Documented parsed targets for Amazon, Walmart, Target, Best Buy, Etsy, Costco, and Lowe's; 25 retailers named on the marketing page
  • +2,000-result free trial, no card, self-serve through Business

Cons

  • -$49 minimum. Overkill if you need 5,000 lookups a month
  • -Billed on any 2xx/4xx page, even when the parser returns nothing useful
  • -eBay is HTML only; Home Depot and Wayfair have no dedicated parser
#3

Scrapingdog

Best for: the cheapest Amazon product pages on any budget

Scrapingdog is a general scraping API with dedicated Amazon, Walmart, eBay, Flipkart, Myntra, and Google Shopping endpoints, all on one credit pool. An Amazon product or search page is 1 credit for the US marketplace (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 by a wide margin. Standard at $90 for 1,000,000 credits is $0.09 per 1,000.

The catch is the weighting. Amazon reviews and best sellers are 5 credits. Walmart and eBay pages are 5 credits. Google Shopping is 10. Amazon search with premium=true is 25. So Walmart on Lite is $1.00 per 1,000, and a reviews-heavy pipeline costs 5x the headline rate. There is no overage: when credits run out, requests return an over-limit response until the next billing date. Failed requests are not charged. No Home Depot, Target, or Best Buy endpoints exist in the docs.

Python example

# scrapingdog_amazon.py - the request we ran on September 3, 2026

import requests

 

params = {

"api_key": "YOUR_API_KEY",

"domain": "com",

"asin": "B07ZPKBL9V",

"country": "us"

}

 

response = requests.get("https://api.scrapingdog.com/amazon/product", params=params)

data = response.json()

print(data["title"], "-", data["price"])

Response (trimmed)

{

"title": "Apple iPhone 11, 64GB, PRODUCT RED - Unlocked (Renewed)",

"location": "Delivering to Atlanta 30301",

"parent_asin": "B0GR1S2JM2",

"brand": "Amazon Renewed Store",

"price": "$172.95",

"price_symbol": "$",

"is_amazon_choice": false,

"number_of_people_bought": "200+ bought in past month",

"availability_status": "In Stock",

"average_rating": "4.2",

"total_reviews": "60,050",

"sold_by": "WirelessSource",

...

}

A flat object with 40 keys and no request envelope. Note that price, average_rating, and total_reviews are strings, so budget a parsing step. The $172.95 here is a different buy box from the $179.99 that Oxylabs, Bright Data, Rainforest, and Apify returned, and from the $172.00 SerpApi saw, all on the same ASIN within a couple of hours; Amazon rotates the offer, the APIs report what they saw. Median response across our five ASINs was 2.8 seconds, the fastest of the four we measured.

Pricing (first five of 27 paid tiers)

PlanPrice/moCredits/moAmazon product per 1KWalmart / eBay per 1K
Free$0200--
Lite$40200,000$0.20$1.00
Standard$901,000,000$0.09$0.45
Pro$2003,000,000$0.067$0.33
Premium$3506,000,000$0.058$0.29

Annual billing is 10 months for 12. Tiers continue to $30,000/month for 1.1 billion credits. No overage; hard stop at the credit limit.

Pros

  • +$0.20/1K Amazon product pages at $40. Nothing else here is close at that spend
  • +Simple GET with an API key, flat JSON object back
  • +Failed requests are not charged; 200 free credits, no card

Cons

  • -5x credit weight on Walmart, eBay, reviews, and best sellers; 10x on Google Shopping
  • -Prices come back as display strings, not numbers
  • -No Home Depot, Target, or Best Buy; hard stop with no overage when credits run out
#4

Bright Data Web Scraper API

Best for: a large recurring free tier and pay-as-you-go with no monthly commitment

Bright Data packages its scrapers as datasets: 14 for Amazon (product by URL or ASIN, keyword, category, best sellers, reviews, sellers), 10 for Walmart, 10 for Home Depot, plus eBay, Wayfair, Target, Best Buy, Etsy, and Google Shopping. Output is JSON, NDJSON, JSON lines, or CSV. You pay per successfully delivered record, $1.50 per 1,000 on pay-as-you-go or $499 for 384,000 records on Scale ($1.30 per 1,000, same rate for additional records). The free tier is 5,000 credits every month, shared across Bright Data's scraping products, with no card.

The API is different from everyone else here. You POST an array of inputs to a dataset ID with a Bearer token. The synchronous endpoint has a one-minute timeout; if it cannot finish, you get a 202 with a snapshot ID and poll for the result. Records, not requests, are the unit: one ASIN is one record, but discovery scrapers return one record per product found, so check the record count before assuming a keyword search costs one unit.

Python example

# brightdata_amazon.py - the request we ran on September 3, 2026 (same shape as the docs quickstart)

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": 60050,

"seller_name": "Woot",

"seller_id": "A1KWJVS57NX03I",

"availability": "In Stock",

"bought_past_month": 200,

"department": "Cell Phones & Accessories",

"timestamp": "2026-09-03T12:40:37.883Z",

...

}]

98 fields per record, numeric prices, and a seller ID you can chain into a seller lookup. Five of our six synchronous calls returned records inline with a median of 9.5 seconds and a slowest of 16.6 seconds; the sixth hit the one-minute window and came back as a 202 with a snapshot_id to poll, so the code above must handle both shapes.

Pricing

PlanPrice/moRecords/moPer 1K recordsAdditional
Free$05,000-resets monthly
Pay as you gononeas used$1.50$1.50/1K
Scale$499384,000$1.30$1.30/1K
Enterprisecustomcustomcustom-

A promo code on the pricing page offered 25% off for 3 months at the time of writing (product pages said 6 months). The site-wide pricing menu shows "$0.75/1k rec" for Scraper APIs, which does not appear on any plan card; we used the cards.

Pros

  • +5,000 free credits every month (shared across its scraping products), the largest free tier here
  • +Pay-as-you-go with spend limits and no plan fee; only successful records billed
  • +Numeric prices and clean field names out of the box

Cons

  • -$1.30 to $1.50/1K is 3x to 6x Oxylabs for the same Amazon page
  • -Async snapshot flow on anything that exceeds the one-minute sync window
  • -Dedicated eBay and Wayfair scrapers could not be confirmed from a product page
#5

Rainforest API (Traject Data)

Best for: Amazon-only teams that want Collections, zip-code targeting, and a mature schema

Rainforest is the longest-running dedicated Amazon API in this list. Traject Data owns it, and the site now carries a "Traject Data joins ScraperAPI" banner, though the API host and plans are unchanged. It is Amazon only: Walmart (BlueCart), Target (RedCircle), Home Depot (BigBox), and eBay (Countdown) are separate Traject products, each with its own subscription starting at $18 per month on annual billing.

The schema is deep: buy box winner, A+ content, variants, bestseller ranks, top reviews, frequently-bought-together, and 23 request types including seller feedback, Q&A, and sales estimation. A product page is 1 credit. Collections let you schedule batches of up to 15,000 requests and receive results by webhook or S3. Pricing is the issue at low volume: Hobbyist is $23 for 500 credits, or $46 per 1,000. It only gets competitive at Production ($375 for 250,000, $1.50 per 1,000) and above.

Python example

# rainforest_amazon.py - the request we ran on September 3, 2026 (same shape as the docs example)

import requests

import json

 

# set up the request parameters

params = {

'api_key': 'YOUR_API_KEY',

'type': 'product',

'amazon_domain': 'amazon.com',

'asin': 'B07ZPKBL9V'

}

 

# make the http GET request to Rainforest API

api_result = requests.get('https://api.rainforestapi.com/request', params)

 

# print the JSON response from Rainforest API

print(json.dumps(api_result.json()))

Response (trimmed)

{

"request_info": {"success": true, "credits_used_this_request": 1, "credits_remaining": 98},

"request_parameters": {"type": "product", "amazon_domain": "amazon.com", "asin": "B07ZPKBL9V"},

"request_metadata": {"created_at": "2026-09-03T14:52:25.843Z", "total_time_taken": 7.1, "amazon_url": "https://www.amazon.com/dp/B07ZPKBL9V?th=1&psc=1"},

"product": {

"title": "Apple iPhone 11, 64GB, PRODUCT RED - Unlocked (Renewed) 64GB (PRODUCT) RED Unlocked Renewed",

"asin": "B07ZPKBL9V",

"parent_asin": "B0GR1S2JM2",

"brand": "Apple",

"rating": 4.2,

"ratings_total": 60049,

"bestsellers_rank": [{"rank": 22, "category": "Amazon Renewed"}, ...],

"buybox_winner": {

"is_prime": false,

"condition": {"is_new": true},

"price": {"symbol": "$", "value": 179.99, "currency": "USD", "raw": "$179.99"}

},

...

}

}

The request_info envelope tells you the credit balance on every call. The product object had 48 keys for this ASIN, and the buy box price arrives as a structured object with a numeric value. Median response across our five ASINs was 7.9 seconds, with one outlier at 21.7 seconds.

Pricing

PlanPrice/mo (monthly)Price/mo (annual)Credits/moPer 1K (monthly)Overage per credit
Trial$0-100--
Hobbyist$23$18500$46.00$0.06
Starter$83$6610,000$8.30$0.0118
Production$375$300250,000$1.50$0.003
BigData$1,000$8001,000,000$1.00$0.002
ScaleUp$2,200$1,7602,500,000$0.88$0.00176
Volume$9,000$7,20020,000,000$0.45$0.0009

A Platform tier ($4,000 for 5M) sits between ScaleUp and Volume. An older Traject landing page still shows Starter at $59; the current pricing page says $83.

Pros

  • +Deepest Amazon schema here: buy box, A+ content, variants, Q&A, seller feedback
  • +Collections for scheduled bulk jobs with webhook or S3 delivery
  • +Per-zip-code pricing and availability on higher tiers

Cons

  • -$46/1K at Hobbyist and $8.30/1K at Starter. Only competitive from $375/month
  • -Amazon only; each other retailer is a separate product and bill
  • -Now under ScraperAPI; older Traject landing pages still show stale prices
#6

SerpApi

Best for: teams already paying SerpApi for Google who need occasional retail lookups

SerpApi has retail engines alongside its search engines: amazon, amazon_product, walmart, walmart_product, ebay, ebay_product, home_depot, and google_shopping. Every call is one search credit regardless of engine or result count, and cached, errored, and failed searches are not counted. The parsed output is thorough and the docs are the best organized in this group.

The price is the same problem it is for SERP data. Starter is $25 for 1,000 searches, or $25 per 1,000. Production, the "most popular" plan, is $150 for 15,000, or $10 per 1,000. That is 4x OpenWeb Ninja's Pro rate and 50x Scrapingdog's Lite rate for the same Amazon product page. There is no overage; when you run out you trigger an early renewal of the whole plan. If your team already has SerpApi for Google, adding a few thousand retail lookups on the existing plan is reasonable. Buying SerpApi for retail data alone is not.

Python example

# serpapi_amazon.py - the request we ran on September 3, 2026 (pip install serpapi)

import serpapi

 

client = serpapi.Client(api_key="YOUR_API_KEY")

results = client.search({

"engine": "amazon_product",

"asin": "B07ZPKBL9V"

})

print(results["product_results"]["title"])

Response (trimmed)

{

"search_metadata": {

"id": "6a9989b2e6cb30edbd6a1bd2",

"status": "Success",

"created_at": "2026-09-03 14:52:34 UTC",

"amazon_product_url": "https://www.amazon.com/dp/B07ZPKBL9V/?",

"total_time_taken": 7.09

},

"search_parameters": {"engine": "amazon_product", "asin": "B07ZPKBL9V", "amazon_domain": "amazon.com", "device": "desktop"},

"product_results": {

"asin": "B07ZPKBL9V",

"title": "Apple iPhone 11, 64GB, PRODUCT RED - Unlocked (Renewed)",

"brand": "Visit the Amazon Renewed Store",

"rating": 4.2,

"reviews": 60030,

"bought_last_month": "200+ bought in past month",

"price": "$172.00",

"extracted_price": 172.0,

"old_price": "$175.00",

"extracted_old_price": 175.0,

...

},

"purchase_options": [...],

"item_specifications": {...},

"about_item": [...],

"bought_together": [...],

"product_details": {...}

}

Thirteen top-level sections, and paired string and numeric fields (price plus extracted_price) that save a parsing step. This run used an existing OpenWeb Ninja SerpApi account. Median across our five ASINs was 10.6 seconds; one repeat ASIN came back in 0.4 seconds from SerpApi's one-hour cache.

Pricing

PlanPrice/moSearches/moPer 1K
Free$0250-
Starter$251,000$25.00
Developer$755,000$15.00
Production$15015,000$10.00
Big Data$27530,000$9.17
Searcher$725100,000$7.25
Volume$1,475250,000$5.90

Tiers continue to 54M searches at $1.96/1K. No annual discount shown. Full refund within 7 days if under 20% of searches used.

Pros

  • +Amazon, Walmart, eBay, Home Depot, and Google Shopping engines on one credit pool
  • +Failed and cached searches are free; the best-organized docs in this group
  • +Legal Shield from the Production plan up; Markdown output mode for LLM pipelines

Cons

  • -$25/1K at Starter and $10/1K at Production, the most expensive here at every tier
  • -No overage; running out triggers an early renewal of the full plan
  • -No Costco, Wayfair, Target, or Best Buy
#7

Apify

Best for: long-tail retailers with no dedicated API, if you accept community-maintained scrapers

Apify is a marketplace of hosted scrapers ("actors"), not a single API. You pay a platform subscription ($0 Free with $5 of usage, $19 Starter, $199 Scale, $999 Business) that comes with an equal amount of prepaid usage, then each actor charges per result out of that credit. The most used Amazon actor, Apify's own junglee/amazon-crawler, is $5.00 per 1,000 results on Free, $4.00 on Starter, $3.50 on Scale, and $3.00 on Business, platform costs included. The "from $3.00" headline on the actor page is the Business rate; Starter users pay a third more.

Cheaper actors exist: axesso_data/amazon-product-details-scraper is a flat $1.50 per 1,000 results on any plan and takes product URLs as input. Walmart and eBay actors are priced per event by their developers; caffein.dev/ebay-sold-listings, for example, is $2.50 to $4.00 per 1,000 results depending on your plan. Quality, uptime, and schema stability vary by developer, and the actor rental model is being retired through October 2026, so check the pricing tab on each actor before you depend on it. Auth is a Bearer token, and the synchronous run endpoint waits up to 300 seconds for the dataset.

Python example

# apify_amazon.py - the request we ran on September 3, 2026 (pip install apify-client)

from apify_client import ApifyClient

 

client = ApifyClient("YOUR_API_TOKEN")

 

run_input = {

"categoryOrProductUrls": [{ "url": "https://www.amazon.com/dp/B07ZPKBL9V" }],

"maxItemsPerStartUrl": 1,

"proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",

"maxSearchPagesPerStartUrl": 9999,

"maxProductVariantsAsSeparateResults": 0,

"maxOffers": 0,

"locationDeliverableRoutes": ["PRODUCT", "SEARCH", "OFFERS"],

}

 

run = client.actor("junglee/amazon-crawler").call(run_input=run_input)

for item in client.dataset(run.default_dataset_id).iterate_items():

print(item)

Response (trimmed)

{

"title": "Apple iPhone 11, 64GB, PRODUCT RED - Unlocked (Renewed)",

"url": "https://www.amazon.com/dp/B07ZPKBL9V",

"asin": "B07ZPKBL9V",

"inStock": true,

"inStockText": "In Stock Only 1 left in stock - order soon.",

"brand": "Apple",

"price": {"value": 179.99, "currency": "$"},

"listPrice": null,

"stars": 4.2,

"starsBreakdown": {"5star": 0.69, "4star": 0.12, "3star": 0.05, "2star": 0.03, "1star": 0.11},

"reviewsCount": 60049,

"breadCrumbs": "Cell Phones & Accessories > Cell Phones",

"seller": {"name": "Woot", "id": "A1KWJVS57NX03I"},

"bestsellerRanks": [{"rank": 22, "category": "Amazon Renewed"}, ...],

...

}

56 keys per item, numeric price and star breakdown, and the seller ID. The Python client call above took 21.8 seconds end to end because it waits for the actor container to start; calling the run-sync-get-dataset-items REST endpoint directly returned in a median of 8.6 seconds across our five ASINs, with HTTP 201 on success. Input is a product, search, or category URL, not a bare ASIN.

Pricing (platform plan + junglee/amazon-crawler)

PlanPrice/moPrepaid usageActor rate per 1K resultsResults covered by plan
Free$0$5$5.001,000
Starter$19$19$4.004,750
Scale$199$199$3.5056,857
Business$999$999$3.00333,000

Usage beyond the prepaid amount is billed at the same rate on the next invoice. Annual billing is 10% off. With the $1.50/1K axesso actor, Starter covers 12,667 results.

Pros

  • +Actors for retailers no one else covers, and you can publish your own
  • +$19 entry with pay-per-result; free tier covers about 1,000 Amazon products
  • +Scheduling, storage, and webhooks are part of the platform

Cons

  • -$3 to $5/1K on the flagship Amazon actor, 6x to 20x Oxylabs
  • -Schema and reliability depend on the individual actor developer
  • -Actor runs pay a container start-up cost: 8.6 seconds median via the sync endpoint, 21.8 seconds through the Python client

What 10K, 50K, and 200K Amazon Product Requests Cost Per Month

Cheapest published plan that covers the volume, monthly billing, September 3, 2026. Amazon product pages only; Walmart or reviews change the math on credit-weighted providers.

API10,000 / mo50,000 / mo200,000 / moPlan used at 200K
OpenWeb Ninja$25$75$150Mega
Oxylabs$49$49$99Starter (220K)
Scrapingdog$40$40$40Lite (200K credits)
Bright Data$15$75$300Pay as you go
Rainforest API$83$375$375Production (250K)
SerpApi$150$725$1,475Volume (250K)
Apify (junglee)$40$199$700Scale + $3.50/1K overage

Two readings of this table. On raw Amazon product pages, Scrapingdog and Oxylabs are cheapest at every volume, and OpenWeb Ninja sits in the middle with Bright Data. Once your pipeline needs reviews, offers, Walmart, or eBay, the credit-weighted providers move: Scrapingdog's 200K Walmart pages need 1M credits ($90 Standard), and Bright Data's per-record billing on discovery runs adds up fast. OpenWeb Ninja's numbers do not move, because every endpoint is one request.

Measured Response Time (Same 5 ASINs):

One request to each provider's Amazon product endpoint per ASIN, for the same five ASINs (B07ZPKBL9V, B0CHX3QBCH, B09G9FPHY6, B0BSHF7WHW, B08L5NP6NG), on September 3, 2026, from a single machine in Israel. Every call succeeded. Small sample; it tells you the order of magnitude, not the tail. No other retailer or endpoint was timed.

APIEndpointMedianFastestSlowestFields returned
OpenWeb Ninjaproduct-details3.7 s3.3 s4.8 s54
Scrapingdogamazon/product2.8 s2.0 s5.4 s40
Oxylabsamazon_product, parse=true3.3 s2.8 s3.7 s51
Bright Datadatasets/v3/scrape (sync)9.5 s6.6 s16.6 s98
Rainforest APIrequest?type=product7.9 s5.9 s21.7 s48
SerpApiengine=amazon_product10.6 s0.4 s (cache)12.4 s18 in product_results
Apify (junglee)run-sync-get-dataset-items8.6 s6.4 s8.8 s56

Field counts are top-level keys in the product object for ASIN B07ZPKBL9V. SerpApi spreads the rest across 12 more top-level sections. The 0.4 second SerpApi result was a repeat ASIN served from its one-hour cache; cached searches are not billed. More fields is not automatically better; check that the ones you need are populated.

Retailer Coverage: Documented Endpoints Only

This table is from each provider's documentation; only the Amazon endpoints were exercised live. A check means a dedicated, documented endpoint or scraper with parsed output. "HTML" means the site is supported but returns unparsed HTML. Marketing-page mentions without docs are not counted.

RetailerOpenWeb NinjaOxylabsScrapingdogBright DataRainforestSerpApiApify
Amazon
Walmart✅ (5 cr)separate productcommunity
eBayHTML✅ (5 cr)separate productcommunity
Home Depotseparate productcommunity
Costcocommunity
Wayfaircommunity
Targetseparate productcommunity
Best Buycommunity
Google Shopping✅ (10 cr)separate productcommunity
Billing unitrequestpageweighted creditrecordcreditsearchresult

How to Choose: 4 Common Scenarios

Price monitoring across several retailers

You track the same SKUs on Amazon, Walmart, and one or two more stores, a few times a day. You want one auth scheme, one billing unit, and fields you can compare across stores without a mapping layer per vendor.

Best choice: OpenWeb Ninja. Amazon, Walmart, eBay, Home Depot, Costco, and Wayfair on one key with identical plan tiers. Oxylabs is the alternative if Target or Best Buy is on the list and you can spend $49 or more a month.

Bulk Amazon catalog pulls, hundreds of thousands of ASINs

You need product pages in volume and nothing else. Latency per request matters less than cost per million and the ability to run wide.

Best choice: Scrapingdog for pure product pages ($0.09/1K at Standard), or Oxylabs when you want numeric fields and a stable parser ($0.40/1K at Advanced, 50 requests per second). OpenWeb Ninja's scale plans reach $0.40/1K at 5M requests if you also need reviews and offers at the same rate.

Seller and marketplace research

You go from a search to an ASIN to the offers list to the seller behind each offer, and you want business identity data on that seller.

Best choice: OpenWeb Ninja. The Seller Profile endpoint returns the legal business name and address, and for EU-registered sellers the VAT and registration numbers; we saw all four on a live amazon.de seller while writing. Every hop in the chain is one flat request. Rainforest is the alternative, with seller_feedback and seller_products request types.

Under 5,000 lookups a month, or just testing

You are validating an idea, not running a pipeline. You want the biggest free allowance and the least setup.

Best choice: Bright Data's 5,000 free records per month is the largest recurring free tier here, with the caveat of the dataset and snapshot API. For a plain GET and one API key across retailers, OpenWeb Ninja's free plan is 100 requests per API per month, and Pay As You Go is $0.005 per request with no subscription.

Pricing Sources

Every price in this article was read from the page below on September 3, 2026, and re-checked on September 4, 2026. Providers change plans without notice; if a number here disagrees with the live page, the live page wins.

FAQ

Most common questions and answers

What is an e-commerce API?

Which e-commerce API is cheapest for Amazon product data?

What is the difference between a scraping API and the Amazon Product Advertising API?

Which e-commerce API covers the most retailers under one account?

Is it legal to scrape Amazon or Walmart product data?

Can I get Amazon product reviews through these APIs?

Do any of these APIs return Amazon price history?

How do credits differ from requests in e-commerce API pricing?

About the author

Adam Ben-Ayoun

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 LinkedIn

One key. 40+ APIs. Start free.

100 free requests per month on every API, no credit card required. Amazon, Walmart, eBay, Home Depot, Costco, Wayfair, Google Shopping, plus SERP, Maps, Jobs, and Finance under one key.

APIs by Category

Didn't find the API you are looking for? Request an API

© 2026 OpenWeb Ninja. All rights reserved.

G2 LogoTrustpilot LogoGitHub