# Amazon Product Scraper — Price, Rating, Seller & ASIN Data (`jaybird/amazon-product-data-scraper`) Actor

Scrape Amazon product pages into clean JSON: price, rating, reviews, availability, seller, images, specs. Pay per result — $2 per 1,000 products scraped.

- **URL**: https://apify.com/jaybird/amazon-product-data-scraper.md
- **Developed by:** [Jaybird Technologies](https://apify.com/jaybird) (community)
- **Categories:** E-commerce, AI, Developer tools
- **Features:** Limited permissions
- **Stats:** 602 total users, 31 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Amazon Product Scraper

Scrape **Amazon product pages** at scale and get clean, structured JSON — price, rating, review count, availability, seller, images, feature bullets, specs, and top reviews. A fast, reliable **Amazon product data API** alternative for price tracking, market research, and catalog enrichment.

### What does Amazon Product Scraper do?

Give it a list of Amazon product URLs (any `/dp/` or `/gp/product/` link) and it returns one structured record per product, ready to download as JSON/CSV/Excel or pipe into your app via API. It is HTTP-only (no headless browser), session-aware, and retries with backoff — built to keep working under Amazon's anti-bot measures. Each run processes up to 100 product URLs; for larger catalogs, split URLs across runs or schedule recurring runs.

### Why use Amazon Product Scraper?

- 💰 **Pay per result — $2 / 1,000 products.** No subscription, no rental. Set `includeNotFound: false` and you pay only for products actually scraped.
- ⚡ **HTTP-only speed** — no browser overhead, low compute per product.
- 📦 **Complete product record** — pricing, ratings, availability, condition, ships-from, byline/brand, seller, images, bullets, description, breadcrumbs, technical details, important information (ingredients, safety), variations, top reviews.
- 🤖 **AI/agent ready** — flat, predictable JSON drops straight into RAG pipelines and agent tools.
- 🗓️ **Apify platform perks** — schedule runs, webhooks, 5,000+ integrations, API + Python/JS SDKs.

### What data can it extract?

| Field | Description |
|---|---|
| `asin`, `url` | Amazon Standard Identification Number and product page URL |
| `title` | Product title |
| `price`, `priceText`, `currency` | Current buy-box price as a number, raw text, and currency symbol or code, in the marketplace's own currency. Empty when the page shows no buy-box price (for example, currently unavailable) |
| `rating`, `ratingText` | Star rating (parsed and raw text) |
| `reviewCount`, `reviewCountText` | Number of ratings (parsed and raw text) |
| `availability`, `condition` | Stock status and product condition |
| `shipsFrom`, `soldBy` | Fulfilment source and selling merchant |
| `sellerName`, `sellerId`, `sellerLink` | Current seller details |
| `bylineText`, `bylineLink` | Brand/byline ("Visit the X Store") info |
| `imageUrls` | Product image URLs |
| `features` | "About this item" feature bullets |
| `description` | Product description text |
| `breadcrumbs` | Category path as `{ text, url }` objects |
| `productDetails` | Technical details / specs table (key–value object), incl. book details (ISBN, publisher) — populated when Amazon serves a specs table (some device pages render specs as images) |
| `aboutProduct` | Product attribute table as `{ label, value }` pairs |
| `importantInformation` | "Important information" section as `{ label, value }` pairs — Ingredients, Safety Information, Directions, Legal Disclaimer (common on grocery, supplement, and health & beauty products) |
| `variationAsins`, `variationDimensions` | Variation (size/color) info when present |
| `topReviews` | Up to 5 top reviews (title, rating, body, author, date, verified) |
| `statusMessage`, `scrapedAt` | `FOUND`/`NOT_FOUND` flag and scrape timestamp |

### How to scrape Amazon product data

1. Click **Try for free** / open the Actor.
2. Paste your **Amazon product URLs** (up to 100 per run).
3. Click **Start** and watch results stream into the dataset.
4. **Download** JSON, CSV, or Excel — or fetch via the API.

### How much will it cost to scrape Amazon?

Pay-per-event: **$0.002 per product scraped — $2 per 1,000 products** (less on paid Apify plans) — plus a small Actor-start fee ($0.007 per run). A full run of 100 product pages costs about **$0.21**; scraping 5,000 products across 50 runs costs about **$10.35**. No monthly fee. By default you always get one record per input URL: dead or removed listings produce a `NOT_FOUND` record and pages Amazon still blocks after all retries produce a `BLOCKED` record, both billed like any result — set `includeNotFound: false` to skip those records and not pay for them. Current per-event prices are always on the **Pricing** tab.

### Input example

```json
{
    "startUrls": [
        { "url": "https://www.amazon.com/dp/B00P8XQPY4" },
        { "url": "https://www.amazon.com/dp/B0DL76BQ5N" }
    ],
    "includeNotFound": true
}
```

`includeNotFound` (default `true`): dead or removed listings yield a record with `statusMessage: "NOT_FOUND"` and the ASIN parsed from your URL, so you can correlate results to input. Set `false` to skip (and not pay for) those pages.

### Output example

```json
{
    "url": "https://www.amazon.com/dp/B07DF46NW9",
    "asin": "B07DF46NW9",
    "title": "DEWALT 9-in-1 Painter's Tool | Carbon Steel w/Soft Grip Handle | DXTT-2-200",
    "price": 14.39,
    "priceText": "$14.39",
    "currency": "$",
    "rating": 4.8,
    "ratingText": "4.8 out of 5",
    "reviewCount": 2305,
    "availability": "In Stock",
    "shipsFrom": "Amazon",
    "soldBy": "LEVEL5 Tools",
    "sellerName": "LEVEL5 Tools",
    "sellerId": "A3GHITH485Z657",
    "imageUrls": ["https://m.media-amazon.com/images/I/31QoNbmFZEL._AC_US100_.jpg"],
    "features": ["Hardened, mirror-polished, high-carbon steel blade"],
    "breadcrumbs": [
        { "text": "Tools & Home Improvement", "url": "https://www.amazon.com/Tools-and-Home-Improvement/b/?node=228013" }
    ],
    "aboutProduct": [{ "label": "Brand", "value": "DEWALT" }],
    "statusMessage": "FOUND",
    "scrapedAt": "2026-06-04T02:41:56.918Z"
}
```

### Integrations

Export to **Google Sheets, Google Drive, S3**, or a database; automate with **Zapier, Make, and webhooks**; **schedule** recurring price-tracking runs; or call it from anywhere via the **Apify API** and JS/Python SDKs.

### Related Actors

- **Want to know which products to scrape?** Our [Amazon Bestsellers Rank Tracker](https://apify.com/jaybird/amazon-bestsellers-movers-shakers-tracker) returns the top 100 of any Best Sellers category on 11 marketplaces and tracks rank changes between runs.
- [Amazon Reviews Scraper](https://apify.com/jaybird/amazon-reviews-scraper): ratings breakdowns, reviews and Amazon's "Customers say" summary for the same products.
- [Amazon Seller Scraper](https://apify.com/jaybird/amazon-seller-info-scraper): the business behind a seller ID, with address, phone, VAT and EU contact emails.

### Feedback and reviews

Something not working, or a field you need? Open an issue on the [Issues tab](https://apify.com/jaybird/amazon-product-data-scraper/issues) and we'll take a look.

If this Actor saved you time, a short [review on Apify Store](https://apify.com/jaybird/amazon-product-data-scraper/reviews) helps other people decide whether it fits their needs.

### FAQ

**Is this an alternative to the Amazon Product Advertising API?** Yes — no approval process, no associate quota, no signature plumbing. Paste URLs, get JSON.

**Which marketplaces work?** Any Amazon domain product URL (`amazon.com`, `.co.uk`, `.de`, …). Non-Amazon URLs are filtered out automatically. Prices come back in the marketplace's own currency (£ on `.co.uk`, € on `.de`, …). Pages are fetched from US servers, so on non-US marketplaces Amazon may show the export price (for delivery outside the country, which can exclude local VAT) rather than the domestic shelf price.

**How do I cap what a run costs?** Set **Maximum cost per run** in the run options. The run stops by itself once the next result would go over it, and its status message says so.

**Is it legal to scrape Amazon?** This Actor extracts only publicly available product data — no private user data. You are responsible for how you use the results; personal data is protected by GDPR and other regulations, so consult your lawyers if unsure.

### Changelog

**0.5.6 (November 2026)** — price fixes. About 1 in 10 runs could return another product's price (for example "$1304" for a $14.39 tool) and no seller, when Amazon served the page as if the visitor were abroad; those pages are now fetched again. Unavailable products no longer pick up a recommended product's price. Used-only listings report the featured offer's price. `shipsFrom` and `soldBy` are cleaned up (no more "and" or whole sentences). Runs stop at your maximum cost per run.

**0.5.5 (October 2026)** — the run summary is now always the final status message (Crawlee's own "Finished!" message could replace it), and progress during a run shows the same summary.

**0.5.4 (October 2026)** — added a Feedback and reviews section; runs that scrape at least one product with none blocked now end with a link to the Store reviews page in the status message. Data, fields and pricing are unchanged.

**0.1 (June 2026)** — extraction accuracy release: corrected `rating` / `topReviews[].rating` parsing (previously could concatenate digits, e.g. `4.75` instead of `4.7`); `imageUrls` now full-resolution (previously thumbnails); dead/removed listings and non-product URLs now return honest `NOT_FOUND` records instead of partial data, with the new `includeNotFound` option to skip them; review `title`/`body` extraction fixed for Amazon's current markup; book pages now yield `price` and `productDetails` (ISBN, publisher, …); price extraction added for buybox-suppressed page variants.

Found a bug or need a field added? Open an issue on the **Issues** tab.

# Actor input Schema

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

Amazon product page URLs (any marketplace domain, /dp/ or /gp/product/ links).

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

When enabled (default), every input URL produces one dataset record — dead or non-product pages yield a NOT_FOUND record (billed like any result). Disable to skip NOT_FOUND pages so they are not pushed or billed.

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

Internal health check: when on, the run FAILS if any request had to escalate to residential proxy (a sign datacenter is being blocked again). Used by a scheduled canary to alert on regressions. Leave off for normal scraping.

## Actor input object example

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

# Actor output Schema

## `dataset` (type: `string`):

No description

## `overview` (type: `string`):

No description

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jaybird/amazon-product-data-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/R5okfWVzmBtS5gUaJ/builds/rmtIB7LrjApHGnoby/openapi.json