Jak monitorować ceny konkurenta automatycznie z Proxies

Dlaczego zautomatyzowane monitorowanie cen ma znaczenie

Na konkurencyjnych rynkach handlu elektronicznego ceny ciągle się zmieniają. Konkurent może obniżyć cenę o 5% o 2: 00 rano, a zanim zauważysz, już straciłeś dzień sprzedaży. Automatyczne monitorowanie cen eliminuje ten ślepy punkt poprzez ciągłe śledzenie cen konkurencyjnych i ostrzeganie o zmianach w czasie rzeczywistym.

Niezależnie od tego, czy jesteś sprzedawcą detalicznym dostosowującym ceny, aby pozostać konkurencyjnym, czy też monitorującym marką MAP (minimalna cena reklamowa), czy analitykiem śledzącym trendy rynkowe, dobrze zbudowany system monitorowania cen szybko się opłaca. Kluczowym składnikiem, który sprawia, że wszystko działa niezawodnie jest solidna infrastruktura proxy - bez niego, Twoje żądania monitorowania zostają zablokowane w ciągu godzin. Aby uzyskać szersze spojrzenie na zbieranie danych e-commerce, zobacz nasz Przewodnik do zeskrobywania danych e-commerce.

Architektura systemu monitorowania cen

System monitorowania cen produktów ma cztery główne komponenty: menedżer URL, silnik scrating, magazyn danych i warstwa alarmowa.

Strategia planowania

Nie wszystkie produkty wymagają tej samej częstotliwości monitorowania. Produkty o najwyższym priorytecie (100 najlepszych SKU, produkty bezpośredniego konkurenta) mogą wymagać cogodzinnych kontroli, podczas gdy produkty o długim ogonie mogą być sprawdzane codziennie. Pierwszeństwo oparte na:

• Niestabilność cen: Produkty, które zmieniają ceny, często wymagają częstszych kontroli.
• Wpływ na dochody: Twoje bestsellery zasługują na wyższy priorytet monitorowania.
• Gęstość konkurencyjna: Kategorie z wieloma konkurentami wymagają ściślejszego monitorowania.

Ustawianie rotacji proxy dla monitorowania

Monitorowanie cen oznacza trafienie tych samych adresów URL wielokrotnie w ciągu dni, tygodni i miesięcy. Ten wzór jest dokładnie tym, co systemy anty-bot są zaprojektowane do wykrywania. Kluczowe znaczenie mają proxy mieszkaniowe z automatyczną rotacją.

Konfiguracja ProxyHat

# 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

Dla monitorowania cen, rotacja perrequest działa najlepiej, ponieważ każda kontrola cen jest niezależną operacją. Stosowanie proxy geoukierunkowane monitorowanie regionalnych różnic cenowych.

Wdrażanie Pythona

Oto kompletny system monitorowania cen zbudowany z Python, za pomocą Python SDK ProxyHat.

Moduł zraszacza cen

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",
    },
}

Schemat monitorowania

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()

Wdrażanie Node.js

Dla zespołów korzystających z Node.js, tutaj jest równoważne ustawienie monitorowania za pomocą Węzeł ProxyHat 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
);

Przechowywanie i analiza danych

Surowe dane cenowe stają się cenne, gdy można analizować trendy w czasie.

Schemat bazy danych

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);

Zapytania trendów cenowych

-- 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;

Powiadomienia i powiadomienia

Automatyczne alarmy zapewniają szybką reakcję na zmiany cen. Wspólne kanały powiadamiania obejmują:

• Haczyki na paski: Idealny do widoczności w całym zespole. Wysyłanie ustrukturyzowanych wiadomości ze szczegółami zmian cen.
• Desery e-mail: Codzienne lub godzinowe podsumowania wszystkich zmian cen powyżej progu.
• Webhook callbacks: Wyrównywanie cen silnika lub innych automatyzacji, gdy ceny się zmieniają.
• Deska rozdzielcza: Rzeczywista wizualizacja trendów cenowych we wszystkich monitorowanych produktach.

Progi ostrzegania

Skonfiguruj różne progi alarmowe dla różnych scenariuszy:

Proxy Najlepsze praktyki w zakresie monitorowania

Ciągły monitoring stwarza unikalne wyzwania dla zarządzania proxy w porównaniu do jednokrotnego drapania.

• Rozpowszechnianie wniosków w czasie: Zamiast sprawdzać wszystkie 10 000 produktów o północy, rozłożyć kontrole przez cały okres. Tworzy to stały, niskoprofilowy wzór żądania.
• Użyj proxy mieszkalnych: Proxy mieszkalne są niezbędne dla długotrwałego monitorowania, ponieważ te same dane IP trafiające na te same strony codziennie będą zakazane.
• Mecz geolokalizacji: Przy monitorowaniu cen regionalnych należy stosować proxy z regionu docelowego. Amerykański IP sprawdzający ceny w Niemczech zobaczy niewłaściwe dane lub zostanie przekierowany.
• Niepowodzenia z wdzięcznością: Jeśli prośba się nie powiedzie, czekać i spróbować ponownie z wykładniczym backupu zamiast natychmiast ponownie poprosić. Monitoruj swój wskaźnik sukcesu i zmniejszyć współzależność, jeśli spadnie.
• Cache i deduplikat: Jeżeli cena nie uległa zmianie, nie należy przechowywać duplikatu. Dzięki temu baza danych jest szczupła i przyspiesza analizę.

Klucz na wynos: Monitoring cen to maraton, a nie sprint. Zaprojektuj swój system dla stałych, zrównoważonych wzorów żądań, a nie pęknięcia scrating.

Skalowanie systemu monitorowania

Wraz z rozwojem katalogu produktów skalowanie staje się kluczowe. Oto wzory, które działają:

• Basen robotniczy: Korzystanie z wielu pracowników ciągnących z kolejki pracy (Redis, RabbitMQ). Każdy pracownik ma własne powiązania proxy i działa niezależnie.
• Kolejki priorytetowe: Produkty o wysokiej wartości są sprawdzane najpierw i częściej. Pozycje o niskim priorytecie wypełniają pozostałą pojemność.
• Adaptacyjny harmonogram: Jeżeli cena produktu nie zmieniła się w ciągu 7 dni, należy automatycznie zmniejszyć częstotliwość kontroli. Jeśli dziś zmieniła się dwukrotnie, zwiększ częstotliwość.
• Ograniczenie stawki na miejsce: Uszanuj limit stawek każdego celu. Amazon, Walmart i sklepy niszowe mają różne tolerancje.

Aby uzyskać więcej informacji na temat operacji scaling, sprawdź nasz przewodnik na najlepsze proxy do skrobania stron internetowych w 2026 i odkrywać Plany cenowe ProxyHat do monitorowania dużych ilości.

Key Takeaways

• Automatyczne monitorowanie cen wymaga solidnej architektury: menedżer URL, silnik scrating, magazyn danych i system ostrzegania.
• Proxy mieszkaniowe z rotacją przedostatnią są niezbędne do stałego monitorowania bez bloków.
• Kontrole harmonogramowe oparte na priorytetach - nie wszystkie produkty wymagają cogodzinowego monitorowania.
• Przechowuj historię cen w schemacie przyjaznym dla czasu do analizy trendów.
• Skonfiguruj szeregowe progi alarmowe w celu zrównoważenia reakcji z redukcją hałasu.
• Rozprowadzanie wniosków równomiernie w czasie dla zrównoważonego, niskoprofilowego wzoru scrating.

Gotowy do budowy systemu monitorowania cen? Zacznij od ProxyHat 's residential proxy i przeczytać nasz Przewodnik po e-handlu dla pełnej strategii. Szczegółowe informacje na temat wdrażania technicznego można znaleźć w przewodnikach przy użyciu proxy w Python oraz przy użyciu proxy w Node.js.