# Amazon Product Scraper - Price, ASIN, BSR, Reviews & Specs (`flash_scraper/amazon-product-data`) Actor

Scrape Amazon products by keyword or ASIN: price, list price and discount, star rating, review count, seller, Prime status, stock, every image, full specifications and best-seller rank. Currency is pinned so prices never drift with the proxy IP. Verified on amazon.com. No API key.

- **URL**: https://apify.com/flash\_scraper/amazon-product-data.md
- **Developed by:** [Flash Scrape](https://apify.com/flash_scraper) (community)
- **Categories:** E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 Data — Prices, Ratings & Specs

**Scrape Amazon products by keyword or ASIN.** Feed in search terms, ASINs, or product URLs and get the full record: price, list price and discount, star rating, review count, seller, Prime status, stock, every hi-res image, the complete specifications table, category breadcrumbs and best-seller rank.

No API key. No third-party Actor in the middle.

***

### The detail most Amazon scrapers get wrong

**Amazon prices in the currency of whichever IP requests the page.** The same laptop stand returns `MAD149.35` from a Moroccan IP and `$15.99` from a US one — and because cloud scrapers rotate through proxy exit nodes in different countries, the currency can change *between rows of the same run*. That silently corrupts every price comparison built on the data.

This Actor pins the currency explicitly and returns it on every row as `currency`, so a price is always interpretable. Set `currency` to override it.

### What you get per product

| Group | Fields |
|---|---|
| Identity | `asin`, `title`, `brand`, `url`, `domain` |
| Pricing | `price`, `list_price`, `discount_pct`, `currency`, `has_coupon` |
| Reception | `rating`, `ratings_count` |
| Availability | `in_stock`, `availability`, `seller`, `ships_from`, `is_prime` |
| Content | `features[]` (bullet points), `images[]` (all hi-res), `main_image`, `images_count` |
| Placement | `categories[]` (breadcrumbs), `best_seller_ranks[]` (rank + category) |
| Technical | `specifications{}` — the full product details table, as key/value |
| Meta | `scraped_at` |

Search-only mode (`fullDetail: false`) returns the lighter subset visible on the results page — `asin`, `title`, `price`, `rating`, `ratings_count`, `image`, `is_sponsored` — which is much faster and cheaper when you only need to shortlist.

### Input

| Field | Type | Notes |
|---|---|---|
| `searchTerms` | array | Keywords, e.g. `["laptop stand", "standing desk"]` |
| `asins` | array | Bare ASINs (`B077B9W343`) or any Amazon product URL; mixes freely with keywords |
| `domain` | select | **`com` is the verified marketplace.** 16 others are selectable but returned a bot-check page from shared cloud IPs when measured — see limits |
| `currency` | string | Pins prices. Defaults to the marketplace's own currency |
| `fullDetail` | boolean | One request per product for the complete record; off = search-page fields only |
| `maxItems` | integer | Hard cap per run |
| `minRating` / `maxPrice` | string | `0` = no filter |
| `onlyPrime` / `onlyInStock` / `skipSponsored` | boolean | `onlyInStock` needs `fullDetail` on |
| `delaySeconds` | string | Pause between requests; lower = higher chance of an early stop |
| `proxyConfiguration` | object | Required in practice — see below |

### Example

```json
{
  "searchTerms": ["mechanical keyboard"],
  "domain": "com",
  "currency": "USD",
  "fullDetail": true,
  "minRating": "4.0",
  "skipSponsored": true,
  "maxItems": 100
}
```

### Honest limits

- **A proxy is required.** Apify blocks direct connections to Amazon from Actors (refused in milliseconds), and Amazon rate-limits repeat IPs. This Actor draws a fresh proxy IP per request; the standard **datacenter** group is enough — you do not need RESIDENTIAL.
- **Only `amazon.com` is verified.** Measured 2026-08-03 from Apify's datacenter proxies: `amazon.co.uk` and `amazon.de` both returned a 2 kb bot-check page rather than results, so the other 16 marketplaces are offered but unverified — they may work behind your own residential proxy. The Actor now reports that case as a bot check rather than as "0 products", so you will never get a silent empty run mistaken for an empty catalogue.
- **One search page per keyword** (~16–48 products). Deeper pagination triggers Amazon's bot check, and this Actor does not attempt to defeat it. To go wider, pass more keywords or narrower ones rather than expecting page 2.
- **`best_seller_ranks` and `brand` are not on every listing.** Amazon omits them for many products; the fields are `null`/`[]` rather than missing, so filtering stays safe.
- **If Amazon's bot check stops a run**, the Actor stops and tells you how many products went unscraped instead of returning a short list that looks complete. You are only charged for products that returned data.
- Prices and availability are marketplace-specific: the same ASIN legitimately differs between `amazon.com` and `amazon.de`.

### Use cases

- **Price monitoring and repricing** — track `price` vs `list_price` and `discount_pct` over time.
- **Competitor and catalogue research** — pull a category's products with ratings and review counts to find gaps.
- **Product sourcing** — filter by rating and price band to shortlist winners before buying.
- **Review-volume analysis** — `ratings_count` and `rating` together separate proven sellers from new listings.
- **Feeding an AI agent** — the `specifications` table and `features` array give a model clean, structured product context.

### Pricing

Pay per result: charged once per **product delivered**. Products removed by your filters, not found, or blocked are **not** charged.

### FAQ

**Do I need an Amazon API key or account?** No. This reads public product pages.

**Why do I need a proxy?** Apify's own network blocks direct egress to Amazon, and Amazon throttles repeated requests from one IP. The datacenter group is sufficient.

**Can I get more than the first page of results?** Not reliably — Amazon presents a bot check on deeper pages, which this Actor deliberately does not try to bypass. Use more, narrower keywords instead.

**Why is `brand` sometimes empty?** Amazon does not render a brand byline on every product. Where it is absent, the `specifications` table often carries `Brand` or `Manufacturer`.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search, e.g. \['laptop stand', 'standing desk']. Every matching product on the first results page is queued.

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

Specific products, as bare ASINs ('B077B9W343') or any Amazon product URL. Combine freely with keywords.

## `domain` (type: `string`):

Which Amazon site to scrape. **Only amazon.com is verified working from shared cloud IPs** - measured 2026-08-03, every other marketplace returned a bot-check page from Apify's datacenter proxies. The others are left available because your own residential proxy may reach them, but treat them as unverified. Prices and availability are marketplace-specific.

## `currency` (type: `string`):

Amazon prices in the currency of whichever IP requests the page, so the same product can come back as USD or MAD depending on the proxy exit node. This pins it. Leave blank to use the marketplace default.

## `fullDetail` (type: `boolean`):

On: one request per product for the complete record (features, all images, specifications, seller, rank). Off: only the lighter fields visible on the search page, which is much faster and cheaper.

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

Hard cap on products returned in one run.

## `minRating` (type: `string`):

e.g. 4.0 to keep only well-reviewed products. 0 or blank = no filter.

## `maxPrice` (type: `string`):

In the forced currency. 0 or blank = no filter.

## `onlyPrime` (type: `boolean`):

Keep only products showing a Prime badge.

## `onlyInStock` (type: `boolean`):

Needs 'Fetch full product pages' on, since stock status is not reliable on the search page.

## `skipSponsored` (type: `boolean`):

Drop paid placements and keep only organic search results.

## `delaySeconds` (type: `string`):

Seconds to pause between requests. Lowering it raises the chance Amazon's bot check stops the run early.

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

Required in practice. Apify blocks direct connections to Amazon from Actors, and Amazon rate-limits repeat IPs, so this Actor draws a fresh proxy IP per request. The standard datacenter group is enough - RESIDENTIAL is not needed.

## Actor input object example

```json
{
  "searchTerms": [
    "laptop stand"
  ],
  "asins": [],
  "domain": "com",
  "currency": "USD",
  "fullDetail": true,
  "maxItems": 50,
  "minRating": "0",
  "maxPrice": "0",
  "onlyPrime": false,
  "onlyInStock": false,
  "skipSponsored": false,
  "delaySeconds": "1.0",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchTerms": [
        "laptop stand"
    ],
    "asins": [],
    "domain": "com",
    "currency": "USD",
    "fullDetail": true,
    "maxItems": 50,
    "minRating": "0",
    "maxPrice": "0",
    "onlyPrime": false,
    "onlyInStock": false,
    "skipSponsored": false,
    "delaySeconds": "1.0",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("flash_scraper/amazon-product-data").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 = {
    "searchTerms": ["laptop stand"],
    "asins": [],
    "domain": "com",
    "currency": "USD",
    "fullDetail": True,
    "maxItems": 50,
    "minRating": "0",
    "maxPrice": "0",
    "onlyPrime": False,
    "onlyInStock": False,
    "skipSponsored": False,
    "delaySeconds": "1.0",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("flash_scraper/amazon-product-data").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 '{
  "searchTerms": [
    "laptop stand"
  ],
  "asins": [],
  "domain": "com",
  "currency": "USD",
  "fullDetail": true,
  "maxItems": 50,
  "minRating": "0",
  "maxPrice": "0",
  "onlyPrime": false,
  "onlyInStock": false,
  "skipSponsored": false,
  "delaySeconds": "1.0",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call flash_scraper/amazon-product-data --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dshUl8grAVfyLEDtH/builds/PybwJdvq4fM8fU0rJ/openapi.json