# Amazon Product Scraper (Cheap) (`data_api/amazon-product-scraper-cheap`) Actor

Amazon product data scraper that extracts titles, prices, ratings, images, and specifications from product pages, so you can automate price monitoring, catalog building, and competitive research at scale.

- **URL**: https://apify.com/data\_api/amazon-product-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

Copying product details off Amazon by hand is slow, and the page layout changes the second you look away. Paste a product link instead and get back a tidy row: name, brand, current price, star rating, review count, the full image set, feature bullets, and the spec table. Works across the US, UK, German, Indian, Japanese, and the other regional stores, with no code and no scraping setup to wrestle with.

![Amazon Product Scraper](cover.jpg)

### What you get

One product link becomes one clean row. Anything Amazon doesn't show for a given item comes back as `null` or an empty list, so your columns line up when you drop the results into a sheet or database. Each row carries three kinds of data:

- **Identity and pricing** — `itemName`, `brandName`, `productAsin`, `currentPrice`, `currencySymbol`, `stockStatus`
- **Reputation and media** — `starRating`, `reviewsTotal`, `imageLink`, `imageGallery`
- **Content and specs** — `highlightBullets`, `itemDescription`, `categoryPath`, `manufacturerName`, `weightLabel`, `dimensionsLabel`, `netQuantityLabel`, `genericLabel`, `specifications`, plus `itemUrl`, `collectedAt`, and `errorMessage`

### Quick start

1. Press **Try for free** and open the input form.
2. Paste one or more Amazon product URLs into **Amazon product URLs**. Both the short `/dp/ASIN` link and a full product page link work.
3. Adjust **Timeout (seconds)** if you expect heavy pages, or leave the default.
4. Hit **Start**, then export the results as JSON, CSV, Excel, or XML once the run finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Price monitoring** — track prices on competitor products and watch for drops or hikes
- **Catalog building** — turn a list of product links into a structured catalog for your store or PIM
- **Competitor research** — compare titles, bullets, images, and ratings across a category
- **Market and demand signals** — sort by `reviewsTotal` and `starRating` to spot what's selling
- **Brand audits** — see how a brand prices and presents its range across regional stores
- **Content sourcing** — pull bullets, descriptions, and images to draft your own product pages

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `targetUrls` | array of strings | Yes | Amazon product page URLs to scrape. Both `/dp/ASIN` short links and full URLs work, and each is processed on its own. Duplicates are removed automatically. |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before giving up. Default `45`; raise it for heavy pages. |

#### Example input

```json
{
    "targetUrls": [
        "https://www.amazon.com/dp/B08N5WRWNW",
        "https://www.amazon.co.uk/dp/B0CHX3QBCH",
        "https://www.amazon.de/dp/B09G9FPHY6"
    ],
    "timeoutSeconds": 45
}
````

### Output

Each product link becomes one record in the dataset. Fields Amazon doesn't publish for a given item come back as `null` (or an empty list), so the shape stays consistent across every row.

#### Example output

```json
{
    "itemUrl": "https://www.amazon.com/dp/B08N5WRWNW",
    "productAsin": "B08N5WRWNW",
    "itemName": "Echo Dot (4th Gen) Smart speaker with Alexa, Charcoal",
    "brandName": "Amazon",
    "currentPrice": 49.99,
    "currencySymbol": "$",
    "starRating": 4.7,
    "reviewsTotal": 284531,
    "stockStatus": "In Stock",
    "imageLink": "https://m.media-amazon.com/images/I/714Rdc+NyxL._AC_SL1000_.jpg",
    "imageGallery": [
        "https://m.media-amazon.com/images/I/714Rdc+NyxL._AC_SL1000_.jpg",
        "https://m.media-amazon.com/images/I/61u48FEs4LL._AC_SL1000_.jpg"
    ],
    "highlightBullets": [
        "Meet the Echo Dot - Our most popular smart speaker with a fabric design.",
        "Voice control your music - Stream songs from Amazon Music, Apple Music, Spotify, and others.",
        "Ready to help - Ask Alexa to play music, answer questions, read the news, and check the weather."
    ],
    "itemDescription": null,
    "categoryPath": [
        "Electronics",
        "Smart Home",
        "Amazon Smart Home",
        "Smart Speakers"
    ],
    "manufacturerName": "Amazon",
    "weightLabel": "12 ounces",
    "dimensionsLabel": "3.9 x 3.9 x 3.5 inches",
    "netQuantityLabel": "1 Count",
    "genericLabel": "Smart Speaker",
    "specifications": {
        "Brand": "Amazon",
        "Color": "Charcoal",
        "Item Weight": "12 ounces",
        "Product Dimensions": "3.9 x 3.9 x 3.5 inches",
        "ASIN": "B08N5WRWNW",
        "Date First Available": "September 30, 2020"
    },
    "collectedAt": "2026-06-29T12:00:00.000000+00:00",
    "errorMessage": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `itemUrl` | string | The Amazon product URL that was scraped |
| `productAsin` | string | Amazon Standard Identification Number (10 characters) |
| `itemName` | string | Full product title as shown on the listing |
| `brandName` | string | Brand name, pulled from the brand byline |
| `currentPrice` | number | Current price as a decimal number |
| `currencySymbol` | string | Currency symbol, such as `$`, `£`, `€`, or `₹` |
| `starRating` | number | Average star rating out of 5.0 |
| `reviewsTotal` | integer | Total number of customer ratings |
| `stockStatus` | string | Stock status text, e.g. `In Stock` or `Currently unavailable` |
| `imageLink` | string | Main product image URL |
| `imageGallery` | array | All product image URLs at the highest available resolution |
| `highlightBullets` | array | Feature bullet strings from the listing |
| `itemDescription` | string | Long-form product description, or `null` when absent |
| `categoryPath` | array | Category breadcrumb from the top level down to the leaf |
| `manufacturerName` | string | Manufacturer name from the detail bullets |
| `weightLabel` | string | Item weight with its unit, e.g. `1.3 Pounds` |
| `dimensionsLabel` | string | Length × width × height with units |
| `netQuantityLabel` | string | Net quantity or pack size |
| `genericLabel` | string | Generic product category name |
| `specifications` | object | Full key-value map of the detail bullets section |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |
| `errorMessage` | string | Reason the page failed; `null` on success |

### Tips for best results

- **Use `/dp/ASIN` links when you can.** Short links like `https://www.amazon.com/dp/B08N5WRWNW` are the steadiest format and work on every regional store.
- **Match the domain to the pricing you want.** An `amazon.com` link returns USD, `amazon.co.uk` returns GBP. Pick the store that matches the currency you need.
- **Raise `timeoutSeconds` for heavy pages.** Listings with long galleries or descriptions occasionally time out — bump it to 60 or 90 if you see that.
- **Failed pages still produce a row.** When an item is removed, region-locked, or unavailable, you get a record with `errorMessage` filled in. Filter on it to separate the misses.
- **Duplicates are handled for you.** The same URL listed twice is scraped once.
- **Schedule it for tracking.** Run on a daily or hourly schedule with Apify's scheduler to build a price and rating history over time.

### How can I use Amazon product data?

**How can I use the Amazon Product Scraper to monitor competitor prices?**
Add the product links you want to watch and run the actor on a schedule. Each row carries `currentPrice`, `currencySymbol`, `stockStatus`, and `collectedAt`, so you can log prices over time, compare the same ASIN across regional stores, and flag changes the day they happen.

**How can I scrape Amazon product details to build a catalog?**
Paste your product URLs and export the dataset to CSV or Excel. You get `itemName`, `brandName`, `productAsin`, `imageGallery`, `highlightBullets`, `categoryPath`, and the full `specifications` map per item — enough to populate a store, PIM, or internal catalog without retyping anything.

**How can I research Amazon competitors and demand with this data?**
Pull a set of products in one category and sort by `reviewsTotal` and `starRating` to see what's resonating. Line up `highlightBullets`, `itemDescription`, and image counts side by side to find gaps in your own listings and learn how top sellers frame their products.

**How do I turn a list of ASINs into Amazon product data?**
Build a URL for each ASIN with the pattern `https://www.amazon.com/dp/{ASIN}` (swap in any regional domain), drop them all into `targetUrls`, and run. Every link comes back as one row with price, rating, images, and specs attached.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `targetUrls` (type: `array`):

Amazon product page links to scrape. Add as many as you like. Works on amazon.com, amazon.co.uk, amazon.de, amazon.in, amazon.co.jp, and the other regional stores.

## `timeoutSeconds` (type: `integer`):

How long to wait on each request before giving up. Raise it if heavy product pages start timing out.

## Actor input object example

```json
{
  "targetUrls": [
    "https://www.amazon.com/dp/B08N5WRWNW",
    "https://www.amazon.co.uk/dp/B0CHX3QBCH",
    "https://www.amazon.de/dp/B09G9FPHY6"
  ],
  "timeoutSeconds": 45
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/amazon-product-scraper-cheap").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 = { "targetUrls": ["https://www.amazon.com/dp/B0BLMQ8BXB"] }

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

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

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

```

## CLI example

```bash
echo '{
  "targetUrls": [
    "https://www.amazon.com/dp/B0BLMQ8BXB"
  ]
}' |
apify call data_api/amazon-product-scraper-cheap --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=data_api/amazon-product-scraper-cheap",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Product Scraper (Cheap)",
        "description": "Amazon product data scraper that extracts titles, prices, ratings, images, and specifications from product pages, so you can automate price monitoring, catalog building, and competitive research at scale.",
        "version": "0.0",
        "x-build-id": "8b8CMmOIKczFBIzLK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~amazon-product-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-amazon-product-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/data_api~amazon-product-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-amazon-product-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/data_api~amazon-product-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-amazon-product-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "targetUrls"
                ],
                "properties": {
                    "targetUrls": {
                        "title": "Amazon product URLs",
                        "type": "array",
                        "description": "Amazon product page links to scrape. Add as many as you like. Works on amazon.com, amazon.co.uk, amazon.de, amazon.in, amazon.co.jp, and the other regional stores.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on each request before giving up. Raise it if heavy product pages start timing out.",
                        "default": 45
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
