Как автоматически мониторить цены конкурентов с помощью прокси

Почему автоматический мониторинг цен так важен

На конкурентных рынках e-commerce цены меняются постоянно. Конкурент может снизить цену на 5% в 2 часа ночи, и к тому моменту, как вы это заметите, вы уже потеряете целый день продаж. Автоматический мониторинг цен устраняет эту слепую зону, непрерывно отслеживая цены конкурентов и оповещая об изменениях в реальном времени.

Будь вы ритейлером, корректирующим цены для сохранения конкурентоспособности, брендом, контролирующим соблюдение минимальных рекламируемых цен (MAP), или аналитиком, отслеживающим рыночные тенденции, хорошо построенная система мониторинга цен быстро окупается. Ключевой компонент, обеспечивающий надёжную работу — это надёжная прокси-инфраструктура: без неё ваши мониторинговые запросы будут заблокированы в течение нескольких часов. Для более широкого обзора сбора данных в e-commerce смотрите наше руководство по скрапингу e-commerce данных.

Архитектура системы мониторинга цен

Система мониторинга цен производственного уровня состоит из четырёх основных компонентов: менеджер URL, движок скрапинга, хранилище данных и система оповещений.

Компонент	Ответственность	Технологии
Менеджер URL	Хранит целевые URL, метаданные расписания и частоту проверок	PostgreSQL, Redis
Движок скрапинга	Получает страницы через прокси, извлекает цены	Python/Node.js, ProxyHat, BeautifulSoup/Cheerio
Хранилище данных	Хранит историю цен с временными метками	PostgreSQL, TimescaleDB, ClickHouse
Система оповещений	Обнаруживает изменения, отправляет уведомления	Webhooks, Slack, Email, SMS

Стратегия расписания

Не все товары требуют одинаковой частоты мониторинга. Высокоприоритетные позиции (ваши топ-100 SKU, товары прямых конкурентов) могут требовать ежечасных проверок, тогда как товары из длинного хвоста можно проверять раз в день. Приоритизируйте на основе:

• Волатильность цен: товары с частыми изменениями цен требуют более частых проверок.
• Влияние на выручку: ваши бестселлеры заслуживают более высокого приоритета мониторинга.
• Конкурентная плотность: категории с большим количеством конкурентов требуют более плотного мониторинга.

Настройка ротации прокси для мониторинга

Мониторинг цен означает многократные обращения к одним и тем же URL на протяжении дней, недель и месяцев. Именно этот паттерн антибот-системы предназначены обнаруживать. Резидентные прокси с автоматической ротацией необходимы.

Конфигурация ProxyHat

# Стандартный ротирующий прокси (новый IP при каждом запросе)
http://USERNAME:PASSWORD@gate.proxyhat.com:8080
# Геотаргетинг для региональных цен (например, цены в США)
http://USERNAME-country-US:PASSWORD@gate.proxyhat.com:8080
# На основе сессий для многостраничных проверок цен
http://USERNAME-session-price001:PASSWORD@gate.proxyhat.com:8080

Для мониторинга цен лучше всего работает ротация при каждом запросе, поскольку каждая проверка цены — независимая операция. Используйте геотаргетированные прокси при мониторинге региональных различий в ценах.

Реализация на Python

Вот полная система мониторинга цен на Python с использованием Python SDK от ProxyHat.

Модуль скрапинга цен

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

Планировщик мониторинга

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."""
        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:
                self.send_alert(url, prev.price, curr.price, change_pct)
        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)
# Использование
if __name__ == "__main__":
    monitor = PriceMonitor(db_connection=None)
    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,
    )
    monitor.run()

Реализация на Node.js

Для команд, использующих Node.js, вот эквивалентная настройка мониторинга с Node SDK от ProxyHat.

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"})`);
    });
  }
}
// Использование
const monitor = new PriceMonitor();
monitor.addProduct(
  "https://www.amazon.com/dp/B0CHX3QBCH",
  { price: "span.a-price-whole", stock: "#availability span", currency: "USD" },
  "0 * * * *"
);
monitor.addProduct(
  "https://www.amazon.com/dp/B0D5BKRY4R",
  { price: "span.a-price-whole", stock: "#availability span", currency: "USD" },
  "*/30 * * * *"
);

Хранение и анализ данных

Сырые данные о ценах становятся ценными, когда вы можете анализировать тренды во времени.

Схема базы данных

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

Запросы для анализа трендов цен

-- Средняя дневная цена за последние 30 дней
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;
-- Товары со снижением цены > 10% за последние 24 часа
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;

Оповещения и уведомления

Автоматические оповещения обеспечивают быструю реакцию на изменения цен. Распространённые каналы уведомлений:

• Вебхуки Slack: идеально подходят для видимости всей команде. Отправляйте структурированные сообщения с деталями об изменении цен.
• Email-дайджесты: ежедневные или ежечасные сводки всех изменений цен выше заданного порога.
• Callback-вебхуки: запускайте ваш движок репрайсинга или другую автоматизацию при изменении цен.
• Дашборд: визуализация трендов цен в реальном времени по всем отслеживаемым товарам.

Пороги оповещений

Настройте разные пороги оповещений для различных сценариев:

Сценарий	Порог	Действие
Снижение цены конкурента > 5%	5%	Уведомление в Slack
Снижение цены конкурента > 15%	15%	Email команде ценообразования + авторепрайсинг
Товар закончился на складе	Смена статуса наличия	Оповещение о возможности
Цена ниже MAP	Ниже значения MAP	Оповещение о нарушении

Лучшие практики использования прокси для мониторинга

Непрерывный мониторинг создаёт уникальные задачи для управления прокси по сравнению с разовым скрапингом.

• Распределяйте запросы во времени: вместо проверки всех 10 000 товаров в полночь, распределите проверки на весь интервал. Это создаёт устойчивый, малозаметный паттерн запросов.
• Используйте резидентные прокси: резидентные прокси необходимы для длительного мониторинга, потому что одни и те же серверные IP, обращающиеся к одним и тем же сайтам ежедневно, будут заблокированы.
• Соответствуйте геолокации: при мониторинге региональных цен используйте прокси из целевого региона. Американский IP, проверяющий немецкие цены, увидит неправильные данные или будет перенаправлен.
• Обрабатывайте ошибки корректно: если запрос не удался, подождите и повторите с экспоненциальной задержкой, а не повторяйте немедленно. Мониторьте процент успешных запросов и снижайте параллельность при его падении.
• Кешируйте и дедуплицируйте: если цена не изменилась, не сохраняйте дубликат записи. Это поддерживает базу данных компактной и ускоряет анализ.

Ключевой вывод: мониторинг цен — это марафон, а не спринт. Проектируйте систему для устойчивых, стабильных паттернов запросов, а не пиковых нагрузок.

Масштабирование системы мониторинга

По мере роста каталога товаров масштабирование становится критически важным. Вот паттерны, которые работают:

• Пул воркеров: используйте несколько воркеров, извлекающих задачи из очереди (Redis, RabbitMQ). Каждый воркер имеет собственные подключения к прокси и работает независимо.
• Приоритетные очереди: высокоценные товары проверяются первыми и чаще. Низкоприоритетные позиции заполняют оставшуюся ёмкость.
• Адаптивное расписание: если цена товара не менялась 7 дней, автоматически снижайте частоту проверок. Если менялась дважды сегодня — увеличивайте.
• Ограничение частоты по сайтам: соблюдайте лимиты частоты запросов каждого целевого сайта. Amazon, Walmart и нишевые магазины имеют разную толерантность.

Подробнее о масштабировании скрапинга читайте в нашем руководстве лучшие прокси для веб-скрапинга в 2026 году и ознакомьтесь с тарифными планами ProxyHat для мониторинга больших объёмов.

Ключевые выводы

• Автоматический мониторинг цен требует надёжной архитектуры: менеджер URL, движок скрапинга, хранилище данных и система оповещений.
• Резидентные прокси с ротацией при каждом запросе необходимы для устойчивого мониторинга без блокировок.
• Планируйте проверки на основе приоритета — не все товары требуют ежечасного мониторинга.
• Храните историю цен в схеме, оптимизированной для временных рядов, для анализа трендов.
• Настройте многоуровневые пороги оповещений для баланса между оперативностью и снижением шума.
• Распределяйте запросы равномерно во времени для устойчивого, малозаметного паттерна скрапинга.

Готовы построить систему мониторинга цен? Начните с резидентных прокси ProxyHat и прочитайте наше руководство по скрапингу e-commerce данных для полной стратегии. Для технических деталей реализации смотрите наши руководства по использованию прокси в Python и использованию прокси в Node.js.