The Cheapest Amazon Scraper API for Developers

One rate for product, search and bestsellers as JSON, across 22 marketplaces. Billed per request, never per result.

Join the List See the Rate Card
Try for Free Read the Build Guide
Prelaunch — not served yet 22 marketplaces 35 product fields 10 Free API Calls No monthly plan

Not live yet. /api/amazon/* does not answer today. The rates on this page are target rates, unverified until launch — they are not served yet. Join the list and we’ll mail you the day they start answering.

One request is one page, and all three endpoints cost the same. Search returns 16–48 ranked product cards, bestsellers a chart of about 30 ASINs, and product a 35-field record — each billed as a single request.

Run a live Amazon search request

No signup and no key. The box sends a real search request and prints exactly what the endpoint returns.

Amazon is in prelaunch, so the box answers the standard unavailable message rather than a result. That is the correct behaviour for an endpoint that is not served yet, not a fault in the box.

Three Amazon Endpoints, One Rate

Product, search and bestsellers, all at one published rate. The unit is per 1,000 requests — never per 1,000 results.

Search

Search

from $0.014
/1K requests (Scale tier)
  • GET /api/amazon/search — one request, one page
  • 16–48 ranked cards per page, at one charge
  • is_sponsored, is_amazons_choice, is_best_seller
  • Pages 1–5 synchronously, to 20 through async
Default$0.020/1K requests
Growth$0.018/1K requests
Scale$0.014/1K requests
Build guide →
Bestsellers

Bestsellers

from $0.014
/1K requests (Scale tier)
  • GET /api/amazon/bestsellers by category
  • About 30 ranked ASINs per chart, at one charge
  • category, category_slug and Amazon’s own rank
  • Categories validated per marketplace before the call
Default$0.020/1K requests
Growth$0.018/1K requests
Scale$0.014/1K requests
All Serpent APIs →

Prelaunch rate card. The rates above are target rates, unverified until launch, and are what you will pay when the endpoints ship — they are not served yet. One rate covers all three endpoints, so a 35-field product record costs exactly what a search page costs. Growth and Scale are earned by a single deposit of $100 and $500; both are one-time, and a tier once earned never downgrades. A search that genuinely returns nothing is an answer and is charged; a failure on our side is refunded.

Read the unit carefully. These are rates per 1,000 requests. A search request is one page of 16–48 product cards and a bestsellers request is a chart of about 30 ASINs, so a rate here is not comparable to a vendor that bills per row without normalising first. Growth and Scale are earned by a single $100 and $500 deposit; both are one-time and never downgrade.

Amazon Data in One Request

One header, one GET. Types are part of the contract: prices are numbers, currency is an ISO-4217 code, and an absent value is null rather than a missing key.

cURL — product, search, bestsellers
# One product record by ASIN — 35 typed fields for one request
curl "https://apiserpent.com/api/amazon/product?asin=B08N5WRWNW&domain=amazon.com" \
  -H "X-API-Key: YOUR_API_KEY"

# One search page — 16–48 ranked product cards, still one request
curl "https://apiserpent.com/api/amazon/search?q=laptop+stand&domain=amazon.co.uk&page=1" \
  -H "X-API-Key: YOUR_API_KEY"

# One category chart — about 30 ranked ASINs, one request
curl "https://apiserpent.com/api/amazon/bestsellers?category=electronics&domain=amazon.de" \
  -H "X-API-Key: YOUR_API_KEY"
Python — one search page into rows
import os, requests

h = {"X-API-Key": os.environ["SERPENT_API_KEY"]}
p = {"q": "laptop stand", "domain": "amazon.com", "page": 1}

data = requests.get("https://apiserpent.com/api/amazon/search",
                    params=p, headers=h, timeout=60).json()

# results[] is the page. results_count is how many cards it carried —
# between 16 and 48, and the whole page costs one request either way.
for r in data["results"]:
    print(r["position"], r["asin"], r["price"], r["currency"], r["rating"])
Node — one product record
const qs = new URLSearchParams({ asin: "B08N5WRWNW", domain: "amazon.com" });

const res = await fetch(`https://apiserpent.com/api/amazon/product?${qs}`, {
  headers: { "X-API-Key": process.env.SERPENT_API_KEY }
});

const { product } = await res.json();
// price and list_price are NUMBERS. list_price is null when there is no list price,
// which is not the same statement as "the list price equals the price".
console.log(product.title, product.price, product.currency, product.rating);
JSON Response — /api/amazon/product (partial)
{
  "success": true,
  "product": {
    "asin": "B08N5WRWNW",
    "parent_asin": "B08N5M7S6K",
    "title": "Adjustable Aluminium Laptop Stand",
    "brand": "Example Brand",
    "price": 34.99,
    "currency": "USD",
    "list_price": 49.99,
    "sns_price": null,
    "coupon": null,
    "availability": "In Stock",
    "bought_past_month": "2K+ bought in past month",
    "sold_by": "Example Brand Store",
    "ships_from": "Amazon",
    "rating": 4.6,
    "ratings_total": 18342,
    "rating_breakdown": [
      { "stars": 5, "percentage": 74 },
      { "stars": 4, "percentage": 15 }
    ],
    "reviews_count": 9,
    "reviews": [
      { "title": "Sturdier than it looks", "rating": 5 }
    ],
    "feature_bullets": [ "Six-stage height adjustment" ],
    "aplus_present": true,
    "aplus_text": "Engineered for all-day use.\n\nSix-stage height adjustment...",
    "aplus_modules": [
      { "heading": "Built to last", "text": "Aircraft-grade aluminium...", "images": [ { "url": "https://m.media-amazon.com/images/S/aplus-media/example.jpg", "alt": "Stand at full height" } ] }
    ],
    "main_image": "https://m.media-amazon.com/images/I/example.jpg",
    "image_count": 7,
    "variants_count": 3,
    "variant_dimensions": [ "Colour" ],
    "categories": [ "Electronics", "Laptop Accessories" ],
    "bestsellers_rank": [
      { "category": "Laptop Stands", "rank": 4 }
    ],
    "specs": { "Material": "Aluminium" }
  },
  "meta": {
    "asin": "B08N5WRWNW",
    "domain": "amazon.com",
    "elapsed": "6120ms"
  }
}

reviews is the sample the product page itself renders — typically 8 to 13 — and reviews_count is the size of that sample, not a site-wide figure. The site-wide number is ratings_total (18,342 above), and the two are different quantities: read reviews_count as a total and you will be out by four orders of magnitude. Every one of the 35 keys is always present, so a field this listing did not carry arrives as null or [] rather than disappearing — your parser never has to branch on whether a key exists.

Every Field an Amazon Call Returns

Named JSON fields, not HTML you have to select against. Nothing here needs a parser of your own, and nothing changes shape between calls.

Product record — 35 fields

  • asin, parent_asin, url, title, brand
  • price, currency, list_price
  • sns_price, coupon
  • availability, delivery, bought_past_month
  • seller_id, sold_by, ships_from
  • rating, ratings_total, rating_breakdown
  • reviews_count, reviews (sample)
  • feature_bullets, description, aplus_present
  • aplus_text, aplus_modules
  • main_image, image_count, image_urls
  • variants_count, variant_dimensions, variants
  • categories, bestsellers_rank, specs

Search result card

  • position, asin, url, title, image
  • price, currency, list_price
  • secondary_offer_price, secondary_offer_currency
  • rating, ratings_total
  • is_sponsored
  • is_amazons_choice
  • is_best_seller
  • badge, badge_type, badges
  • bought_past_month, delivery

Page & chart wrappers

  • search_term, current_page
  • total_results, total_results_text
  • results_count, results[]
  • category, category_id
  • category_slug, category_url
  • rank (Amazon’s displayed rank)
  • meta.elapsed, meta.domain

Request parameters

  • asin (or url) — product
  • q — search query
  • page (1–5 sync, to 20 async)
  • category — bestsellers
  • domain (amazon.com, .co.uk, .de …)
  • country (alias for domain)
  • language (where the marketplace allows it)

Read secondary_offer_price carefully. It is the other-sellers offer on a search card, not the card’s own price — price is that. On every one of the 43 recorded cards carrying both, the secondary offer came in below the card price, and on some cards it is a used listing rather than a new one. Treat it as a second offer to inspect, never as the price of the product.

What is Amazon product data, and why teams use it

It is the record behind a listing: price, currency, rating, availability, bullets, variants and rank. Four things decide whether it is usable.

The unit is a page, not a row

One search request returns a whole page of 16–48 product cards and costs one request; one bestsellers request returns a chart of about 30 ASINs — 36 on the site-wide directory, which renders six carousels of six — and also costs one request. Vendors who bill per returned row charge you 16 to 48 times for the same page.

Normalised per product record, a Default search works out at $0.0004–$0.0013 per 1,000 products: $0.020 per 1,000 requests divided by the 48 cards of a full page at best, and by the 16 of a short one at worst. That is the comparison to run before you compare headline rates, and the worst case is quoted from the smallest page we have measured rather than the largest.

Currency is a gate, not a label

A price is only a price if its currency is the one that marketplace trades in. A euro figure on an amazon.com listing is another region’s page leaking through, and a “price is not blank” check passes it every time.

currency is always ISO-4217 — USD, GBP, JPY — never a glyph, and a price whose currency does not match the marketplace you asked for is not handed to you as that marketplace’s price.

22 marketplaces, and the one that is missing

23 named Amazon domains ship. Twenty-two serve product, search and bestsellers; amazon.eg is bestsellers-only, because its product pages do not carry a price or review block we can stand behind.

amazon.cn is deliberately absent. It no longer serves a storefront, so listing it would inflate a marketplace count with a domain that returns no products — a number that looks like coverage and is not.

Reviews are a sample, and they say so

reviews is the sample the product page renders, typically 8 to 13 of them. reviews_count is the size of that sample — not a site-wide figure, which is ratings_total — and rating_breakdown is the star histogram as {stars, percentage} rows, percentages only.

There is no wholesale review crawl and no review pagination endpoint. Saying that plainly is worth more than a field that implies completeness it cannot deliver, and it is the field teams most often discover was hollow after they built on it.

Amazon API Pricing, Side by Side

Every figure is the vendor’s own published rate. Where a cheap rate needs a monthly plan or a sales call, the requirement is in the table.

Provider What one unit is Cost per 1,000 — entry Cost per 1,000 — lowest published What the lowest rate requires Free tier
Serpent API Per request. A search page of 16–48 cards, a chart of ~30 ASINs, or one product. $0.020
all three endpoints
$0.014
all three endpoints
A single $500 deposit, spendable as balance. No monthly plan; the tier never expires or downgrades. 10 free API calls
ScrapingDog — Amazon Search & Product Per request (1 credit) $0.20 (LITE, $40/month) $0.027 $30,000 per month 200 credits
ScrapingDog — Amazon Bestsellers Per request (5 credits) $1.00 (LITE, $40/month) $0.136 $30,000 per month 200 credits
Oxylabs Per successful result $0.50 (Micro, $49/month) $0.25 Custom plan, contact sales. Advanced $249/month is $0.40; Business $999/month is $0.30. Trial, 2,000 results
Rainforest (Traject Data) Per request (1 credit) $46.00 (Hobbyist, $23/month) $0.45 Volume plan, $9,000 per month, billed annually. Monthly billing adds 25%. Free trial, size not published
Bright Data Per record $1.50 (pay as you go) $1.30 Scale plan, $499 per month 5,000 records/month
Apify — junglee/amazon-crawler Per result (one product) $5.00 $0.80 Diamond plan, contact sales. Gold and Business at $999/month are $3.00. $5 platform credit
Apify — pro100chok/amazon-scraper Per result (one product) $5.00 $1.00 Bronze plan, $19 per month $5 platform credit

Where we win, and what the cheapest rival rate actually costs. Rates checked against each vendor’s own live pricing page on 2026-09-08. At the rate a new account actually pays, we are a tenth of the cheapest rival entry rate — $0.020 per 1,000 requests against ScrapingDog’s $0.20, and below Oxylabs’ $0.50, Bright Data’s $1.50, Apify’s $5.00 and Rainforest’s $46.00. Three of those entry rates are monthly plans billed whether or not you call the API — ScrapingDog’s $40 LITE, Oxylabs’ $49 Micro and Rainforest’s $23 Hobbyist — and there is no monthly plan here at all. The lowest rate anyone in this table publishes is ScrapingDog’s $0.027 per 1,000, and it takes $30,000 of spend a month, $360,000 a year, to reach it. Our $0.020 Default is under that on the first call, with no deposit and no plan at all; our $0.014 Scale asks a single $500 deposit that stays spendable and never expires. Every other rate in this table, entry or lowest published, sits above both. What a vendor will quote privately on a contact-sales plan is not published, and we make no claim about it. The unit is a separate argument from the price: Oxylabs, Bright Data and Apify bill per row, and we bill one page of 16–48 cards as one request; normalised per product record a Default search is $0.0004–$0.0013 per 1,000 products, against Bright Data’s cheapest $1.30 and Apify junglee’s cheapest $0.80. Rainforest’s plans are billed annually and its $59 Starter tier no longer exists; trajectdata.com now carries a “Traject Data joins ScraperAPI” banner, so Rainforest and ScraperAPI are no longer independent vendors.

What Teams Actually Pull Amazon Data For

Four jobs that account for most Amazon data traffic, and the endpoint and parameters each one needs.

Price and availability monitoring

Poll /api/amazon/product on a list of ASINs and store price, list_price, sns_price, coupon and availability. All four price fields are numbers, so a drop is arithmetic rather than string parsing.

Keep currency in the same row. A price that changes currency between two polls did not change — the page you were served did — and that is the single most common source of a bogus price alert.

Catalogue and competitor research

One product call carries feature_bullets, description, aplus_text, aplus_modules, categories, bestsellers_rank, variants and variant_dimensions — a listing turned into a research row without a second request.

You get a competitor’s enhanced brand content as text, not just a flag that they have some. aplus_text is the whole A+ region as one readable string; aplus_modules splits the same copy into its blocks, each with its heading, its body text and its image alt strings — and on A+ the alt strings matter, because much of the wording is set inside the artwork. aplus_present stays as the cheap boolean to filter on before you read anything.

Bestseller and category movers

Poll /api/amazon/bestsellers for a category and diff the chart day over day. Each entry carries Amazon’s own displayed rank plus asin, price and rating, so a mover is visible without a second lookup.

category_slug comes back on every chart, which is what lets you reject a chart served for a slug that is only valid on another marketplace instead of silently charting the wrong list.

Cross-marketplace price comparison

Send the same ASIN at domain=amazon.com, amazon.co.uk and amazon.de and you get three records with three ISO-4217 currencies, ready to convert against one rate table.

Because the unit is a request rather than a row, a 22-marketplace sweep of one ASIN is 22 requests — $0.00044 at Default — and the cost is the same whether the listing is thin or carries seven images and three variants.

Bash — nightly price log for a list of ASINs
# One line per ASIN: date, asin, price, currency, availability.
# One request per ASIN — the whole 35-field record costs the same as the price alone.
while IFS= read -r asin; do
  curl -s -G "https://apiserpent.com/api/amazon/product" \
      -d "asin=$asin" -d "domain=amazon.com" \
      -H "X-API-Key: $SERPENT_API_KEY" \
    | jq -r '[.product.asin, (.product.price|tostring), .product.currency,
              (.product.availability // "unknown")] | @csv' \
    | sed "s|^|$(date -u +%F),|" >> amazon-prices.csv
done < asins.txt

Amazon Scraper API Questions

Yes. /api/amazon/product, /api/amazon/search and /api/amazon/bestsellers all answer today, and every rate on this page is the live rate. One thing worth knowing before you build: Amazon refuses automated traffic in waves that last tens of minutes and land on every network the same way, so a synchronous call can come back empty even when the product is really there. For anything past an occasional lookup, send the work to the async job endpoint instead. It carries a far longer budget and rides out those windows, and an empty answer is refunded rather than charged.
One page of structured product data, 35 fields: identity (asin, parent_asin, url, title, brand); pricing (price, list_price, sns_price for Subscribe and Save, coupon, currency); availability (availability, delivery, bought_past_month); seller (seller_id, sold_by, ships_from); ratings (rating, ratings_total, rating_breakdown, a small sample of reviews and the reviews_count that sizes it); content (feature_bullets, description, aplus_present, aplus_text, aplus_modules, main_image, image_urls, image_count); variants (variants, variant_dimensions, variants_count); and classification (categories, bestsellers_rank, specs). The record arrives under a top-level product key alongside success and meta.
Per 1,000 requests, never per 1,000 results. One search request is one page of 16–48 product cards, one bestsellers request is a chart of about 30 ASINs, and one product request is one product. All three endpoints cost the same: $0.020/1K requests on Default, $0.018 on Growth and $0.014 on Scale. Product is not priced above search — a 35-field record, its review sample and its rating histogram all cost one request. Growth unlocks at a single $100 deposit and Scale at $500; both are one-time and neither ever downgrades.
No published rate is lower. Every Amazon endpoint here is $0.020 per 1,000 requests on Default and $0.014 on Scale, and the cheapest rival entry rate is ScrapingDog’s $0.20 on its $40-a-month LITE plan — we are a tenth of that, with no monthly plan at all (checked 2026-09-08). The lowest rate any rival publishes anywhere is ScrapingDog’s floor of $0.027 per 1,000, and reaching it takes $30,000 of spend a month; even that floor sits above our Default rate, which every account pays from the first call with no deposit and no plan. On the unit, we bill one search page of 16–48 cards as one request, so normalised per product record a Default search is $0.0004–$0.0013 per 1,000 products, against Bright Data’s cheapest $1.30 and Apify junglee’s cheapest $0.80 per 1,000 results. The table on this page carries every vendor’s lowest published rate; what a vendor will quote privately on a contact-sales plan is not published, and we make no claim about it.
23 named Amazon domains ship: 22 serve product, search and bestsellers, and amazon.eg is bestsellers-only because its product pages do not carry a verifiable price or review block. Pick one with domain=amazon.co.uk or with the country parameter. amazon.cn is deliberately absent — it no longer serves a storefront, so listing it would be a false claim rather than a feature.
No, and the response says so. reviews is the sample Amazon renders into the product page itself — typically 8 to 13 of them — and reviews_count is the size of that sample, never a site-wide figure. The site-wide number is ratings_total, which is a different quantity and is not comparable to reviews_count. rating_breakdown carries the star histogram as {stars, percentage} rows, percentages only: a per-star count would have to be derived from the percentage and would inherit Amazon’s own rounding. There is no wholesale review crawl and no review pagination endpoint.
Pages 1 to 5 on the synchronous endpoint, and up to page 20 through the async form. Ask for a deeper page synchronously and you get a 400 that names the async endpoint rather than a quietly truncated page — serving page 5 when page 9 was requested is both a wrong result and a confusing invoice.
No. There is no monthly plan anywhere in Serpent’s pricing. Growth and Scale are earned by a single deposit of $100 and $500, the deposit is spendable balance rather than a fee, and the tier is permanent — it never downgrades if your usage drops. That is the structural difference from vendors whose cheapest published rate is attached to a plan you keep paying for in a quiet month.
A search that genuinely returns nothing is an answer and is charged; a failure on our side is refunded. A call that runs out of time says so plainly instead of pretending to be complete, and returns the rows it already holds — six fields parsed and one missed still ships six. Its response carries an async_endpoint field naming where to send the same request as a background job, which runs on a far larger time budget.
Yes. The box at the top of this page sends a real request with no signup and no key, and prints exactly what the endpoint returns — which, while Amazon is in prelaunch, is the standard unavailable message. A signed-up account gets 10 free API calls, shared across every free-eligible endpoint, with no card required.

Join the Amazon API list

Start using the Amazon Scraper API

The endpoints are not served yet. Join and we’ll mail you the day they start answering. No card, no commitment, and the 10 free API calls are waiting on every other endpoint in the meantime.

10 free API calls, shared across every free-eligible endpoint. No card, no subscription, no monthly plan. Amazon product, search and bestseller data at one rate, from $0.014/1K requests.

Get your free API key

Related guides

More on working with marketplace and commerce data in code.

Best Amazon Scraping APIsEvery vendor compared on price, unit and field coverage. Build an Amazon Scraper in PythonA runnable route to product and search records. Best Google Shopping APIProduct listings from the other side of the buying journey. The Cheapest SERP API in 2026A full cost comparison across every major provider. Best Residential Proxy ProvidersWhat the build-it-yourself route actually costs. TikTok APIProfile, video, hashtag, search and music as JSON. SERP APISearch results from five engines in one response shape. PricingEvery published rate, and the two one-time deposit tiers.