Wie man Wettbewerberpreise automatisch mit Proxies überwacht

Warum Automatisierte Preisüberwachung

In wettbewerbsfähigen E-Commerce-Märkten ändern sich die Preise ständig. Ein Konkurrent könnte ihren Preis um 5% bei 2 AM fallen, und wenn Sie bemerken, haben Sie bereits einen Verkaufstag verloren. Automatisierte Preisüberwachung eliminiert diesen blinden Fleck, indem Sie die Wettbewerberpreise kontinuierlich verfolgen und Sie auf Änderungen in Echtzeit aufmerksam machen.

Ob Sie ein Händler sind, der die Preise anpasst, um wettbewerbsfähig zu bleiben, eine Markenüberwachung MAP (Minimum Advertised Price) Compliance oder ein Analyst Tracking Markttrends, ein gut gebautes Preisüberwachungssystem zahlt sich schnell aus. Der Hauptbestandteil, der alles zuverlässig funktioniert, ist eine robuste Proxy-Infrastruktur – ohne dass Ihre Überwachungsanforderungen innerhalb von Stunden blockiert werden. Für einen breiteren Blick auf die E-Commerce-Datenerhebung, siehe unsere e-Commerce Daten-Schrottführer.

Architektur eines Preisüberwachungssystems

Ein produktionsfähiges Preisüberwachungssystem verfügt über vier Hauptkomponenten: einen URL-Manager, einen Abstreifmotor, einen Datenspeicher und eine Warnschicht.

Programmplanung

Nicht alle Produkte benötigen dieselbe Überwachungsfrequenz. Hochprioritätsartikel (Ihre Top 100 SKUs, direkte Konkurrentenprodukte) benötigen möglicherweise stündliche Kontrollen, während Long-Tail-Artikel täglich überprüft werden können. Priorität basierend auf:

• Preisvolatilität: Produkte, die die Preise ändern, benötigen häufigere Kontrollen.
• Einnahmen: Ihre Bestseller verdienen eine höhere Überwachungspriorität.
• Wettbewerbsdichte: Kategorien mit vielen Konkurrenten benötigen eine engere Überwachung.

Einrichten von Proxy-Rotation zur Überwachung

Preisüberwachung bedeutet, die gleichen URLs mehrmals über Tage, Wochen und Monate zu treffen. Dieses Muster ist genau das, was Anti-Bot-Systeme zu erkennen. Wohn-Proxie mit automatischer Rotation sind unerlässlich.

ProxyHat Konfiguration

# Standard rotating proxy (new IP per request)
http://USERNAME:PASSWORD@gate.proxyhat.com:8080
# Geo-targeted for regional pricing (e.g., US prices)
http://USERNAME-country-US:PASSWORD@gate.proxyhat.com:8080
# Session-based for multi-page price checks
http://USERNAME-session-price001:PASSWORD@gate.proxyhat.com:8080

Für die Preisüberwachung funktioniert die Per-Request-Rotation am besten, weil jede Preisprüfung eine unabhängige Operation ist. Verwendung Geotargets bei der Überwachung regionaler Preisunterschiede.

Implementierung von Python

Hier ist ein komplettes Preisüberwachungssystem mit Python gebaut, mit ProxyHat's Python SDK.

Preis Scraper Modul

import requests
from bs4 import BeautifulSoup
import json
import time
import random
from datetime import datetime
from dataclasses import dataclass, asdict
PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
]
@dataclass
class PriceResult:
    url: str
    price: float | None
    currency: str | None
    in_stock: bool
    scraped_at: str
    seller: str | None = None
def scrape_price(url: str, selectors: dict) -> PriceResult:
    """Scrape a product price from any e-commerce site."""
    headers = {
        "User-Agent": random.choice(USER_AGENTS),
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
    }
    proxies = {"http": PROXY_URL, "https": PROXY_URL}
    try:
        response = requests.get(url, headers=headers, proxies=proxies, timeout=30)
        response.raise_for_status()
    except requests.RequestException as e:
        return PriceResult(
            url=url, price=None, currency=None,
            in_stock=False, scraped_at=datetime.utcnow().isoformat()
        )
    soup = BeautifulSoup(response.text, "html.parser")
    price = extract_price(soup, selectors.get("price"))
    currency = selectors.get("currency", "USD")
    in_stock = check_stock(soup, selectors.get("stock"))
    return PriceResult(
        url=url,
        price=price,
        currency=currency,
        in_stock=in_stock,
        scraped_at=datetime.utcnow().isoformat(),
    )
def extract_price(soup, selector: str) -> float | None:
    """Extract and parse price from a CSS selector."""
    if not selector:
        return None
    el = soup.select_one(selector)
    if not el:
        return None
    text = el.get_text(strip=True)
    # Remove currency symbols, commas, spaces
    cleaned = "".join(c for c in text if c.isdigit() or c == ".")
    try:
        return float(cleaned)
    except ValueError:
        return None
def check_stock(soup, selector: str) -> bool:
    """Check if product is in stock."""
    if not selector:
        return True
    el = soup.select_one(selector)
    if not el:
        return False
    text = el.get_text(strip=True).lower()
    return "in stock" in text or "available" in text
# Site-specific selector configurations
SITE_SELECTORS = {
    "amazon.com": {
        "price": "span.a-price-whole",
        "stock": "#availability span",
        "currency": "USD",
    },
    "walmart.com": {
        "price": "[data-testid='price-wrap'] span.f2",
        "stock": "[data-testid='fulfillment-badge']",
        "currency": "USD",
    },
    "target.com": {
        "price": "[data-test='product-price']",
        "stock": "[data-test='fulfillmentSection']",
        "currency": "USD",
    },
}

Monitoringplaner

import schedule
import threading
from collections import defaultdict
class PriceMonitor:
    def __init__(self, db_connection):
        self.db = db_connection
        self.price_history = defaultdict(list)
    def add_product(self, url: str, site: str, check_interval_minutes: int = 60):
        """Register a product for monitoring."""
        selectors = SITE_SELECTORS.get(site, {})
        def check():
            result = scrape_price(url, selectors)
            self.price_history[url].append(result)
            self.store_result(result)
            self.check_alerts(url, result)
            time.sleep(random.uniform(1, 3))
        schedule.every(check_interval_minutes).minutes.do(check)
    def store_result(self, result: PriceResult):
        """Store price result in database."""
        # Insert into price_history table
        self.db.execute(
            "INSERT INTO price_history (url, price, currency, in_stock, scraped_at) "
            "VALUES (%s, %s, %s, %s, %s)",
            (result.url, result.price, result.currency,
             result.in_stock, result.scraped_at)
        )
    def check_alerts(self, url: str, result: PriceResult):
        """Check if price change triggers an alert."""
        history = self.price_history[url]
        if len(history) < 2:
            return
        prev = history[-2]
        curr = history[-1]
        if prev.price and curr.price:
            change_pct = ((curr.price - prev.price) / prev.price) * 100
            if abs(change_pct) >= 5:  # 5% threshold
                self.send_alert(url, prev.price, curr.price, change_pct)
        # Stock status change
        if prev.in_stock and not curr.in_stock:
            self.send_alert(url, msg="Product went out of stock")
        elif not prev.in_stock and curr.in_stock:
            self.send_alert(url, msg="Product back in stock")
    def send_alert(self, url, old_price=None, new_price=None,
                   change_pct=None, msg=None):
        """Send price change notification."""
        if msg:
            print(f"ALERT [{url}]: {msg}")
        else:
            direction = "dropped" if change_pct < 0 else "increased"
            print(f"ALERT [{url}]: Price {direction} {abs(change_pct):.1f}% "
                  f"(${old_price} -> ${new_price})")
    def run(self):
        """Start the monitoring loop."""
        while True:
            schedule.run_pending()
            time.sleep(1)
# Usage
if __name__ == "__main__":
    monitor = PriceMonitor(db_connection=None)  # Replace with actual DB
    # Monitor competitor products
    monitor.add_product(
        "https://www.amazon.com/dp/B0CHX3QBCH",
        site="amazon.com",
        check_interval_minutes=60,
    )
    monitor.add_product(
        "https://www.amazon.com/dp/B0D5BKRY4R",
        site="amazon.com",
        check_interval_minutes=30,  # Higher priority
    )
    monitor.run()

Node.js Implementierung

Für Teams mit Node.js ist hier ein gleichwertiges Monitoring-Setup mit ProxyHat's Node SDK.

const axios = require("axios");
const cheerio = require("cheerio");
const { HttpsProxyAgent } = require("https-proxy-agent");
const cron = require("node-cron");
const PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080";
const agent = new HttpsProxyAgent(PROXY_URL);
const USER_AGENTS = [
  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
];
async function scrapePrice(url, selectors) {
  try {
    const { data } = await axios.get(url, {
      httpsAgent: agent,
      headers: {
        "User-Agent": USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
        "Accept-Language": "en-US,en;q=0.9",
      },
      timeout: 30000,
    });
    const $ = cheerio.load(data);
    const priceText = $(selectors.price).first().text().trim();
    const price = parseFloat(priceText.replace(/[^0-9.]/g, "")) || null;
    return {
      url,
      price,
      currency: selectors.currency || "USD",
      inStock: $(selectors.stock).text().toLowerCase().includes("in stock"),
      scrapedAt: new Date().toISOString(),
    };
  } catch (err) {
    return { url, price: null, currency: null, inStock: false, scrapedAt: new Date().toISOString() };
  }
}
class PriceMonitor {
  constructor() {
    this.products = [];
    this.history = new Map();
  }
  addProduct(url, selectors, cronExpression = "0 * * * *") {
    this.products.push({ url, selectors, cronExpression });
    this.history.set(url, []);
    cron.schedule(cronExpression, async () => {
      const result = await scrapePrice(url, selectors);
      const prev = this.history.get(url);
      prev.push(result);
      if (prev.length >= 2) {
        const last = prev[prev.length - 2];
        if (last.price && result.price) {
          const changePct = ((result.price - last.price) / last.price) * 100;
          if (Math.abs(changePct) >= 5) {
            console.log(`ALERT [${url}]: Price changed ${changePct.toFixed(1)}%`);
          }
        }
      }
      console.log(`Checked ${url}: $${result.price} (${result.inStock ? "in stock" : "out of stock"})`);
    });
  }
}
// Usage
const monitor = new PriceMonitor();
monitor.addProduct(
  "https://www.amazon.com/dp/B0CHX3QBCH",
  { price: "span.a-price-whole", stock: "#availability span", currency: "USD" },
  "0 * * * *"  // Every hour
);
monitor.addProduct(
  "https://www.amazon.com/dp/B0D5BKRY4R",
  { price: "span.a-price-whole", stock: "#availability span", currency: "USD" },
  "*/30 * * * *"  // Every 30 minutes
);

Datenspeicherung und -analyse

Rohe Preisdaten werden wertvoll, wenn Sie Trends im Laufe der Zeit analysieren können.

Datenbankschema

CREATE TABLE monitored_products (
    id SERIAL PRIMARY KEY,
    url TEXT NOT NULL,
    site VARCHAR(100) NOT NULL,
    product_name VARCHAR(500),
    our_sku VARCHAR(100),
    check_interval_minutes INT DEFAULT 60,
    is_active BOOLEAN DEFAULT true,
    created_at TIMESTAMPTZ DEFAULT now()
);
CREATE TABLE price_history (
    id SERIAL PRIMARY KEY,
    product_id INT REFERENCES monitored_products(id),
    price DECIMAL(10, 2),
    currency VARCHAR(3) DEFAULT 'USD',
    in_stock BOOLEAN,
    scraped_at TIMESTAMPTZ NOT NULL,
    created_at TIMESTAMPTZ DEFAULT now()
);
CREATE INDEX idx_price_history_product_time
    ON price_history (product_id, scraped_at DESC);

Preis Trend Quers

-- Average daily price for the last 30 days
SELECT
    date_trunc('day', scraped_at) AS day,
    AVG(price) AS avg_price,
    MIN(price) AS min_price,
    MAX(price) AS max_price
FROM price_history
WHERE product_id = 1
  AND scraped_at >= now() - INTERVAL '30 days'
GROUP BY day
ORDER BY day;
-- Products with price drops > 10% in the last 24 hours
SELECT
    mp.product_name,
    mp.url,
    old_prices.avg_price AS price_yesterday,
    new_prices.avg_price AS price_today,
    ((new_prices.avg_price - old_prices.avg_price) / old_prices.avg_price * 100) AS change_pct
FROM monitored_products mp
JOIN LATERAL (
    SELECT AVG(price) AS avg_price
    FROM price_history
    WHERE product_id = mp.id
      AND scraped_at BETWEEN now() - INTERVAL '48 hours' AND now() - INTERVAL '24 hours'
) old_prices ON true
JOIN LATERAL (
    SELECT AVG(price) AS avg_price
    FROM price_history
    WHERE product_id = mp.id
      AND scraped_at >= now() - INTERVAL '24 hours'
) new_prices ON true
WHERE ((new_prices.avg_price - old_prices.avg_price) / old_prices.avg_price * 100) < -10;

Benachrichtigungen und Meldungen

Automatisierte Alarme sorgen dafür, dass Sie schnell auf Preisänderungen reagieren. Gemeinsame Benachrichtigungskanäle umfassen:

• Slack Webhooks: Ideal für teamweite Sichtbarkeit. Senden Sie strukturierte Nachrichten mit Preisänderungen Details.
• E-Mail: Tägliche oder stündliche Zusammenfassungen aller Preisänderungen über Ihrer Schwelle.
• Webhook Callbacks: Auslösen Sie Ihren Nachrüstmotor oder andere Automatisierung, wenn sich die Preise ändern.
• Dashboard: Echtzeit-Visualisierung von Preistrends in allen überwachten Produkten.

Alarmschwellen

Konfigurieren Sie verschiedene Alarmschwellen für verschiedene Szenarien:

Proxy Best Practices zur Überwachung

Kontinuierliche Überwachung schafft einzigartige Herausforderungen für das Proxy-Management im Vergleich zum einmaligen Schrott.

• Anträge im Laufe der Zeit verteilen: Anstatt alle 10.000 Produkte um Mitternacht zu überprüfen, verteilte Kontrollen über das gesamte Intervall. Dadurch entsteht ein stetiges, Low-Profil-Anforderungsmuster.
• Benutzen Sie Wohn-Proxies: Wohngebiete sind für eine langfristige Überwachung unerlässlich, da die gleichen Rechenzentren-IPs, die die gleichen Websites täglich treffen, verboten werden.
• Geo-Standort: Bei der Überwachung der regionalen Preise verwenden Sie Proxies aus der Zielregion. Eine US-IP-Überprüfung der deutschen Preise wird die falschen Daten sehen oder umgeleitet.
• Griffausfälle anmutig: Wenn eine Anfrage fehlschlägt, warten und retry mit exponentiellem Backoff, anstatt sofort neu zu erfragen. Überwachen Sie Ihre Erfolgsquote und reduzieren Sie die Konkurrenz, wenn sie sinkt.
• Cache und deduplizieren: Wenn sich ein Preis nicht geändert hat, speichern Sie keinen doppelten Datensatz. Dies hält Ihre Datenbank schlank und macht die Analyse schneller.

Key Takeaway: Preisüberwachung ist ein Marathon, kein Sprint. Entwerfen Sie Ihr System für stetige, nachhaltige Anforderungsmuster, anstatt Schrott zu platzen.

Skalierung Ihres Überwachungssystems

Wenn Ihr Produktkatalog wächst, wird Skalierung kritisch. Hier sind die Muster, die funktionieren:

• Arbeitspool: Verwenden Sie mehrere Arbeiter, die von einer Job-Quue (Redis, RabbitMQ) ziehen. Jeder Arbeiter hat seine eigenen Proxyverbindungen und arbeitet unabhängig.
• Vorrangige Warteschlangen: Hochwertige Produkte werden zuerst und häufiger überprüft. Niedrige Prioritätselemente füllen Restkapazität.
• Anpassungsplanung: Wenn sich der Preis des Produkts in 7 Tagen nicht geändert hat, reduzieren Sie die Prüffrequenz automatisch. Wenn es sich heute zweimal geändert hat, erhöhen Sie die Frequenz.
• Bemessungsgrenze pro Standort: Überprüfen Sie die Geschwindigkeitslimits der einzelnen Zielseite. Amazon, Walmart und Nischengeschäfte haben alle unterschiedliche Toleranzen.

Weitere Informationen zu Skalierschaben finden Sie in unserem Leitfaden beste Proxies für Web-Schrott in 2026 und entdecken Preise von ProxyHat für eine hochvolumige Überwachung.

Schlüsselanhänger

• Die automatisierte Preisüberwachung erfordert eine robuste Architektur: URL-Manager, Abstreifmotor, Datenspeicher und Alarmsystem.
• Für eine dauerhafte Überwachung ohne Blöcke sind gebietsansässige Proxie mit Per-Request-Rotation unerlässlich.
• Zeitplan-Kontrollen auf der Grundlage der Priorität — nicht alle Produkte benötigen stündliche Überwachung.
• Speichern Sie Preisgeschichte in einem zeitreihenfreundlichen Schema für Trendanalysen.
• Konfigurieren Sie bindende Alarmschwellen, um die Reaktionsfähigkeit mit Lärmminderung auszugleichen.
• Anträge gleichmäßig über die Zeit für ein nachhaltiges, profilarmes Abstreifmuster verteilen.

Bereit, Ihr Preisüberwachungssystem aufzubauen? Beginnen Sie mit ProxyHat's Wohn-Proxies und unsere E-Commerce-Schrottführer für die volle Strategie. Nähere Informationen zur technischen Umsetzung finden Sie in unseren Anleitungen mit Proxies in Python und mit Proxies in Node.js.