# Amazon Product Scraper — Price, Rating, Seller & ASIN Data (`scrapers-hub/amazons-products-scrapers`) Actor

Amazon Product Scraper extracts price, rating, review count, availability, ASIN, seller, ships-from, images, features and breadcrumbs from any product URL. 📦 Powers price tracking, buy-box monitoring, review mining and competitor research.

- **URL**: https://apify.com/scrapers-hub/amazons-products-scrapers.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 – Price, Rating, Seller & ASIN Data Extraction

The **Amazon Product Scraper** turns any list of Amazon product URLs or bare ASINs into clean, structured JSON containing price, rating, review count, seller identity, availability, images, bullet features and full product specifications. Point it at a handful of listings or a batch of thousands, and it returns one flat record per product that drops straight into a spreadsheet, a pricing database, or a BI dashboard.

This Amazon scraper is built for people who need reliable retail data rather than screenshots: e-commerce analysts tracking competitor pricing, brand managers policing MAP violations, dropshippers validating margins, and market researchers mapping a category before they commit inventory. It fetches product detail pages directly over HTTP with rotated TLS fingerprints, parses them with a fast HTML engine, and never depends on a headless browser — so runs stay lightweight and predictable.

Every field in the output comes from the live product detail page. Nothing is estimated, enriched, or filled in from a cached third-party catalogue.

***

### 📊 What Data Can You Extract with This Amazon Product Scraper?

The Amazon Product Scraper returns a single record per product URL, covering identity, commercial terms, social proof and full merchandising content.

| Category | Fields | What it gives you |
|---|---|---|
| 🆔 Product identity | `url`, `asin`, `title` | Canonical listing URL, the 10-character ASIN, and the full product title as rendered on the page |
| 💰 Pricing | `price`, `priceText`, `currency` | Numeric price ready for arithmetic, the price exactly as displayed, and the currency symbol/code |
| ⭐ Ratings & reviews | `rating`, `ratingText`, `reviewCount`, `reviewCountText`, `topReviews` | Average star score, raw rating string, total review volume, and the top customer reviews shown on the page |
| 📦 Availability & seller | `availability`, `soldBy`, `shipsFrom`, `condition`, `bylineText` | Stock status, the merchant of record, the fulfilment origin, item condition, and the brand byline link text |
| 🖼️ Media & marketing copy | `imageUrls`, `features`, `description`, `aboutProduct`, `importantInformation` | All gallery image URLs, the bullet feature list, long-form description, structured attribute pairs, and safety/compliance notes |
| 🗂️ Taxonomy & variants | `breadcrumbs`, `productDetails`, `variationAsins`, `variationDimensions` | Category path with links, the specification table, sibling ASINs for other variants, and the dimensions those variants vary along |
| 🔎 Run metadata | `statusMessage`, `errorMessage`, `scrapedAt` | Per-record outcome, failure reason if any, and the exact scrape timestamp |

The genuinely underrated field here is `variationAsins`. A single parent listing often hides dozens of child ASINs across sizes and colours, each with its own price and stock position. Capturing them means you can expand one seed URL into a complete variant map instead of tracking only the default child Amazon happens to show you.

***

### 🌟 Key Features of the Amazon Product Scraper

| Feature | Description |
|---|---|
| 🔗 URL or ASIN input | Accepts full `https://www.amazon.com/dp/ASIN` links *or* bare 10-character ASINs in the same `startUrls` list, so you never have to reformat an existing product sheet |
| 🔄 Automatic proxy rotation | Proxy sessions rotate behind the scenes on every retry — no proxy configuration, credentials, or IP pool management on your side |
| 🧬 Rotating TLS fingerprints | Each retry attempt uses a fresh browser TLS fingerprint and a randomised delay, which keeps request patterns from looking mechanical |
| ⚙️ Tunable concurrency | `maxConcurrency` controls how many product pages are fetched in parallel, letting you trade throughput against a gentler request rate |
| 🔁 Configurable retries | `maxRetries` sets how many attempts each product URL gets before the scraper gives up on it, with each attempt using a new session |
| 🐤 Canary diagnostic mode | `canaryMode` scrapes only the first URL and logs HTTP status and response length per attempt — a 30-second sanity check that selectors still work |
| 🚫 Explicit not-found records | With `includeNotFound` enabled (the default), dead or 404 listings return a record with `statusMessage: "NOT_FOUND"` rather than vanishing from the dataset |
| ⚡ No headless browser | Pages are fetched over plain HTTP and parsed with a fast C-backed HTML parser, so memory use stays low and runs finish without Chromium overhead |
| 🧾 Deep specification capture | `productDetails`, `aboutProduct` and `importantInformation` preserve Amazon's structured attribute tables instead of flattening them into free text |

***

### 🚀 Why Choose This Amazon Product Scraper?

**Complete listing coverage in one pass.** Most Amazon scrapers stop at title, price and rating. This one also returns the specification table, the "About this item" attribute pairs, gallery image URLs, category breadcrumbs, variant ASINs and top reviews — so a single run gives you enough to rebuild a product page, not just a price alert.

**Failures are visible, not silent.** Every record carries `statusMessage` and `errorMessage`, and not-found listings are pushed as explicit `NOT_FOUND` rows by default. When you feed in 5,000 ASINs and get 4,900 rows back, you can tell exactly which 100 failed and why, instead of guessing.

**Diagnostics built into the input.** Amazon changes its markup regularly. `canaryMode` exists so you can verify selectors against one live URL — with HTTP status and response length logged per attempt — before spending a run on a large batch that might come back empty.

**Predictable, browser-free execution.** Because the scraper uses direct HTTP requests with rotated TLS fingerprints and a lightweight parser rather than a headless browser, runs consume far less memory and behave consistently under load.

***

### 📥 Input

```json
{
  "startUrls": [
    { "url": "https://www.amazon.com/dp/B07DF46NW9" },
    { "url": "https://www.amazon.com/dp/B08N5WRWNW" }
  ],
  "canaryMode": false,
  "includeNotFound": true,
  "maxConcurrency": 5,
  "maxRetries": 5
}
```

#### 🔧 Amazon Product Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `startUrls` | array | ✅ Yes | — | Amazon product URLs (e.g. `https://www.amazon.com/dp/ASIN`) or bare 10-character ASINs to scrape |
| `canaryMode` | boolean | No | `false` | Scrapes only the first start URL and logs extra diagnostic info (HTTP status and response length per attempt). Use to quickly verify selectors still work before running a full batch |
| `includeNotFound` | boolean | No | `true` | When enabled, pushes a record with `statusMessage` `"NOT_FOUND"` for URLs that 404 or resolve to Amazon's page-not-found template, instead of silently skipping them |
| `maxConcurrency` | integer | No | `5` | Maximum number of product pages fetched in parallel |
| `maxRetries` | integer | No | `5` | Attempts per product URL before giving up. Each retry uses a fresh proxy session, a randomised delay, and a rotated browser TLS fingerprint |

#### 💡 Input Examples

**Quick selector health check before a large run:**

```json
{
  "startUrls": [{ "url": "https://www.amazon.com/dp/B07DF46NW9" }],
  "canaryMode": true
}
```

**High-throughput batch with aggressive retries:**

```json
{
  "startUrls": [
    { "url": "https://www.amazon.com/dp/B07DF46NW9" },
    { "url": "https://www.amazon.com/dp/B0BSHF7WHW" },
    { "url": "https://www.amazon.com/dp/B09B8V1LZ3" }
  ],
  "maxConcurrency": 10,
  "maxRetries": 8
}
```

**Clean dataset with dead listings excluded:**

```json
{
  "startUrls": [{ "url": "https://www.amazon.com/dp/B08N5WRWNW" }],
  "includeNotFound": false,
  "maxConcurrency": 3
}
```

***

### 📤 Output

```json
{
  "url": "https://www.amazon.com/dp/B07DF46NW9",
  "asin": "B07DF46NW9",
  "title": "DEWALT 9-in-1 Painter's Tool | Straight Scraper, Curved Scraper, Gouger, Roller Cleaner, Can Opener…",
  "price": 13.04,
  "priceText": "$13.04",
  "currency": "$",
  "rating": 4.8,
  "ratingText": "4.8 out of 5",
  "reviewCount": 2368,
  "reviewCountText": "(2,368)",
  "imageUrls": ["https://m.media-amazon.com/images/I/61y7JLUgQPL._AC_SL1500_.jpg"],
  "aboutProduct": [
    { "label": "Material", "value": "Carbon Steel" },
    { "label": "Brand", "value": "DEWALT" }
  ]
}
```

#### 🧾 Amazon Product Output Fields

| Field | Type | Description |
|---|---|---|
| `url` | string | null | Canonical URL of the scraped item |
| `asin` | string | null | Amazon Standard Identification Number |
| `statusMessage` | string | null | Status message of the item |
| `errorMessage` | string | null | Error message of the item |
| `scrapedAt` | string | null | When this record was scraped |
| `title` | string | null | Title of the item |
| `price` | number | null | Price of the item |
| `priceText` | string | null | Price as displayed, including currency symbol |
| `currency` | string | null | Currency code of the price |
| `rating` | number | null | Average rating score |
| `ratingText` | string | null | Text of the rating |
| `reviewCount` | integer | null | Number of reviews |
| `reviewCountText` | string | null | Text of the review count |
| `availability` | string | null | Availability of the item |
| `bylineText` | string | null | Text of the byline |
| `shipsFrom` | string | null | Ships from of the item |
| `soldBy` | string | null | Sold by of the item |
| `condition` | string | null | Condition of the item |
| `imageUrls` | array | null | Image URLs values collected for the item |
| `features` | array | null | Features values collected for the item |
| `description` | string | null | Long-form description text |
| `breadcrumbs` | array | null | Breadcrumbs values collected for the item |
| `productDetails` | object | null | Product details of the item |
| `aboutProduct` | array | null | About product values collected for the item |
| `importantInformation` | array | null | Important information values collected for the item |
| `variationAsins` | object | null | Variation ASINs of the item |
| `variationDimensions` | object | null | Variation dimensions of the item |
| `topReviews` | array | null | Top reviews values collected for the item |

Fields that Amazon does not render on a given listing come back as empty strings or `null` rather than being omitted, so every record keeps a stable shape across the whole dataset.

***

### 💻 How to Use the Amazon Product Scraper (Step by Step)

#### Step 1: Assemble Your ASIN or Product URL List

Start by collecting the listings you care about. The `startUrls` field accepts full product URLs in the `https://www.amazon.com/dp/ASIN` form as well as bare 10-character ASINs, which means an existing inventory export with an ASIN column can be pasted in without transformation. Mixing both formats in the same list is fine. If you are building a competitor set from scratch, work category by category so you can attribute results back to a specific segment later using the `breadcrumbs` field.

#### Step 2: Run a Canary Check First

Before committing a large batch, set `canaryMode` to `true` and run with a single representative URL. The scraper will fetch only the first start URL and log the HTTP status and response length for each attempt. This tells you in seconds whether the page is being served normally and whether the parser is still finding the elements it expects. It is a cheap habit that saves you from discovering a markup change halfway through a several-thousand-URL run.

#### Step 3: Tune Concurrency and Retries for Your Batch

`maxConcurrency` defaults to 5 parallel page fetches and `maxRetries` defaults to 5 attempts per URL. For a small batch of a few dozen products, the defaults are usually right. For large runs, raising concurrency shortens wall-clock time but increases the request rate; lowering it produces a gentler, more patient crawl that tends to yield a higher completion rate on stubborn listings. Retries matter more than raw speed — each retry uses a fresh proxy session, a randomised delay and a rotated TLS fingerprint, so a URL that fails on attempt one frequently succeeds on attempt three.

#### Step 4: Decide How to Handle Missing Listings

`includeNotFound` is enabled by default, which means URLs that 404 or land on Amazon's page-not-found template are pushed as records with `statusMessage` set to `"NOT_FOUND"`. Keep this on when you are reconciling a catalogue and need to know which ASINs have been delisted. Switch it off when you want a clean analytical dataset with no placeholder rows and are tracking coverage separately.

#### Step 5: Start the Run and Watch the Log

Click **Start** in the Apify console, or trigger the run through the API. The log reports per-URL progress along with retry activity, so you can see in real time whether pages are being served cleanly or whether the scraper is working through repeated attempts. A run that shows retries succeeding on later attempts is behaving exactly as designed; a run where every URL exhausts `maxRetries` is a signal to reduce concurrency.

#### Step 6: Export the Dataset in Your Preferred Format

When the run finishes, the dataset is available as JSON, CSV, Excel, XML or RSS from the **Storage** tab. CSV is convenient for pricing spreadsheets, but note that nested fields such as `productDetails`, `variationAsins`, `breadcrumbs` and `topReviews` flatten awkwardly in a spreadsheet. If you need those structures intact, export JSON and load it into your database or analysis notebook instead.

#### Step 7: Schedule Recurring Amazon Price Monitoring

Pricing and stock data ages quickly. Use Apify's scheduler to re-run the same input on a fixed cadence — daily for fast-moving categories, weekly for stable ones — and append each run's dataset to a warehouse table keyed on `asin` and `scrapedAt`. That combination gives you a proper price history instead of a series of disconnected snapshots, which is what makes trend analysis and MAP violation detection possible.

***

### 🔌 API Access & Integrations

Run the Amazon Product Scraper synchronously and get dataset items back in a single HTTP call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~amazons-products-scrapers/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{ "url": "https://www.amazon.com/dp/B07DF46NW9" }],
    "maxConcurrency": 5,
    "maxRetries": 5
  }'
```

Or drive it from Python with the official client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "startUrls": [
        {"url": "https://www.amazon.com/dp/B07DF46NW9"},
        {"url": "https://www.amazon.com/dp/B08N5WRWNW"},
    ],
    "includeNotFound": True,
    "maxConcurrency": 5,
    "maxRetries": 5,
}

run = client.actor("scrapers-hub/amazons-products-scrapers").call(run_input=run_input)

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

The Actor also connects to Zapier, Make, Google Sheets, Slack and any HTTP webhook, so finished runs can push new price data into your own systems without manual export.

***

### 💡 Best Use Cases for Amazon Product Data

#### 💲 Competitor Price Tracking and Repricing

Schedule repeated runs across your competitor set and store `price`, `priceText` and `currency` alongside `scrapedAt` to build a time series per ASIN. Feeding that history into a repricing rule lets you react to undercutting within hours rather than discovering it at month-end. Pairing `price` with `soldBy` also reveals whether a price drop came from Amazon itself or from a third-party merchant.

#### 🛡️ MAP Violation and Brand Protection Monitoring

Brands enforcing minimum advertised pricing need evidence, not anecdotes. Combining `price`, `soldBy`, `shipsFrom` and `condition` identifies exactly which seller is breaching policy and whether the item is new, used or refurbished. Because `scrapedAt` is stamped on every record, each violation comes with a defensible timestamp for enforcement correspondence.

#### 📈 Product Research and Category Opportunity Analysis

Before launching into a category, pull a broad set of ASINs and analyse `rating`, `reviewCount` and `price` together. High review volume with a mediocre rating is the classic signature of unmet demand, and `breadcrumbs` lets you segment those findings by Amazon's own category taxonomy rather than by your guess at the market structure.

#### 🧩 Catalogue Enrichment and Content Benchmarking

If you sell on Amazon, the `title`, `features`, `description`, `aboutProduct`, `importantInformation` and `imageUrls` fields let you benchmark your listing content against the best performers in your category. Counting bullet points, gallery images and populated attribute pairs across top-ranked competitors produces a concrete content checklist for your own listing optimisation.

#### 🎨 Variant and Assortment Mapping

`variationAsins` and `variationDimensions` expose the full child-ASIN family behind a parent listing and the attributes those children vary along — size, colour, pack count. Expanding a seed list through these fields turns a shortlist of parent products into a complete assortment map, which is essential for gap analysis against your own SKU range.

#### 🗣️ Review Mining and Voice-of-Customer Analysis

The `topReviews` array captures the customer reviews surfaced on the product page. Running those through a sentiment or topic model, grouped by `asin` and category from `breadcrumbs`, surfaces recurring complaints and praise themes that inform product development far more directly than an aggregate star score does.

#### 📦 Availability and Stockout Intelligence

Tracking `availability` and `shipsFrom` over successive runs shows when competitors go out of stock and how long they stay there. Stockout windows are prime opportunities for promotional spend, and repeated fulfilment-origin changes in `shipsFrom` can signal a supply chain shift worth investigating.

***

### ⚙️ Tips for Better Amazon Scraping Results

- **Always canary before you batch.** A `canaryMode` run against one URL costs almost nothing and confirms the parser is still aligned with Amazon's current markup before you commit a large job.
- **Prefer more retries over more concurrency.** Raising `maxRetries` improves completion rate on difficult listings because each attempt gets a fresh proxy session and TLS fingerprint. Raising `maxConcurrency` only makes the run faster, and past a point it makes failures more likely.
- **Split very large ASIN lists into several runs.** Batches of a few hundred to a few thousand URLs are easier to monitor, cheaper to retry, and let you spot a systemic failure early rather than after everything has finished.
- **Key your warehouse on `asin`, not `url`.** Amazon URLs carry tracking parameters and regional variations, whereas the ASIN is stable. Store `url` for reference but join on `asin`.
- **Use `price` for maths and `priceText` for display.** The numeric field strips formatting; the text field preserves exactly what a shopper saw, including the currency symbol, which matters when you need to evidence a price point.
- **Keep `includeNotFound` on for catalogue reconciliation.** Delisted ASINs are information. A `NOT_FOUND` row tells you a product has gone; a missing row tells you nothing at all.

***

### 🛠️ Troubleshooting

**Why are `availability`, `soldBy` and `shipsFrom` empty on some products?**
Amazon does not render these blocks consistently across every listing, category or buy-box state. When a field is absent from the page it is returned as an empty string rather than being dropped, which keeps the record shape uniform. If these fields are empty across the entire dataset rather than on scattered rows, run `canaryMode` to check whether the page is being served in full.

**All my records have `statusMessage` of `NOT_FOUND`. What went wrong?**
Either the ASINs genuinely no longer exist, or the URLs are malformed. Check that each entry is a valid `https://www.amazon.com/dp/ASIN` link or a clean 10-character ASIN with no surrounding whitespace or quotation marks. A single valid URL run in `canaryMode` will confirm which of the two it is.

**The run is slow or many URLs exhaust their retries.**
Lower `maxConcurrency` so fewer pages are requested in parallel, and raise `maxRetries` so each URL gets more attempts with fresh sessions. A patient configuration nearly always returns a higher completion rate than an aggressive one on a large batch.

**Nested fields look like unreadable text in my CSV export.**
`productDetails`, `variationAsins`, `breadcrumbs`, `aboutProduct` and `topReviews` are objects and arrays. Spreadsheet exports serialise them into a single cell. Export the dataset as JSON when you need those structures, and reserve CSV for the flat pricing and rating fields.

**Prices differ from what I see in my own browser.**
Amazon personalises pricing, currency and buy-box selection by region, account history and delivery address. The scraper sees an unauthenticated visitor's view of the page, which is the correct baseline for competitive analysis but will not match a logged-in session with Prime pricing or a local address applied.

***

### ❓ Frequently Asked Questions About Amazon Product Scraping

**What does this Amazon Product Scraper actually extract?**
It extracts the full product detail page for each URL or ASIN you supply: title, price, currency, star rating, review count, availability, seller and fulfilment details, condition, gallery image URLs, bullet features, long-form description, category breadcrumbs, the specification table, structured attribute pairs, variant ASINs and the top reviews shown on the page.

**Can I use plain ASINs instead of full Amazon URLs?**
Yes. The `startUrls` field accepts bare 10-character ASINs as well as full `https://www.amazon.com/dp/ASIN` links, and you can mix both in the same list. This makes it straightforward to feed in an existing product export without reformatting it first.

**Do I need to configure proxies for this Amazon scraper?**
No. Proxy rotation is handled automatically inside the Actor, and each retry attempt uses a fresh proxy session together with a rotated browser TLS fingerprint. There is no proxy configuration field and no credentials for you to manage.

**How many Amazon products can I scrape in one run?**
There is no fixed cap in the input — the `startUrls` list can be as long as you need. In practice, splitting very large lists into batches of a few hundred to a few thousand makes runs easier to monitor and cheaper to retry if something goes wrong partway through.

**Does the Amazon Product Scraper use a headless browser?**
No. It fetches product pages over direct HTTP requests and parses them with a fast HTML parser. That keeps memory use low and run behaviour predictable compared with browser-based scrapers.

**What is canary mode and when should I use it?**
`canaryMode` scrapes only the first start URL and logs extra diagnostic information — HTTP status and response length for each attempt. Use it as a pre-flight check before a large batch, or whenever a run returns unexpectedly sparse data, to confirm the page is being served and parsed correctly.

**Why do some fields come back as `null` or empty strings?**
Amazon's product pages are not uniform. A grocery listing, a book and a power tool render different blocks, and buy-box state changes what is displayed. Rather than omitting absent fields, the scraper returns them empty so every record in the dataset has the same shape and your downstream schema stays stable.

**Can I scrape Amazon marketplaces outside amazon.com?**
The input is designed around Amazon product detail page URLs. Marketplace behaviour varies by domain, so test a small batch with `canaryMode` against the specific marketplace URLs you intend to use before scaling up a run.

**How do I track Amazon price changes over time?**
Schedule the same input to run on a recurring basis and append each dataset to a table keyed on `asin` and `scrapedAt`. Because every record carries its own scrape timestamp, the resulting history supports proper trend analysis, price-drop alerting and MAP violation evidence.

**What is the difference between `price` and `priceText`?**
`price` is a number with formatting stripped, ready for calculations and comparisons. `priceText` is the price string exactly as displayed on the page, including the currency symbol. Use the numeric field for analysis and the text field when you need to show or evidence what a shopper actually saw.

**Does it return product variations such as size and colour?**
Yes, through `variationAsins` and `variationDimensions`. The first lists the sibling ASINs belonging to the same parent listing; the second describes the attributes those variants differ on. You can feed the discovered ASINs back into `startUrls` to scrape each variant in full.

**Are customer reviews included in the Amazon scraper output?**
The `topReviews` array captures the reviews Amazon surfaces on the product detail page itself. This is the on-page review sample rather than a complete review archive, and it is well suited to sentiment sampling and theme detection across a category.

**What happens to Amazon URLs that no longer exist?**
With `includeNotFound` left at its default of `true`, those URLs produce a record with `statusMessage` set to `"NOT_FOUND"` so you can identify delisted products. Set it to `false` if you would rather have a clean dataset with no placeholder rows.

**Which export formats does the Amazon product data support?**
Datasets can be exported as JSON, CSV, Excel, XML or RSS from the Apify console, or pulled through the API. Choose JSON when you need nested fields like `productDetails` and `breadcrumbs` intact; CSV works well for the flat pricing and ratings columns.

**Can I integrate the Amazon Product Scraper with my own tools?**
Yes. Runs can be triggered through the Apify API or the Python and JavaScript clients, and finished runs can push data onward through Zapier, Make, Google Sheets, Slack or a custom webhook, so scraped Amazon data lands in your systems automatically.

***

### 🆘 Support & Feedback

Found a bug, a listing layout the parser mishandles, or a field that consistently returns empty? Please open a report in the **Issues** tab of this Actor — include the exact input JSON and one affected product URL so it can be reproduced quickly.

Need a custom build? Variant expansion, a different Amazon marketplace, review pagination, or a bespoke output schema shaped to your warehouse — get in touch at **scraperhubapi@gmail.com** and describe what you need.

If the Amazon Product Scraper saves you time, please leave a review on the Actor page. Honest feedback about which fields matter most directly shapes what gets improved next.

***

### ⚖️ Disclaimer

This Amazon Product Scraper collects only publicly available information from Amazon product detail pages — the same content any visitor can see without logging in. It does not access private accounts, order histories, customer data, or any content behind authentication.

You are responsible for how you use the data this Actor produces. Amazon product pages may contain personal data in customer reviews, including reviewer names and review text. If you process that information for users in the EU, UK or other regulated jurisdictions, you must establish a lawful basis under the GDPR or the equivalent local framework, honour data subject rights, and retain the data no longer than your stated purpose requires.

Scraping is also subject to Amazon's Terms of Service and robots directives. Review those terms and take your own legal advice before running large-scale or commercial collection. Nothing in this document constitutes legal advice.

If you believe personal data relating to you has been collected through this Actor and you would like it removed, contact **scraperhubapi@gmail.com** with the relevant details and the request will be handled promptly.

# Actor input Schema

## `startUrls` (type: `array`):

Amazon product URLs (e.g. https://www.amazon.com/dp/ASIN) or bare 10-character ASINs to scrape.

## `canaryMode` (type: `boolean`):

Scrapes only the first start URL and logs extra diagnostic info (HTTP status and response length per attempt). Use to quickly verify selectors still work before running a full batch.

## `includeNotFound` (type: `boolean`):

When enabled, pushes a record with statusMessage "NOT\_FOUND" for URLs that 404 or resolve to Amazon's page-not-found template, instead of silently skipping them.

## `maxConcurrency` (type: `integer`):

Maximum number of product pages fetched in parallel.

## `maxRetries` (type: `integer`):

Attempts per product URL before giving up. Each retry uses a fresh proxy session, a randomized delay, and a rotated browser TLS fingerprint.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.amazon.com/dp/B07DF46NW9"
    }
  ],
  "canaryMode": false,
  "includeNotFound": true,
  "maxConcurrency": 5,
  "maxRetries": 5
}
```

# Actor output Schema

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

Records scraped by Amazon Product Scraper — Price, Rating, Seller & ASIN Data, stored in the run's default dataset.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.amazon.com/dp/B07DF46NW9"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/amazons-products-scrapers").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 = { "startUrls": [{ "url": "https://www.amazon.com/dp/B07DF46NW9" }] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/amazons-products-scrapers").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 '{
  "startUrls": [
    {
      "url": "https://www.amazon.com/dp/B07DF46NW9"
    }
  ]
}' |
apify call scrapers-hub/amazons-products-scrapers --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/amazons-products-scrapers"
        }
    }
}

```

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/MgJbg2eWpCufq7tv4/builds/YuGXlDlFm6nb7n9b6/openapi.json