# Amazon Competitor Price Tracker (`khadinakbar/amazon-competitor-price-tracker`) Actor

Track Amazon competitor prices against your reference ASIN, with price delta, Buy Box winner, FBA or FBM, stock and webhook alerts on undercuts. Covers 18 marketplaces; works with Apify MCP and the API.

- **URL**: https://apify.com/khadinakbar/amazon-competitor-price-tracker.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, MCP servers
- **Features:** Limited permissions
- **Stats:** 15 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 asin trackeds

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?

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

### What is Amazon Competitor Price Tracker?

Amazon Competitor Price Tracker compares a reference ASIN against competitor ASINs in one Apify Actor run. It accepts either a manual competitor list or a search query for competitor discovery, plus an Amazon marketplace. Each returned record represents one ASIN, with fields such as `price`, `priceDelta`, `priceDeltaPercent`, `isUndercut`, `isLowest`, `buyBoxWinner`, `seller`, `isFBA`, `isPrime`, `availability`, `inStock`, `rating`, `reviewCount`, and `scrapedAt`. The outcome is a comparison dataset you can use for repricing, monitoring, alerts, and time-series analysis. This Actor is also usable through Apify MCP.

### Best fit and connected workflows

This Actor fits workflows that start with one product you own or monitor, then compare it against a compact set of competitor ASINs or a marketplace search result set.

Common workflow paths:

- Repricing inputs: use `priceDelta` and `isUndercut` to feed a pricing rule or dashboard.
- Brand and channel monitoring: track Buy Box state, seller, fulfillment mode, and stock changes for a reference ASIN and its competitors.
- Category research: provide a `searchQuery` when you want Amazon search results to become the tracked competitor set.
- Alert automation: connect `alertWebhookUrl` to a Slack, Discord, Zapier, Make, n8n, or custom HTTPS endpoint workflow.
- Follow-up review research: pair the returned ASINs with [`khadinakbar/amazon-reviews-scraper`](https://apify.com/khadinakbar/amazon-reviews-scraper) when the next step is review collection.

### Practical scenario

Maya manages a private-label headphone listing. She starts with her own ASIN as `referenceAsin` and provides three competitor ASINs from her category watchlist. The run returns one row for Maya's ASIN and one row per competitor, including `price`, `priceDelta`, `priceDeltaPercent`, `buyBoxWinner`, `seller`, `isFBA`, `isPrime`, and `inStock`. She sees one competitor with a negative `priceDelta` and `isUndercut = true`, then updates her repricing rule and routes the affected ASIN to a Slack alert using the webhook field.

### Input fields

| Field | Type | Purpose |
|---|---|---|
| `referenceAsin` | string | Required reference product ASIN. All deltas are computed against this row. |
| `competitorAsins` | array of strings | Manual list of competitor ASINs to track against the reference ASIN. |
| `searchQuery` | string | Amazon search keyword for auto-discovering competitor ASINs. |
| `country` | string | Amazon marketplace code such as `US`, `UK`, `DE`, or `JP`. |
| `maxCompetitors` | integer | Number of search results to track when using `searchQuery`. |
| `alertWebhookUrl` | string | Optional HTTPS endpoint for undercut alerts. |
| `alertUndercutPercent` | integer | Threshold for webhook alerts when a competitor undercuts the reference. |
| `proxyConfiguration` | object | Proxy setup, with Apify Residential as the default. |

#### Input example

```json
{
  "referenceAsin": "B0CHWRXH8B",
  "competitorAsins": ["B09G9HD6PD", "B0BDHWDR12"],
  "country": "US",
  "alertUndercutPercent": 5
}
```

### Output fields

Each dataset row represents one ASIN in the current run.

| Field | Type | Meaning |
|---|---|---|
| `asin` | string | Amazon Standard Identification Number. |
| `isReference` | boolean | Indicates the reference product row. |
| `title` | string or null | Product title. |
| `url` | string | Canonical product URL. |
| `marketplace` | string | Marketplace code used for the run. |
| `brand` | string or null | Brand or manufacturer. |
| `price` | number or null | Current marketplace price. |
| `listPrice` | number or null | Original or list price. |
| `currency` | string or null | ISO currency code. |
| `discountPercent` | number or null | Discount percentage. |
| `priceDelta` | number or null | Competitor price minus reference price. |
| `priceDeltaPercent` | number or null | Delta as a percentage of the reference price. |
| `isUndercut` | boolean or null | Indicates whether the competitor price is below the reference price. |
| `isLowest` | boolean or null | Indicates the lowest price in the run. |
| `buyBoxWinner` | string or null | Seller currently winning the Buy Box. |
| `rating` | number or null | Star rating. |
| `reviewCount` | integer or null | Review count. |
| `availability` | string or null | Stock status text. |
| `inStock` | boolean or null | Indicates whether the item is purchasable. |
| `isPrime` | boolean or null | Prime eligibility. |
| `seller` | string or null | Seller name. |
| `isFBA` | boolean or null | Indicates fulfillment by Amazon. |
| `thumbnail` | string or null | Primary thumbnail URL. |
| `alertFired` | boolean or null | Indicates an alert was dispatched for this row. |
| `scrapedAt` | string | ISO timestamp for the row. |
| `_warnings` | array of strings or null | Per-row warnings. |

#### Output example

```json
{
  "asin": "B09G9HD6PD",
  "isReference": false,
  "title": "Example Wireless Earbuds",
  "url": "https://www.amazon.com/dp/B09G9HD6PD",
  "marketplace": "US",
  "price": 69.99,
  "currency": "USD",
  "priceDelta": -10,
  "priceDeltaPercent": -12.5,
  "isUndercut": true,
  "isLowest": true,
  "buyBoxWinner": "Example Seller",
  "inStock": true,
  "isPrime": true,
  "seller": "Example Seller",
  "isFBA": true,
  "scrapedAt": "2026-05-03T19:30:00.000Z"
}
```

### How it works

1. The Actor reads a reference ASIN and either a manual competitor list or a search query.
2. It targets the selected Amazon marketplace.
3. It fetches one row per tracked ASIN and computes reference-based comparison fields.
4. It extracts price, list price, currency, Buy Box winner, seller, fulfillment, stock, rating, and review count.
5. When a webhook URL is present, it dispatches an alert if a competitor undercuts the reference by the configured threshold.
6. It writes the comparison rows to the dataset, with `scrapedAt` available for time-series use.

### Pricing

This Actor uses Pay per event pricing on Apify with Apify platform usage included. The tracked rows are billed as event-based activity, and successful webhook dispatches are billed separately when alerts are enabled. Actor start is also event-based. For the current live pricing details, open the Pricing tab on the Actor page.

Example in words: if you track one reference ASIN and five competitors in a single run, the execution includes six ASIN-tracked events, plus any alert-dispatched events if webhook alerts fire, plus the Actor start event. Apify platform usage is included in the event price.

### Use with AI agents (MCP)

This Actor is available through Apify MCP as a tool for Amazon price comparison and undercut monitoring workflows. It accepts a reference ASIN, an optional competitor list or search query, and marketplace settings, then returns a comparison dataset with per-ASIN pricing and stock context.

Exact Actor identity: `khadinakbar/amazon-competitor-price-tracker`

> Compare the prices of my reference ASIN `B0CHWRXH8B` against these competitors in `US`. Return the dataset rows, highlight any undercuts, and tell me which ASIN is lowest in this run. If a competitor undercuts by at least 5%, dispatch the webhook alert and include the returned `scrapedAt` timestamps for follow-up analysis.

Output interpretation for agents:

- `priceDelta < 0` indicates the competitor is priced below the reference.
- `isUndercut = true` marks a competitor that is cheaper than the reference.
- `isLowest = true` marks the lowest price in the current run.
- `buyBoxWinner`, `seller`, `isFBA`, and `isPrime` help separate price movement from fulfillment and seller changes.
- `alertFired = true` shows which rows triggered a webhook dispatch.
- `scrapedAt` is useful when an agent builds a time-series or compares successive runs.

Scope and cost guidance:

- Each tracked ASIN is one billed event.
- The reference ASIN is included in the tracked set.
- Webhook alerts add separate billed events when they are successfully dispatched.
- For large comparison sets, agents can budget by counting the reference row plus each competitor row before calling the tool.

### Apify API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/amazon-competitor-price-tracker').call({
  referenceAsin: 'B0CHWRXH8B',
  competitorAsins: ['B09G9HD6PD', 'B0BDHWDR12'],
  country: 'US',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log('Dataset rows:');
for (const item of items) {
  console.log(item.asin, item.price, item.priceDelta, item.scrapedAt);
}
```

### Best results and outcome guidance

Use a reference ASIN that matches the product you want to compare against, then choose one input path:

- Use `competitorAsins` when your competitor set is already known.
- Use `searchQuery` when you want the Actor to discover competitors from Amazon search results.
- Use the correct `country` for the marketplace where the product sells.
- Use `alertUndercutPercent` to route only the undercuts that matter for your workflow.
- Use `scrapedAt` as the time key when storing rows in a dashboard or warehouse.

### Design note

I found that the dataset contract includes both a comparison view and a full snapshot view, and both expose `scrapedAt` as the time anchor for repeated runs. That makes the output useful both for comparison tables and for time-series tracking.

### FAQ

**When should I use `competitorAsins` instead of `searchQuery`?**\
Use `competitorAsins` when you already know which ASINs matter. Use `searchQuery` when you want Amazon search results to define the competitor set.

**Can I monitor more than one marketplace?**\
Run the Actor separately per marketplace code, such as `US`, `UK`, or `DE`, so each dataset reflects localized pricing and availability.

**How do webhook alerts connect to downstream automation?**\
Set `alertWebhookUrl` to your HTTPS endpoint or automation service. The Actor posts alert payloads when a competitor undercuts the reference by the configured threshold.

**What should I do after I collect the comparison rows?**\
Use `priceDelta`, `isUndercut`, `buyBoxWinner`, and `inStock` to decide whether to reprioritize, repricing, or escalate the ASIN to a downstream review workflow.

**How does this connect to reviews research?**\
Use If the comparison execution surfaces competitor ASINs you want to inspect further, send those ASINs to [`khadinakbar/amazon-reviews-scraper`](https://apify.com/khadinakbar/amazon-reviews-scraper) for review extraction.

### Related Actors

- [`khadinakbar/amazon-reviews-scraper`](https://apify.com/khadinakbar/amazon-reviews-scraper) - use after this Actor when your workflow needs ratings, reviews, or comments for a returned ASIN.

### Responsible use

This Actor works with publicly accessible Amazon product pages. Use it in a way that fits your organization, marketplace rules, and applicable law. Keep alerting and comparison workflows focused on legitimate pricing, monitoring, and research use cases.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/amazon-competitor-price-tracker/changelog.md

# Actor input Schema

## `referenceAsin` (type: `string`):

The ASIN you want to compare competitors against — usually your own product (e.g. 'B08N5WRWNW'). Every other ASIN's priceDelta is computed relative to this one. Required. NOT a URL — paste the 10-character ASIN code from the URL `/dp/<ASIN>`. NOT a search keyword — use 'searchQuery' for that.

## `competitorAsins` (type: `array`):

Up to 100 specific competitor ASINs to track against the reference (e.g. \['B09G9HD6PD','B0BDHWDR12']). Use this when you already know who you're competing with. Leave empty to auto-discover competitors via 'searchQuery'. NOT a URL list — for direct URLs use 'startUrls'. Each ASIN must be exactly 10 alphanumeric characters.

## `searchQuery` (type: `string`):

Free-text Amazon search keyword (e.g. 'wireless earbuds noise cancelling'). The top results from the marketplace search are tracked as competitors against the reference ASIN. Use this when you want category-level competitor monitoring rather than a fixed list. Ignored if 'competitorAsins' is provided.

## `country` (type: `string`):

Which Amazon marketplace to track. Pricing, currency, and availability are localized — match this to where your reference product sells. Defaults to US (amazon.com).

## `maxCompetitors` (type: `integer`):

How many competitors to pull from the search results when 'searchQuery' is used. Ignored if 'competitorAsins' is provided. Each tracked ASIN is billed as one 'asin-tracked' event at $0.005. The reference ASIN is also billed (1 + N events total).

## `alertWebhookUrl` (type: `string`):

Optional HTTPS endpoint that receives a POST with the alert payload whenever a competitor undercuts the reference by at least 'alertUndercutPercent'. Use to wire into Slack/Discord/Zapier/Make/n8n/your own endpoint. Fire-and-forget: 5s timeout, 1 retry, webhook failures never fail the run. Adds an 'alert-dispatched' charge ($0.002) per successful POST.

## `alertUndercutPercent` (type: `integer`):

Minimum percentage by which a competitor must undercut the reference to fire a webhook (e.g. 5 = alert when competitor is ≥5% cheaper). Lower = noisier alerts; higher = only big movers. Ignored if 'alertWebhookUrl' is empty. Defaults to 5%.

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

Amazon blocks datacenter IPs — residential proxies are required and are the default. Override only if you have a specific compliance reason.

## Actor input object example

```json
{
  "referenceAsin": "B0CHWRXH8B",
  "competitorAsins": [],
  "searchQuery": "wireless earbuds noise cancelling",
  "country": "US",
  "maxCompetitors": 10,
  "alertWebhookUrl": "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXX",
  "alertUndercutPercent": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "referenceAsin": "B0CHWRXH8B",
    "country": "US",
    "maxCompetitors": 10,
    "alertUndercutPercent": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/amazon-competitor-price-tracker").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 = {
    "referenceAsin": "B0CHWRXH8B",
    "country": "US",
    "maxCompetitors": 10,
    "alertUndercutPercent": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/amazon-competitor-price-tracker").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 '{
  "referenceAsin": "B0CHWRXH8B",
  "country": "US",
  "maxCompetitors": 10,
  "alertUndercutPercent": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/amazon-competitor-price-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/amazon-competitor-price-tracker"
        }
    }
}
```

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/YcsIkMSAtizGOmMev/builds/IyeOeRjeXoXakDO9Z/openapi.json