# Amazon Affiliate Link Health Monitor (`whatelsebyvinc/amazon-affiliate-link-monitor`) Actor

Surveille une liste de produits Amazon (ASIN) et détecte les liens affiliés cassés, ruptures de stock, changements de prix significatifs et mismatches de titre.

- **URL**: https://apify.com/whatelsebyvinc/amazon-affiliate-link-monitor.md
- **Developed by:** [Vincent NAGELEISEN](https://apify.com/whatelsebyvinc) (community)
- **Stats:** 2 total users, 1 monthly users, 0.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/actors/running/actors-in-store.md#pay-per-usage

## 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 Affiliate Link Health Monitor

Stop losing affiliate commissions to dead links you don't know about.

If you run Amazon affiliate content — Pinterest pins, blog posts, YouTube descriptions — every link you've ever published is a silent liability. Products get delisted. They go out of stock for weeks. Prices jump so much the link no longer matches what your content promised. None of that shows up until a reader clicks through and you've already lost the sale — and the commission.

This Actor checks a list of Amazon products on a schedule and tells you exactly which links need your attention, before your audience finds out for you.

### What it checks

For every ASIN you provide, the Actor detects:

| Status | Meaning |
|---|---|
| `OK` | Product is live, in stock, price within your threshold |
| `DELISTED` | The product page no longer exists |
| `OUT_OF_STOCK` | Currently unavailable |
| `PRICE_CHANGED` | Price moved beyond the threshold you set (compared to the last check) |
| `TITLE_MISMATCH` | The product title changed since the last check — often a sign the listing was merged or repurposed for a different product |
| `IMAGE_CHANGED` | The main product image changed since the last check — same red flag as a title mismatch, can trigger independently |
| `ERROR` | Couldn't be checked this run (temporary block) — reported honestly instead of guessing |

Each result can carry multiple signals at once: `status` holds the most critical one, and `flags` lists everything that was detected.

### Why not just use Keepa or CamelCamelCamel?

Those tools are built for shoppers tracking a single product's price history. This Actor is built for **affiliates managing a catalog of links** — it's meant to run on a schedule, feed a spreadsheet or dashboard, and push a Slack/webhook alert the moment something needs a human to look at it. Output is structured JSON designed to plug into your own workflow, not a price-history chart for one product.

### How it works

1. Give it a list of ASINs (and optionally a marketplace, price-change threshold, and alert webhook).
2. It checks each product using a real Chromium browser (via Apify Proxy + Playwright) to reliably get past Amazon's bot detection.
3. It compares each result to the last run, using Apify's built-in storage — no database setup needed.
4. If anything needs attention, it sends a single alert to your webhook (Slack-compatible out of the box).

### Input

| Field | Required | Description |
|---|---|---|
| `asins` | Yes | List of Amazon ASINs to monitor |
| `marketplace` | No | Amazon domain to target (default: `amazon.fr`) |
| `priceChangeThresholdPercent` | No | % price change (up or down) that triggers `PRICE_CHANGED` (default: 15) |
| `proxyConfiguration` | No | Apify Proxy config — residential proxy strongly recommended |
| `alertWebhookUrl` | No | URL that receives a JSON summary if any product needs attention (leave empty to disable) |

### Output

One item per ASIN in the default dataset:

```json
{
  "asin": "B09B8X9RGM",
  "url": "https://www.amazon.fr/dp/B09B8X9RGM",
  "status": "PRICE_CHANGED",
  "flags": ["PRICE_CHANGED"],
  "title": "Echo Dot (Nouvelle génération) ...",
  "price": 19.99,
  "previousPrice": 24.99,
  "priceChangePercent": -20,
  "imageUrl": "https://m.media-amazon.com/images/I/71wQobPqbyL._AC_SY355_.jpg",
  "checkedAt": "2026-09-22T16:25:05.131Z"
}
```

### Alert webhook

If `alertWebhookUrl` is set and at least one product isn't `OK`, a single JSON POST is sent at the end of the run:

```json
{
  "text": "🚨 2 product(s) need attention:\n• [PRICE_CHANGED] B0XXXXXXX — ...\n• [OUT_OF_STOCK] B0YYYYYYY — ...",
  "runUrl": "https://console.apify.com/actors/runs/<runId>",
  "alerts": [ { "asin": "...", "status": "...", "flags": [...], "title": "...", "price": "...", "previousPrice": "...", "priceChangePercent": "...", "url": "...", "checkedAt": "..." } ]
}
```

The `text` field works directly with a **Slack Incoming Webhook**. A custom endpoint, Zapier, or Make can ignore `text` and use the `alerts` array directly. A failed webhook delivery is logged but never fails the run.

### Notes

- Amazon's page structure changes over time; selectors may occasionally need updates.
- A residential proxy is strongly recommended — without one, requests are far more likely to get blocked.
- Price-change and title/image-mismatch detection compare against the previous run only (no long-term price history yet).

# Actor input Schema

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

List of Amazon ASINs (product IDs, e.g. B0ABCD1234) to check.

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

Amazon domain to target.

## `priceChangeThresholdPercent` (type: `integer`):

Price change percentage (up or down) since the previous run that triggers the PRICE\_CHANGED status.

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

Amazon aggressively blocks scraping without a residential proxy.

## `alertWebhookUrl` (type: `string`):

URL (Slack Incoming Webhook, Zapier, Make, or a custom endpoint) that receives a JSON summary of products needing attention (DELISTED, OUT\_OF\_STOCK, PRICE\_CHANGED, TITLE\_MISMATCH, IMAGE\_CHANGED). Leave empty to disable.

## Actor input object example

```json
{
  "asins": [
    "B0ABCD1234"
  ],
  "marketplace": "amazon.com",
  "priceChangeThresholdPercent": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One item per ASIN with its status, flags, price and price change.

# 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": [
        "B0ABCD1234"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("whatelsebyvinc/amazon-affiliate-link-monitor").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": ["B0ABCD1234"] }

# Run the Actor and wait for it to finish
run = client.actor("whatelsebyvinc/amazon-affiliate-link-monitor").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": [
    "B0ABCD1234"
  ]
}' |
apify call whatelsebyvinc/amazon-affiliate-link-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,whatelsebyvinc/amazon-affiliate-link-monitor"
        }
    }
}
```

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/LL4rtM0790tGv1fkE/builds/AqcaA608C8eK8FIKi/openapi.json