How to Build an Amazon Price Tracker with Python (2026)

Build an amazon price tracker python script with Telegram alerts and price charts. Uses an API instead of scraping — 150 lines, full working code.

Amazon prices change dozens of times a day and you’re not watching. An Amazon price tracker Python script fixes that: 150 lines of code, a free API, and your phone buzzes the moment a deal hits.

An Amazon price tracker in Python is a script that monitors product prices via API, stores history, and alerts you when prices drop below your target — and the FlyByAPIs Amazon Product Data API makes it possible without scraping. That’s the gap Keepa and other tracking softwares leave open — you can see that a product hits $189 every few months, but knowing that doesn’t help unless you’re refreshing the page every day. You need something that watches for you and tells you the second the number you care about shows up.

~150 lines

of Python — that's the whole tracker

So here’s what we’re building: an amazon price tracker in Python that checks prices every few hours, stores the history in a CSV, plots a chart, and sends you a Telegram message the moment a price hits your target. The whole thing is about 150 lines of code. It runs on your laptop, a Raspberry Pi, or any cheap VPS.

And it uses the Amazon Product Data API instead of web scraping, so it won’t break when Amazon changes their HTML for the 47th time this year.

Build a working Amazon price tracker in Python in about 150 lines of code using the FlyByAPIs Amazon Product Data API — no scraping, no proxies, no maintenance. The free tier (2,000 requests/month) covers 10 products checked every 6 hours at $0/month.

Full code is on the FlyByAPIs GitHub repo . Grab it and run it.

~150

Lines of Python

2,000

Free requests/month

21

Amazon marketplaces

$0/mo

For 10 products @ 6h checks

What your Amazon price tracker does

By the end of this tutorial, your price tracker will:

  • Check prices for as many ASINs as you want, on any of 21 Amazon marketplaces
  • Store every price check in a CSV file (your own price history database)
  • Compare the current price against your target and the historical low
  • Send you a Telegram message the instant a price drops below your threshold
  • Skip repeat alerts — once warned about a product, it stays silent for 30 days
  • Generate a matplotlib chart showing price trends for all tracked products

No browser automation. No proxies. No BeautifulSoup selectors that break every week. Just clean JSON from API calls.

API vs. scraping vs. Keepa — a quick comparison

Before diving into the code, here is how the three main approaches to Amazon price tracking stack up:

FlyByAPIs APIDIY ScrapingKeepa / CamelCamelCamel
Real-time prices✓ Live data per call✓ If not blocked✗ Periodic snapshots
Custom alerts✓ Telegram, email, any channel✓ Must build yourself✗ Email only (Keepa paid)
Marketplaces21 countries1 per scraper setup10 (Keepa)
Proxy costs$0 — included$50–300/mo$0 — not needed
Setup time~15 minutesHours to days~5 minutes (no code)
Maintenance✓ Zero — API handles changes✗ Breaks on site updates✓ Managed service
Free tier2,000 req/moN/ALimited history only
Full programmable control✓ REST API + Python✓ Full control✗ No API access (free)

FlyByAPIs gives you the programmability of DIY scraping with zero proxy costs and zero maintenance. Keepa is still the best research tool for historical charts, but it cannot trigger custom Telegram alerts or feed data into your own Python pipeline.

Use Keepa to find your target price

I said Keepa is the competition, but it’s really not. It’s the research tool. We’re building the action tool.

Here’s the workflow:

  1. Install the Keepa browser extension (free version works fine)
  2. Go to any Amazon product page — Keepa shows the full price history chart right on the page
  3. Look at the historical low. If AirPods Pro have hit $169 before, that’s your realistic target
  4. Set that price (or a bit above it) as your alert threshold in our tracker

Keepa tells you what’s possible. A tracker powered by the Amazon product data extraction API tells you when it happens. Research vs. execution. You need both.

Now let’s build it.

Prerequisites

You need three things:

  • Python 3.10+ installed on your machine
  • A RapidAPI key. Sign up at RapidAPI and subscribe to the Amazon Product Data API . The free tier gives you 2,000 requests/month, enough to track dozens of products.
  • A Telegram bot. Takes 2 minutes to set up (instructions below).

Why Telegram instead of email? No SMTP server config. No app passwords. No spam folder eating your alerts. A Telegram bot sends messages to your phone instantly, and setting one up takes about 60 seconds.

Create your Telegram bot

  1. Open Telegram and search for @BotFather
  2. Type /newbot and follow the steps — pick a name like “Price Tracker Bot”
  3. BotFather hands you a bot token — keep it somewhere safe
  4. Create a Telegram group or channel and add your new bot as an admin
  5. Post any message in that group or channel
  6. Open https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates in your browser and look for "chat":{"id": ...} — that’s your chat ID. It will be a negative number like -1001234567890. Use that number directly — @channel_name won’t work.

Done. Your bot now has permission to post into that chat.

The complete Python script from this tutorial is available in the FlyByAPIs GitHub repo . Clone it, fork it, or just grab the file and run it directly.

If you just want to get the thing running, here’s the complete script. Copy both files, fill in your credentials, and skip to the run instructions . The step-by-step breakdown follows for those who want to understand what each part does.

config.py — your credentials and product list:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# config.py
RAPIDAPI_KEY = "your-rapidapi-key-here"
TELEGRAM_BOT_TOKEN = "your-telegram-bot-token"
TELEGRAM_CHAT_ID = "your-chat-id"

PRODUCTS = {
    "B0BJQWYLYN": {
        "name": "AirPods Pro 2",
        "target_price": 189.00,
        "country": "US",
    },
    "B09XS7JWHH": {
        "name": "Sony WH-1000XM5",
        "target_price": 248.00,
        "country": "US",
    },
}

CHECK_INTERVAL_HOURS = 6
CSV_FILE = "price_history.csv"

tracker.py — the full script:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

import csv
import json
import os
import sys
import time
from datetime import datetime, timedelta

import requests
import schedule

try:
    import config
except ImportError:
    print("Missing config.py — copy config.example.py to config.py and fill in your values.")
    sys.exit(1)

API_URL = "https://real-time-amazon-data-the-most-complete.p.rapidapi.com/product-details"

def fetch_price(asin: str, country: str = "US") -> dict | None:
    headers = {
        "x-rapidapi-host": "real-time-amazon-data-the-most-complete.p.rapidapi.com",
        "x-rapidapi-key": config.RAPIDAPI_KEY,
    }
    params = {"asin": asin, "country": country}
    try:
        resp = requests.get(API_URL, headers=headers, params=params, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        product = data.get("data", {})
        raw_price = product.get("price")
        if not raw_price:
            return None
        price = float(str(raw_price).replace("$", "").replace("€", "").replace("£", "").replace("¥", "").replace("₹", "").replace(",", "").strip())
        return {
            "asin": asin,
            "title": product.get("title", "Unknown"),
            "price": price,
            "currency": product.get("price_symbol", ""),
            "original_price": "",
            "country": country,
            "timestamp": datetime.now().isoformat(),
        }
    except Exception as e:
        print(f"  [ERROR] Failed to fetch {asin}: {e}")
        return None

FIELDS = ["asin", "title", "price", "currency", "original_price", "country", "timestamp"]

def save_price(record: dict):
    file_exists = os.path.exists(config.CSV_FILE)
    with open(config.CSV_FILE, "a", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS)
        if not file_exists:
            writer.writeheader()
        writer.writerow(record)

def load_history(asin: str) -> list[dict]:
    if not os.path.exists(config.CSV_FILE):
        return []
    records = []
    with open(config.CSV_FILE, "r") as f:
        for row in csv.DictReader(f):
            if row["asin"] == asin:
                row["price"] = float(row["price"])
                records.append(row)
    return records

def get_lowest_price(asin: str) -> float | None:
    history = load_history(asin)
    if not history:
        return None
    return min(r["price"] for r in history)

ALERT_LOG = "alert_log.json"

def load_alert_log() -> dict:
    if not os.path.exists(ALERT_LOG):
        return {}
    with open(ALERT_LOG, "r") as f:
        return json.load(f)

def save_alert_log(log: dict):
    with open(ALERT_LOG, "w") as f:
        json.dump(log, f, indent=2)

def already_alerted(asin: str, days: int = 30) -> bool:
    log = load_alert_log()
    if asin not in log:
        return False
    last = datetime.fromisoformat(log[asin])
    return datetime.now() - last < timedelta(days=days)

def mark_alerted(asin: str):
    log = load_alert_log()
    log[asin] = datetime.now().isoformat()
    save_alert_log(log)

def send_telegram(message: str):
    url = f"https://api.telegram.org/bot{config.TELEGRAM_BOT_TOKEN}/sendMessage"
    payload = {
        "chat_id": config.TELEGRAM_CHAT_ID,
        "text": message,
        "parse_mode": "HTML",
    }
    try:
        resp = requests.post(url, json=payload, timeout=10)
        resp.raise_for_status()
    except Exception as e:
        print(f"  [ERROR] Telegram failed: {e}")

def check_and_alert(record: dict, target_price: float):
    if already_alerted(record["asin"]):
        return
    current = record["price"]
    lowest = get_lowest_price(record["asin"])
    name = config.PRODUCTS[record["asin"]]["name"]
    lines = []
    if current <= target_price:
        lines.append("🔥 <b>Price drop alert!</b>")
        lines.append(f"<b>{name}</b> is now <b>${current:.2f}</b>")
        lines.append(f"Your target was: ${target_price:.2f}")
    if lowest and current < lowest:
        lines.append(f"📉 New all-time low! Previous: ${lowest:.2f}")
    if lines:
        lines.append(f"\nhttps://www.amazon.com/dp/{record['asin']}")
        send_telegram("\n".join(lines))
        mark_alerted(record["asin"])

def plot_prices():
    try:
        import matplotlib.pyplot as plt
        import matplotlib.dates as mdates
    except ImportError:
        print("matplotlib not installed. Run: pip install matplotlib")
        return
    fig, ax = plt.subplots(figsize=(10, 5))
    for asin, info in config.PRODUCTS.items():
        history = load_history(asin)
        if not history:
            continue
        dates = [datetime.fromisoformat(r["timestamp"]) for r in history]
        prices = [r["price"] for r in history]
        ax.plot(dates, prices, marker="o", markersize=4, label=info["name"])
        ax.axhline(y=info["target_price"], linestyle="--", alpha=0.4)
    ax.set_xlabel("Date")
    ax.set_ylabel("Price (USD)")
    ax.set_title("Amazon Price Tracker")
    ax.legend()
    ax.xaxis.set_major_formatter(mdates.DateFormatter("%b %d"))
    fig.autofmt_xdate()
    ax.grid(True, alpha=0.3)
    fig.tight_layout()
    fig.savefig("price_chart.png", dpi=150)
    plt.show()

def check_all():
    print(f"\n[{datetime.now().strftime('%Y-%m-%d %H:%M')}] Checking prices...")
    for asin, info in config.PRODUCTS.items():
        record = fetch_price(asin, info["country"])
        if not record:
            print(f"  {info['name']}: failed to fetch")
            continue
        save_price(record)
        lowest = get_lowest_price(asin)
        low_str = f"${lowest:.2f}" if lowest else "n/a"
        print(f"  {info['name']}: ${record['price']:.2f} (target: ${info['target_price']:.2f}, lowest: {low_str})")
        check_and_alert(record, info["target_price"])
    print("[DONE]")

if __name__ == "__main__":
    if len(sys.argv) > 1 and sys.argv[1] == "--plot":
        plot_prices()
    elif len(sys.argv) > 1 and sys.argv[1] == "--once":
        check_all()
    else:
        print(f"Amazon Price Tracker — tracking {len(config.PRODUCTS)} products every {config.CHECK_INTERVAL_HOURS}h")
        print("Press Ctrl+C to stop.\n")
        check_all()
        schedule.every(config.CHECK_INTERVAL_HOURS).hours.do(check_all)
        try:
            while True:
                schedule.run_pending()
                time.sleep(60)
        except KeyboardInterrupt:
            print("\nStopped.")

Step 1 — Set up the project

Create a directory and install the three dependencies:

1
2

mkdir amazon-price-tracker && cd amazon-price-tracker
pip install requests schedule matplotlib

Create a config.py with your credentials and the products you want to track:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# config.py
RAPIDAPI_KEY = "your-rapidapi-key-here"
TELEGRAM_BOT_TOKEN = "your-telegram-bot-token"
TELEGRAM_CHAT_ID = "your-chat-id"

PRODUCTS = {
    "B0BJQWYLYN": {
        "name": "AirPods Pro 2",
        "target_price": 189.00,
        "country": "US",
    },
    "B09XS7JWHH": {
        "name": "Sony WH-1000XM5",
        "target_price": 248.00,
        "country": "US",
    },
}

CHECK_INTERVAL_HOURS = 6
CSV_FILE = "price_history.csv"

Add as many ASINs as you want. You can find a product’s ASIN on any Amazon URL — it’s the 10-character code after /dp/. The target_price is the number that triggers a Telegram alert. Use Keepa to pick a realistic one.

Step 2 — Fetch Amazon prices with the API

This is where most tutorials tell you to install BeautifulSoup, figure out the right CSS selectors, rotate user agents, and hope Amazon doesn’t block you. We’re skipping all of that.

One API call. Structured JSON back. That’s the whole thing.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import requests
from datetime import datetime
import config

API_URL = "https://real-time-amazon-data-the-most-complete.p.rapidapi.com/product-details"

def fetch_price(asin: str, country: str = "US") -> dict | None:
    headers = {
        "x-rapidapi-host": "real-time-amazon-data-the-most-complete.p.rapidapi.com",
        "x-rapidapi-key": config.RAPIDAPI_KEY,
    }
    params = {"asin": asin, "country": country}

    try:
        resp = requests.get(API_URL, headers=headers, params=params, timeout=30)
        resp.raise_for_status()
        data = resp.json()
        product = data.get("data", {})

        raw_price = product.get("price")
        if not raw_price:
            return None

        price = float(str(raw_price).replace("$", "").replace("€", "").replace("£", "").replace("¥", "").replace("₹", "").replace(",", "").strip())

        return {
            "asin": asin,
            "title": product.get("title", "Unknown"),
            "price": price,
            "currency": product.get("price_symbol", ""),
            "original_price": "",
            "country": country,
            "timestamp": datetime.now().isoformat(),
        }
    except Exception as e:
        print(f"  [ERROR] Failed to fetch {asin}: {e}")
        return None

The Amazon Product Data API returns live prices across 21 marketplaces. No cached data, no stale results. If you need the full list of response fields, check the product details endpoint documentation .

Step 3 — Store price history in CSV

Every time we check a price, we append it to a CSV. This builds up your own price history database over time.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import csv
import os

FIELDS = ["asin", "title", "price", "currency", "original_price", "country", "timestamp"]

def save_price(record: dict):
    file_exists = os.path.exists(config.CSV_FILE)
    with open(config.CSV_FILE, "a", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS)
        if not file_exists:
            writer.writeheader()
        writer.writerow(record)

def load_history(asin: str) -> list[dict]:
    if not os.path.exists(config.CSV_FILE):
        return []
    records = []
    with open(config.CSV_FILE, "r") as f:
        for row in csv.DictReader(f):
            if row["asin"] == asin:
                row["price"] = float(row["price"])
                records.append(row)
    return records

def get_lowest_price(asin: str) -> float | None:
    history = load_history(asin)
    if not history:
        return None
    return min(r["price"] for r in history)

Why CSV instead of SQLite? Fewer moving parts. You can open the file in Excel or Google Sheets to eyeball the data anytime. The Amazon data API returns clean JSON, so the conversion to CSV rows is trivial. For tracking under 100 products, CSV is more than enough. If you outgrow it, swap in SQLite later — the rest of the code stays the same.

The get_lowest_price() function is what makes the tracker smart. It scans your entire history and returns the lowest price you’ve ever recorded. When a new price beats that, you know something interesting is happening.

Step 4 — Send Telegram alerts on price drops

This is the part that makes the whole project worth building. Without alerts, you’re just collecting data nobody looks at.

One problem with naive alert systems: if a product stays below your target for weeks, you’d get spammed every 6 hours. The fix is a simple cooldown — once an alert fires for a product, it won’t fire again for 30 days. The tracker stores the last alert timestamp per ASIN in an alert_log.json file. On each check, it reads that file first. If less than 30 days have passed, it skips the alert entirely.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

import json
from datetime import datetime, timedelta

ALERT_LOG = "alert_log.json"

def load_alert_log() -> dict:
    if not os.path.exists(ALERT_LOG):
        return {}
    with open(ALERT_LOG, "r") as f:
        return json.load(f)

def save_alert_log(log: dict):
    with open(ALERT_LOG, "w") as f:
        json.dump(log, f, indent=2)

def already_alerted(asin: str, days: int = 30) -> bool:
    log = load_alert_log()
    if asin not in log:
        return False
    last = datetime.fromisoformat(log[asin])
    return datetime.now() - last < timedelta(days=days)

def mark_alerted(asin: str):
    log = load_alert_log()
    log[asin] = datetime.now().isoformat()
    save_alert_log(log)

def send_telegram(message: str):
    url = f"https://api.telegram.org/bot{config.TELEGRAM_BOT_TOKEN}/sendMessage"
    payload = {
        "chat_id": config.TELEGRAM_CHAT_ID,
        "text": message,
        "parse_mode": "HTML",
    }
    try:
        resp = requests.post(url, json=payload, timeout=10)
        resp.raise_for_status()
    except Exception as e:
        print(f"  [ERROR] Telegram failed: {e}")

def check_and_alert(record: dict, target_price: float):
    if already_alerted(record["asin"]):
        return

    current = record["price"]
    lowest = get_lowest_price(record["asin"])
    name = config.PRODUCTS[record["asin"]]["name"]

    lines = []

    if current <= target_price:
        lines.append("🔥 <b>Price drop alert!</b>")
        lines.append(f"<b>{name}</b> is now <b>${current:.2f}</b>")
        lines.append(f"Your target was: ${target_price:.2f}")

    if lowest and current < lowest:
        lines.append(f"📉 New all-time low! Previous: ${lowest:.2f}")

    if lines:
        lines.append(f"\nhttps://www.amazon.com/dp/{record['asin']}")
        send_telegram("\n".join(lines))
        mark_alerted(record["asin"])

Two triggers fire alerts: when the price drops below your target, and when it hits a new all-time low since you started tracking. Once an alert fires, that product goes quiet for 30 days — no repeat pings while the price stays low. The message includes a direct Amazon link so you can buy before the price bounces back.

The Telegram message looks something like this:

🔥 Price drop alert! AirPods Pro 2 is now $169.00 Your target was: $189.00 📉 New all-time low! Previous: $179.00

https://www.amazon.com/dp/B0BJQWYLYN

Straight to your phone. No spam folder. No delay.

Start tracking prices for free →

2,000 requests/month free · No credit card required

Step 5 — Plot your price history

After a few days of data, you’ll want to see the trends. This function generates a matplotlib chart showing all your tracked products with their target price lines.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

def plot_prices():
    try:
        import matplotlib.pyplot as plt
        import matplotlib.dates as mdates
    except ImportError:
        print("matplotlib not installed. Run: pip install matplotlib")
        return

    fig, ax = plt.subplots(figsize=(10, 5))

    for asin, info in config.PRODUCTS.items():
        history = load_history(asin)
        if not history:
            continue

        dates = [datetime.fromisoformat(r["timestamp"]) for r in history]
        prices = [r["price"] for r in history]

        ax.plot(dates, prices, marker="o", markersize=4, label=info["name"])
        ax.axhline(y=info["target_price"], linestyle="--", alpha=0.4)

    ax.set_xlabel("Date")
    ax.set_ylabel("Price (USD)")
    ax.set_title("Amazon Price Tracker")
    ax.legend()
    ax.xaxis.set_major_formatter(mdates.DateFormatter("%b %d"))
    fig.autofmt_xdate()
    ax.grid(True, alpha=0.3)
    fig.tight_layout()
    fig.savefig("price_chart.png", dpi=150)
    plt.show()

Run it with python tracker.py --plot to generate the chart. Each product gets its own colored line, and the dashed horizontal lines show your target prices. When the solid line crosses below the dashed one, that’s when your phone buzzed.

The chart saves as price_chart.png too, so you can share it or embed it somewhere.

Step 6 — Run it on a schedule

Last piece: making it run automatically so you can forget about it.

Option A: Built-in scheduler (simplest)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import sys
import schedule
import time

def check_all():
    print(f"\n[{datetime.now().strftime('%Y-%m-%d %H:%M')}] Checking prices...")
    for asin, info in config.PRODUCTS.items():
        record = fetch_price(asin, info["country"])
        if not record:
            print(f"  {info['name']}: failed to fetch")
            continue
        save_price(record)
        lowest = get_lowest_price(asin)
        low_str = f"${lowest:.2f}" if lowest else "n/a"
        print(f"  {info['name']}: ${record['price']:.2f} (target: ${info['target_price']:.2f}, lowest: {low_str})")
        check_and_alert(record, info["target_price"])
    print("[DONE]")

if __name__ == "__main__":
    if len(sys.argv) > 1 and sys.argv[1] == "--plot":
        plot_prices()
    elif len(sys.argv) > 1 and sys.argv[1] == "--once":
        check_all()
    else:
        print(f"Amazon Price Tracker — tracking {len(config.PRODUCTS)} products every {config.CHECK_INTERVAL_HOURS}h")
        print("Press Ctrl+C to stop.\n")
        check_all()
        schedule.every(config.CHECK_INTERVAL_HOURS).hours.do(check_all)
        try:
            while True:
                schedule.run_pending()
                time.sleep(60)
        except KeyboardInterrupt:
            print("\nStopped.")

Run python tracker.py and leave it running. It checks immediately, then every N hours. Good for your laptop or a Raspberry Pi.

Option B: Cron job (better for a server)

If you’re running this on a VPS, use cron instead:

1
2
3
4
5

# Edit crontab
crontab -e

# Add this line — runs every 6 hours
0 */6 * * * cd /path/to/amazon-price-tracker && python3 tracker.py --once

No background process to babysit. Cron handles the scheduling, the script runs once, checks all prices, sends alerts if needed, and exits.

The complete amazon price tracker Python script

The complete tracker.py and config.example.py are in the FlyByAPIs GitHub repo — clone it or copy the files directly. The script includes --once and --plot argument handling so you can run single checks or generate charts from the command line. Three commands to get going:

1
2
3

cp config.example.py config.py   # Fill in your keys
pip install -r requirements.txt
python tracker.py                # Start tracking

Or run it once to test: python tracker.py --once

And when you’ve accumulated some data: python tracker.py --plot

How much does this cost?

Let’s do the math. Say you’re tracking 10 products, checking every 6 hours:

ProductsChecks/dayRequests/monthPlan neededCost
1040~1,200Free$0
25100~3,000Pro$9.99/mo
50 (hourly)1,200~36,000Ultra$49.99/mo

The Amazon Product Data API free tier lets you track Amazon prices across 10 products without spending a cent.

Now compare that to running your own scraper: residential proxies ($50-300/month), a headless browser instance, server infrastructure, and the engineering time to fix it every time Amazon updates their page structure. The Amazon scraper API is the saner path. And if you need to track competitor pricing across search engines too, the Google Search API covers that angle.

Get tracking

The combination of Keepa for research and this script for alerts is genuinely useful. You spend 5 minutes figuring out what price is realistic, set the tracker loose, and forget about it. Your phone buzzes when it’s time to buy.

150 lines of Python. No scraping headaches. No proxy bills. The Amazon product data API handles data extraction across 21 Amazon marketplaces so your tracker script stays under 150 lines and never breaks when Amazon changes their HTML. If you’re building an e-commerce tool that also needs multilingual product descriptions, the Translator API can handle that. If you’re also interested in tracking current Amazon deals and lightning offers, check out our Amazon deals bot tutorial for a complementary approach.

Get your API key — it's free →

25 endpoints · 21 Amazon marketplaces · Free to start

P.S. — Once you have a few weeks of data, run --plot. There’s something weirdly addictive about watching those price lines move. Like a stock ticker, but for things you actually want to buy.

FAQ

Frequently Asked Questions

Q Can I track products on Amazon UK, Germany, or other marketplaces?

Yes. FlyByAPIs Amazon Product Data API covers 21 marketplaces including US, GB, DE, FR, CA, JP, IN, AU, IT, and ES. Change the country field in your config to any supported code and prices return in the local currency.

Q How is this different from Keepa or CamelCamelCamel?

Keepa and CamelCamelCamel are passive tools — you check them when you remember. The FlyByAPIs-powered tracker checks prices every 6 hours and sends a Telegram alert the instant your target is hit. With 150 lines of Python and 2,000 free API requests per month, it replaces manual price watching entirely.

Q Will Amazon block me for using this API?

No. You are not scraping Amazon directly. FlyByAPIs handles data extraction server-side with its own infrastructure across 21 marketplaces. Your script makes standard REST API calls and Amazon never sees your IP address.

Q Can I use email alerts instead of Telegram?

Yes, you can swap send_telegram() for SMTP email sending using Python's smtplib in under 10 lines of code. However, Telegram is faster to set up — no mail server, no app passwords, no spam folder. FlyByAPIs users typically choose Telegram because alerts arrive in under 2 seconds.

Q How many products can I realistically track with FlyByAPIs?

The FlyByAPIs free tier gives you 2,000 requests per month, enough for about 15 products with 6-hour checks. The Pro plan at $9.99/month provides 10,000 requests, handling 80+ products with hourly checks.

Q What happens if a product goes out of stock on Amazon?

The FlyByAPIs API returns a null price when a product is unavailable. The tracker script handles this gracefully — it skips the price check and retries at the next 6-hour interval without crashing or sending false alerts.

Q Do I need a server to run this amazon price tracker python script?

No server is required. The script runs on your laptop, a $35 Raspberry Pi, or any cheap VPS. FlyByAPIs handles the heavy lifting of data extraction, so your hardware requirements are minimal — just Python 3.10+ and an internet connection.

Q How accurate are the prices from the FlyByAPIs Amazon API?

FlyByAPIs returns real-time, live Amazon prices across 21 marketplaces — not cached or estimated data. Every API call fetches the current price in under 3 seconds, so your tracker always works with the exact number a shopper would see on the product page.
Tags #amazon-price-tracker #python #telegram-bot #price-tracking #amazon-api
Share this article
X / Twitter LinkedIn
Oriol Marti
Oriol Marti
Founder & CEO

Computer engineer and entrepreneur based in Andorra. Founder and CEO of FlyByAPIs, building reliable web data APIs for developers worldwide.

Previous How to Build an Amazon Deals Bot With Telegram Alerts Next SerpAPI Alternatives: 7 Smarter Options for SERP Scraping (2026)
Free tier available

Ready to stop maintaining scrapers?

Production-ready APIs for web data extraction. Whatever you're building, up and running in minutes.

Start for free on RapidAPI