# Amazon Price Tracker (`arched_friend/amazon-price-tracker`) Actor

Track Amazon prices and stock for any list of ASINs or product URLs. Returns the current price, list price, discount, stock status and rating for each product, and flags every price drop, price rise and stock change since your last run.

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

## Pricing

$10.00 / 1,000 product checkeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Price Tracker: Monitor ASIN Prices and Stock Daily

Give it a list of ASINs and get back the current price, list price, discount, stock status and rating for every one. Run it again tomorrow and it tells you exactly what moved: which prices dropped, which rose, what went out of stock and what came back.

Built for sellers, resellers and brand owners who need to hear about a competitor's price change on the day it happens, not at the end of the month.

### How it works

```mermaid
flowchart LR
    A["ASINs or product URLs"] --> B["Render each product page<br/>(residential proxy)"]
    B --> C["Price, list price,<br/>stock, rating"]
    C --> D{"Compare with<br/>last run"}
    D -->|cheaper| E["price drop"]
    D -->|dearer| F["price rise"]
    D -->|now available| G["back in stock"]
    D -->|now unavailable| H["went out of stock"]
    E --> I[("Alert rows")]
    F --> I
    G --> I
    H --> I
```

Amazon serves block pages under HTTP 200, so a status code proves nothing. This Actor treats a page as read only when it actually rendered product content, retries anything else on a fresh proxy session, and reports a dead ASIN as `not-found` rather than pretending it was blocked.

### Built for

- **Amazon sellers** watching competitor pricing on the ASINs they compete with
- **Brand owners** policing MAP breaches and unauthorised discounting
- **Resellers and arbitrage buyers** catching markdowns and restocks early
- **Retail analysts** tracking discount depth across a category or a season

### Input

```json
{
  "asins": [
    "B0FGJF172R",
    "https://www.amazon.com/dp/B0FGJCYQKK"
  ],
  "marketplace": "US",
  "onlyChanged": true,
  "minDiscount": 15
}
```

| Setting | What it does |
| --- | --- |
| `asins` | Bare ASINs or full Amazon product URLs, mixed freely |
| `marketplace` | Which Amazon site to price against: `US`, `UK`, `DE`, `JP` and 11 more |
| `onlyChanged` | Return only drops, rises and stock flips. Turn on for scheduled runs |
| `onlyInStock` / `onlyDiscounted` | Focus on what is buyable or genuinely marked down |
| `minPrice` / `maxPrice` | Stay inside a price band |
| `minDiscount` | Only real markdowns, by percent off list price |

### Output

```json
{
  "asin": "B0FGJF172R",
  "marketplace": "www.amazon.com",
  "title": "Zojirushi SM-VH72-AZ GoCafe Insulated Stainless Steel Mug",
  "brand": "Zojirushi",
  "price": 28.99,
  "currency": "$",
  "listPrice": 39.99,
  "discountPercent": 27.5,
  "inStock": true,
  "availabilityText": "In Stock",
  "lowStock": false,
  "rating": 4.6,
  "reviewCount": 1243,
  "previousPrice": 34.99,
  "priceChange": -6.0,
  "changePercent": -17.1,
  "changeType": "price-drop",
  "url": "https://www.amazon.com/dp/B0FGJF172R",
  "checkedAt": "2026-09-15T18:04:11.402Z"
}
```

`changeType` is the field to filter on. It is one of `price-drop`, `price-rise`, `back-in-stock`, `went-out-of-stock`, `new`, `unchanged` or `first-run`.

### Turn it into a daily alert

Set `onlyChanged` to true and schedule it every morning. The first run records the baseline and returns everything. Every run after that returns only what actually moved, which is usually a handful of rows.

```json
{
  "asins": ["B0FGJF172R", "B0FGJCYQKK", "B0FGJFWHH4"],
  "onlyChanged": true
}
```

### Prices outside the US

Set `marketplace` and the prices come back in that country's currency, parsed correctly. European sites write prices as `1.234,56 €` rather than `$1,234.56`, which is a classic source of silently null prices in scrapers that assume a dollar sign.

```json
{
  "asins": ["B0FGJF172R"],
  "marketplace": "DE"
}
```

### Run it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~amazon-price-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "asins": ["B0FGJF172R", "B0FGJCYQKK"],
    "marketplace": "US",
    "onlyChanged": true
  }'
```

### Pricing

You pay $0.01 for each product actually read. Retries are free, and a run that finds nothing changed costs the same as one that finds ten drops.

| Watching 50 ASINs daily | Monthly cost |
| --- | --- |
| Checking by hand | roughly 25 hours |
| Most repricing and monitoring suites | $99 to $500 per month |
| This Actor | $15 per month |

### Common questions

**Why does it need a residential proxy?** Amazon blocks datacentre IPs outright. Residential is not a speed optimisation here, it is the only configuration that returns a product page at all. It is the default and you should leave it alone.

**What happens to an ASIN that no longer exists?** It is reported in the run summary as `not-found` rather than silently dropped or mislabelled as a block.

**Where is the price history kept?** Each run stores the price and stock it saw and compares the next run against them, so history builds from your first run onward. Nothing to set up.

**Can it track sold prices or historical charts?** No. It reads what Amazon shows right now, and builds history forward from the day you start.

### Related products

- **Amazon Stock & Buy Box Alert** to watch who is winning the buy box on the same ASINs
- **Amazon Deals & Coupon Monitor** to catch clippable coupons and lightning deals
- **eBay Price Tracker** to price the same product against live eBay listings
- **Shopify Price Tracker** to watch the same brands on their own storefronts
- **Multi-Store Stock Alert** to chain Amazon, eBay and Shopify into one alert feed

# Actor input Schema

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

The products to track, one per line. A bare ASIN such as B0FGJF172R works, and so does any full Amazon product URL.

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

Which Amazon site to read the prices from. Use a country code such as US, UK or DE, or a full domain such as amazon.co.uk.

## `onlyChanged` (type: `boolean`):

Return only price drops, price rises, stock flips and newly added products. Turn this on for scheduled monitoring so each run is a short alert list rather than your whole catalogue.

## `onlyInStock` (type: `boolean`):

Keep only products Amazon currently shows as available.

## `onlyDiscounted` (type: `boolean`):

Keep only products priced below their list price.

## `minPrice` (type: `integer`):

Keep only products at or above this price. 0 means no minimum.

## `maxPrice` (type: `integer`):

Keep only products at or below this price. 0 means no maximum.

## `minDiscount` (type: `integer`):

Keep only products discounted by at least this much off the list price.

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

How many product pages to load at once. Lower this if you see blocks on a large list.

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

Amazon blocks datacentre IPs, so this defaults to Apify residential proxy. Changing it away from residential will cause blocks.

## Actor input object example

```json
{
  "asins": [
    "B0FGJF172R",
    "B0FGJCYQKK"
  ],
  "marketplace": "US",
  "onlyChanged": false,
  "onlyInStock": false,
  "onlyDiscounted": false,
  "minPrice": 0,
  "maxPrice": 0,
  "minDiscount": 0,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `products` (type: `string`):

One row per ASIN, with its current price, list price, discount, stock status, rating and what changed since the last run.

## `runSummary` (type: `string`):

Counts of products checked, price drops, price rises and stock flips, plus any ASINs that could not be read.

# 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": [
        "B0FGJF172R",
        "B0FGJCYQKK"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/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": [
        "B0FGJF172R",
        "B0FGJCYQKK",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("arched_friend/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": [
    "B0FGJF172R",
    "B0FGJCYQKK"
  ]
}' |
apify call arched_friend/amazon-price-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arched_friend/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/olC27piSvwesKybvc/builds/FlSBwa1SHggcXLUd4/openapi.json