# Amazon Price Tracker - Price Drop & Back-in-Stock Alerts (`deanko/amazon-price-tracker`) Actor

Amazon price tracker for any ASIN: price history, lowest-ever flag, price drop and back-in-stock alerts to Slack, Discord or webhook. 11 marketplaces.

- **URL**: https://apify.com/deanko/amazon-price-tracker.md
- **Developed by:** [dean ko](https://apify.com/deanko) (community)
- **Categories:** E-commerce, Automation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 price checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## Amazon Price Tracker: price drop and back-in-stock alerts

**Amazon Price Tracker** watches the price and stock of any Amazon products by **ASIN** and tells you what changed since the last check. Run it on an Apify **Schedule** (for example every 6 hours or daily). It remembers each product's **price history** between runs and can send **price drop alerts** and **back-in-stock alerts** to **Slack, Discord or any webhook**.

No database, no spreadsheet formulas and no Amazon API key. Add ASINs, schedule it, and get alerts.

### What it does

Each run checks every ASIN on your list and compares it with the previous run:

- **Price drop** and **price increase** with the change in money and in %
- **Back in stock** and **out of stock** events
- **Lowest and highest price seen**, plus an `isLowestEver` flag
- One alert message per run to Slack, Discord or your endpoint, for drops above your threshold and for restocks
- Works on **11 marketplaces**: amazon.com, .ca, .co.uk, .de, .fr, .it, .es, .co.jp, .com.au, .in, .com.mx

### Who it's for

- **Amazon sellers and brands**: watch competitor prices and stock-outs on the products you compete with.
- **Deal hunters and resellers**: get notified when a product hits a new low or comes back in stock.
- **Repricing and analytics teams**: build a price history dataset without running your own scraper.
- **Agencies**: one watchlist per client using `trackerName`.

### Why this Actor

- **Change detection built in.** Most Amazon scrapers give you today's price only, and you have to diff it yourself. This tracker stores state in your Apify account and returns the event (`price_drop`, `back_in_stock`, ...) with previous price, change and lowest/highest price.
- **Alerts out of the box.** Paste a Slack or Discord webhook URL; no Zapier or Make needed. Other endpoints get the full JSON.
- **Real local prices.** The proxy country is pinned to the marketplace and the local currency is requested, so you see what a local shopper sees instead of a "doesn't ship to your country" page.
- **Fewer false alerts.** Captcha and empty pages are retried with a new session instead of being recorded as "out of stock". You set the minimum drop % that triggers an alert.
- **Flat, predictable price.** $0.009 per product checked. No monthly rental.

### How to use

1. Add ASINs (e.g. `B0764MS2Q2`) or full Amazon product URLs.
2. Pick the **Marketplace** the products belong to.
3. Optional: paste a Slack or Discord **webhook URL** and set the **drop threshold** (default 5%).
4. Click **Start**. The first run records starting prices (`event: "first_seen"`).
5. Open **Schedules** in Apify Console and run it every few hours or daily. Each later run reports changes and sends alerts.

Example input:

```json
{
  "asins": ["B0764MS2Q2", "https://www.amazon.com/dp/B000GTFOBA"],
  "marketplace": "com",
  "dropThresholdPercent": 5,
  "webhookUrl": "https://hooks.slack.com/services/XXX/YYY/ZZZ",
  "onlyChanges": false,
  "trackerName": "my-watchlist",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

Tip: turn on **Output only changes** to keep the dataset small. Unchanged products are then skipped in the dataset (they are still checked).

### Output sample

```json
{
  "asin": "B0764MS2Q2",
  "title": "Nutricost Vitamin D3 5,000 IU (125mcg), 240 Softgels, GMO-Free",
  "url": "https://www.amazon.com/dp/B0764MS2Q2",
  "price": 10.95,
  "currency": "$",
  "inStock": true,
  "availability": "In Stock",
  "event": "price_drop",
  "previousPrice": 12.95,
  "change": -2,
  "changePercent": -15.44,
  "lowestPrice": 10.95,
  "highestPrice": 12.95,
  "isLowestEver": true,
  "alert": true,
  "marketplace": "com",
  "checkedAt": "2026-10-17T08:00:00.000Z"
}
```

| Field | Description |
|---|---|
| `event` | `first_seen`, `price_drop`, `price_increase`, `back_in_stock`, `out_of_stock` or `no_change` |
| `alert` | `true` if this row triggered an alert (drop at or above the threshold, or back in stock) |
| `price`, `currency` | Current price and currency symbol |
| `previousPrice`, `change`, `changePercent` | Price at the last check and the difference |
| `lowestPrice`, `highestPrice`, `isLowestEver` | Price range seen by this tracker, and whether today is the lowest |
| `inStock`, `availability` | Stock flag and Amazon's stock text |
| `asin`, `title`, `url`, `marketplace`, `checkedAt` | Product and check details |

**Webhook message.** One POST per run when there are alerts. The JSON body has `text` (Slack), `content` (Discord) and the full `alerts` array. Slack/Discord message example:

```
Amazon price alerts (1)
🔻 -15.44%: Nutricost Vitamin D3 5,000 IU ... — $12.95 → $10.95 (lowest ever) https://www.amazon.com/dp/B0764MS2Q2
```

### Pricing

Pay-per-event. You pay only for products checked:

| Event | Price |
|---|---|
| Price check (one product checked: price, stock and history update) | $0.009 |
| Actor start | $0.00005 per GB of memory, once per run |

**Worked example.** You watch 10 ASINs once a day for 30 days: 10 x 30 = 300 checks x $0.009 = **$2.70 per month**. Checking 10 ASINs every 6 hours costs 4 times that, $10.80 per month.

The run stops by itself when it reaches the maximum charge you set for the run.

### API and integrations

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("deanko/amazon-price-tracker").call(run_input={
    "asins": ["B0764MS2Q2"],
    "marketplace": "com",
    "dropThresholdPercent": 5,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["asin"], row["event"], row["price"], row["previousPrice"])
```

**JavaScript / Node.js** (`npm install apify-client`):

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('deanko/amazon-price-tracker').call({
    asins: ['B0764MS2Q2', 'B000GTFOBA'],
    marketplace: 'com',
    onlyChanges: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((r) => r.alert));
```

You can also send results to Google Sheets, Make, Zapier, n8n or email from the **Integrations** tab.

### FAQ

**Is it legal to track Amazon prices?**
The Actor reads only publicly visible product pages (price, title, stock). It doesn't log in and collects no personal data. You are responsible for using the data lawfully and in line with the terms that apply to you.

**Where is the price history stored?**
In a key-value store named `amazon-price-tracker` in your own Apify account, one record per tracker name and marketplace. Nothing is shared with other users.

**Why does the first run show no alerts?**
The first run only records starting prices (`first_seen`). Alerts start from the second run.

**Can I track products from several countries?**
Yes. Run one task per marketplace. History is kept separately for each marketplace.

**How do I get alerts by email?**
Use an Apify integration or a Make/Zapier webhook that forwards the `alerts` array to email.

**Do I need a Keepa or Amazon API subscription?**
No. Prices come directly from the public product page at the time of each check. Earlier history starts when you start tracking.

### Limitations

- History starts from your first run; past prices before that are not available.
- The price is the main (buy box) price shown on the product page. Other sellers' offers and coupons are not collected.
- A product with no price shown is treated as out of stock.
- Prices can vary slightly by delivery location within a country.

### Support and feedback

Found a bug or need another field? Open an issue in the **Issues** tab. Include a run link if you can. Feature requests are welcome.

Related Actors: **Amazon Product Scraper** (search, ASIN details, reviews), **Amazon Keyword Rank Tracker**, **Amazon Best Sellers Tracker**.

# Actor input Schema

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

Products to monitor: ASINs (e.g. `B0764MS2Q2`) or full Amazon product URLs. Each product checked per run is one billable price check. Duplicates are removed.

## `marketplace` (type: `string`):

Amazon store the ASINs belong to. The proxy country is matched to it automatically, so you see the local price and stock.

## `dropThresholdPercent` (type: `integer`):

Only price drops at least this large (in %) trigger an alert. Back-in-stock always alerts. 0 = alert on any drop. Every check is written to the dataset regardless.

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

Optional. Paste a Slack incoming-webhook URL, a Discord webhook URL or any HTTPS endpoint. One message per run lists all alerts. The JSON body has `text` (Slack), `content` (Discord) and the full `alerts` array.

## `onlyChanges` (type: `boolean`):

If on, products whose price and stock did not change are not written to the dataset. Every product checked is still one price check.

## `trackerName` (type: `string`):

Price history is stored per tracker name in your Apify account and survives between runs. Use different names for separate watchlists or clients.

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

Residential proxy recommended; Amazon blocks datacenter IPs quickly. Country is matched to the marketplace automatically.

## Actor input object example

```json
{
  "asins": [
    "B0764MS2Q2",
    "B000GTFOBA"
  ],
  "marketplace": "com",
  "dropThresholdPercent": 5,
  "onlyChanges": false,
  "trackerName": "default",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "asins": [
        "B0764MS2Q2",
        "B000GTFOBA"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deanko/amazon-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 = {
    "asins": [
        "B0764MS2Q2",
        "B000GTFOBA",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("deanko/amazon-price-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "asins": [
    "B0764MS2Q2",
    "B000GTFOBA"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call deanko/amazon-price-tracker --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/1ctowQf3Hlj3kna2Z/builds/jPHfehXvGZ2BGfCyn/openapi.json