# Price Tracker – Amazon, Walmart, Best Buy & Shopify (`arisma_tech/multi-retailer-price-tracker-apify-actor`) Actor

Track prices, stock and sellers on Amazon, Walmart, Best Buy and any Shopify store. Scheduled price monitoring with price history, price-drop, MAP-violation, stock and Buy Box seller alerts, plus webhooks. Handles anti-bot protection. Pay only for successful results.

- **URL**: https://apify.com/arisma_tech/multi-retailer-price-tracker-apify-actor.md
- **Developed by:** [Arishma](https://apify.com/arisma_tech) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 tracked products

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

## Price Tracker — Amazon, Walmart, Best Buy & Shopify

Track product **prices, stock and sellers** across **Amazon, Walmart, Best Buy and any Shopify store** in one run, for **$3 per 1,000 tracked products** plus Apify platform usage (about $10 per 1,000 all-in). Schedule it, and every run tells you what changed since the last one: **price drops, MAP violations, stock-outs, restocks and Buy Box seller changes**, delivered to your webhook (Slack, Zapier, Make or your own backend).

Built for **brands enforcing MAP**, **e-commerce agencies** reporting to clients, and **resellers and analysts** who need clean price data without paying for a SaaS seat.

![Price Tracker output: Amazon, Walmart, Best Buy and Shopify prices with change % and alerts in one dataset](https://raw.githubusercontent.com/usama913/price-tracker-guide/main/1-dataset.png)

### Why use it

- **One actor, four retailers.** Paste product URLs; the retailer is detected automatically. No separate scraper per site.
- **$3 per 1,000 products, only for successes.** Failed products are reported in the dataset and never charged.
- **Price history built in.** Each scheduled run compares against the previous one: previous price, change %, lowest and highest price seen.
- **MAP enforcement.** Add a MAP price per product and get a `MAP_VIOLATION` alert with the exact amount below MAP.
- **Alerts that matter:** `PRICE_DROP`, `MAP_VIOLATION`, `OUT_OF_STOCK`, `BACK_IN_STOCK`, `SELLER_CHANGED` (for example, the Amazon Buy Box seller switched).
- **Webhooks.** All alerts from a run are POSTed as one JSON payload, so you only hear about what moved.
- **Pay only for change, if you want.** Turn on *Only output changed products* and unchanged products are neither output nor charged.

![MAP violation, price drop and out-of-stock alerts delivered to your webhook](https://raw.githubusercontent.com/usama913/price-tracker-guide/main/2-alert.png)

### What it costs

| Watchlist | Checks per month | Tracking fee ($3/1k) | All-in, incl. platform usage (~$10.34/1k) |
|---|---|---|---|
| 100 SKUs, once a day | ~3,000 | ~$9 | **~$31** |
| 500 SKUs, once a day | ~15,000 | ~$45 | **~$155** |
| 500 SKUs, 4 times a day | ~60,000 | ~$180 | **~$620** |

You pay two things: the $3 / 1,000 tracking fee, and Apify platform usage (compute and residential proxy traffic) for your runs. Platform usage currently averages about **$7.34 per 1,000 products** (Apify's figure for this actor), is cheaper on higher Apify plans, and is lower for Shopify-heavy watchlists. *Only output changed products* lowers the tracking fee but not platform usage. The free Apify plan's monthly credit is enough to try it on a real watchlist.

![Pricing: $3 per 1,000 tracked products, about $31/month for 100 SKUs daily, failed products never charged](https://raw.githubusercontent.com/usama913/price-tracker-guide/main/3-pricing.png)

### Use cases

- **MAP monitoring for brands.** Put every authorized and unauthorized listing of your SKUs in one watchlist, set `mapPrice`, and get a daily list of violations with the seller name.
- **Agency client reporting.** One Monitor ID per client; export the dataset to Google Sheets, Looker Studio or your BI tool on a schedule.
- **Competitor price watch.** Track competing products across Amazon, Walmart, Best Buy and competitors' Shopify stores; get a `PRICE_DROP` alert when they discount.
- **Stock and Buy Box watch.** Know when a product goes out of stock or the Buy Box moves to another seller.
- **Deal and arbitrage alerts.** Low `priceDropThresholdPercent` plus a webhook to Slack or Discord.

### How to use it

1. Add product URLs (or the advanced `products` list with `mapPrice`, `sku`, `label`).
2. Set a **Monitor ID** for this watchlist (for example `brand-x-retailers`).
3. Create a **Schedule** in Apify Console (for example every 6 hours) with this input. Each run alerts on what changed since the last one.

#### Input example

```json
{
  "monitorId": "acme-map-watch",
  "products": [
    { "url": "https://www.amazon.com/dp/B09B8V1LZ3", "mapPrice": 49.99, "sku": "ACME-001" },
    { "url": "https://www.walmart.com/ip/123456789", "mapPrice": 49.99, "sku": "ACME-001" },
    { "url": "https://www.bestbuy.com/site/product/6525446.p?skuId=6525446", "sku": "ACME-002" },
    { "url": "https://store.example.com/products/acme-widget?variant=42", "sku": "ACME-003" }
  ],
  "priceDropThresholdPercent": 5,
  "webhookUrl": "https://hooks.example.com/price-alerts"
}
```

#### Output example

```json
{
  "status": "ok",
  "retailer": "amazon",
  "productId": "B09B8V1LZ3",
  "sku": "ACME-001",
  "title": "Acme Widget",
  "price": 44.99,
  "currency": "USD",
  "listPrice": 59.99,
  "previousPrice": 49.99,
  "priceChangePct": -10.0,
  "lowestPriceSeen": 44.99,
  "inStock": true,
  "seller": "CheapDeals LLC",
  "mapPrice": 49.99,
  "mapViolation": true,
  "alertTypes": ["MAP_VIOLATION", "PRICE_DROP", "SELLER_CHANGED"],
  "scrapedAt": "2026-10-08T12:00:00+00:00"
}
```

The run's `OUTPUT` record in the key-value store contains a summary (success rate and all alerts). The webhook receives the same summary.

### Supported URLs

| Retailer | URL format |
|---|---|
| Amazon (.com, .ca, .co.uk, .de, .fr, .it, .es, .co.jp, .in, .com.au, .com.mx) | any URL containing `/dp/<ASIN>` or `/gp/product/<ASIN>` |
| Walmart | `walmart.com/ip/.../<itemId>` |
| Best Buy | `bestbuy.com/site/...<sku>.p?skuId=<sku>` |
| Shopify (any store) | any URL containing `/products/<handle>`; add `?variant=<id>` to track one variant |

### Reliability

The actor handles retailer anti-bot protection and retries difficult products automatically, so there is nothing to configure. Shopify products are read from the store's product data, so they are fast and unaffected by theme changes. Use US residential proxies for Amazon, Walmart and Best Buy (the default).

### Pricing

Pay-per-event. You only pay for products that were tracked successfully:

| Event | Price | When |
|---|---|---|
| Tracked product (`price-result`) | **$3.00 / 1,000** | Each product successfully scraped and output |
| Protected page add-on (`browser-render`) | $5.00 / 1,000 | Only for products on heavily protected pages that needed extra processing |
| Webhook alert delivery (`webhook-delivery`) | $0.01 / run | Only when alerts were found and successfully POSTed to your webhook |

Failed products are never charged. Most products, including all Shopify products, never need the add-on, and you can turn off *Handle protected pages* to never pay it. Platform usage (compute and proxy traffic) is billed at standard Apify rates. Set a maximum charge per run in Apify Console and the actor stops cleanly when it is reached.

### Integrations

- **Webhook:** set `webhookUrl` to a Slack incoming webhook, Zapier/Make catch hook or your own endpoint.
- **API:** start runs and read results with the Apify API or the Python/JavaScript clients.
- **Exports:** download the dataset as JSON, CSV or Excel, or send it to Google Sheets with Apify integrations.

### Guide: MAP monitoring with Slack alerts in 15 minutes

1. **Build the watchlist.** Use the `products` list so every result maps back to your SKU and MAP price. Use one `monitorId` per brand or client.
2. **Run it once.** The first run records baseline prices and raises only `MAP_VIOLATION` alerts. Check the *Prices* view: `ok` rows have price, stock and seller; `failed` rows have an `error` and cost nothing.
3. **Schedule it.** Console → Schedules → Create → this actor with your saved input → cron `0 */6 * * *` (every 6 hours). From the second run on you also get `PRICE_DROP`, `OUT_OF_STOCK`, `BACK_IN_STOCK` and `SELLER_CHANGED`.
4. **Send alerts to Slack.** Slack incoming webhooks expect a `text` field, so put Zapier or Make in the middle (Catch Hook → Formatter → Slack), or point `webhookUrl` at your own endpoint. Each alert carries `type`, `retailer`, `sku`, `title`, `url`, `seller`, and for MAP alerts `price`, `mapPrice` and `belowMapBy`.
5. **Get the data out.** Actor → Integrations → Google Sheets, or the Apify API:

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("arisma_tech/multi-retailer-price-tracker-apify-actor").call(run_input={
    "monitorId": "acme-map-watch",
    "urls": ["https://www.amazon.com/dp/B09B8V1LZ3"],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["status"] == "ok" and item.get("mapViolation"):
        print(item["retailer"], item["seller"], item["price"], "MAP", item["mapPrice"])
```

6. **Keep costs predictable.** Set *Max total charge* per run in the run options, use *Only output changed products* for stable catalogs, and turn off *Handle protected pages* if you never want the add-on.

| Symptom | Fix |
|---|---|
| Many `failed` rows on Amazon, Walmart or Best Buy | Keep the default US residential proxy and *Handle protected pages* on. |
| No `PRICE_DROP` alerts | Alerts need history: scheduled runs must use the same `monitorId`. |
| Shopify price in the wrong currency | Set *Shopify currency*; Shopify's product data doesn't include it. |
| Wrong Shopify variant | Add `?variant=<id>` to the URL. |

### Changelog

**October 16, 2026**

- Tracked product price lowered to **$3 per 1,000** (was $5). Platform usage is billed as before; failed products are still free.
- Webhook and `OUTPUT` alerts now include the **seller name**, so a `MAP_VIOLATION` shows who broke MAP.
- Fixed the Protected page add-on charge, and rewrote this page with cost examples, use cases and the setup guide above.

Next up, tell us what matters most in the Issues tab: keyword discovery, more retailers (Target, Home Depot, eBay), formatted Slack messages without Zapier.

### FAQ

**Is this legal?** The actor collects publicly available product data (prices, availability) and no personal data. Check the terms of the sites you monitor and your local laws.

**Why did a product fail?** It appears in the dataset with `status: "failed"` and an `error`. You are not charged for it. Common causes: the product was delisted, or the retailer temporarily blocked access. Blocked products are retried automatically on the next scheduled run.

**Can I track thousands of SKUs?** Yes. Large watchlists are supported; 4 GB of memory is recommended.

**Can I find products by keyword?** Not yet. The actor tracks product URLs you provide. Tell us in the Issues tab if keyword discovery would help you.

**Something broke or a retailer changed its page?** Open an issue in the Issues tab with the product URL. Fixes for supported retailers are a priority.

# Actor input Schema

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

Product page URLs from Amazon, Walmart, Best Buy or any Shopify store (URLs containing /products/). Retailer is auto-detected.

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

Optional. Objects like {"url": "...", "mapPrice": 49.99, "sku": "YOUR-SKU", "label": "Retailer A"}. Use this for MAP-violation alerts and to map results back to your own SKUs.

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

Name of this watchlist. Price history is stored per monitor, so scheduled runs with the same ID compare against the previous run.

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

Raise a PRICE_DROP alert when the price falls by at least this percentage since the last run.

## `alertOnStockChange` (type: `boolean`):

Raise OUT_OF_STOCK / BACK_IN_STOCK alerts.

## `alertOnSellerChange` (type: `boolean`):

Raise SELLER_CHANGED alerts (e.g. the Amazon Buy Box seller switched).

## `onlyEmitChanges` (type: `boolean`):

Skip products whose price, stock and seller did not change since the last run. You are only charged for results that are output.

## `webhookUrl` (type: `string`):

Optional. All alerts from the run are POSTed here as JSON when the run finishes.

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

Stop after this many results. Leave empty for no limit.

## `allowProtectedPages` (type: `boolean`):

Some retailer pages are heavily protected and need extra processing to track. These are charged as the Protected page add-on. Turn off to skip them: they are reported as failed and not charged.

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

Maximum number of products checked in parallel.

## `defaultCurrency` (type: `string`):

Shopify's product endpoint doesn't expose currency; this value is used for Shopify results.

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

US residential proxies are strongly recommended for Amazon, Walmart and Best Buy.

## Actor input object example

```json
{
  "urls": [
    "https://www.amazon.com/dp/B09B8V1LZ3"
  ],
  "products": [],
  "monitorId": "default",
  "priceDropThresholdPercent": 5,
  "alertOnStockChange": true,
  "alertOnSellerChange": true,
  "onlyEmitChanges": false,
  "allowProtectedPages": true,
  "maxConcurrency": 10,
  "defaultCurrency": "USD",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `prices` (type: `string`):

No description

## `summary` (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 = {
    "urls": [
        "https://www.amazon.com/dp/B09B8V1LZ3"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("arisma_tech/multi-retailer-price-tracker-apify-actor").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 = {
    "urls": ["https://www.amazon.com/dp/B09B8V1LZ3"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("arisma_tech/multi-retailer-price-tracker-apify-actor").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 '{
  "urls": [
    "https://www.amazon.com/dp/B09B8V1LZ3"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call arisma_tech/multi-retailer-price-tracker-apify-actor --silent --output-dataset

```

## MCP server setup

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

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/SRzgDxiuvfVnl7pVM/builds/iCMezy1wz0tbTF59A/openapi.json