Einen Price-Tracking-Bot in Python bauen (Amazon + Google Shopping)

Ein Price-Tracking-Bot besteht aus vier Teilen: die Produkte finden, die sich zu beobachten lohnen, ihren Preis nach Zeitplan prüfen, den Verlauf speichern und jemanden benachrichtigen, wenn der Preis fällt. Hier sind alle vier, mit der Kreditrechnung für eine realistische Bot-Größe.

Schritt 1: Produkte über die Suche entdecken

Starte mit einer Kategorie oder einem Keyword, nicht mit einer von Hand getippten Liste. Der /amazon-Such-Endpoint liefert organische Produkte mit asin, price, extracted_price und Bewertungsdaten für 1 Credit pro Anfrage:

import re

import requests

API_KEY = "faf_live_..."  # dein FastAF-Key

def discover(query, domain="com", pages=1):
    products = []
    for page in range(1, pages + 1):
        resp = requests.get(
            "https://api.fastaf.co/v1/amazon",
            params={"query": query, "domain": domain, "page": page},
            headers={"Authorization": f"Bearer {API_KEY}"},
            timeout=60,
        )
        resp.raise_for_status()
        products.extend(
            item for item in resp.json()["results"]
            if item["type"] == "search_product"
        )
    return products

candidates = discover("mechanical keyboard")
watchlist = [p["asin"] for p in candidates if p.get("stars", 0) >= 4.0]

Führe das einmal pro Kategorie aus, um deine Watchlist aufzubauen, und wechsle dann für das eigentliche Tracking zum Produkt-Endpoint. Suchergebnisse können sich zwischen Anfragen neu sortieren, ASINs nicht.

Schritt 2: Preis nach ASIN tracken

resource=product holt das komplette Listing für eine ASIN, inklusive aktuellem Preis, Verfügbarkeit und Buybox-Verkäufer, für 1 Credit:

def check_price(asin, domain="com"):
    resp = requests.get(
        "https://api.fastaf.co/v1/amazon",
        params={"resource": "product", "asin": asin, "domain": domain},
        headers={"Authorization": f"Bearer {API_KEY}"},
        timeout=60,
    )
    resp.raise_for_status()
    # resource=product liefert ein flaches Objekt (title, price, ...), keine results-Liste.
    # Das price-Feld ist ein Anzeige-String wie "$25.49 with 40 percent savings" (geprueft August 2026).
    product = resp.json()
    match = re.search(r"[\d][\d.,]*", product.get("price") or "")
    price = float(match.group().replace(",", "")) if match else None
    return price, product.get("title")

Schritt 3: Verlauf in SQLite speichern

import sqlite3
import time

conn = sqlite3.connect("prices.db")
conn.execute("""
    CREATE TABLE IF NOT EXISTS price_history (
        asin TEXT,
        price REAL,
        checked_at INTEGER
    )
""")

def record_price(asin, price):
    conn.execute(
        "INSERT INTO price_history VALUES (?, ?, ?)",
        (asin, price, int(time.time())),
    )
    conn.commit()

def last_price(asin):
    row = conn.execute(
        "SELECT price FROM price_history WHERE asin = ? ORDER BY checked_at DESC LIMIT 1",
        (asin,),
    ).fetchone()
    return row[0] if row else None

Schritt 4: Prüfungen einplanen und bei Preisstürzen alarmieren

Ein Cron-Job (oder eine einfache Schleife mit time.sleep, falls du keine Maschine mit Cron hast), der die Watchlist durchgeht und mit dem zuletzt gespeicherten Preis vergleicht:

def run_check(watchlist, threshold_pct=5):
    for asin in watchlist:
        price, title = check_price(asin)
        if price is None:
            continue

        previous = last_price(asin)
        record_price(asin, price)

        if previous and price < previous * (1 - threshold_pct / 100):
            drop_pct = round((1 - price / previous) * 100, 1)
            alert(f"{title}: ${previous:.2f} -> ${price:.2f} ({drop_pct}% off)")

def alert(message):
    print(message)  # hier durch E-Mail, Slack-Webhook oder was du wirklich checkst ersetzen

Plane run_check(watchlist) so, wie es zu deinem Setup passt: Cron, ein systemd-Timer oder ein geplanter Worker, wenn du das auf einer Serverless-Plattform deployst. Ein paar Prüfungen pro Tag reichen für die meisten Konsumgüter, stündlich ist übertrieben, außer du jagst gezielt Blitzangebote.

Über Amazon hinaus im Blick behalten

Amazon ist nicht der einzige Ort, an dem sich ein Preis bewegt. Für einen breiteren Marktcheck schickst du den Produktnamen durch /serp, die Google-Suche, und liest die organischen Listings: Welche Händler für das Produkt ranken und ob ein neuer Verkäufer in den Ergebnissen aufgetaucht ist, ist ein nützliches Signal, auch ohne dedizierten Shopping-Feed:

def market_check(product_name, country="us"):
    resp = requests.get(
        "https://api.fastaf.co/v1/serp",
        params={"query": f"{product_name} price", "country": country},
        headers={"Authorization": f"Bearer {API_KEY}"},
        timeout=60,
    )
    resp.raise_for_status()
    return [r["link"] for r in resp.json().get("organic_results", [])]

Das kostet 5 Credits pro Produkt und lohnt sich wöchentlich, nicht täglich: Es geht darum, einen neuen Konkurrenten oder ein Delisting zu erkennen, nicht darum, stündliche Preisschwankungen zu erwischen.

Was kostet das wirklich?

Ein konkreter Bot: 200 ASINs, dreimal täglich getrackt, plus ein wöchentlicher Marktcheck für dieselben 200 Produkte, plus 20 Discovery-Suchen im Monat, um die Watchlist zu aktualisieren.

Aufgabe	Anfragen (30 Tage)	Credits je	Credits (30 Tage)
ASIN-Preischecks (200 x 3/Tag)	18.000	1	18.000
Wöchentlicher Marktcheck (200 x 4)	800	5	4.000
Discovery-Suchen	20	1	20
Gesamt			~22.020

Ein $29-Growth-Paket (75.000 Credits) reicht dafür mehr als drei Monate, oder einen Monat mit einer Watchlist von über 600 ASINs. Der Free Tier (500 Credits, keine Karte) reicht, um genau diesen Bot eine Woche lang gegen eine Watchlist mit 15 ASINs laufen zu lassen, bevor du entscheidest, ob sich das Bezahlen lohnt.

Kurzversion

Entdecke mit der Suche, tracke mit dem Produkt-Endpoint, speichere jede Prüfung, auch wenn sich nichts geändert hat (du brauchst den Verlauf, um einen Rückgang in Prozent zu berechnen), und alarmiere erst ab einem Schwellenwert, damit du nicht wegen einer Schwankung von $0,01 benachrichtigt wirst. Kalkuliere mit etwa 1 Credit pro ASIN pro Prüfung: Bei dieser Rate kostet das tägliche Tracking von Hunderten Produkten einstellige Dollarbeträge für einen Monat an Prüfungen. Die vollständige Parameterliste findest du in den Docs.