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

Track Amazon competitor prices vs your reference ASIN: priceDelta, Buy Box winner, FBA/FBM, stock + webhook alerts on undercut. MCP-ready. 18 marketplaces. $0.020/ASIN.

- **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
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 asin trackeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Competitor Price Tracker

**Track Amazon competitor prices for any reference ASIN — Buy Box winner, FBA/FBM, stock, and price-delta — in one schedule-friendly run. Optional webhook alerts on undercut.**

### What you get

One row per ASIN per run, with the *comparison math already done*:

| Field | Meaning |
|---|---|
| `asin` | The product's ASIN |
| `isReference` | `true` for the row representing your product |
| `price`, `currency` | Current price in marketplace currency |
| `priceDelta` | `competitor.price − reference.price` (negative = undercut) |
| `priceDeltaPercent` | Same delta as a percentage of reference price |
| `isUndercut` | `true` when the competitor is cheaper |
| `isLowest` | `true` for the cheapest ASIN this run |
| `buyBoxWinner` | The seller currently winning the Buy Box |
| `seller`, `isFBA`, `isPrime` | Merchant + fulfillment posture |
| `inStock`, `availability` | Whether you can buy it right now |
| `rating`, `reviewCount` | Social proof gap |
| `scrapedAt` | ISO timestamp — pivot on this for time-series tracking |
| `alertFired` | `true` if a webhook fired for this row this run |

Schedule it hourly or daily and you have a full price/Buy-Box history at $0.005 per ASIN — no separate database, no Keepa subscription, no fragile spreadsheet.

### When to use

- **Repricing.** Feed `priceDelta` into your repricer or a Slack alert.
- **MAP enforcement.** Detect resellers selling below your minimum advertised price.
- **Brand monitoring.** Watch unauthorized sellers grab your Buy Box.
- **Category research.** Auto-discover the top N competitors on a search keyword.
- **Agentic workflows.** Claude/GPT can call this every N minutes — input is one ASIN + a list, output is a clean comparison table.

### When NOT to use

- For full Amazon product detail extraction (A+ content, variant grids, deep BSR), use [`khadinakbar/amazon-product-intelligence`](https://apify.com/khadinakbar/amazon-product-intelligence).
- For review extraction, use [`khadinakbar/amazon-reviews-scraper`](https://apify.com/khadinakbar/amazon-reviews-scraper).
- For raw search-result scraping (no reference comparison), use [`khadinakbar/amazon-product-scraper`](https://apify.com/khadinakbar/amazon-product-scraper).

### Pricing

Pay per event + Apify platform usage (compute and proxy at cost). No subscription.

| Event | Price |
|---|---|
| Actor start | $0.001 |
| **ASIN tracked** (per row pushed) | **$0.020** |
| Alert dispatched (per webhook POST) | $0.005 |

Plus standard Apify platform compute and residential proxy fees (paid directly to Apify).

**Typical costs.** Reference + 5 competitors = ~$0.121 per run + ~$0.02–0.05 platform usage. 100 ASINs daily for a month ≈ $60–80 all-in. Comparable Keepa premium plans start at $19/mo per ASIN tracked — at 100 ASINs that's $1,900+/mo. We give you raw data feed for ~$70.

### Input

Required:
- `referenceAsin` — your product's 10-character ASIN (e.g. `B0CHWRXH8B`).

One of (pick the mode):
- `competitorAsins` — manual list of up to 100 competitor ASINs.
- `searchQuery` — Amazon search keyword; the top results become competitors.

Optional:
- `country` — marketplace code (defaults to `US`). 18 marketplaces supported: US, UK, DE, FR, CA, ES, IT, JP, AU, IN, MX, BR, NL, SE, PL, TR, AE, SG.
- `maxCompetitors` — how many competitors to pull when using `searchQuery` (default 10, max 50).
- `alertWebhookUrl` — HTTPS endpoint that receives a POST when a competitor undercuts.
- `alertUndercutPercent` — minimum % undercut to fire an alert (default 5).
- `proxyConfiguration` — defaults to Apify Residential (required for Amazon).

#### Example: track 5 named competitors against your product

```json
{
  "referenceAsin": "B0CHWRXH8B",
  "competitorAsins": ["B09G9HD6PD", "B0BDHWDR12", "B0BTYCRJSS", "B09JQMJHXY", "B0BDJ7RGQR"],
  "country": "US"
}
````

#### Example: auto-discover competitors on a keyword

```json
{
  "referenceAsin": "B0CHWRXH8B",
  "searchQuery": "wireless earbuds noise cancelling",
  "maxCompetitors": 15,
  "country": "US"
}
```

#### Example: alert Slack when undercut by 10%

```json
{
  "referenceAsin": "B0CHWRXH8B",
  "competitorAsins": ["B09G9HD6PD", "B0BDHWDR12"],
  "alertWebhookUrl": "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXX",
  "alertUndercutPercent": 10
}
```

### Webhook payload (alerts)

When a competitor crosses the undercut threshold, a `POST` is sent with:

```json
{
  "type": "competitor-undercut",
  "referenceAsin": "B0CHWRXH8B",
  "competitorAsin": "B09G9HD6PD",
  "referencePrice": 79.99,
  "competitorPrice": 69.99,
  "priceDelta": -10.0,
  "priceDeltaPercent": -12.5,
  "currency": "USD",
  "marketplace": "US",
  "competitorTitle": "Sony WF-1000XM4 Wireless Earbuds",
  "competitorSeller": "Sony Direct",
  "competitorUrl": "https://www.amazon.com/dp/B09G9HD6PD",
  "threshold": 5,
  "triggeredAt": "2026-05-03T19:30:00.000Z"
}
```

Fire-and-forget: 5-second timeout, 1 retry. Webhook errors never fail the run. Charged $0.002 per successful POST.

### Scheduling for time-series

Pair with [Apify Scheduler](https://docs.apify.com/platform/schedules) to run hourly or daily. Each run's rows are stamped with `scrapedAt`, so the dataset becomes a price-history database you can query with the [Apify dataset API](https://docs.apify.com/api/v2#tag/DatasetsCommon-actions/operation/dataset_getItems):

```bash
## Pull last 24h of comparison rows
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?clean=true&fields=asin,price,priceDelta,scrapedAt&desc=true&limit=1000"
```

### Code examples

#### JavaScript / Node.js

```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();
const reference = items.find((r) => r.isReference);
const undercutting = items.filter((r) => r.isUndercut);

console.log(`Reference at ${reference.currency} ${reference.price}`);
console.log(`${undercutting.length} competitor(s) undercutting`);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("khadinakbar/amazon-competitor-price-tracker").call(
    run_input={
        "referenceAsin": "B0CHWRXH8B",
        "searchQuery": "wireless earbuds",
        "maxCompetitors": 15,
        "country": "US",
    }
)

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
lowest = min((r for r in rows if r.get("price")), key=lambda r: r["price"])
print(f"Lowest price ASIN: {lowest['asin']} @ {lowest['currency']} {lowest['price']}")
```

#### MCP / agentic workflow

Once published, the actor is callable via Apify MCP as `apify--amazon-competitor-price-tracker`. Tool description signals when to use, return shape, and per-call cost — agents can budget-check before calling.

### How it works

1. Fetches the reference ASIN page (CheerioCrawler + Apify Residential proxy, country-matched to the marketplace).
2. Either fetches each named competitor ASIN, or runs an Amazon search and picks the top N organic (non-Sponsored) ASINs.
3. Extracts price, list price, currency, Buy Box winner, seller, FBA/Prime, stock, rating, review count.
4. Computes `priceDelta`, `priceDeltaPercent`, `isUndercut`, `isLowest` against the reference price.
5. If a webhook is configured, dispatches alerts for any competitor that undercuts by ≥ threshold.
6. Pushes one row per ASIN to the dataset and charges `$0.005` per row.

Built with [Crawlee](https://crawlee.dev) on `apify/actor-node:24`. Session pool with cookie persistence + per-request retry/backoff handles Amazon's rate limits and CAPTCHA challenges. Sessions are retired automatically on 403/429/503 or robot-check pages.

### FAQ

**How accurate is the Buy Box winner?**
Extracted from `#merchant-info` / Buy Box DOM. Accurate when the page renders a Buy Box; null when the page only shows "See All Buying Options" (multi-seller without a clear winner).

**What about variants?**
Each ASIN is tracked independently. If you want to compare variants, pass each variant ASIN explicitly in `competitorAsins`.

**How do I export to BigQuery / Snowflake?**
Use Apify's [BigQuery integration](https://apify.com/apify/google-bigquery-integration) or call `client.dataset(...).downloadItems('csv')` and load via your normal ETL.

**Can I track 1000 ASINs in one run?**
The `competitorAsins` list is capped at 100 per run for reliability. For larger universes, run multiple actor calls in parallel — Apify charges per row regardless.

**What if Amazon blocks?**
Datacenter proxies are blocked by Amazon — residential is the default and required. The session pool retires on 403/429/503; retries with exponential backoff. If you see persistent failures, check your proxy quota.

**Is this Keepa?**
No. Keepa stores the full price history server-side and gives you a chart UI. This actor gives you the *raw deltas + Buy Box state* so you can build your own repricing logic, MAP alerts, or dashboards.

### Legal disclaimer

This actor scrapes publicly accessible Amazon product pages. You are responsible for ensuring your use case complies with Amazon's [Conditions of Use](https://www.amazon.com/gp/help/customer/display.html?nodeId=508088) and applicable law in your jurisdiction. Do not use the data to harass sellers, violate antitrust law, or engage in deceptive pricing.

### Related actors

- [`khadinakbar/amazon-product-intelligence`](https://apify.com/khadinakbar/amazon-product-intelligence) — full Amazon product detail (A+ content, BSR, variants).
- [`khadinakbar/amazon-product-scraper`](https://apify.com/khadinakbar/amazon-product-scraper) — search/category/keyword scraping.
- [`khadinakbar/amazon-reviews-scraper`](https://apify.com/khadinakbar/amazon-reviews-scraper) — deep review extraction.
- [`khadinakbar/google-shopping-scraper`](https://apify.com/khadinakbar/google-shopping-scraper) — pair with this to compare prices across Amazon vs Google Shopping.

# 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("💾 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 '{
  "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": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=khadinakbar/amazon-competitor-price-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Competitor Price Tracker",
        "description": "Track Amazon competitor prices vs your reference ASIN: priceDelta, Buy Box winner, FBA/FBM, stock + webhook alerts on undercut. MCP-ready. 18 marketplaces. $0.020/ASIN.",
        "version": "0.1",
        "x-build-id": "4p8zNxeMPX3jkxhqm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~amazon-competitor-price-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-amazon-competitor-price-tracker",
                "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/khadinakbar~amazon-competitor-price-tracker/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-amazon-competitor-price-tracker",
                "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/khadinakbar~amazon-competitor-price-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-amazon-competitor-price-tracker",
                "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": [
                    "referenceAsin"
                ],
                "properties": {
                    "referenceAsin": {
                        "title": "Reference ASIN (your product)",
                        "pattern": "^[A-Z0-9]{10}$",
                        "type": "string",
                        "description": "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": {
                        "title": "Competitor ASINs (manual list)",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Z0-9]{10}$"
                        },
                        "default": []
                    },
                    "searchQuery": {
                        "title": "Search query (auto-discover competitors)",
                        "type": "string",
                        "description": "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": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "US",
                            "UK",
                            "DE",
                            "FR",
                            "CA",
                            "ES",
                            "IT",
                            "JP",
                            "AU",
                            "IN",
                            "MX",
                            "BR",
                            "NL",
                            "SE",
                            "PL",
                            "TR",
                            "AE",
                            "SG"
                        ],
                        "type": "string",
                        "description": "Which Amazon marketplace to track. Pricing, currency, and availability are localized — match this to where your reference product sells. Defaults to US (amazon.com).",
                        "default": "US"
                    },
                    "maxCompetitors": {
                        "title": "Max competitors (when auto-discovering)",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "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).",
                        "default": 10
                    },
                    "alertWebhookUrl": {
                        "title": "Alert webhook URL (optional)",
                        "type": "string",
                        "description": "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": {
                        "title": "Alert undercut threshold (%)",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "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%.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Amazon blocks datacenter IPs — residential proxies are required and are the default. Override only if you have a specific compliance reason.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
