Como Monitorar Precos de Concorrentes Automaticamente com Proxies

Por Que Importa Monitoramento Automático de Preços

Nos mercados competitivos de comércio electrónico, os preços mudam constantemente. Um concorrente pode baixar seu preço em 5% às 2 AM, e quando você percebe, você já perdeu um dia de vendas. Monitoramento automático de preços elimina este ponto cego acompanhando continuamente os preços dos concorrentes e alertando-o para mudanças em tempo real.

Se você é um varejista ajustando os preços para se manter competitivo, um monitoramento da marca conformidade MAP (Mínimo Preço Anunciado), ou um analista rastreando as tendências do mercado, um sistema de monitoramento de preços bem construído se paga rapidamente. O ingrediente chave que faz tudo funcionar de forma confiável é uma infraestrutura proxy robusta — sem ela, suas solicitações de monitoramento ficam bloqueadas em horas. Para uma análise mais ampla da coleta de dados do comércio eletrônico, consulte Guia de raspagem de dados do comércio electrónico.

Arquitetura de um sistema de monitoramento de preços

Um sistema de monitoramento de preços de nível de produção tem quatro componentes principais: um gerenciador de URL, um motor de raspagem, uma loja de dados e uma camada de alerta.

Estratégia de Agendamento

Nem todos os produtos precisam da mesma frequência de monitoramento. Itens de alta prioridade (seus 100 melhores SKUs, produtos concorrentes diretos) podem precisar de verificações horárias, enquanto itens de cauda longa podem ser verificados diariamente. Priorizar com base em:

• Volatilidade dos preços: Produtos que mudam de preços frequentemente precisam de verificações mais frequentes.
• Impacto das receitas: Seus best-sellers merecem maior prioridade de monitoramento.
• Densidade competitiva: Categorias com muitos concorrentes precisam de monitoramento mais apertado.

Configurar a Rotação do Proxy para Monitoramento

Monitoramento de preços significa bater as mesmas URLs repetidamente ao longo de dias, semanas e meses. Este padrão é exatamente o que sistemas anti-bots são projetados para detectar. Proxies residenciais com rotação automática são essenciais.

Configuração do 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

Para monitoramento de preços, a rotação por pedido funciona melhor porque cada verificação de preços é uma operação independente. Utilização proxies geo-alvo no acompanhamento das diferenças regionais de preços.

Implementação em Python

Aqui está um sistema completo de monitoramento de preços construído com Python, usando O SDK Python do ProxyHatName.

Módulo do raspador de preço

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

Monitoramento do Escalonador

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

Implementação Node.js

Para equipes usando Node.js, aqui está uma configuração de monitoramento equivalente usando O Nó do 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
);

Armazenamento e Análise de Dados

Dados de preço brutos se tornam valiosos quando você pode analisar tendências ao longo do tempo.

Esquema da Base de Dados

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

Tendências de preços

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

Alertas e notificações

Alertas automatizados garantem que você reage às mudanças de preços rapidamente. Os canais comuns de notificação incluem:

• Webhooks: Ideal para visibilidade em toda a equipe. Envie mensagens estruturadas com detalhes de mudança de preço.
• Digestões por e- mail: Resumos diários ou horários de todas as variações de preços acima do seu limiar.
• Chamadas para o Webhook: Ative o seu motor de repricing ou outra automação quando os preços mudarem.
• Painel: Visualização em tempo real das tendências de preços em todos os produtos monitorados.

Alertar Limiares

Configurar diferentes limiares de alerta para diferentes cenários:

Melhores práticas de monitoramento

Monitoramento contínuo cria desafios únicos para o gerenciamento de proxy em comparação com raspagem única.

• Distribuir pedidos ao longo do tempo: Em vez de verificar todos os 10.000 produtos à meia-noite, espalhe os controlos em todo o intervalo. Isso cria um padrão de solicitação estável e de baixo perfil.
• Usar proxies residenciais: Proxies residenciais são essenciais para o monitoramento de longo prazo porque os mesmos IPs datacenters que atingem os mesmos sites diariamente serão banidos.
• Coincidir com a localização geográfica: Ao monitorar os preços regionais, use proxies da região alvo. Um IP dos EUA que verifica os preços alemães verá os dados errados ou será redirecionado.
• Lidar com falhas graciosamente: Se um pedido falhar, aguarde e tente novamente com backoff exponencial em vez de re-requesting imediatamente. Monitore sua taxa de sucesso e reduza a concorrência se cair.
• Cache e desduplicar: Se um preço não tiver mudado, não guarde um registro duplicado. Isto mantém a sua base de dados magra e torna a análise mais rápida.

Key takeaway: Monitoramento de preços é uma maratona, não um sprint. Projete seu sistema para padrões de solicitação estáveis e sustentáveis, em vez de raspar a explosão.

Escalar seu sistema de monitoramento

À medida que seu catálogo de produtos cresce, a escala se torna crítica. Aqui estão os padrões que funcionam:

• Grupo de trabalhadores: Use vários trabalhadores puxando de uma fila de trabalho (Redis, RabbitMQ). Cada trabalhador tem suas próprias conexões proxy e opera de forma independente.
• Filas de prioridade: Produtos de alto valor são verificados primeiro e mais frequentemente. Itens de baixa prioridade preenchem a capacidade remanescente.
• Programação adaptativa: Se o preço de um produto não tiver mudado em 7 dias, reduza automaticamente a frequência de verificação. Se mudou duas vezes hoje, aumente a frequência.
• Limite de taxa por local: Respeite os limites de taxa de cada local alvo. Amazon, Walmart e nichos de lojas têm tolerâncias diferentes.

Para mais informações sobre operações de raspagem de escala, consulte nosso guia melhores proxies para raspagem web em 2026 e explorar Planos de preços da ProxyHat para monitorização de alto volume.

Tiras de Chaves

• O monitoramento automatizado de preços requer uma arquitetura robusta: gerenciador de URLs, motor de raspagem, armazenamento de dados e sistema de alerta.
• Proxies residenciais com rotação por solicitação são essenciais para monitorização sustentada sem bloqueios.
• Controlos de calendário baseados na prioridade — nem todos os produtos necessitam de monitorização horária.
• Armazene o histórico de preços em um esquema de tempo-série-friendly para análise de tendências.
• Configure os limiares de alerta em camadas para equilibrar a resposta com redução de ruído.
• Distribua pedidos uniformemente ao longo do tempo para um padrão de raspagem sustentável e de baixo perfil.

Pronto para construir seu sistema de monitoramento de preços? Iniciar com Proxies residenciais do ProxyHat e ler o nosso Guia de raspagem do comércio electrónico para a estratégia completa. Para detalhes técnicos de implementação, consulte nossos guias usando proxies em Python e usando proxies em Node.js.