# Amazon Product Details Scraper (`scraper-engine/amazon-product-details-scraper`) Actor

Scrape detailed Amazon product data effortlessly! This actor extracts titles, prices, ratings, reviews, ASINs, images, availability, and more from product pages or search results. Ideal for e-commerce insights, market analysis, and price monitoring across Amazon marketplaces worldwide.

- **URL**: https://apify.com/scraper-engine/amazon-product-details-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 6 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 — Price, Rating, Reviews and Rank Data

Amazon Product Details Scraper turns a list of Amazon ASINs or product URLs into one structured JSON record per product — featured-offer price, list price, brand, star rating and its histogram, bestseller rank, the full attribute table, images, variation ASINs and the reviews shown on the page. No parsing, no CSS selectors: every field arrives typed and ready to load into a database, spreadsheet or LLM pipeline. Run it on Apify and the first product record streams back before the run finishes.

### What is Amazon Product Details Scraper?

Amazon Product Details Scraper is an Apify Actor that fetches a set of Amazon ASINs or product URLs and returns one structured product record for each — price, brand, rating, the attribute table, images, variations and the reviews shown on the page. It reads Amazon's public product pages directly; no Amazon account, API key or login is required to run it. It's built for e-commerce teams, market researchers and AI engineers who need consistent, typed product data without maintaining their own scraper or Amazon credentials.

### What Amazon product data is publicly available to scrape?

Everything a shopper sees on a product page without signing in is public — title, price, rating, attributes and reviews included. Placing an order, submitting a review, or seeing a Prime-exclusive deal price requires a signed-in Amazon account.

| Data category | Publicly available | Restricted (needs a signed-in Amazon account) |
| --- | --- | --- |
| Title, brand/author, description, images | ✅ visible to any visitor | |
| Featured-offer price, list price, delivery estimate | ✅ for the marketplace and country you request | Prime-exclusive deal pricing, shown only to a signed-in Prime session |
| Star rating, rating histogram, bestseller rank | ✅ | |
| Full product attribute / specification table | ✅ | |
| Reviews rendered on the product page | ✅ | Submitting a review; browsing beyond the page's own review list |
| Variation ASINs, format editions (Kindle/Hardcover/etc.) | ✅ | |
| Seller name, fulfiller and seller ID of the featured offer | ✅ | Contacting the seller directly |

Amazon Product Details Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

### What data can I extract with Amazon Product Details Scraper?

Every run returns identity and descriptive fields, pricing and rating metrics, and media/review/nested data for each ASIN — 45 fields per product record in total.

#### 🏷️ Identity, description and attribute fields

| Field name | Description |
| --- | --- |
| `asin` | The 10-character Amazon Standard Identification Number. |
| `url` | The product page URL that was fetched. |
| `amazonDomain` | The marketplace the record was read from, e.g. `amazon.com`. |
| `title` | Product title. |
| `manufacturer` | Brand, read from the product's brand attribute. `null` on listings that publish an author instead. |
| `author` | Author credit for books and media. `null` for non-book products. |
| `warehouseAvailability` | Stock text as shown on the page, e.g. `In Stock`, `Only 2 left in stock`. |
| `soldBy` | Merchant name of the featured offer. |
| `fulfilledBy` | Who ships the featured offer. |
| `sellerId` | Merchant ID of the featured offer, read from the add-to-cart form. |
| `features` | Bullet-point feature list. |
| `aboutProduct` | The product overview table as `{name, value}` pairs. |
| `productDetails` | The full attribute table, merged across the layouts Amazon alternates between, as `{name, value}` pairs. |
| `productSpecification` | The same attribute list as `productDetails` (both keys are populated from the same parse). |
| `attributeCount` | Number of attribute rows in `productDetails`. |
| `productDescription` | Description / book description text. |
| `categoriesExtended` | Breadcrumb trail as `{name, url, node}`, with the Amazon category node ID. |
| `importantInformation` | Safety/important-information bullet list. Present only on listings that publish it. |
| `pastSales` | Social-proof sales text, e.g. `"10K+ bought in past month"`, when Amazon shows it. |
| `variations` | Sibling ASINs of the same parent product, with their size/colour/style labels — see below. |
| `bookVariations` | Kindle / Hardcover / Paperback / Audiobook editions, with price, ASIN and link. |
| `language` | The `language` input value used for this run, echoed back on the row. |
| `proxyCountry` | The country the request was priced for. |

#### 💲 Price, rating, availability and status fields

| Field name | Description |
| --- | --- |
| `statusCode` | `200` when the page was read, `404` when Amazon has no page for the ASIN, `0` when the page could not be read after retries. |
| `statusMessage` | `FOUND`, `NOT_FOUND`, or `UNAVAILABLE`. |
| `success` | `true` only when `statusMessage` is `FOUND`. |
| `productRating` | Star rating as text, e.g. `"4.6 out of 5 stars"`. |
| `countReview` | Number of ratings. |
| `starsBreakdown` | Percentage of ratings per star, e.g. `{"5star":81,"4star":11,...}`. `null` when Amazon shows no histogram. |
| `bestsellerRanks` | Best Sellers Rank per category, as `{rank, category, url}`. |
| `buyBoxPresent` | Whether a featured-offer price was shown on the page. |
| `buyBoxCondition` | `"New"`, `"Used"`, or `null` when no featured offer is shown. |
| `price` | The featured-offer price, read only from inside the buy-box container. `null` when `buyBoxPresent` is `false` — never `0`, never a different item's price. |
| `retailPrice` | List / "was" price. Only returned when it is genuinely above the current price. |
| `priceSaving` | `retailPrice − price`, rounded to 2 decimals, only when both are real. |
| `buyBoxUsed` | `{price, condition}` for the used offer, when the page shows one; otherwise `null`. |
| `shippingPrice` | `0.0` for free delivery, the charged amount when shown, `null` when the page shows no delivery line. |
| `priceShippingInformation` | The delivery/shipping line as written on the page. |
| `deliveryMessage` | Same delivery text as `priceShippingInformation` (both keys are populated from the same parse). |

#### 🖼️ Media, reviews and run metadata

| Field name | Description |
| --- | --- |
| `mainImage` | `{imageUrl, width, height, imageResolution}` — the largest gallery image and its measured dimensions. `null` if no image is found. |
| `imageUrlList` | Gallery image URLs, largest first. |
| `videoeUrlList` | Video URLs (`.mp4` / `.m3u8`) featured on the product page. *(This is the exact key name the Actor returns — it carries a spelling irregularity in the source, not a typo in this document.)* |
| `reviews` | Every review rendered on the product page, each with `reviewId`, `title`, `text`, `rating`, `date`, `userName`, `profilePath`, `url`, `verifiedPurchase`, `helpfulVotes`, `reviewCountry`, `locale` (`{language, country, countryName, marketplaceId}`), `variationList` and `imageUrlList`. |
| `reviewsOnPage` | Count of items in `reviews`. |
| `scrapedAt` | ISO-8601 UTC timestamp of when the row was collected. |

#### 🤖 Add-on: Need additional Amazon data?

Pair this Actor with **Amazon Search Scraper** to first turn a keyword into a list of ASINs, or **Amazon Price Tracker** to watch these same fields change over time. For seller-side research on the German marketplace, **Amazon DE Sellers Leads Scraper** returns seller business details instead of product details.

### How does Amazon Product Details Scraper differ from the official Amazon API?

Amazon's official product-data API for third parties is the **Creators API**, which replaced Product Advertising API 5.0 (PA-API); Amazon's own documentation confirms PA-API is deprecated and calls to it now return a 403 `AccessDeniedException` directing callers to migrate ([affiliate-program.amazon.com, checked 2026-08-15](https://affiliate-program.amazon.com/creatorsapi/docs/en-us/paapiv5-deprecation)). Both the old and new API are scoped to Amazon's affiliate program, not general-purpose product-data access.

| Feature | Amazon Creators API (official) | Amazon Product Details Scraper |
| --- | --- | --- |
| Who can get access | An approved Amazon Associate with at least 10 qualifying sales in the past 30 days ([affiliate-program.amazon.com, checked 2026-08-15](https://affiliate-program.amazon.com/creatorsapi/docs)) | Any Apify account — no Amazon account or sales history needed |
| Built for | Publishers, influencers and affiliate partners monetizing product links ([affiliate-program.amazon.com, checked 2026-08-15](https://affiliate-program.amazon.com/creatorsapi/docs)) | Anyone needing structured product data — research, price monitoring, catalog enrichment, AI pipelines |
| Predecessor status | Replaces PA-API 5.0, now deprecated by Amazon ([affiliate-program.amazon.com, checked 2026-08-15](https://affiliate-program.amazon.com/creatorsapi/docs/en-us/paapiv5-deprecation)) | N/A — reads the public product page directly, independent of Amazon's affiliate program |
| Access continuity | Tied to maintaining the qualifying-sales threshold | Not tied to any sales or account performance |
| Setup | Associates account approval, then Creators API registration | Paste ASINs or product URLs, run |

Use the Creators API if you're an approved Associate monetizing affiliate links and want data tied to your account. Use Amazon Product Details Scraper when you need ASIN-level product data without an Associates account, a sales history, or ongoing eligibility to maintain.

### How to use Amazon Product Details Scraper

Amazon Product Details Scraper is published on the Apify Store and runs like any other Apify Actor — no separate signup or API key beyond your Apify account.

1. Open the Actor's page in Apify Console and click **Try for free** (or **Run**, if you already use it).
2. Provide the required input, `asins` — a list of bare ASINs, `/dp/` URLs, or `/gp/product/` URLs, one per line.
3. Optionally set `amazonDomain` to a different marketplace, `language` to force page language, or `proxyCountry` to change which country's prices are read.
4. Start the run.
5. Download the results as JSON, CSV, Excel or the other export formats Apify's dataset supports, or stream them via the API as each row is pushed.

⚠️ **Every ASIN you submit is billed, even if it fails.** The Actor charges the `row_result` pay-per-event on every `push_data` call — including rows where the ASIN turned out to be delisted (`NOT_FOUND`) or couldn't be read after retries (`UNAVAILABLE`). There's no separate uncharged accounting row, and no built-in filter for it — check `success` (or `statusMessage`) in your own results if you need to separate collected products from misses.

#### How to scale to bulk product extraction

`asins` is an array — add as many ASINs or product URLs as you want in one run, and they're processed one after another with a result pushed to the dataset as soon as each is collected, so you don't wait for the whole list to finish before reading results. There is no fixed cap in the input schema.

### What can you do with Amazon product data?

- 🏷️ **Catalog managers** enrich a product feed using `manufacturer`, `productDetails` and `mainImage` to fill in brand, specifications and imagery without manual entry.
- 💰 **Price analysts** track `price`, `retailPrice` and `priceSaving` across a list of ASINs to catch discounting patterns before a launch or a competitor's promotion.
- 🏆 **Category researchers** use `bestsellerRanks` and `starsBreakdown` to see where a product sits in its category and how its ratings are actually distributed.
- 📮 **Operations teams** check `soldBy`, `fulfilledBy` and `warehouseAvailability` to confirm who is fulfilling an offer before relying on it for sourcing decisions.
- 🤖 **AI engineers** feed `title`, `productDescription`, `features` and `reviews[].text` into a RAG pipeline or agent tool for product-question answering grounded in real listing text.

### How does Amazon Product Details Scraper handle rate limits and blocking?

Every request routes through Apify Proxy — by default the `RESIDENTIAL` proxy group. If a page isn't served correctly on the current connection tier, the next attempt escalates to a fallback tier and opens a fresh proxy session. Each ASIN gets up to 6 fetch attempts before it's marked unavailable, with an increasing pause between attempts and a short random pause between products in the same run. A page is only accepted as a real product page when it returns HTTP 200, contains the product title, and doesn't match the structural markers Amazon's own verification/interstitial pages carry — a captcha or bot-check page is never mistaken for a product page. The scraper does not solve CAPTCHAs; it retries with a new session and proxy tier instead. If a product still can't be read after every attempt, the row is returned with `statusMessage: "UNAVAILABLE"` rather than failing the whole run.

### ⬇️ Input

| Parameter | Required | Type | Description | Example value |
| --- | --- | --- | --- | --- |
| `asins` | Yes | array of strings | One product per line. Accepts a bare ASIN (`B07GBZ4Q68`), a `/dp/` URL, or a `/gp/product/` URL. Duplicates are collapsed. | `["B07GBZ4Q68", "https://www.amazon.com/dp/B00FLYWNYQ"]` |
| `amazonDomain` | No | string (select) | The marketplace the ASINs are read from. Prices, availability and delivery text are marketplace-specific. Default `"amazon.com"`. | `"amazon.co.uk"` |
| `language` | No | string (select) | Forces the language of the product page text (titles, bullet points, attribute names). Leave empty to use the marketplace default. Default `""` (marketplace default). | `"de-DE"` |
| `proxyCountry` | No | string (select) | `AUTO` matches the marketplace above. Choosing a country that doesn't match the marketplace can return a different currency and different delivery figures for the same ASIN. Default `"AUTO"`. | `"GB"` |
| `proxyConfiguration` | No | object | Connection settings for the run. Default is the configuration these pages are reliably served on. Default `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}`. | `{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}` |

**`amazonDomain` enum values:** `amazon.com`, `amazon.co.uk`, `amazon.de`, `amazon.fr`, `amazon.es`, `amazon.it`, `amazon.nl`, `amazon.se`, `amazon.pl`, `amazon.com.be`, `amazon.ie`, `amazon.ca`, `amazon.com.mx`, `amazon.com.br`, `amazon.com.au`, `amazon.co.jp`, `amazon.in`, `amazon.sg`, `amazon.ae`, `amazon.sa`, `amazon.eg`, `amazon.com.tr`.

**`language` enum values:** `""` (marketplace default), `en-US`, `en-GB`, `de-DE`, `fr-FR`, `es-ES`, `it-IT`, `ja-JP`, `zh-CN`.

**`proxyCountry` enum values:** `AUTO`, `US`, `GB`, `DE`, `FR`, `ES`, `IT`, `NL`, `SE`, `PL`, `BE`, `IE`, `CA`, `MX`, `BR`, `AU`, `JP`, `IN`, `SG`, `AE`, `SA`, `EG`, `TR`.

#### Example input

```json
{
  "asins": [
    "B07GBZ4Q68",
    "https://www.amazon.com/dp/B00FLYWNYQ",
    "0735211299"
  ],
  "amazonDomain": "amazon.com",
  "language": "",
  "proxyCountry": "AUTO",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### ⬆️ Output

One typed JSON row per ASIN, pushed to the dataset the moment it's collected — the schema is identical whether the product was found, not found, or unreadable. Export as JSON, CSV, Excel, XML, RSS or HTML directly from the Apify Console, or read it through the API.

#### Example output

```json
{
  "statusCode": 200,
  "statusMessage": "FOUND",
  "success": true,
  "url": "https://www.amazon.com/dp/B07GBZ4Q68",
  "asin": "B07GBZ4Q68",
  "amazonDomain": "amazon.com",
  "title": "Logitech G502 Hero Wired Gaming Mouse",
  "manufacturer": "Logitech G",
  "author": null,
  "productRating": "4.6 out of 5 stars",
  "countReview": 58460,
  "starsBreakdown": { "5star": 81, "4star": 11, "3star": 4, "2star": 1, "1star": 3 },
  "bestsellerRanks": [
    { "rank": 17, "category": "Video Games", "url": "https://www.amazon.com/gp/bestsellers/videogames" },
    { "rank": 2, "category": "PC Gaming Mice", "url": "https://www.amazon.com/gp/bestsellers/pc-mice" }
  ],
  "buyBoxPresent": true,
  "buyBoxCondition": "New",
  "price": 31.99,
  "retailPrice": 69.99,
  "priceSaving": 38.0,
  "buyBoxUsed": { "price": 26.52, "condition": "Used - Good" },
  "shippingPrice": 0.0,
  "priceShippingInformation": "FREE delivery Friday, August 14 on orders shipped by Amazon over $35",
  "deliveryMessage": "FREE delivery Friday, August 14 on orders shipped by Amazon over $35",
  "warehouseAvailability": "In Stock",
  "soldBy": "Amazon.com",
  "fulfilledBy": "Amazon.com",
  "sellerId": "ATVPDKIKX0DER",
  "features": ["HERO 25K sensor with a software-adjustable DPI range", "11 programmable buttons"],
  "aboutProduct": [{ "name": "Brand", "value": "Logitech G" }],
  "productDetails": [
    { "name": "Connectivity Technology", "value": "USB" },
    { "name": "Item model number", "value": "910-005469" }
  ],
  "productSpecification": [
    { "name": "Connectivity Technology", "value": "USB" },
    { "name": "Item model number", "value": "910-005469" }
  ],
  "attributeCount": 36,
  "productDescription": "The Logitech G502 HERO high-performance gaming mouse features an advanced optical sensor.",
  "categoriesExtended": [
    { "name": "Video Games", "url": "https://www.amazon.com/video-games", "node": "468642" }
  ],
  "importantInformation": [],
  "pastSales": "10K+ bought in past month",
  "mainImage": {
    "imageUrl": "https://m.media-amazon.com/images/I/61mpMH5TzkL._AC_SL1500_.jpg",
    "width": 1500,
    "height": 1500,
    "imageResolution": "1500 x 1500"
  },
  "imageUrlList": [
    "https://m.media-amazon.com/images/I/61mpMH5TzkL._AC_SL1500_.jpg",
    "https://m.media-amazon.com/images/I/71a2j3B0jVL._AC_SL1500_.jpg"
  ],
  "videoeUrlList": [
    "https://m.media-amazon.com/images/S/vse-vms-transcoding-artifact/default.jobtemplate.hls.m3u8"
  ],
  "variations": [
    {
      "variationName": "color / connectivity / style",
      "values": [
        {
          "asin": "B0BL66ZW9H",
          "value": "Black / Wired / Mouse + Mousepad",
          "labels": ["Black", "Wired", "Mouse + Mousepad"],
          "dpUrl": "https://www.amazon.com/dp/B0BL66ZW9H",
          "selected": false
        }
      ]
    }
  ],
  "bookVariations": [],
  "reviews": [
    {
      "reviewId": "R1ABCD2EFGH3IJ",
      "title": "Best mouse I have owned",
      "text": "Comfortable grip, tracks perfectly on every surface I've tried.",
      "rating": "5.0 out of 5 stars",
      "date": "Reviewed in the United States on July 2, 2026",
      "userName": "Alex R.",
      "profilePath": "/gp/profile/amzn1.account.EXAMPLE",
      "url": "https://www.amazon.com/gp/customer-reviews/R1ABCD2EFGH3IJ",
      "verifiedPurchase": true,
      "helpfulVotes": 14,
      "reviewCountry": "the United States",
      "locale": { "language": null, "country": "US", "countryName": "the United States", "marketplaceId": "ATVPDKIKX0DER" },
      "variationList": ["Color: Black"],
      "imageUrlList": []
    }
  ],
  "reviewsOnPage": 13,
  "language": null,
  "proxyCountry": "US",
  "scrapedAt": "2026-08-15T09:12:41Z"
}
```

### How does it work?

Amazon Product Details Scraper opens a fresh session for each connection tier, warms it up against the marketplace's homepage, then requests each product page directly through Apify Proxy — by default the `RESIDENTIAL` group, priced for the country implied by the marketplace you picked (or the country you set explicitly). Amazon's anti-bot and verification pages are detected structurally, by the markers those interstitial pages carry, not by a keyword guess; a page that matches one is retried with a new session rather than parsed as a product. Only the HTML Amazon serves to that session is read — nothing is submitted, nothing is clicked, and no Amazon account is used. Because the parser targets the same structural containers (buy box, product overview table, detail bullets, review nodes) rather than page-wide text matching, the output field names and shapes stay stable even when Amazon changes a page's visual layout.

### Integrations

Amazon Product Details Scraper works with the tools you already use for automation and analysis — no plugin required, since it's just an Apify Actor reachable over the standard Apify API.

#### Calling Amazon Product Details Scraper programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("scraper-engine/amazon-product-details-scraper").call(run_input={
    "asins": ["B07GBZ4Q68", "https://www.amazon.com/dp/B00FLYWNYQ"],
    "amazonDomain": "amazon.com",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["asin"], item.get("price"))
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request against the Apify API.

#### No-code tools (n8n, Make, LangChain)

In **n8n**, use the HTTP Request node pointed at the Actor's run-sync-get-dataset-items endpoint with your API token, or the dedicated Apify node if you have it installed. In **Make**, the Apify app's "Run an Actor" module accepts the same `asins` input and returns the dataset items to the next module. In **LangChain**, the `ApifyWrapper` / Apify Actor tool can call this Actor and load its dataset directly as `Document` objects for a retrieval pipeline.

### Is it legal to scrape Amazon product data?

Scraping publicly available product data is generally lawful — Amazon Product Details Scraper returns only what any visitor's browser can already load from a product page, without bypassing a login, password or paywall. Product listings, prices and attribute tables are business/product data, not personal data, so GDPR and CCPA do not attach to the bulk of this Actor's output; the relevant frameworks instead are Amazon's own terms of service and the database-rights protections that can apply to a compiled catalogue in some jurisdictions. The `reviews` field does carry a reviewer's public display name and profile link exactly as Amazon shows them on the page — treat that slice of the output with the same care you'd give any publicly posted username. Consult legal counsel if your use case involves bulk storage of personal data.

### Frequently asked questions

#### What Amazon product fields does Amazon Product Details Scraper return?

The top fields are `title`, `price`, `manufacturer`, `productRating` and `bestsellerRanks`. See [What data can I extract](#what-data-can-i-extract-with-amazon-product-details-scraper) above for the complete field tables — 45 fields per record in total.

#### Does Amazon Product Details Scraper require an Amazon account or login?

No. It reads the public product page exactly as a browser would — no Amazon account, API key or login is needed to run it.

#### How many products can I extract in one run?

As many ASINs or product URLs as you add to the `asins` list — there's no fixed cap in the input schema. Each is processed sequentially and pushed to the dataset as soon as it's collected, so results start streaming before the run finishes.

#### What happens if a product is delisted or out of stock?

A delisted ASIN — one Amazon has no page for — returns `statusMessage: "NOT_FOUND"` with `success: false` and an otherwise empty row, so a bad identifier is visible rather than silently dropped. An out-of-stock product is different: if the page still loads, you get a normal `success: true` row with `buyBoxPresent: false` and `price: null`, since there's no featured offer to report a price for. If the page can't be read at all after every retry, the row comes back as `statusMessage: "UNAVAILABLE"`.

#### Can I scrape multiple Amazon ASINs at once?

Yes — `asins` is an array; add as many ASINs or product URLs as you need in a single run.

#### Does Amazon Product Details Scraper work with Claude, ChatGPT and other AI agent tools?

Yes, as an HTTP endpoint. Any agent framework that can call the Apify API — directly or through `apify_client` — can start a run and read the resulting JSON rows as tool output.

#### How does Amazon Product Details Scraper compare to other Amazon scrapers?

Most Amazon ASIN scrapers return a price for every row by grabbing the first price-looking element on the page — which can be an accessory's price, a carousel item's price, or a per-unit price. This Actor reads `price` only from inside the buy-box container; when that container has no price, the row reports `buyBoxPresent: false` and `price: null` instead of substituting a different number.

#### Does Amazon Product Details Scraper return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with consistent field names across runs — no HTML parsing, no selectors. Pass it directly to an LLM, index it into a vector store, or feed it to an agent tool.

#### What happens when Amazon changes its page layout or anti-bot system?

The Actor is maintained, and the output field names and shapes stay stable across layout changes because the parser targets structural containers rather than page-wide text matching. No specific turnaround time is promised for any given layout change.

#### Can I use Amazon Product Details Scraper without managing proxies or browser infrastructure?

Yes — proxy connections, session handling and retry/escalation on a blocked or interstitial page are all handled by the Actor through Apify Proxy. You don't configure or run any infrastructure yourself.

#### Which Amazon product fields work best for AI training data and RAG indexing?

For RAG, index the high-information text fields: `title`, `productDescription`, `features` and `reviews[].text`. For training data, the most consistently structured fields across records are `price`, `productRating`, `countReview` and `productDetails`. All fields return as typed primitives (strings, numbers, booleans, or plain arrays/objects) rather than raw HTML.

### Related scrapers

| Scraper | What it extracts |
| --- | --- |
| Amazon Search Scraper | Amazon keyword or search-URL results as structured product rows: ASIN, title, price, rating and organic rank |
| Amazon Price Tracker | Amazon prices, ratings, reviews, sellers and stock for a list of ASINs |
| Amazon DE Sellers Leads Scraper | Seller leads from Amazon.de with business details, price, ratings and contact info |
| eBay Product Listing Scraper | eBay listing data: titles, prices, conditions, images and product links |
| Shopify Products Scraper | A Shopify store's full product catalogue: variants, SKUs, price range and stock |
| Walmart Reviews Scraper | Walmart product reviews |

### Your feedback

Found a bug, or missing a field you need from an Amazon product page? Open an issue on this Actor's **Issues** tab in Apify Console — that's the fastest way to reach the maintainer directly.

# Actor input Schema

## `asins` (type: `array`):

One product per line. Accepts a bare ASIN (B07GBZ4Q68), a /dp/ URL, or a /gp/product/ URL. Duplicates are collapsed. Example: B07GBZ4Q68 + https://www.amazon.com/dp/B00FLYWNYQ → 2 product records.

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

The marketplace the ASINs are read from. Prices, availability and delivery text are marketplace-specific. Default is amazon.com.

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

Forces the language of the product page text (titles, bullet points, attribute names). Leave empty to use the marketplace default. Example: de-DE on amazon.com returns the German rendering of the same product.

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

AUTO matches the marketplace above (amazon.com → US, amazon.co.uk → GB, and so on). Choosing a country that does not match the marketplace can return a different currency and different delivery figures for the same ASIN.

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

Connection settings for the run. The default is the configuration these pages are reliably served on — leave it as it is unless you have a specific requirement.

## Actor input object example

```json
{
  "asins": [
    "B07GBZ4Q68"
  ],
  "amazonDomain": "amazon.com",
  "language": "",
  "proxyCountry": "AUTO",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One row per input ASIN or product URL: title, brand, featured-offer and list price, star rating breakdown, category ranks, the full attribute table, images, variations and the reviews shown on the page.

# 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 = {
    "asins": [
        "B07GBZ4Q68"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/amazon-product-details-scraper").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 = {
    "asins": ["B07GBZ4Q68"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/amazon-product-details-scraper").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 '{
  "asins": [
    "B07GBZ4Q68"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraper-engine/amazon-product-details-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/eZfPYda5OBn5iYgHh/builds/5xCrSZ6mxBo0AcaNi/openapi.json