# Amazon Price Tracker — CamelCamelCamel Alternative (`khadinakbar/camelcamelcamel-alternative`) Actor

Track known Amazon products against your target prices. Export current prices, target decisions, changes, source links, and buyer-owned history for scheduled price checks and downstream alerts.

- **URL**: https://apify.com/khadinakbar/camelcamelcamel-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 amazon target-price decisions

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 — CamelCamelCamel Alternative

Track known Amazon products against your target prices. Export current prices, target decisions, changes, source links, and buyer-owned history for scheduled price checks and downstream alerts. For price-monitoring operators, dataset records connect each watched product's current price to its target decision and retained history.

### Workflow: put the results to work

Add the exact products and target prices you want to watch. Reuse the same history store when building a time series, then inspect target decisions and observed changes. Connect a separate alert workflow when you want notifications; the saved rows supply the evidence for that decision.

### Target-price monitoring workflow

A purchasing operator starts with an exact Amazon product and a maximum acceptable price. They add the ASIN and target, schedule the Actor, and keep the same `historyStoreName` across executions. Each later execution compares the current price with the target and the operator's previous observation. The resulting dataset can then feed a webhook, spreadsheet, dashboard, purchasing queue, or AI agent.

### Quick start input

```json
{
  "watches": [
    {
      "asinOrUrl": "B07DF46NW9",
      "targetPrice": 12.99,
      "label": "DEWALT painter tool"
    }
  ],
  "marketplace": "US",
  "providerStrategy": "auto",
  "historyStoreName": "camelcamelcamel-alternative-history",
  "outputHistoryPoints": 30,
  "historyRetentionPoints": 365
}
```

Bare ASINs use the selected default marketplace. Full Amazon product URLs infer the marketplace from their domain. Each execution accepts up to 50 unique marketplace-and-ASIN watches.

`providerStrategy: "auto"` is the recommended reliability setting. It calls `jaybird/amazon-product-data-scraper` first and sends only unresolved products to the independent `igview-owner/amazon-product-data-scraper`. Both are public Apify Actors, so this workflow requires no separate upstream API key. Select `primaryOnly` for the lowest expected provider cost or `fallbackOnly` when you intentionally want the independent route.

### Output contract

One dataset row represents one requested product with a validated current price and target decision. Source rows without a usable price stay visible in the terminal records instead of becoming estimated values.

| Field | Meaning |
|---|---|
| `asin`, `marketplace`, `productUrl` | Stable product identity and canonical Amazon source URL |
| `currentPrice`, `currency`, `targetPrice` | Current observed price and buyer-defined threshold |
| `targetReached` | `true` when the current price is at or below the target |
| `previousPrice`, `priceChange`, `priceChangePercent` | Change from the preceding retained observation |
| `lowestObservedPrice`, `highestObservedPrice`, `averageObservedPrice` | Statistics over buyer-owned retained observations |
| `recentHistory`, `historyPoints` | Bounded observation history and retained count |
| `collectedAt`, `sourceProvider`, `providerRunId` | Freshness and upstream provenance |
| `warnings` | Product-level quality notes |

```json
{
  "watchId": "3ac05b13360f64cbaecb",
  "asin": "B07DF46NW9",
  "label": "DEWALT painter tool",
  "marketplace": "amazon.com",
  "productUrl": "https://www.amazon.com/dp/B07DF46NW9",
  "title": "DEWALT 9-in-1 Painter's Tool",
  "currentPrice": 14.39,
  "currency": "USD",
  "targetPrice": 12.99,
  "targetReached": false,
  "amountAboveTarget": 1.4,
  "amountBelowTarget": 0,
  "previousPrice": 15.49,
  "priceChange": -1.1,
  "priceChangePercent": -7.1,
  "lowestObservedPrice": 14.39,
  "highestObservedPrice": 15.49,
  "averageObservedPrice": 14.94,
  "historyPoints": 2,
  "recentHistory": [],
  "availability": "FOUND",
  "sellerName": "Amazon",
  "rating": 4.8,
  "reviewCount": 2388,
  "collectedAt": "YYYY-MM-DDTHH:mm:ss.sssZ",
  "providerRunId": "provider-run-id",
  "sourceProvider": "jaybird/amazon-product-data-scraper",
  "warnings": []
}
```

The default dataset contains the target decisions. The default key-value store exposes `OUTPUT` and `RUN_SUMMARY`. Persistent observations live in the named key-value store from `historyStoreName`, keyed by a stable hash of marketplace and ASIN.

### Terminal outcomes and recovery

| Outcome | Meaning and next action |
|---|---|
| `COMPLETE` | Every requested watch produced a validated result; continue with the dataset. |
| `PARTIAL` | At least one result was stored; use the stored rows and review `missingAsins` or `invalidPriceAsins`. |
| `VALID_EMPTY` | The source completed with no usable requested price; retry later or select the independent provider route. |
| `INVALID_INPUT` | Adjust the fields described in `OUTPUT`; result events remain zero. |
| `UPSTREAM_FAILED` | Retry the source or switch provider strategy after checking the provider status recorded in `RUN_SUMMARY`. |

### Best results

- Provide canonical ASINs or Amazon product URLs and realistic positive target prices.
- Keep one stable `historyStoreName` for each monitoring workflow so observations accumulate across schedules.
- Start with `auto`, then use `fallbackOnly` when validating the independent source during a primary incident.
- Schedule at a frequency appropriate for the purchasing decision and confirm the collection timestamp before acting.
- Verify price, seller, availability, shipping, taxes, and currency on the canonical product URL before purchase.

### Use through the API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~camelcamelcamel-alternative/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"watches":[{"asinOrUrl":"B07DF46NW9","targetPrice":12.99}],"marketplace":"US"}'
```

After completion, read the default dataset plus `OUTPUT` and `RUN_SUMMARY`. Use the outcome, charged-event count, source URL, collection time, and provider provenance as the handoff contract for downstream code.

### Use with AI agents through Apify MCP

Review the Pricing tab for current event rates. Total run cost includes the events actually charged and Apify platform usage; any separately billed provider access is described in the input and data-access guidance.

The prompt stays within the Actor's exact-product scope. Agents should treat the dataset as the product-level result and `OUTPUT` as the execution-level completion record.

### How this workflow compares with CamelCamelCamel

| Decision | This Actor | CamelCamelCamel |
|---|---|---|
| Workflow scope | Exact-product target decisions for software workflows | Broader hosted consumer price-tracking experience |
| Billing model | Pay per validated stored decision plus Apify platform usage | Free consumer service |
| Delivery efficiency | One callable execution produces structured records for downstream software | Interactive consumer tracking produces hosted charts and alerts |
| Input | ASIN or Amazon product URL plus target price | Consumer product-search and tracking workflow |
| Output contract | Structured dataset, `OUTPUT`, and `RUN_SUMMARY` | Hosted charts, alerts, and feeds |
| Integrations | Apify API, schedules, datasets, webhooks, and exports | Browser extensions and RSS |
| Automation | Saved inputs with repeatable schedules and stable buyer-owned history | Consumer alerts and wishlist-based tracking |
| Freshness and provenance | Collection time, canonical URL, provider name, and upstream execution ID per row | Consumer-facing history and alert presentation |
| Historical depth | Observations retained from your own runs | Existing hosted historical price charts |

CamelCamelCamel is a trademark of its owner. This independent Actor is not affiliated with, associated with, or endorsed by CamelCamelCamel.

### Builder's note

I built this around the point where price monitoring becomes operational: a current price alone is less useful than a stable target decision, a previous-observation delta, source provenance, and a terminal record that downstream automation can trust. My goal was to keep the input small while making every stored row explain where and when the price was observed.

### Responsible use

Use public or otherwise authorized product data, follow applicable laws and site terms, apply a respectful schedule, and independently confirm commercial details before purchasing.

### Pricing and run costs

This Actor uses **Pay per event plus Apify platform usage**. The [Pricing tab](https://apify.com/khadinakbar/camelcamelcamel-alternative/pricing) lists the current event rates and billing terms.

| Event | Billing unit | When it applies |
|---|---|---|
| `apify-actor-start` | Actor Start | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). |
| `watch-evaluated` | Amazon target-price decision | One validated current-price decision persisted with buyer-owned observation history. |

Run cost combines the charged events and Apify platform usage. Review the run charge limit and requested result count before starting.

### Connect an AI agent

Use the [Apify MCP configurator](https://mcp.apify.com) to choose an available client connection. Inspect this Actor’s current input schema and required credentials before running it.

#### Example agent request

> Track known Amazon products against your target prices. Use the inputs I supply, confirm the result limit, and return the available results with their source context and any partial or missing-data outcome.

# Actor input Schema

## `watches` (type: `array`):

Add 1–50 exact Amazon products. Each item needs an ASIN or Amazon product URL and a positive target price. A usable stored result costs $0.03 plus platform usage; missing products and invalid source prices are not charged as results.

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

Marketplace used for bare ASINs. Full Amazon URLs infer their marketplace from the domain.

## `providerStrategy` (type: `string`):

Use auto for the highest completion rate: the low-cost primary runs first and an independent fallback is called only for unresolved products. Primary only minimizes upstream cost; fallback only is useful for incident recovery and route testing.

## `historyStoreName` (type: `string`):

Named key-value store used for buyer-owned observations across runs. Keep this stable on schedules that should share history.

## `outputHistoryPoints` (type: `integer`):

Recent observations copied into each output row. Use 0 for compact results; retained history is still stored.

## `historyRetentionPoints` (type: `integer`):

Maximum buyer-owned observations retained for each marketplace and ASIN in the named store.

## Actor input object example

```json
{
  "watches": [
    {
      "asinOrUrl": "B07DF46NW9",
      "targetPrice": 12.99,
      "label": "DEWALT painter tool"
    }
  ],
  "marketplace": "US",
  "providerStrategy": "auto",
  "historyStoreName": "camelcamelcamel-alternative-history",
  "outputHistoryPoints": 30,
  "historyRetentionPoints": 365
}
```

# Actor output Schema

## `targetDecisions` (type: `string`):

One validated target-price decision per usable Amazon product.

## `runOutput` (type: `string`):

Terminal outcome, counts, provider provenance, and charges.

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

Detailed machine-readable run summary for automation and diagnostics.

# 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 = {
    "watches": [
        {
            "asinOrUrl": "B07DF46NW9",
            "targetPrice": 12.99,
            "label": "DEWALT painter tool"
        }
    ],
    "marketplace": "US",
    "providerStrategy": "auto",
    "historyStoreName": "camelcamelcamel-alternative-history",
    "outputHistoryPoints": 30,
    "historyRetentionPoints": 365
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/camelcamelcamel-alternative").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 = {
    "watches": [{
            "asinOrUrl": "B07DF46NW9",
            "targetPrice": 12.99,
            "label": "DEWALT painter tool",
        }],
    "marketplace": "US",
    "providerStrategy": "auto",
    "historyStoreName": "camelcamelcamel-alternative-history",
    "outputHistoryPoints": 30,
    "historyRetentionPoints": 365,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/camelcamelcamel-alternative").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 '{
  "watches": [
    {
      "asinOrUrl": "B07DF46NW9",
      "targetPrice": 12.99,
      "label": "DEWALT painter tool"
    }
  ],
  "marketplace": "US",
  "providerStrategy": "auto",
  "historyStoreName": "camelcamelcamel-alternative-history",
  "outputHistoryPoints": 30,
  "historyRetentionPoints": 365
}' |
apify call khadinakbar/camelcamelcamel-alternative --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/camelcamelcamel-alternative"
        }
    }
}
```

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/59pEgCNYErqWZPcWT/builds/bg1APYkBywZjRtgVv/openapi.json