# Amazon Scraper API & Price Monitor (21 Markets) (`winningsolutions/amazon-product-scraper-monitor`) Actor

Scrape Amazon product data by ASIN or keyword across 21 marketplaces, or run it on a schedule to track price, Buy Box and stock changes since the last check. Returns clean JSON with title, price, rating, seller and availability. No HTML captchas, no vendor account.

- **URL**: https://apify.com/winningsolutions/amazon-product-scraper-monitor.md
- **Developed by:** [Winning Solutions](https://apify.com/winningsolutions) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 product checks

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/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 Scraper API & Price Monitor (21 Markets)

Scrape Amazon product data with department, price, and sort filters. Then monitor prices, featured offers, sellers, and availability across 21 marketplaces. EU-first marketplace codes. Built-in change detection for scheduled runs. This Amazon scraper reads a merchant API instead of Amazon HTML pages.

**Release notes:** v0.1 - ASIN monitoring, Product search, named-store diffs, pay-per-event billing. Launch rates until 30 November 2026.

  <br>

> ## Launch pricing: about 30% off
>
> **$0.005 per product check**
>
> Launch rates apply until 30 November 2026. Regular rates start on 1 December 2026. Regular rates stay competitive. See the [price tables](#pricing).

<br>

***

### Why use this Actor

- **Product Search** - Filter by department, price, and sort. Set `searchOnly` to stop after the listing.
- **Change detection** - Compare each run to a named baseline. Get `changes_only` output for alerts.
- **21 marketplaces** - Run DE, FR, IT, ES, GB, and 16 more in one input.
- **EU-first** - Per-market language codes (`de_DE`, `fr_FR`, ...). No URL guessing.
- **No HTML captchas** - Data comes from the merchant API, not from Amazon HTML pages. You do not fight captcha walls.
- **Scheduler-ready** - Stable `monitorId`, webhooks on `ACTOR.RUN.SUCCEEDED`, dataset views for changes.

You pay Apify pay-per-event only. The Actor owner supplies API credentials. You do not need a vendor account.

***

### Features

- **No HTML captchas** - Data comes from the merchant API, not from Amazon HTML pages.
- **Change detection** - Built-in named-store diffs. Compare each run to a saved baseline.
- **21 marketplaces** - Run DE, FR, IT, ES, GB, and 16 more in one input.
- **EU language mapping** - Per-market `language_code` (`de_DE`, `fr_FR`, ...). No URL guessing.
- **Buy Box and featured offer** - Set `includeSellers: true` for seller and offer fields.
- **Price history** - Named Key-Value Store per `monitorId`. Up to 365 days.
- **Output modes** - `full`, `changes_only`, or `full_with_changes` for alerts or full snapshots.
- **Fast results** - Results usually arrive within one minute.

***

### Use cases

#### 1. MAP and repricing alerts

Schedule daily runs with `outputMode: "changes_only"` and `priceChangeThreshold` for noise control. Push only rows where `changes.anyChange` is true to your webhook or database.

#### 2. EU expansion

Monitor the same ASINs on DE, FR, IT, ES, and GB in one run. Compare price and availability per market without five separate scrapers.

#### 3. Buy Box watch

Set `includeSellers: true`. Track `buyBoxSeller` and `changes.buyBoxChanged` when the featured offer moves to another seller.

#### 4. Competitor intelligence

Use Product search to discover SERP leaders. Apply Search Filters, then pin top ASINs in ASIN mode for stable long-term monitoring. Avoid treating SERP churn as product removal.

#### 5. Catalog enrichment

Enable `includeProductDetails` for titles, images, attributes, and variant lists. Disable it for lightweight price-only checks.

#### 6. Filtered listing only

Set `mode` to `keyword` and `searchOnly` to true. Add `department`, `priceMin`, `priceMax`, or `sortBy`. The run writes listing rows and skips Monitor work.

***

### Pricing

Pay-per-event. Monitor runs charge after each saved product row. Search-only charges `keyword-search` once per keyword and marketplace, not per listing row.

Launch pricing is active until 30 November 2026.
A product check costs **$0.005**. Unchanged checks use the same rate.
Seller and Product search tasks cost **$0.005** each at launch.

From **1 December 2026** the regular rates apply.

#### Launch prices (until 30 November 2026)

| Cost item | Launch rate |
| --- | --- |
| Product check | $0.005 per ASIN × marketplace |
| Seller enrichment (optional) | $0.005 per successful sellers task |
| Keyword search / Product search | $0.005 per keyword × marketplace |
| Change detected | $0.001 extra when a field changed |
| Actor start | $0.01 once per run |
| Apify platform compute (RAM/time) | Billed by Apify platform pricing |

> **Cost per check:** about **$0.015** for one ASIN on one market (start + check). 50 ASINs on DE daily, no sellers: about **$0.26/day**.

No tier discounts during launch. Every plan pays the same launch rate.

#### Regular prices (from 1 December 2026)

| Cost item | Regular rate |
| --- | --- |
| Product check | $0.007 per ASIN × marketplace |
| Seller enrichment (optional) | $0.006 per successful sellers task |
| Keyword search / Product search | $0.006 per keyword × marketplace |
| Change detected | $0.002 extra when a field changed |
| Actor start | $0.02 once per run |
| Apify platform compute (RAM/time) | Billed by Apify platform pricing |

Same `product-check` price for changed and unchanged rows.

#### Cost examples (launch rates)

**Scenario A: 1 ASIN on DE, no sellers**

- Actor start: $0.01
- 1 product check: $0.005
- **Total: $0.015**

**Scenario B: 50 ASINs on DE daily, no sellers**

- Actor start: $0.01
- 50 product checks: $0.25
- **Total: $0.26/day**

**Scenario C: 10 ASINs on DE with sellers**

- Actor start: $0.01
- 10 product checks: $0.05
- 10 seller tasks: $0.05
- **Total: $0.11**

**Scenario D: Product search only, 5 keywords on DE**

- Actor start: $0.01
- 5 keyword-search events: $0.025
- **Total: $0.035**

Set `maxTotalChargeUsd` to cap spend. The run stops new charges but keeps rows already written.

***

### Input

#### Core fields

| Field | Description |
| --- | --- |
| `mode` | `asin` or `keyword` |
| `asins` | ASIN list when mode is `asin` |
| `keywords` | Keyword list when mode is `keyword` |
| `searchOnly` | Stop after Product Search. Default false. |
| `department` | English Amazon department. Product search only. |
| `priceMin` / `priceMax` | Price range in the marketplace currency. |
| `sortBy` | Listing sort. Example: `price_low_to_high`. |
| `marketplaces` | Marketplace codes. Default `["DE"]`. Each ASIN is checked on every selected market. |
| `monitorId` | Stable ID for baselines. Use the same value on every scheduled run. |
| `outputMode` | `full`, `changes_only`, or `full_with_changes`. Use `changes_only` for schedules. |
| `includeSellers` | Fetch offers. Required for Buy Box / featured-offer change tracking. |
| `includeProductDetails` | Fetch ASIN details. Disable for price-only runs. |
| `priceChangeThreshold` | Minimum price change % to flag. `0` means any change. |
| `trackPriceHistory` | Store price history in the named Key-Value Store. |
| `maxHistoryDays` | Retain history up to 365 days. Default 90. |
| `languageCode` | Optional override for all markets (e.g. `fr_FR` for Belgium French). |
| `locationName` | Optional postal or city for delivery-sensitive prices. |
| `maxTotalChargeUsd` | Budget cap. Default 25. |

#### Example: ASIN monitor on Germany

```json
{
  "mode": "asin",
  "asins": ["B09V3KXJPB", "B0BSHF7WHW", "B0BDHB9Y8H", "B08N5WRWNW", "B07PXGQC1Q"],
  "marketplaces": ["DE"],
  "monitorId": "de-core-catalog",
  "outputMode": "full_with_changes",
  "includeProductDetails": true,
  "includeSellers": false
}
```

#### Example: Keyword discovery on EU5

```json
{
  "mode": "keyword",
  "keywords": ["wireless earbuds"],
  "maxProductsPerKeyword": 20,
  "marketplaces": ["DE", "FR", "IT", "ES", "GB"],
  "monitorId": "eu-earbuds-discovery",
  "outputMode": "full",
  "includeProductDetails": true
}
```

Review results. Copy ASINs you want to track. Switch to ASIN mode with a dedicated `monitorId` for stable monitoring.

#### Example: Search only with Search Filters

```json
{
  "mode": "keyword",
  "keywords": ["wireless earbuds"],
  "searchOnly": true,
  "department": "Electronics",
  "priceMin": 20,
  "priceMax": 80,
  "sortBy": "price_low_to_high",
  "maxProductsPerKeyword": 20,
  "marketplaces": ["DE"]
}
```

This run writes listing rows. It does not write a Monitor baseline.

#### Example: Daily scheduled changes only

```json
{
  "mode": "asin",
  "asins": ["B09V3KXJPB", "B0BSHF7WHW"],
  "marketplaces": ["DE", "FR", "IT", "ES", "GB"],
  "monitorId": "eu-map-watch",
  "outputMode": "changes_only",
  "includeSellers": true,
  "priceChangeThreshold": 1,
  "trackPriceHistory": true,
  "maxHistoryDays": 90
}
```

***

### Output

Each dataset row is one ASIN on one marketplace. Failed fetches still use the same shape with `_metadata.error`.

Key fields: `price`, `currency`, `isAvailable`, `buyBoxSeller`, `sellers`, `listingStatus`, `changes`, `priceHistory`, `isNewProduct`, `keyword`, `searchRank`.

Dataset views: **overview**, **search**, **changes**, **sellers**.

#### Example output with changes

```json
{
  "asin": "B09V3KXJPB",
  "marketplace": "DE",
  "marketplaceDomain": "amazon.de",
  "url": "https://www.amazon.de/dp/B09V3KXJPB",
  "monitorId": "eu-map-watch",
  "scrapedAt": "2026-09-02T08:00:00.000Z",
  "title": "Example Wireless Earbuds",
  "price": 79.99,
  "currency": "EUR",
  "isAvailable": true,
  "buyBoxSeller": "Amazon",
  "buyBoxSellerId": "A1PA6795UKMFR9",
  "sellers": [
    {
      "sellerName": "Amazon",
      "sellerId": "A1PA6795UKMFR9",
      "price": 79.99,
      "currency": "EUR",
      "isBuyBoxWinner": true,
      "isFulfilledByAmazon": true
    }
  ],
  "sellerCount": 3,
  "listingStatus": "ok",
  "isNewProduct": false,
  "changes": {
    "priceChanged": true,
    "previousPrice": 89.99,
    "priceChange": -10.0,
    "priceChangePercent": -11.11,
    "availabilityChanged": false,
    "buyBoxChanged": false,
    "anyChange": true
  },
  "priceHistory": [
    { "date": "2026-09-01", "price": 89.99 },
    { "date": "2026-09-02", "price": 79.99 }
  ],
  "_metadata": {
    "resultCharged": true
  }
}
```

On the first run, `isNewProduct` is true and price fields in `changes` are not set.

***

### Daily schedule guide

1. **Pick a stable `monitorId`.** Example: `brand-x-eu-daily`. Use it on every schedule run.
2. **Set `outputMode` to `changes_only`.** You get rows only when something changed or a product is new.
3. **Results usually arrive within one minute.**
4. **Create an Apify Schedule.** Run once per day at your preferred time.
5. **Add a webhook.** In Integrations, listen for `ACTOR.RUN.SUCCEEDED`. Filter dataset items where `changes.anyChange === true`.
6. **Optional:** Set `includeSellers: true` for Buy Box alerts. Set `priceChangeThreshold` to ignore small moves.

Baselines live in the named Key-Value Store `amazon-monitor-{monitorId}`. Do not change `monitorId` mid-stream or diffs reset.

***

### API and MCP usage

Run from API, CLI, or MCP with the same JSON input as the Console form.

```bash
apify call YOUR_USERNAME/amazon-product-scraper-monitor --input '{
  "mode": "asin",
  "asins": ["B09V3KXJPB"],
  "marketplaces": ["DE"],
  "monitorId": "api-test"
}'
```

Fetch results from the run dataset. Use the **changes** view for alert pipelines.

***

### FAQ

**Does this guarantee zero blocking?**\
No. The merchant API can return empty results or errors. This Actor avoids Amazon HTML captchas. It does not bypass all upstream limits.

**Why is my first schedule run large?**\
The first run creates baselines. Every product is `isNewProduct`. Later runs shrink with `changes_only`.

**Belgium and Egypt language?**\
Belgium defaults to Dutch (`nl_NL`). Set `languageCode` to `fr_FR` for French. Egypt defaults to `ar_SA`. Retry with `ar_AE` if language errors occur.

***

### Limits

- Max 500 ASIN × marketplace checks per run (also capped by `maxTotalChargeUsd`).
- Max 100 tasks per priority API batch (split automatically).
- Internal concurrency defaults to 10.
- Keyword mode: products can drop from search without being delisted (`droppedFromSearch`).
- Currency is per record. Do not compare prices across markets without conversion.

# Actor input Schema

## `mode` (type: `string`):

Choose ASIN list or Product search. Example: asin

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

One ASIN per row. Example: B09V3KXJPB

## `keywords` (type: `array`):

One keyword per row. Example: wireless earbuds

## `maxProductsPerKeyword` (type: `integer`):

Maximum products to resolve per keyword and marketplace. Example: 20

## `searchOnly` (type: `boolean`):

Stop after Product Search. No Monitor in this run. Example: false

## `department` (type: `string`):

Amazon department name in English. Applies to Product search. Example: Electronics

## `priceMin` (type: `integer`):

Minimum price in the marketplace currency. Example: 20

## `priceMax` (type: `integer`):

Maximum price in the marketplace currency. Example: 80

## `sortBy` (type: `string`):

Sort Product Search results. Example: price\_low\_to\_high

## `marketplaces` (type: `array`):

Each ASIN is checked on every selected marketplace. EU codes appear first. Example: DE

## `languageCode` (type: `string`):

Override language\_code for all selected markets. Example: fr\_FR for Belgium French

## `locationName` (type: `string`):

Optional location\_name for delivery-sensitive prices. Example: 1050,Brussels,Belgium

## `monitorId` (type: `string`):

Stable ID for named-store baselines across scheduled runs. Example: eu-core

## `outputMode` (type: `string`):

Control which records are saved. Example: full\_with\_changes

## `trackPriceHistory` (type: `boolean`):

Store price history in the named key-value store.

## `maxHistoryDays` (type: `integer`):

Days of price history to retain. Example: 90

## `priceChangeThreshold` (type: `number`):

Minimum percent change to flag priceChanged. Zero means any change. Example: 0

## `includeSellers` (type: `boolean`):

Fetch offers. Required for featured-offer change tracking. Adds one sellers task per ASIN and marketplace.

## `maxSellersPerProduct` (type: `integer`):

Maximum sellers to keep per product. Example: 10

## `includeProductDetails` (type: `boolean`):

Call the ASIN endpoint for images, attributes, and variant list. Disable for price-only runs.

## `expandVariants` (type: `boolean`):

If the ASIN is a parent, also monitor child ASINs from product\_asins.

## `maxVariantsPerProduct` (type: `integer`):

Cap child ASINs when expandVariants is enabled. Example: 10

## `maxTotalChargeUsd` (type: `number`):

Stop new pay-per-event charges when this amount is reached. Example: 25

## Actor input object example

```json
{
  "mode": "asin",
  "asins": [
    "B09V3KXJPB"
  ],
  "keywords": [
    "wireless earbuds"
  ],
  "maxProductsPerKeyword": 20,
  "searchOnly": false,
  "marketplaces": [
    "DE"
  ],
  "monitorId": "default",
  "outputMode": "full_with_changes",
  "trackPriceHistory": true,
  "maxHistoryDays": 90,
  "priceChangeThreshold": 0,
  "includeSellers": false,
  "maxSellersPerProduct": 10,
  "includeProductDetails": true,
  "expandVariants": false,
  "maxVariantsPerProduct": 10,
  "maxTotalChargeUsd": 25
}
```

# Actor output Schema

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

HTTP URL of the default dataset items endpoint.

# 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 = {
    "mode": "asin",
    "asins": [
        "B09V3KXJPB"
    ],
    "keywords": [
        "wireless earbuds"
    ],
    "marketplaces": [
        "DE"
    ],
    "monitorId": "default",
    "outputMode": "full_with_changes"
};

// Run the Actor and wait for it to finish
const run = await client.actor("winningsolutions/amazon-product-scraper-monitor").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 = {
    "mode": "asin",
    "asins": ["B09V3KXJPB"],
    "keywords": ["wireless earbuds"],
    "marketplaces": ["DE"],
    "monitorId": "default",
    "outputMode": "full_with_changes",
}

# Run the Actor and wait for it to finish
run = client.actor("winningsolutions/amazon-product-scraper-monitor").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 '{
  "mode": "asin",
  "asins": [
    "B09V3KXJPB"
  ],
  "keywords": [
    "wireless earbuds"
  ],
  "marketplaces": [
    "DE"
  ],
  "monitorId": "default",
  "outputMode": "full_with_changes"
}' |
apify call winningsolutions/amazon-product-scraper-monitor --silent --output-dataset

```

## MCP server setup

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

```

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/DS9eqLdaZXbeHw7p4/builds/4NUcxoiQ0b3h0Pf0z/openapi.json