# Amazon Product Data API - Search, Prices, Offers, Bestsellers (`nabeelbaghoor/amazon-product-data-api`) Actor

Read Amazon product data from 24 marketplaces: keyword search results, product pages by ASIN, GTIN or URL, seller offers and the buy box, bestseller, category and deals listings, seller profiles and feedback, brand stores, charts, wishlists, autocomplete and ASIN to GTIN lookups. Bring your own key.

- **URL**: https://apify.com/nabeelbaghoor/amazon-product-data-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** E-commerce, Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 listing result returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Amazon Product Data API - Search, Prices, Offers, Bestsellers

Turn a list of search terms or ASINs into a dataset from any of 24 Amazon marketplaces: what ranks, what it costs, who sells it, how it is rated, and what sits next to it.

### What it collects

- **Search and browse**: search results for a keyword with sort order, category, refinement and sponsored filters; category listings by category id or URL; bestseller pages including new releases, movers and shakers, most wished for and gift ideas; deals pages filtered by deal type, price tier, discount, Prime access and rating.
- **Product pages**: one product by ASIN, GTIN, EAN, UPC, ISBN or URL, with title, brand, buy box price and availability, rating and rating breakdown, images and videos, feature bullets, specifications, attributes, variants and their prices, bestseller ranks, A plus content, book formats and editions, and the also viewed, also bought and frequently bought together lists.
- **Offers and stock**: every seller offer for a product with price, condition, Prime eligibility, delivery and seller details; a stock estimate read from the shopping cart for the buy box winner or one named offer.
- **Sellers and reviewers**: a seller's profile with its feedback summary, pages of customer feedback for a seller, a seller's whole catalogue with refinements, and a reviewer's profile with their first pages of reviews.
- **Stores, charts, wishlists and authors**: the products on a brand store page, the entries on an Amazon Charts page, the items on a public wishlist, and an author's titles by format and sort order.
- **Lookups**: autocomplete suggestions for a search term by department, GTIN, EAN, UPC and ISBN codes for an ASIN, and the category tree with standard, bestseller and deals category ids to feed the other services.
- **Your account**: plan, credits used and remaining, reset date and platform status, free at the provider.

### FAQ

#### What is an Amazon product data API used for?

Reading Amazon at a scale a browser cannot. A brand tracks the buy box price and the sellers on its own ASINs every morning across six marketplaces. A seller reads the first three pages of search results for its keywords and the bestseller page for its category to see where it ranks. A price comparison product pulls product pages by GTIN so it can match Amazon listings to its own catalogue. An analyst reads a competitor's whole seller catalogue and feedback history. The common shape is a list of terms or identifiers in and a table of structured records out, which is exactly what this actor is.

#### How do I tell it what to read?

Pick a service, then give it lines. Search and autocomplete read search terms, one per line. Every other service reads identifiers, one per line: an ASIN for product, offers, also bought, shop by look, stock estimate and ASIN to GTIN; a seller id for the seller services; a reviewer id, brand store id or wishlist id for those; a category id for bestsellers, category and deals. A line that starts with http is sent as that page's URL wherever the service accepts one, and a 12 to 14 digit line is sent as a GTIN where the service converts them. Each line is sent as exactly one identifier kind, because a wrongly typed identifier is a charged request about the wrong thing, and you can set the kind explicitly when a line could be mistaken.

#### Where do category ids and seller ids come from?

From the actor itself. The category tree service lists the root categories of a marketplace, the children of any parent, or every category whose name contains a search term, in standard, bestseller or deals flavours, and each row carries the id the other services take. Seller ids and offer ids come back on every row of the offers service, reviewer ids on reviews, brand store ids and URLs on product pages, and format ids on author pages.

#### What happens to an ASIN with no data?

It becomes its own row, marked `found: false`, with the provider's own explanation in the note: the product is not on that marketplace, the request combined parameters the provider does not support, or the provider's parser for that request type is temporarily unavailable. That last case is reported with the provider's suggested wait and is never charged, and the remaining identifiers in the run are recorded as not attempted rather than sent into the same incident. A run over a hundred ASINs therefore returns a hundred rows rather than eighty-eight, and you can see at a glance which twelve were empty.

#### How does paging work?

Two ways, and you choose. Set pages per identifier and the actor walks a listing page by page, one request per page, stopping when the provider reports no further page or the maximum results is reached; wishlists, which scroll rather than number their pages, are followed by the token the provider hands back. Or set the provider-side max page, up to five, and the provider reads and concatenates the pages in one request, marking each entry with the page it came from. Either way the provider charges one credit per page actually returned.

#### Can this actor spend money beyond the data call?

No. The provider also publishes routes that create and start collections of thousands of requests, add zipcodes to an account and configure upload destinations, and none of them is wired up anywhere in this actor. Every route it can reach is a read: the real-time request endpoint, the categories reference and the account summary. That is a deliberate limit, because a scheduled run that could enqueue fifteen thousand requests on your plan is a scheduled run that eventually will.

#### Which request types are missing, and why?

Reviews, review comments, questions, question answers, sales estimation and formats and editions. The provider lists all six as request types but has unpublished their parameter pages, so their filters cannot be read from the documentation, and this actor does not invent parameters. The extra query parameters input passes anything the provider documents for a wired service through verbatim, but it does not add request types.

#### Which routes were checked against the live API?

All three. On 2026-09-24 the request, categories and account routes each answered a deliberately invalid key with the provider's own 401 envelope, while an invented path answered a bare 404, which is what confirms the route table. The request and result field names come from the provider's published reference for each request type. No real data was read while building this actor, so it is not live-tested against a paid key, and the provider's example responses are the only guide to what a record looks like.

#### Do I need my own API key?

Yes. This actor is bring-your-own-key and never ships a key of its own. Paste the key from your provider account, or set it once as the DATA\_API\_KEY environment secret. The provider documents one way to send it, as the api\_key query parameter, so that is how it travels; be aware that this puts the key in the request URL on the provider's side, which is the provider's design rather than this actor's choice.

#### What does it cost?

Pay per result. A full page record, which is a whole product page, seller profile, reviewer profile or stock estimate, costs the most, because one row is a complete answer about one thing. A listing entry, which is one search result, offer, bestseller, deal, feedback entry or store product, costs a third of that, because one request commonly returns dozens. A lookup row, which is one autocomplete suggestion, one GTIN or one category, costs half that again. Reading your own account is priced near zero. Platform usage is included, and identifiers the provider returns nothing for are never charged. Your provider account is charged separately by the provider, one credit per page and more for the product options that say so.

#### How fast will it run?

The provider's rate limit depends on your plan and is not published as one number, so the actor defaults to thirty requests a minute and lets you raise it. A rate limit refusal is retried against the provider's own Retry-After header rather than a guessed delay, and a server error is retried with backoff before the run is failed.

### Example output

```json
{
  "service": "search",
  "serviceLabel": "Search results",
  "amazonDomain": "amazon.com",
  "requested": "memory cards",
  "requestedAs": "search_term",
  "page": 1,
  "found": true,
  "recordType": "item",
  "asin": "B09X7BK27V",
  "title": "SanDisk 128GB Extreme microSDXC UHS-I Memory Card with Adapter",
  "link": "https://www.amazon.com/dp/B09X7BK27V",
  "price": { "symbol": "$", "value": 16.99, "currency": "USD", "raw": "$16.99" },
  "rating": 4.8,
  "ratingsTotal": 210433,
  "retrievedAt": "2026-09-24T09:14:52.118Z",
  "record": { "...": "every field the provider published for this result, unchanged" },
  "note": null
}
```

### Keyword map

Amazon product data API, Amazon search results API, Amazon product API, Amazon price API, Amazon buy box API, Amazon offers API, Amazon seller data API, Amazon bestsellers API, Amazon category API, Amazon deals API, Amazon brand store data, Amazon wishlist data, Amazon charts data, ASIN lookup API, GTIN to ASIN, UPC to ASIN, ASIN to GTIN, EAN to ASIN, ISBN to ASIN, Amazon product details by ASIN, Amazon stock estimation, Amazon autocomplete API, Amazon marketplace data, ecommerce product data API, competitor price monitoring Amazon, Amazon scraper API alternative, Amazon data for 24 marketplaces.

# Actor input Schema

## `service` (type: `string`):

One service per run. Listing services return one row per entry on the page: search results, bestsellers, category, deals, offers, also bought, shop by look, seller catalogue, seller feedback, brand store, charts, wishlist and author titles. Page services return one row per identifier: product page, seller profile, reviewer profile and stock estimate. Lookup services return many small rows: autocomplete, ASIN to GTIN and the category tree. The account service reads your own plan and credits and costs the provider nothing.

## `amazonDomain` (type: `string`):

Which Amazon site to read from. Sent with every request except the account summary. A page URL given as an identifier carries its own domain and the provider uses that instead.

## `searchTerms` (type: `array`):

One search term per line, for the search, autocomplete and category tree services. A line that starts with http is sent as a search results page URL instead, for the search service.

## `identifiers` (type: `array`):

One per line, for every other service: an ASIN (or a 12 to 14 digit GTIN, EAN, UPC or ISBN-13 where the service converts them) for product, offers, also bought, shop by look, stock estimate and ASIN to GTIN; an author ASIN for author page; a seller id for seller profile, feedback and products; a reviewer id for reviewer profile; a brand store id; a wishlist id; a category id for bestsellers, category and deals (leave empty for the deals homepage); a parent category id for the category tree (leave empty for the root). A line that starts with http is sent as that page's URL wherever the service accepts one.

## `identifierType` (type: `string`):

Leave on automatic and each line is read by its shape: a URL when it starts with http, a GTIN when it is 12 to 14 digits and the service converts them, otherwise the kind the selected service reads by default. Set it explicitly when a line could be mistaken, for example a numeric category id on a service that also takes ASINs, or to look one category up by id in the category tree.

## `pages` (type: `integer`):

How many pages of a listing to walk for each search term or identifier, one request per page, stopping early when the provider reports no further page. Each page costs one credit at the provider. Ignored when a provider-side max page is set, because the provider then concatenates the pages itself.

## `page` (type: `integer`):

The page to start from, for the listing services that number their pages. Leave blank to start at the first page.

## `maxPage` (type: `integer`):

Ask the provider to read this many pages in one request and concatenate them, for the listing services. The provider allows up to 5 on real-time requests and charges one credit per page actually returned. When set, the pages per identifier input is ignored.

## `sortBy` (type: `string`):

How to order the entries, on the services that take a sort. Search and category take the first six. The Audible values apply to search on Audible domains only. Popularity, publication date and most reviews apply to author pages, and priority to wishlists.

## `searchCategoryId` (type: `string`):

A category id from the category tree service to restrict search results to. Accepted by the search service only; on bestsellers, category and deals the category id is the identifier itself.

## `refinements` (type: `string`):

A comma separated list of refinement values, for example p\_85/2470955011,p\_36/2421886011, to filter search, category or seller product results by rating, price range, brand and similar. Refinement values are returned in the refinements array of a first, unfiltered request and change by search term and category.

## `excludeSponsored` (type: `boolean`):

Leave sponsored search results out of the search service's answer.

## `directSearch` (type: `boolean`):

Stop the provider from auto correcting a suspected spelling mistake in a search term.

## `numberOfResults` (type: `integer`):

Ask for this many search results per page. You cannot request more than the search page shows.

## `topFree` (type: `boolean`):

Read the Top 100 Free version of a bestsellers category rather than the paid one. Not every category has one.

## `dealTypes` (type: `string`):

Which deal types to include on the deals service, comma separated: lightning\_deal, customers\_most\_loved, trending, summer\_favorites, back\_to\_school, off\_to\_college. Leave blank for all. Deal types vary by marketplace and a type that does not exist there is redirected to Today's Deals by the provider, and still charged.

## `priceRange` (type: `string`):

A price tier for the deals service. On amazon.com the tiers are 1 (under $25), 2 ($25 to $50), 3 ($50 to $100), 4 ($100 to $200) and 5 ($200 and above); other marketplaces have their own tiers.

## `discount` (type: `string`):

Only deals with a discount inside this range, for the deals service.

## `primeEarlyAccess` (type: `boolean`):

Filter the deals service to Prime Early Access deals.

## `primeExclusive` (type: `boolean`):

Filter the deals service to Prime Exclusive deals.

## `minimumRating` (type: `string`):

Only deals for products at or above this customer rating, for the deals service.

## `offersPrime` (type: `boolean`):

Limit the offers service to offers that are Prime eligible.

## `offersFreeShipping` (type: `boolean`):

Limit the offers service to offers with free shipping.

## `conditionNew` (type: `boolean`):

Limit the offers service to offers in new condition.

## `conditionUsedLikeNew` (type: `boolean`):

Limit the offers service to offers in used, like new condition.

## `conditionUsedVeryGood` (type: `boolean`):

Limit the offers service to offers in used, very good condition.

## `conditionUsedGood` (type: `boolean`):

Limit the offers service to offers in used, good condition.

## `conditionUsedAcceptable` (type: `boolean`):

Limit the offers service to offers in used, acceptable condition.

## `showDifferentAsins` (type: `boolean`):

Keep offers the provider returns for ASINs other than the one asked for, which happens when the original is out of stock. Off by default, so the offers are about the ASIN you gave.

## `skipGtinCache` (type: `boolean`):

The provider caches each GTIN to ASIN mapping for two months. Set this to look a GTIN up again, at two credits instead of one, when you suspect the cached mapping is stale. Product and offers services.

## `includeSummarizationAttributes` (type: `boolean`):

Add the summarization attributes and what customers say to a product page, at two credits instead of one.

## `includeAPlusBody` (type: `boolean`):

Add the HTML of the manufacturer's A plus description section to a product page.

## `variantPrices` (type: `boolean`):

Add a price to each variant of a product, at two credits instead of one.

## `includeBookDescriptionRaw` (type: `boolean`):

Add the raw HTML of a book's description to a product page, for ASINs that have one.

## `includeSafetyProductResources` (type: `boolean`):

Add the safety images and contacts section to a product page, at three credits instead of one.

## `includeAllBookFormats` (type: `boolean`):

Add every format and edition of a book to a product page, at one extra credit per supported format.

## `includeImageBlockVideos` (type: `boolean`):

Add the structured video data from the product's image block, at two credits instead of one.

## `importDelivery` (type: `boolean`):

Add shipping and import delivery costs to the buy box of a product page, at two credits instead of one.

## `autocompleteAlias` (type: `string`):

The department alias to scope autocomplete suggestions to, for example aps for all departments or stripbooks for books on amazon.com. Aliases vary by marketplace; leave blank for all departments.

## `reviewerProfilePages` (type: `integer`):

How many pages of a reviewer's reviews to read on the reviewer profile service, ten reviews per page and one credit per page.

## `offerId` (type: `string`):

Estimate stock for one specific seller offer rather than the buy box winner, using an offer id from a recent offers request. Offer ids change over time.

## `formatId` (type: `string`):

Restrict an author's titles to one format, using a format id from the format\_ids array of an earlier author page result.

## `categoryType` (type: `string`):

Which kind of category ids to browse on the category tree service: standard ids work with search and category, the bestseller kinds with bestsellers, and deals with deals.

## `customerLocation` (type: `string`):

Read the page as a customer in this country would see it, which surfaces cross border shipping and pricing. Leave blank to read as a customer in the marketplace's own country. Cannot be combined with a customer zipcode, and the deals service does not take it.

## `customerZipcode` (type: `string`):

Read the page as a customer at this postal code, for highly localised listings such as grocery delivery. The zipcode must first be set up for the marketplace in your provider dashboard. Cannot be combined with a customer location, and the deals service does not take it.

## `language` (type: `string`):

The display language for the Amazon page, as a locale code the marketplace supports, for example en\_US, de\_DE or es\_MX.

## `currency` (type: `string`):

The currency to request Amazon pages in, where the marketplace supports it, for example EUR or GBP.

## `associateId` (type: `string`):

Your Amazon affiliate tag, appended to every product link the provider returns.

## `includeFields` (type: `string`):

A comma separated list of response fields to keep, in dot notation, for example search\_results.title,search\_results.asin,search\_results.price. Everything else is left out of the record.

## `excludeFields` (type: `string`):

A comma separated list of response fields to drop, in dot notation, for example product.images.

## `extraParameters` (type: `object`):

Any other parameter the provider documents for the selected service that this actor does not have its own field for. Given as a JSON object, for example {"output": "json"}. Nothing here is invented: it is passed to the provider exactly as written, so check the name against the provider's own documentation first.

## `maxResults` (type: `integer`):

Stop after this many rows. A listing page can return dozens of entries and a walk over several pages hundreds, so this is what bounds a run that reads a long list of search terms.

## `requestsPerMinute` (type: `integer`):

Pacing ceiling. The provider's rate limit depends on your plan, so the default is conservative. Raise it if your plan allows.

## `apiKey` (type: `string`):

Your own API key for the Amazon product data provider. This actor is bring-your-own-key and never ships a key of its own. Leave blank to use the DATA\_API\_KEY environment secret instead.

## `baseUrl` (type: `string`):

Override the host the actor calls. Only useful for testing against a different environment.

## Actor input object example

```json
{
  "service": "search",
  "amazonDomain": "amazon.com",
  "identifierType": "auto",
  "pages": 1,
  "excludeSponsored": false,
  "directSearch": false,
  "topFree": false,
  "primeEarlyAccess": false,
  "primeExclusive": false,
  "offersPrime": false,
  "offersFreeShipping": false,
  "conditionNew": false,
  "conditionUsedLikeNew": false,
  "conditionUsedVeryGood": false,
  "conditionUsedGood": false,
  "conditionUsedAcceptable": false,
  "showDifferentAsins": false,
  "skipGtinCache": false,
  "includeSummarizationAttributes": false,
  "includeAPlusBody": false,
  "variantPrices": false,
  "includeBookDescriptionRaw": false,
  "includeSafetyProductResources": false,
  "includeAllBookFormats": false,
  "includeImageBlockVideos": false,
  "importDelivery": false,
  "categoryType": "standard",
  "maxResults": 500,
  "requestsPerMinute": 30
}
```

# Actor output Schema

## `records` (type: `string`):

One row per record, alongside the search term or identifier that produced it.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/amazon-product-data-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/amazon-product-data-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call nabeelbaghoor/amazon-product-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/amazon-product-data-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6bLqpjdeFUTTbThRz/builds/yY5Q6NJLeFOqnYAOw/openapi.json