# Price Intelligence — Amazon, Walmart, Best Buy & Shopify (`luckborn/price-intelligence`) Actor

Monitor prices across 4 e-commerce platforms in one unified API. Track price history, detect drops, compare cross-platform competitors. Pay per ASIN check — no subscription needed.

- **URL**: https://apify.com/luckborn/price-intelligence.md
- **Developed by:** [Luck Born](https://apify.com/luckborn) (community)
- **Categories:** E-commerce, AI, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## 🏪 Multi-Platform Price Intelligence

**Monitor prices across Amazon, Walmart, Best Buy, and Shopify — in one unified API.**

[![Apify Store](https://img.shields.io/badge/Available_on-Apify_Store-1a73e8?style=flat-square)](https://apify.com/luckborn/multi-platform-price-intelligence)
[![PPE](https://img.shields.io/badge/Pricing-Pay_Per_Event-00c853?style=flat-square)](#-pricing)
[![Platforms](https://img.shields.io/badge/Platforms-Amazon_•_Walmart_•_Best_Buy_•_Shopify-ff6d00?style=flat-square)](#-supported-platforms)

---

### 📋 What It Does

Stop switching between tabs. Give this actor a list of ASINs or product URLs and get back a **unified price report** across all 4 platforms — with price history, drop alerts, and competitor comparison.

````

INPUT  →  \[B08N5WRWNW, B0B7X9X1Y2, ...]
│
▼
┌─────────────────────┐
│  Amazon  (Cheerio)   │  $0.0003 compute / ASIN
│  Walmart (Playwright)│  $0.002  compute / ASIN
│  BestBuy (Cheerio)   │  $0.0003 compute / ASIN
│  Shopify (Cheerio)   │  $0.0003 compute / ASIN
└────────┬────────────┘
▼
┌─────────────────────┐
│  Normalize & Compare │  Unified schema, same fields
│  Price History (KVS) │  Persisted across runs (90 days)
│  Alert Detection     │  Price drops, stock changes, competitors
└────────┬────────────┘
▼
OUTPUT → { price, stock, history, alerts, competitors }

````

**The only actor on the Store that unifies 4 platforms into one price intelligence dataset.**

---

### ✨ Key Features

| Feature | Description |
|---|---|
| **4 platforms, 1 API** | Amazon, Walmart, Best Buy, and Shopify in one unified schema |
| **Smart URL detection** | Paste any product URL — platform auto-detected |
| **Price history** | 90-day price history stored in KVS across runs. See min/max/avg/trend |
| **Price drop alerts** | Detect drops above your threshold percentage. Get `priceDrop` alerts in output |
| **Stock change alerts** | Know when products go out of stock or come back |
| **Competitor comparison** | Compare prices across platforms side-by-side |
| **BuyBox tracking** | Amazon only — see who's winning the buy box |
| **BSR + reviews** | Best Sellers Rank, ratings, and review counts |
| **Bulk processing** | Check 1,000+ ASINs in a single run |
| **Scheduling** | Run daily via Apify scheduler — automatic price history accumulation |
| **Pay per use** | $0.01/ASIN. No minimum, no subscription. |

---

### 🔧 Input

Three ways to provide products:

#### 1. Amazon ASINs (quickest)
```json
{
  "asins": ["B08N5WRWNW", "B0B7X9X1Y2", "B09G9D7K1S"]
}
````

#### 2. Any-platform URLs (auto-detected)

```json
{
  "urls": [
    "https://www.amazon.com/dp/B08N5WRWNW",
    "https://www.walmart.com/ip/Sony-WH-1000XM5/123456789"
  ]
}
```

#### 3. Structured objects (full control)

```json
{
  "products": [
    {"platform": "amazon", "productId": "B08N5WRWNW"},
    {"platform": "shopify", "productId": "sony-headphones", "domain": "example"}
  ]
}
```

#### Other parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `enablePriceHistory` | boolean | `true` | Track prices over time (KVS storage) |
| `enableAlerts` | boolean | `true` | Detect drops, stock changes, competitors |
| `priceDropThresholdPercent` | integer | `5` | Alert if price drops ≥ this % |
| `competitorPrices` | array | `[]` | Manual competitor prices for comparison |
| `maxConcurrency` | integer | `3` | Parallel scrapes (1-10) |
| `outputFormat` | string | `json` | `json` / `csv` / `both` |

***

### 📤 Output Example

```json
{
  "status": "success",
  "productId": "B08N5WRWNW",
  "platform": "amazon",
  "title": "Sony WH-1000XM5 Wireless Noise Cancelling Headphones",
  "brand": "Sony",

  "currentPrice": {
    "amount": 328.00,
    "currency": "USD",
    "isPrime": true,
    "isSale": true,
    "msrp": 399.99,
    "discountPercent": 18
  },

  "buyBox": {
    "seller": "Amazon.com",
    "price": 328.00,
    "isAmazon": true
  },

  "inStock": true,
  "stockLevel": "in_stock",

  "productDetails": {
    "rating": 4.6,
    "reviewCount": 8732,
    "bsr": { "rank": 42, "category": "Electronics > Headphones" }
  },

  "priceHistory": [
    { "date": "2026-07-01", "price": 348.00 },
    { "date": "2026-07-02", "price": 348.00 },
    { "date": "2026-07-03", "price": 328.00 }
  ],

  "priceStats": {
    "min": 328.00,
    "max": 399.99,
    "avg": 356.33,
    "trend": "down"
  },

  "competitorPrices": [
    { "platform": "walmart", "price": 319.99, "inStock": true }
  ],

  "alerts": [
    {
      "type": "priceDrop",
      "severity": "medium",
      "message": "Price dropped 5.7% from $348.00 to $328.00",
      "dropPercent": 5.7
    }
  ]
}
```

***

### 💰 Pricing

#### Pay Per Event — no subscription, no minimum

| Tier | Price | What's included |
|---|---|---|
| **Single check** | **$0.01/ASIN** | Current price, stock, rating, basic details |
| **Bulk 1,000** | **$5.00** | 1,000 products + price history + alerts + competitors |
| **Scheduling** | Free (Apify native) | Run daily → accumulate 90-day history automatically |

#### Cost examples

| Use case | Products | Runs | Monthly cost |
|---|---|---|---|
| Small seller checking 20 ASINs | 20/mo | Manual | **~$0.20/mo** |
| Active seller monitoring 200 ASINs daily | 6,000/mo | Daily | **~$30/mo** ($5 bulk + daily compute) |
| Brand tracking 500 SKUs across 4 platforms | 15,000/mo | Daily | **~$75/mo** |
| Agency monitoring 2,000 SKUs for 5 clients | 10,000/mo | Daily | **~$50/mo** |

> 💡 **Pro tip:** Run daily via Apify scheduler. The first run gives you a snapshot. After 30 days you have a full price history curve. After 90 days you have seasonal trend data.

***

### 🎯 Supported Platforms

| Platform | Scraper Type | Anti-block | Speed |
|---|---|---|---|
| **Amazon** | CheerioCrawler | Minimal (product pages are public) | ⚡ Fast — ~1s/product |
| **Walmart** | PlaywrightCrawler | Residential proxy recommended | 🐢 Slower — ~5s/product |
| **Best Buy** | CheerioCrawler | Minimal | ⚡ Fast — ~1s/product |
| **Shopify** | CheerioCrawler | None needed | ⚡ Fast — ~1s/product |

***

### 🎯 Use Cases

| Who | How they use it |
|---|---|
| **Amazon FBA seller** | Monitor 200 ASINs daily for competitor price drops. Reprice automatically when Walmart drops below your margin. |
| **DTC brand** | Track your Amazon listing vs your Shopify store vs Walmart marketplace. Ensure MAP compliance across channels. |
| **Retail analyst** | Build a competitive pricing dashboard. Run 5,000 SKUs weekly, export to Google Sheets, analyze trends. |
| **Price monitoring agency** | Run 10,000+ SKUs daily for 20+ clients. Charge $500/mo per client for the intelligence. |
| **Arbitrage / deal hunter** | Scrape Amazon and Walmart for price gaps. Get alerted when one platform is 15%+ cheaper. |

***

### 📊 Comparison

| Feature | This Actor | Keepa ($19/mo) | CamelCamelCamel | Walmart scrapers | Shopify scrapers |
|---|---|---|---|---|---|
| Amazon price | ✅ | ✅ | ✅ | ❌ | ❌ |
| Walmart price | ✅ | ❌ | ❌ | ✅ | ❌ |
| Best Buy price | ✅ | ❌ | ❌ | ❌ | ❌ |
| Shopify price | ✅ | ❌ | ❌ | ❌ | ✅ |
| Cross-platform compare | ✅ **UNIQUE** | ❌ | ❌ | ❌ | ❌ |
| Price history (90 days) | ✅ | ✅ | ✅ | ✅ | ❌ |
| Price drop alerts | ✅ | ✅ | ✅ | ✅ | ❌ |
| Stock monitoring | ✅ | ❌ | ❌ | ✅ | ✅ |
| API access | ✅ | ✅ (paid) | ❌ | ❌ | ❌ |
| **Pay per use** | ✅ **$0.01** | ❌ $19/mo | ❌ Free (limited) | ❌ | ❌ |
| Scheduling | ✅ (Apify) | ✅ | ❌ | ❌ | ❌ |

***

### 🚀 Quick Start

#### 1. Try with the prefill data

The input already has 3 Amazon ASINs pre-filled. Click **"Run"** and get back price snapshots in seconds.

#### 2. Add your own products

Replace the prefill with your ASINs or product URLs. Auto-detection handles any platform.

#### 3. Enable scheduling

Set a daily schedule in Apify Console. Each run appends to the price history automatically.

#### 4. Get alerts

Check the `alerts` array in each output record. Price drops, stock changes, and competitor alerts are computed every run.

#### 5. Integrate via API

```bash
curl -X POST "https://api.apify.com/v2/acts/luckborn~multi-platform-price-intelligence/runs" \
  -H "Content-Type: application/json" \
  -d '{
    "asins": ["B08N5WRWNW", "B0B7X9X1Y2"],
    "priceDropThresholdPercent": 10
  }'
```

***

### 🧠 Tips

1. **Run daily, not hourly** — prices change daily. Hourly runs waste money and increase blocking risk.
2. **Start small** — test with 10 ASINs first. Validate output format, then scale to hundreds.
3. **Set a realistic alert threshold** — 5% is good for electronics, 10%+ for consumables. Too low = noise.
4. **Use the `competitorPrices` input** — provide known competitor prices manually for cross-platform alerts.
5. **Check `priceStats.trend`** — `"down"` means this product is in a price war. `"up"` means supply constraints.

***

### 🔒 Privacy & Compliance

- **No login required** — all scraping is from public product pages
- **No customer data** — only product pricing data is extracted
- **Compliant with** standard web scraping practices for publicly listed prices
- **Rate-limited** by design — we don't hammer any single domain

***

### 🐛 Known Limitations

- **Walmart** uses JS-rendered prices — Playwright is slower and may fail with aggressive anti-bot on high-volume runs
- **Shopify** stores vary in template structure — standard Liquid stores work reliably; custom templates may return partial data
- **Price history** is only as good as your run frequency — daily runs give 90-day windows
- **Competitor prices** require manual input in MVP — full auto-discovery coming in v1.1

***

### 📦 Changelog

#### v1.0 (Current)

- 4 platform scrapers: Amazon, Walmart, Best Buy, Shopify
- Smart URL auto-detection
- Price history engine (KVS, 90-day window)
- Price stats (min/max/avg/trend)
- Alert detection (price drops, stock changes, competitor below)
- Bulk processing (1,000+ ASINs)
- Apify scheduling support

#### v1.1 (Planned)

- Auto competitor discovery (search-based)
- CSV export in key-value store
- Email/Webhook alerts
- Additional platforms (Target, Costco)

***

*Built with ❤️ by [luckborn](https://apify.com/luckborn) on the Apify platform.*

# Actor input Schema

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

List of Amazon ASIN codes (10 characters). These will be checked on Amazon.com. For other platforms, use the URLs input or the Products array below.

## `urls` (type: `array`):

Full product URLs from any supported platform. Platform is auto-detected from the URL structure.

## `products` (type: `array`):

Advanced mode — specify platform, productId, and optional overrides per product.

## `enablePriceHistory` (type: `boolean`):

Store and retrieve historical prices for each product across runs. Enables price drop alerts and trend analysis.

## `enableAlerts` (type: `boolean`):

Detect price drops, stock changes, and competitor undercutting. Alerts are included in the output.

## `priceDropThresholdPercent` (type: `integer`):

Minimum percentage drop to trigger a price drop alert. Example: 5 = alert if price drops 5% or more since last check.

## `competitorPrices` (type: `array`):

Optional — provide known competitor prices for cross-platform comparison. These will be included in the output and used for competitor alerts.

## `maxConcurrency` (type: `integer`):

Maximum number of products to scrape simultaneously. Higher = faster but more likely to trigger rate limits.

## `proxyConfiguration` (type: `string`):

auto = use residential for Walmart/large runs, datacenter for Amazon/Shopify. Override for specific needs.

## `outputFormat` (type: `string`):

JSON = structured (best for API). CSV = spreadsheet-friendly.

## Actor input object example

```json
{
  "asins": [
    "B08N5WRWNW",
    "B0B7X9X1Y2",
    "B09G9D7K1S"
  ],
  "urls": [
    "https://www.amazon.com/dp/B08N5WRWNW",
    "https://www.walmart.com/ip/Sony-WH-1000XM5/123456789",
    "https://www.bestbuy.com/site/sony-wh-1000xm5/12345.p",
    "https://example.myshopify.com/products/sony-headphones"
  ],
  "products": [
    {
      "platform": "amazon",
      "productId": "B08N5WRWNW",
      "url": "https://www.amazon.com/dp/B08N5WRWNW"
    },
    {
      "platform": "walmart",
      "productId": "123456789"
    },
    {
      "platform": "shopify",
      "productId": "sony-headphones",
      "domain": "example"
    }
  ],
  "enablePriceHistory": true,
  "enableAlerts": true,
  "priceDropThresholdPercent": 5,
  "competitorPrices": [
    {
      "platform": "walmart",
      "price": 329.99,
      "seller": "Walmart"
    },
    {
      "platform": "bestbuy",
      "price": 349.99,
      "seller": "Best Buy"
    }
  ],
  "maxConcurrency": 3,
  "proxyConfiguration": "auto",
  "outputFormat": "json"
}
```

# 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 = {
    "asins": [
        "B08N5WRWNW",
        "B0B7X9X1Y2",
        "B09G9D7K1S"
    ],
    "urls": [
        "https://www.amazon.com/dp/B08N5WRWNW",
        "https://www.walmart.com/ip/Sony-WH-1000XM5/123456789",
        "https://www.bestbuy.com/site/sony-wh-1000xm5/12345.p",
        "https://example.myshopify.com/products/sony-headphones"
    ],
    "products": [
        {
            "platform": "amazon",
            "productId": "B08N5WRWNW",
            "url": "https://www.amazon.com/dp/B08N5WRWNW"
        },
        {
            "platform": "walmart",
            "productId": "123456789"
        },
        {
            "platform": "shopify",
            "productId": "sony-headphones",
            "domain": "example"
        }
    ],
    "competitorPrices": [
        {
            "platform": "walmart",
            "price": 329.99,
            "seller": "Walmart"
        },
        {
            "platform": "bestbuy",
            "price": 349.99,
            "seller": "Best Buy"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("luckborn/price-intelligence").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 = {
    "asins": [
        "B08N5WRWNW",
        "B0B7X9X1Y2",
        "B09G9D7K1S",
    ],
    "urls": [
        "https://www.amazon.com/dp/B08N5WRWNW",
        "https://www.walmart.com/ip/Sony-WH-1000XM5/123456789",
        "https://www.bestbuy.com/site/sony-wh-1000xm5/12345.p",
        "https://example.myshopify.com/products/sony-headphones",
    ],
    "products": [
        {
            "platform": "amazon",
            "productId": "B08N5WRWNW",
            "url": "https://www.amazon.com/dp/B08N5WRWNW",
        },
        {
            "platform": "walmart",
            "productId": "123456789",
        },
        {
            "platform": "shopify",
            "productId": "sony-headphones",
            "domain": "example",
        },
    ],
    "competitorPrices": [
        {
            "platform": "walmart",
            "price": 329.99,
            "seller": "Walmart",
        },
        {
            "platform": "bestbuy",
            "price": 349.99,
            "seller": "Best Buy",
        },
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("luckborn/price-intelligence").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 '{
  "asins": [
    "B08N5WRWNW",
    "B0B7X9X1Y2",
    "B09G9D7K1S"
  ],
  "urls": [
    "https://www.amazon.com/dp/B08N5WRWNW",
    "https://www.walmart.com/ip/Sony-WH-1000XM5/123456789",
    "https://www.bestbuy.com/site/sony-wh-1000xm5/12345.p",
    "https://example.myshopify.com/products/sony-headphones"
  ],
  "products": [
    {
      "platform": "amazon",
      "productId": "B08N5WRWNW",
      "url": "https://www.amazon.com/dp/B08N5WRWNW"
    },
    {
      "platform": "walmart",
      "productId": "123456789"
    },
    {
      "platform": "shopify",
      "productId": "sony-headphones",
      "domain": "example"
    }
  ],
  "competitorPrices": [
    {
      "platform": "walmart",
      "price": 329.99,
      "seller": "Walmart"
    },
    {
      "platform": "bestbuy",
      "price": 349.99,
      "seller": "Best Buy"
    }
  ]
}' |
apify call luckborn/price-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Price Intelligence — Amazon, Walmart, Best Buy & Shopify",
        "description": "Monitor prices across 4 e-commerce platforms in one unified API. Track price history, detect drops, compare cross-platform competitors. Pay per ASIN check — no subscription needed.",
        "version": "1.0",
        "x-build-id": "dYB2vXecjey3mTKmp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/luckborn~price-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-luckborn-price-intelligence",
                "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/luckborn~price-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-luckborn-price-intelligence",
                "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/luckborn~price-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-luckborn-price-intelligence",
                "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",
                "properties": {
                    "asins": {
                        "title": "Amazon ASINs (Quick Input)",
                        "type": "array",
                        "description": "List of Amazon ASIN codes (10 characters). These will be checked on Amazon.com. For other platforms, use the URLs input or the Products array below."
                    },
                    "urls": {
                        "title": "Product URLs (Any Platform)",
                        "type": "array",
                        "description": "Full product URLs from any supported platform. Platform is auto-detected from the URL structure."
                    },
                    "products": {
                        "title": "Structured Product List (Advanced)",
                        "type": "array",
                        "description": "Advanced mode — specify platform, productId, and optional overrides per product."
                    },
                    "enablePriceHistory": {
                        "title": "Enable Price History Tracking",
                        "type": "boolean",
                        "description": "Store and retrieve historical prices for each product across runs. Enables price drop alerts and trend analysis.",
                        "default": true
                    },
                    "enableAlerts": {
                        "title": "Enable Alerts",
                        "type": "boolean",
                        "description": "Detect price drops, stock changes, and competitor undercutting. Alerts are included in the output.",
                        "default": true
                    },
                    "priceDropThresholdPercent": {
                        "title": "Price Drop Alert Threshold (%)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Minimum percentage drop to trigger a price drop alert. Example: 5 = alert if price drops 5% or more since last check.",
                        "default": 5
                    },
                    "competitorPrices": {
                        "title": "Manual Competitor Prices",
                        "type": "array",
                        "description": "Optional — provide known competitor prices for cross-platform comparison. These will be included in the output and used for competitor alerts."
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrent Scrapes",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of products to scrape simultaneously. Higher = faster but more likely to trigger rate limits.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "enum": [
                            "auto",
                            "datacenter",
                            "residential",
                            "none"
                        ],
                        "type": "string",
                        "description": "auto = use residential for Walmart/large runs, datacenter for Amazon/Shopify. Override for specific needs.",
                        "default": "auto"
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "json",
                            "csv",
                            "both"
                        ],
                        "type": "string",
                        "description": "JSON = structured (best for API). CSV = spreadsheet-friendly.",
                        "default": "json"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
