# Amazon Product Scraper: Prices, Stock, BSR & 64 Fields (`amazonscrapers/amazon-product-details`) Actor

Scrape Amazon product data by ASIN, URL, search term or category. 64 fields per product: price, list price, discount, stock, bestseller rank, ratings, images, specifications, variants, delivery and sales estimates. 19 marketplaces. You only pay for rows that arrive with a price.

- **URL**: https://apify.com/amazonscrapers/amazon-product-details.md
- **Developed by:** [Amazon Scrapers](https://apify.com/amazonscrapers) (community)
- **Categories:** E-commerce, SEO tools
- **Stats:** 2 total users, 1 monthly users, 92.9% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 product with prices

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Amazon product scraper: prices, ASIN, BSR and 64 data fields

Give it ASINs, product URLs, a search term or a category link. Get back one clean row per product with 64 fields: the price and what it used to cost, how many people bought it last month and what that is worth, bestseller rank, stock, ratings, every image, the full specification table, variants, return policy, delivery date and more.

It reads 19 Amazon marketplaces, from amazon.com to amazon.co.jp, and it reads them in their own language. A German product's rating says "4,5 von 5 Sternen" and a Japanese one puts the number last. Both come back as 4.5.

Fields are empty only when Amazon does not show them on that page. They are never empty because something went wrong. There is a difference, and this Actor is built around it.

### What to know before you start

All 64 fields work on every marketplace. Prices are the one field Amazon does not always serve, and how often depends on the marketplace. Eight of them measured on the same day, same settings:

| Marketplace | Products priced |
| --- | --- |
| amazon.com | 57 of 60 |
| amazon.co.uk | 5 of 6 |
| amazon.ca | 5 of 5 |
| amazon.fr | 4 of 5 |
| amazon.it | 1 of 5 |
| amazon.es | 1 of 5 |
| amazon.de | 0 of 8 |
| amazon.com.au | 0 of 5 |

The unpriced rows are not failures to read. On those pages Amazon sends everything, twenty specifications, the rating, the brand, every image, and leaves the buy box out, mostly for products it will not ship to the country your request appears to come from. Which products price and which do not is set by Amazon per product, not by this Actor. Five approaches were tried before writing this paragraph, including the shop's own language, matching country addresses, locale cookies and the mobile page.

Two things follow. Rows without a price are delivered in full and are never charged for, so a marketplace that will not give you prices costs you nothing to find out. And the `currency` field reports what Amazon actually quoted: amazon.ca, for example, quotes US dollars to a visitor it places in the United States.

Run a small job on your marketplace first and see what you get.

### It will not guess a price

Amazon puts up to nine price-shaped numbers on a product page: the subscribe-and-save option, a used offer, a struck-through list price, a per-unit price, a bundle. Reading markup and picking one gets it wrong more often than it gets it right.

This Actor takes the price from the buy box data Amazon itself uses to render the page. Nowhere else. Nine out of nine correct in the test set against zero out of six for markup reading.

When that data is not on the page, you get no price rather than a wrong one, and the row arrives with everything else filled in. The `priceSource` field tells you where every price came from.

### What you get per product

Sixty-four fields. The market leader offers 56.

#### Price and offer

| Field | What it holds |
| --- | --- |
| `price` | Current price from Amazon's own buy box data |
| `listPrice` | The struck-through price, when Amazon shows one |
| `savingsAmount` | How much is off in money |
| `discountPercent` | How much is off as a percentage |
| `currency` | Three-letter code, from the page itself |
| `pricePerUnit` | Price per count, ounce, litre, whatever Amazon uses |
| `priceSource` | Where the price came from, so you can audit it |
| `isDiscounted` | Whether it is currently below list price |
| `coupon` | The clip-coupon text, when there is one |
| `dealBadge` | Lightning deal, limited time deal, and similar |
| `hasSubscribeAndSave` | Whether a subscription price exists |
| `hasUsedOffer` | Whether a used copy is offered |
| `isRefurbished` | Renewed and refurbished listings |
| `otherSellersCount` | How many other sellers offer it |

#### Demand and rank

| Field | What it holds |
| --- | --- |
| `boughtInPastMonth` | Units bought last month as a number |
| `boughtInPastMonthText` | Amazon's own wording, such as 10K+ bought in past month |
| `estimatedMonthlySales` | Units, derived from the line above |
| `estimatedMonthlyRevenue` | Units times price |
| `bestsellerRanks` | Every rank with its category, not just the first |
| `isBestSeller` | The orange best seller badge |
| `isAmazonChoice` | The Amazon's Choice badge |
| `rating` | Average stars, read in every shop language |
| `reviewCount` | How many ratings, as a number |

#### Stock and delivery

| Field | What it holds |
| --- | --- |
| `inStock` | True, false, or null when Amazon does not say |
| `availability` | Amazon's own availability sentence |
| `stockLeft` | Only three left in stock, when shown |
| `deliveryInfo` | The delivery date Amazon promises |
| `returnPolicy` | The return terms in full |
| `isPrime` | Prime delivery on this offer |

#### Identity and catalogue

| Field | What it holds |
| --- | --- |
| `asin` | The product id |
| `parentAsin` | The parent listing, for variant families |
| `title` | Full product title, shortened only past 1000 characters |
| `brand` | Brand name |
| `manufacturer` | Manufacturer, when different from brand |
| `modelNumber` | Model number |
| `partNumber` | Manufacturer part number |
| `gtin` | GTIN, EAN or UPC |
| `marketplace` | Which shop this row came from |
| `url` | The page this was read from |
| `scrapedAt` | Timestamp of the read |

#### Description, media and variants

| Field | What it holds |
| --- | --- |
| `description` | The product description under the fold, as plain text |
| `features` | The bullet points at the top |
| `image` | Main image at the largest size Amazon offers |
| `images` | Every gallery image, largest version first |
| `imageCount` | How many images there are |
| `videoCount` | How many videos are on the page |
| `hasAPlusContent` | Whether the brand added enhanced content |
| `variantAsins` | Sibling products in the variant family |
| `variantCount` | How many variants there are |
| `variantAttributes` | What varies, such as size and colour |
| `category` | The most specific category |
| `categories` | The full breadcrumb path |

#### Specifications, pulled apart

Amazon names the same fact half a dozen ways depending on the page. Item Weight, Product Weight, Gewicht, Poids. You get one name for it.

| Field | What it holds |
| --- | --- |
| `specifications` | Every row of every detail table, merged |
| `productFacts` | Amazon's newer facts panel |
| `weight` | Weight with its unit |
| `dimensions` | Package or product dimensions |
| `colour` | Colour |
| `material` | Material |
| `unitCount` | How many units in the pack |
| `firstAvailable` | Date first available on Amazon |
| `countryOfOrigin` | Country of origin |
| `warranty` | Warranty description |
| `importantInformation` | Safety and legal text, when present |
| `isClimatePledgeFriendly` | The Climate Pledge Friendly badge |

### A real row

One product from a real run, trimmed to the interesting parts:

```
asin                     B0DXXYS4BJ
title                    Roku Streaming Stick HD with Voice Remote
price                    29.99
currency                 USD
priceSource              buybox-data
inStock                  true
brand                    Roku
category                 Streaming Media Players
rating                   4.6
reviewCount              23344
boughtInPastMonth        10000
estimatedMonthlyRevenue  290000
bestsellerRanks          #6 in Electronics, and one more
imageCount               12
variantCount             3
deliveryInfo             Saturday, August 29
returnPolicy             FREE Returns, return this item for free
```

Thirty-nine fields carried content on that product. Six of the sixty-four were empty because that page does not have a coupon, a deal badge, a used offer or a video.

### You do not need the ASINs

Four ways in, and you can mix them in one run.

Product URLs or ASINs. Paste them in any shape: a bare ASIN, a full product URL with tracking parameters, a shortened link, even a spreadsheet cell that still says `ASIN: B08N5WRWNW`. Duplicates are removed, so you never pay twice for the same product.

Search terms. Type `wireless keyboard` and it walks the search results for you.

Category and bestseller links. Paste `https://www.amazon.com/gp/bestsellers/electronics` and it takes the products off the list.

Search result URLs. Paste a filtered search you built in your own browser and it continues from there.

### Marketplaces

```
com      co.uk    de       fr       es
it       nl       se       pl       com.tr
ae       sa       in       sg       co.jp
com.au   ca       com.mx   com.br
```

Set `marketplace` and the Actor follows it: the right domain, the right language headers, the right currency preference, and a proxy in the matching country when your plan has addresses there.

### Input

| Field | What it does |
| --- | --- |
| `productUrls` | ASINs or Amazon product URLs. Duplicates removed. |
| `search` | Search terms, search URLs, category links, bestseller pages. |
| `marketplace` | One of 19, from `com` to `co.jp`. |
| `proxyCountry` | Leave empty and it follows the marketplace. |
| `maxItems` | Hard ceiling on delivered products. Zero means no ceiling. |
| `maxItemsPerList` | Products to take from each search or category link, up to 10000. |
| `maxListPages` | Result pages to walk per list, up to 100. |
| `lanes` | Products read at once, each on its own exit address. Eight by default, up to 24. Eight is the most accurate. Sixteen halves the run time and costs a few prices, because Amazon strips the buy box sooner when you push. |
| `maxAttempts` | Attempts per product, each from a different address. Twelve by default. |
| `economical` | Stops reading a page once the last field it needs has arrived. |
| `residentialFallback` | Off by default. Retries through residential addresses after half the attempts have failed. |
| `minDelayMs`, `maxDelayMs` | Pause between products, per lane. |
| `proxyConfiguration` | Apify Proxy is on by default. Running without one gets you blocked after roughly 85 to 120 products. |

### How it works, in plain terms

Every product is one page fetch. The Actor asks Amazon for the page, reads it, and writes one row.

Amazon refuses a large share of those requests, so each product gets up to twelve tries, every one of them from a different exit address. A refusal costs about four kilobytes, which makes retrying far cheaper than losing the product.

Addresses that get through are remembered for the rest of the run. The Actor keeps a small squad of proven ones, never uses the same address twice in a row, and drops an address after two refusals. That is the difference between a run that starts well and slowly dies, and a run that gets better as it goes.

Between requests it waits, and the wait grows when Amazon starts saying no more often. Politeness here is about pace per address, not about total speed, which is why running eight products at once through eight different addresses is gentler than one product at a time through one.

Anything still refused at the end goes into a second pass, at half speed, using the squad of proven addresses built up during the first pass. In five runs of sixty products, that second pass was needed once and rescued the product.

### What you can build with it

Price monitoring. Run it on a schedule against a list of ASINs and write the rows to a sheet or a database. `price`, `listPrice`, `savingsAmount` and `deliveryInfo` are the fields that move.

Competitor tracking. Point it at a category or a search and watch which products enter and leave the top ranks, using `bestsellerRanks` and `boughtInPastMonth`.

Product research for private label. `estimatedMonthlyRevenue`, `reviewCount`, `rating` and `otherSellersCount` together tell you whether a niche is worth entering.

Catalogue building. `gtin`, `modelNumber`, `weight`, `dimensions` and `specifications` are what you need to list the same product somewhere else.

Repricing. `price`, `otherSellersCount` and `isPrime` are the inputs a repricer needs.

Feeding a language model. One row per product, consistent field names, no HTML, no marketing fluff.

Dropshipping and arbitrage. `price`, `pricePerUnit`, `otherSellersCount`, `weight` and `dimensions` are what you need to work out whether a product is worth sourcing and shipping.

Brand protection. Watch who else is selling your ASINs with `otherSellersCount`, and whether your listing still holds its `bestsellerRanks`.

Market sizing. Point it at a whole category, take `estimatedMonthlyRevenue` across every product, and you have a defensible number for how big that niche is.

### Working it into your stack

Every run writes to an Apify dataset. From there you can:

Download it as CSV, JSON, Excel or XML from the run page, with one click.

Pull it through the Apify API, in any language, with the run id or the dataset id.

Send it onward automatically with Apify integrations: Google Sheets, Airtable, Slack, Zapier, Make, or a webhook to your own endpoint.

Schedule it. The Schedules tab runs this on a cron of your choosing, which is how most price monitoring is set up: once a day, one list of ASINs, one growing table of prices over time.

Call it from another Actor. This one is a normal Actor, so it can be a step inside a bigger pipeline you build.

### Reading the run log

The log tells you what happened per product, in plain English:

```
6 product(s) on https://www.amazon.com (0 given, 6 found from lists)
4/6 B0DGHMNQ5Z  Apple AirPods 4 Wireless Earbuds 99 USD
1/6 B08JHCVHTY  delivered without a price after 12 attempts; not charged.
Done: 5 charged (+1 delivered without a price, free), 0 refused by Amazon, 0 other.
Exit addresses: 23 used, 3 proven good, 2 burned.
Attempts by outcome: {"refused by Amazon":16,"page carried no buy box":7,"ok":5}
```

The last line is worth understanding. Refused by Amazon means an exit address was turned away and the product was tried again elsewhere. Page carried no buy box means the page arrived complete but without a price. Neither of those is charged for.

### How it compares

| | This Actor | The market leader |
| --- | --- | --- |
| Fields offered | 64 | 56 |
| Fields with content, measured on real runs | 58 | 41 |
| Price, currency, stock | every product | every product |
| Brand, category, rating, reviews | every product | every product |
| Bestseller rank, images, features | every product | every product |
| Units bought last month | every product | every product |
| Specifications | every product | 2 of 5 |
| Monthly sales and revenue estimate | yes | no |
| Discount percent and amount saved | yes | no |
| Price per unit, return policy, delivery | yes | partly |
| Weight, dimensions, model, GTIN, warranty | yes | no |
| Climate Pledge, A plus content, video count | yes | partly |
| Ratings and stock outside English | every marketplace | English wording only |
| Where the price came from | yes | no |
| Seller names, review text | never, by design | returned |

Those two top rows are not taken from anyone's description. They come from running both Actors and counting which fields actually arrived. The market leader offers 56 and left 15 of them empty on every product, including the return policy, the shipping price, the condition and the Amazon's Choice badge.

Its run failure rate over the last 30 days, from Apify's own numbers, is 12.2 percent.

### Measured on sixty products it had never seen

Sixty products taken straight off three Amazon bestseller lists, none of them used while building this. Five runs across a working day:

```
60 asked for    60 delivered    0 blocked    57 priced
60 asked for    60 delivered    0 blocked    57 priced
60 asked for    60 delivered    0 blocked    56 priced
60 asked for    60 delivered    0 blocked    57 priced
60 asked for    59 delivered    0 blocked    49 priced
```

Delivery holds at 60 out of 60. Nothing was lost to a block in any of these runs. The one run that fell short was pushed to sixteen lanes on purpose, to find out what speed costs.

One thing changed since those runs and it belongs here rather than in a footnote. They were measured with the residential fallback on, and that setting now defaults to off, because it turned out to be roughly ninety percent of the bill for two extra products in sixty. Re-measured on 26 August 2026 with the current default: sixty products asked for, sixty delivered, fifty-three priced. Delivery held; the priced share is the thing that moves, and rows without a price are free.

On the last full run, 58 of the 64 fields carried content on at least one product, no price fell outside a possible range, no rating landed outside nought to five, and no product arrived without a title.

Run the same products twice and nothing moves except the things that really move: price, delivery date and bestseller rank. Title, brand, category, rating, review count, image, variants, list price and the badges were identical across runs, every time.

### Blocking, and what actually helps

Amazon refuses roughly six in ten requests to a fresh datacenter address. That is normal and it is not a defect. What matters is what happens next.

Every product gets up to twelve attempts, each from a different exit address. A refused attempt costs about 4 kilobytes, so retrying is cheap insurance.

Addresses that work are remembered. The Actor keeps a small squad of proven addresses, never uses the same one twice in a row, and retires an address after two refusals.

Products that survive all that go into a second pass at the end of the run, at half the lane count, using the squad that has been built up in the meantime.

Pace adapts. When Amazon starts refusing more, the Actor slows down on its own.

### Pricing

Eight dollars per 1000 products with a price, plus three cents to start a run.

You are not charged for a product that arrives without a price, and you are not charged for a product that never arrives. Platform usage is included, so there is nothing on top.

You can cap the spend of any single run. When the cap is reached the Actor stops cleanly instead of running up costs with nothing to show.

### What it does not collect

No review text. No reviewer names. No customer questions and answers. No seller names that could belong to a person.

That is a design decision, not an oversight. Scraping personal data out of a public website is almost always a GDPR problem in Europe, and a purely commercial interest does not count as a legitimate one. An average score and a review count are product facts, not personal data, so you get those.

If you need review text, this is not the Actor for you, and you should think carefully about whether you need it.

### Questions people ask

Does it work without an ASIN. Yes. Give it a search term, a category link or a bestseller page and it finds the products itself.

Can I export to CSV or Excel. Yes. Apify writes every run to a dataset you can download as CSV, JSON, Excel or XML, or pull through the API.

Can I run it on a schedule. Yes, from the Schedules tab in Apify. Price monitoring is the most common reason people do.

How many products can it handle in one run. There is no built-in ceiling. Set `maxItems` to zero, point it at a category, and it keeps going. Sixty products take about nine minutes at the default settings.

Why is a field empty. Because Amazon does not show it on that page. Coupons, deal badges, videos and used offers are on some product pages and not others. Every field that can be read is read.

Why does a product have no price. Either Amazon sent the page without a buy box, which happens often outside amazon.com, or the product genuinely has no price right now, such as a subscription plan or an app. Either way the row is delivered free.

Is my run charged if nothing is found. Only the three cent start fee. A search that returns nothing finishes as a successful, empty run.

### Settings worth knowing about

Lanes. Eight products at once is the tested default and the most accurate. Sixteen finishes the same sixty products in about half the time and returns a few more products without a price, because Amazon strips the buy box sooner when you push. Twenty-four is the ceiling. If you raise lanes for a large job, raise the run memory with it.

Attempts. Twelve per product by default. Lowering it makes runs cheaper and loses products; raising it rarely helps, because a product that fails twelve different addresses is usually a page Amazon will not serve today.

Residential fallback. Off by default. After half the attempts on a product have failed, it retries through residential addresses instead of datacenter ones. Measured 2026-08-26 on two sixty-product runs of the same list: with it on, 53 products came back priced for $0.1192 of platform usage; with it off, 51 came back priced for $0.0205. Residential transfer was ninety percent of the bill and bought two products. Turn it on when a marketplace is refusing everything, and leave it off the rest of the time.

Economical mode. Off by default. When on, the Actor stops downloading a page as soon as the last field it needs has arrived, and loses the fields that sit late in the page, mostly ratings and review counts. Measured 2026-08-26 across three pairs of runs, the bandwidth it saves ranged from 18 percent to minus 6 percent, so treat it as a way to drop late fields rather than as a saving. Hanging up mid-page produces aborted connections that come back as retries, and a retry downloads the whole page again.

Proxy country. Leave it empty and it follows the marketplace. Setting it by hand is only useful when you want prices as they appear to a shopper in a specific country.

Maximum cost per run. Set by you, honoured by the Actor. When the cap is reached it stops cleanly, mid-run, rather than continuing to spend.

### Legal note

This Actor reads pages that are public and takes only product facts. Product data, prices, availability and aggregate ratings are business information about an item, not information about a person.

You are responsible for what you do with the output. Check Amazon's terms for your own use case, and if you are in Europe, keep in mind that combining public data into a profile of a person is a different activity from tracking the price of a lamp.

# Actor input Schema

## `productUrls` (type: `array`):

Amazon product URLs or bare ASINs, one per line. Leave empty if you are using Search instead. Duplicates are removed so you are never charged twice.

## `search` (type: `array`):

Anything that lists products: a plain search term ("tower fan"), an Amazon search URL, a category link, or a bestsellers page. Each one is crawled and every product found is scraped. Use this when you do not know the ASINs up front.

## `marketplace` (type: `string`):

Which Amazon site to read. The currency of the price follows the marketplace and the proxy country.

## `proxyCountry` (type: `string`):

Which country the requests should appear to come from. Leave empty and it follows the marketplace: amazon.de is read from Germany, amazon.co.uk from the UK. This matters more than it looks -- Amazon shows different prices, currencies and even availability depending on where you appear to be.

## `maxItems` (type: `integer`):

Hard ceiling on delivered products. 0 means no ceiling: the Actor keeps going until the lists run out or your limits stop it.

## `maxItemsPerList` (type: `integer`):

Products to take from each search term or category link. Up to 10000.

## `proxyConfiguration` (type: `object`):

Datacenter proxies were enough in testing: 30 out of 30 products returned with zero blocks. They are the cheaper option and the default. Switch to residential if you start seeing blocked pages at higher volume. Running without any proxy stops after roughly 85-120 products, because Amazon closes the door on a single IP address for over an hour.

## `lanes` (type: `integer`):

How many products to read at the same time. Each lane uses its own exit address, so more lanes never means asking one address more often. Eight is the tested default and the most accurate. Sixteen finishes the same sixty products in about half the time, but measured on 2026-08-24 it returned six more products without a price, because Amazon strips the buy box sooner under pressure. Raise it when speed matters more than the last few prices.

## `maxAttempts` (type: `integer`):

How often to retry a product Amazon refuses, each time from a different exit IP. A refusal is a property of one address, not of the product, and a refused attempt costs about 4 KB. Twelve tries is cheap insurance against a run that comes back short.

## `residentialFallback` (type: `boolean`):

After half the attempts have failed, retry through residential addresses instead of datacenter ones. Measured 2026-08-26: residential transfer was 90 percent of the bill on a sixty product run ($0.150 of $0.167) while a run that never touched it delivered all sixty anyway. Leave it off unless you are losing products; turn it on when a marketplace refuses everything.

## `economical` (type: `boolean`):

Hang up on each product page once the price is in, instead of reading it to the end. Roughly three times less traffic and about three times faster. Measured cost: over 30 products this lost 2 ratings, 4 review counts and 1 brand, because Amazon sometimes puts the rating below the price. Prices were identical either way. Leave this off unless you only need prices and are paying per gigabyte.

## `engine` (type: `string`):

"Built-in" is the default because it measured better: 12 of 15 against 7 of 15 for the browser-like client on the same list. Browser-like mimics a real Chrome handshake and may do better on other days -- both are kept so you can compare.

## `maxListPages` (type: `integer`):

Result pages to walk per list. Up to 100. Amazon itself stops earlier on most searches.

## `minDelayMs` (type: `integer`):

Pause between products. Measured 2026-08-23: at 1-2 seconds this returned 10 of 15 products; at 8-15 seconds it returned 12 of 15 on the same list. Pace turned out to matter more than anything else. The market leader waits about 14 seconds per product.

## `maxDelayMs` (type: `integer`):

Upper bound for the pause between products. The actual pause is random between the minimum and this value, which looks less mechanical than a fixed interval.

## `retryPauseMs` (type: `integer`):

How long to wait before trying a refused product again. Kept short because the retry already switches to a different exit IP, and waiting longer only makes the run more expensive.

## `diagnostics` (type: `boolean`):

Log which building blocks each page contains. For maintenance only.

## Actor input object example

```json
{
  "productUrls": [
    "B09B8V1LZ3",
    "https://www.amazon.com/dp/B0DXXYS4BJ"
  ],
  "search": [],
  "marketplace": "com",
  "maxItems": 0,
  "maxItemsPerList": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "lanes": 8,
  "maxAttempts": 12,
  "residentialFallback": false,
  "economical": false,
  "engine": "own",
  "maxListPages": 5,
  "minDelayMs": 8000,
  "maxDelayMs": 15000,
  "retryPauseMs": 300,
  "diagnostics": false
}
```

# Actor output Schema

## `products` (type: `string`):

One row per product, 64 fields. Rows without a price are delivered in full and are never charged for.

## `summary` (type: `string`):

Counts per outcome, exit addresses used, and bytes per delivered result.

# 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 = {
    "productUrls": [
        "B09B8V1LZ3",
        "https://www.amazon.com/dp/B0DXXYS4BJ"
    ],
    "search": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("amazonscrapers/amazon-product-details").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 = {
    "productUrls": [
        "B09B8V1LZ3",
        "https://www.amazon.com/dp/B0DXXYS4BJ",
    ],
    "search": [],
}

# Run the Actor and wait for it to finish
run = client.actor("amazonscrapers/amazon-product-details").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 '{
  "productUrls": [
    "B09B8V1LZ3",
    "https://www.amazon.com/dp/B0DXXYS4BJ"
  ],
  "search": []
}' |
apify call amazonscrapers/amazon-product-details --silent --output-dataset

```

## MCP server setup

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

```

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/UGXhx3kNugIa0vEca/builds/hz2HqM7KvNTOslZVR/openapi.json