PlaybookMarkUDown
MarkUDownPythonE-commerceWebhooksIntermediário

Monitor de preços de concorrentesem tempo real

Dois endpoints do MarkUDown, sem scheduler local, sem browser para gerenciar. /api/monitor cria assinaturas persistentes que disparam um webhook quando o conteúdo muda. /api/extract extrai o preço como número tipado via LLM — independente do formato da página.

30 de abril de 202615 min de leituraPor Scrape Technology

O cenário

Preço é a variável mais sensível do e-commerce. Uma diferença de 5% já move o cliente para o concorrente. Uma promoção relâmpago numa sexta à noite pode vazar a demanda do fim de semana inteiro antes que você perceba o que está acontecendo.

O problema não é falta de dado. O preço está lá — público, visível, no site do concorrente. O problema é velocidade. Você não consegue monitorar dezenas de produtos em múltiplos concorrentes de forma contínua sem uma equipe dedicada ou uma ferramenta cara de SaaS.

A dor

A abordagem clássica:

  • Alguém abre uma planilha toda segunda-feira de manhã
  • Entra manualmente em cada site concorrente
  • Anota os preços, compara, atualiza a tabela
  • Duas horas de trabalho repetitivo — cego nos outros seis dias

Os concorrentes não esperam segunda-feira. Eles mudam preço numa quinta à tarde, num sábado de manhã. Nessas janelas, você está exposto. Toda venda perdida é invisível — você não sabe o que não viu.

A solução

Dois endpoints. Nenhum browser para configurar. Nenhum scheduler local.

/api/monitor — assinaturas persistentes

Registre uma vez cada URL de concorrente. O MarkUDown verifica aquela página no intervalo que você configurou e dispara um webhook para o seu servidor quando detecta que o conteúdo mudou. Sem cron job. Sem servidor em background.

/api/extract — preço como número tipado

Quando o monitor detecta mudança, você chama /api/extract para obter os campos estruturados. LLM normaliza qualquer formato — "R$ 699,90", "699.90", "6x de 116,65 sem juros" — e devolve current_price como float, pronto para comparação.

Abrasio incluso — sem configuração

O Abrasio — nosso browser antidetecção com Chromium e fingerprint humano — é a terceira camada interna do MarkUDown. Se as camadas mais rápidas forem bloqueadas pelo site do concorrente, o MarkUDown escala automaticamente. Você não configura nada.

Como funciona

register.py → POST /api/monitor para cada URL (rode uma vez)

↓

MarkUDown → verifica cada URL no intervalo configurado

↓ (quando detecta mudança)

POST /webhook → seu servidor recebe a notificação

↓

webhook.py → POST /api/extract para extrair o preço

↓

Comparação → detecta queda acima do threshold

↓

Slack → alerta com produto, concorrente e preços

Tutorial

Você vai precisar de uma API key do MarkUDown e um servidor com URL pública para o webhook.

1

Crie sua conta e obtenha a API key

Acesse o dashboard do MarkUDown, crie uma conta gratuita e copie sua API key. Ela vai como header X-API-KEY em todas as chamadas.

2

Instale as dependências

terminal
pip install requests python-dotenv fastapi uvicorn

Configure o .env:

.env
# .env
MARKUDOWN_API_KEY=sua_chave_aqui
WEBHOOK_URL=https://seu-servidor.com/webhook
SLACK_WEBHOOK_URL=https://hooks.slack.com/services/XXX/YYY/ZZZ
PRICE_DROP_THRESHOLD=0.05
INTERVAL_MINUTES=60

Webhook URL pública

O WEBHOOK_URL precisa ser acessível pela internet — é para lá que o MarkUDown vai enviar as notificações de mudança. Em desenvolvimento, use ngrok http 8090 para expor seu servidor local.
3

Configure os produtos

O products.json define quais produtos monitorar e as URLs de cada concorrente. Você pode ter quantos produtos e concorrentes quiser.

products.json
[
  {
    "id": "nike-air-max-270",
    "name": "Nike Air Max 270",
    "our_price": 699.90,
    "competitors": [
      {
        "store": "Concorrente A",
        "url": "https://concorrente-a.com.br/nike-air-max-270"
      },
      {
        "store": "Concorrente B",
        "url": "https://concorrente-b.com.br/tenis/nike-air-max-270"
      }
    ]
  },
  {
    "id": "adidas-ultraboost-22",
    "name": "Adidas Ultraboost 22",
    "our_price": 849.90,
    "competitors": [
      {
        "store": "Concorrente A",
        "url": "https://concorrente-a.com.br/adidas-ultraboost-22"
      }
    ]
  }
]
4

Defina o schema de extração

O schema informa ao /api/extract quais campos extrair e com qual tipo. O LLM normaliza qualquer formato de preço e devolve os valores já tipados — sem regex, sem parser manual.

schema
PRICE_SCHEMA = [
    {"name": "product_name",        "type": "String", "active": True},
    {"name": "current_price",       "type": "Number", "active": True},
    {"name": "original_price",      "type": "Number", "active": True},
    {"name": "discount_percentage", "type": "Number", "active": True},
    {"name": "availability",        "type": "String", "active": True},
]
5

Registre os monitors (rode uma vez)

O register.py chama POST /api/monitor para cada URL de concorrente e salva os subscription_id no subscriptions.json. Você executa isso uma vez — o MarkUDown cuida do agendamento daí em diante.

register.py
"""
register.py — Registra um monitor por URL de concorrente via /api/monitor.
Execute uma vez. O MarkUDown cuida do agendamento — sem scheduler local.
"""
import json
import os
import requests
from pathlib import Path
from dotenv import load_dotenv

load_dotenv()

MARKUDOWN_URL = "https://api.scrapetechnology.com"
API_KEY = os.getenv("MARKUDOWN_API_KEY")
WEBHOOK_URL = os.getenv("WEBHOOK_URL")
INTERVAL_MINUTES = int(os.getenv("INTERVAL_MINUTES", "60"))

PRODUCTS_FILE = Path("products.json")
SUBSCRIPTIONS_FILE = Path("subscriptions.json")


def register_monitors():
    products = json.loads(PRODUCTS_FILE.read_text(encoding="utf-8"))
    subscriptions = {}

    for product in products:
        for competitor in product["competitors"]:
            url = competitor["url"]
            store = competitor["store"]

            print(f"Registrando monitor: {store} — {url}")

            resp = requests.post(
                f"{MARKUDOWN_URL}/api/monitor",
                headers={"X-API-KEY": API_KEY},
                json={
                    "url": url,
                    "callback_url": WEBHOOK_URL,
                    "interval_minutes": INTERVAL_MINUTES,
                    "main_content": True,
                },
                timeout=30,
            )
            resp.raise_for_status()
            data = resp.json()
            sub_id = data["subscription_id"]

            subscriptions[sub_id] = {
                "product_id": product["id"],
                "product_name": product["name"],
                "our_price": product["our_price"],
                "store": store,
                "url": url,
            }
            print(f"  OK — subscription_id: {sub_id}")

    SUBSCRIPTIONS_FILE.write_text(
        json.dumps(subscriptions, ensure_ascii=False, indent=2), encoding="utf-8"
    )
    print(f"\n{len(subscriptions)} monitors registrados em subscriptions.json")


if __name__ == "__main__":
    register_monitors()

Sem scheduler local

Após rodar o register.py, você não precisa manter nenhum processo em background para os checks de monitoramento. O MarkUDown verifica as URLs no intervalo configurado e chama o seu webhook quando algo muda.
6

Servidor de webhook

O webhook.py é um servidor FastAPI que recebe as notificações do MarkUDown. Quando o payload tem changed: true, ele chama o /api/extract para obter o preço atual, compara com o histórico e envia o alerta no Slack se a queda for maior que o threshold configurado.

webhook.py
"""
webhook.py — Recebe notificações do MarkUDown e alerta quando preço cai.
Execute: uvicorn webhook:app --host 0.0.0.0 --port 8090
"""
import json
import os
import time
from datetime import datetime
from pathlib import Path

import requests
from fastapi import FastAPI, Request
from dotenv import load_dotenv

load_dotenv()

MARKUDOWN_URL = "https://api.scrapetechnology.com"
API_KEY = os.getenv("MARKUDOWN_API_KEY")
SLACK_WEBHOOK_URL = os.getenv("SLACK_WEBHOOK_URL")
PRICE_DROP_THRESHOLD = float(os.getenv("PRICE_DROP_THRESHOLD", "0.05"))

SUBSCRIPTIONS_FILE = Path("subscriptions.json")
PRICES_DB_FILE = Path("prices_db.json")

PRICE_SCHEMA = [
    {"name": "product_name",        "type": "String", "active": True},
    {"name": "current_price",       "type": "Number", "active": True},
    {"name": "original_price",      "type": "Number", "active": True},
    {"name": "discount_percentage", "type": "Number", "active": True},
    {"name": "availability",        "type": "String", "active": True},
]

app = FastAPI()


def load_json(path: Path) -> dict:
    return json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}


def save_json(path: Path, data: dict) -> None:
    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")


def extract_price(url: str) -> dict | None:
    """Chama /api/extract e aguarda o job completar."""
    resp = requests.post(
        f"{MARKUDOWN_URL}/api/extract",
        headers={"X-API-KEY": API_KEY},
        json={
            "url": url,
            "extract_query": "nome do produto, preco atual, preco original, desconto e disponibilidade",
            "schema": PRICE_SCHEMA,
            "extraction_scope": "single_page",
        },
        timeout=30,
    )
    resp.raise_for_status()
    job_id = resp.json()["job_id"]

    for _ in range(40):
        time.sleep(3)
        result = requests.get(
            f"{MARKUDOWN_URL}/api/extract/{job_id}",
            headers={"X-API-KEY": API_KEY},
            timeout=10,
        ).json()
        if result.get("status") == "completed":
            items = result.get("items", [])
            if items:
                data = items[0].get("extracted_data", [{}])
                return data[0] if data else None
    return None


def send_slack_alert(meta: dict, current_price: float, previous_price: float) -> None:
    if not SLACK_WEBHOOK_URL:
        return
    drop_pct = round((previous_price - current_price) / previous_price * 100, 1)
    our_price = meta["our_price"]
    gap_pct = round((our_price - current_price) / our_price * 100, 1)
    lines = [
        ":rotating_light: *Queda de preco detectada!*",
        f"*Produto:* {meta['product_name']}",
        f"*Concorrente:* {meta['store']}",
        f"*Preco anterior:* R$ {previous_price:.2f}",
        f"*Novo preco:* R$ {current_price:.2f} ({drop_pct}% de queda)",
        f"*Nosso preco:* R$ {our_price:.2f} ({abs(gap_pct)}% {'acima' if gap_pct > 0 else 'abaixo'})",
        f"*Link:* {meta['url']}",
    ]
    requests.post(SLACK_WEBHOOK_URL, json={"text": "\n".join(lines)}, timeout=10)


@app.post("/webhook")
async def handle_monitor_event(request: Request):
    payload = await request.json()

    if not payload.get("changed"):
        return {"ok": True}

    subscription_id = payload.get("subscription_id")
    url = payload.get("url")

    subscriptions = load_json(SUBSCRIPTIONS_FILE)
    meta = subscriptions.get(subscription_id)
    if not meta:
        return {"ok": True}

    print(f"Mudanca detectada: {meta['store']} — {url}")

    extracted = extract_price(url)
    if not extracted:
        return {"ok": True}

    current_price = extracted.get("current_price")
    if not current_price:
        return {"ok": True}

    print(f"  Preco atual: R$ {current_price:.2f}")

    db = load_json(PRICES_DB_FILE)
    key = f"{meta['product_id']}::{meta['store']}"
    previous_price = db.get(key, {}).get("current_price")

    if previous_price and previous_price > 0:
        change_ratio = (previous_price - current_price) / previous_price
        if change_ratio >= PRICE_DROP_THRESHOLD:
            print(f"  ALERTA: R$ {previous_price:.2f} -> R$ {current_price:.2f}")
            send_slack_alert(meta, current_price, previous_price)

    db[key] = {
        **extracted,
        "url": url,
        "store": meta["store"],
        "product_id": meta["product_id"],
        "checked_at": datetime.now().isoformat(),
    }
    save_json(PRICES_DB_FILE, db)
    return {"ok": True}
7

Execute

terminal
# 1. Instalar dependências
pip install -r requirements.txt

# 2. Registrar os monitors (rode uma vez)
python register.py

# 3. Subir o servidor de webhook
uvicorn webhook:app --host 0.0.0.0 --port 8090

Pronto

O MarkUDown começa a verificar as URLs no intervalo configurado. Quando detecta mudança, chama o /webhook. O servidor extrai o preço e alerta.

Alternativa: polling com /api/extract

Se você não tiver um servidor com URL pública para receber webhooks, use o /api/extract diretamente em modo polling — um agendador local que verifica cada URL a cada hora. Menos eficiente (extrai mesmo quando nada mudou), mas funciona sem infraestrutura adicional.

poll_monitor.py
"""
poll_monitor.py — Alternativa sem webhook: polling com /api/extract.
Útil quando você não tem um servidor com URL pública.
Execute: python poll_monitor.py --once  (teste)
         python poll_monitor.py          (roda a cada hora)
"""
import json, os, time, sys, requests
from datetime import datetime
from pathlib import Path
from dotenv import load_dotenv

load_dotenv()

MARKUDOWN_URL = "https://api.scrapetechnology.com"
API_KEY = os.getenv("MARKUDOWN_API_KEY")
SLACK_WEBHOOK_URL = os.getenv("SLACK_WEBHOOK_URL")
PRICE_DROP_THRESHOLD = float(os.getenv("PRICE_DROP_THRESHOLD", "0.05"))

PRODUCTS_FILE = Path("products.json")
PRICES_DB_FILE = Path("prices_db.json")

PRICE_SCHEMA = [
    {"name": "product_name",        "type": "String", "active": True},
    {"name": "current_price",       "type": "Number", "active": True},
    {"name": "original_price",      "type": "Number", "active": True},
    {"name": "discount_percentage", "type": "Number", "active": True},
    {"name": "availability",        "type": "String", "active": True},
]

def load_json(path):
    return json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}

def save_json(path, data):
    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")

def extract_price(url):
    resp = requests.post(
        f"{MARKUDOWN_URL}/api/extract",
        headers={"X-API-KEY": API_KEY},
        json={
            "url": url,
            "extract_query": "nome do produto, preco atual, preco original, desconto e disponibilidade",
            "schema": PRICE_SCHEMA,
            "extraction_scope": "single_page",
        },
        timeout=30,
    )
    resp.raise_for_status()
    job_id = resp.json()["job_id"]
    for _ in range(40):
        time.sleep(3)
        result = requests.get(
            f"{MARKUDOWN_URL}/api/extract/{job_id}",
            headers={"X-API-KEY": API_KEY},
        ).json()
        if result.get("status") == "completed":
            items = result.get("items", [])
            if items:
                data = items[0].get("extracted_data", [{}])
                return data[0] if data else None
    return None

def run():
    print(f"Monitor: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    products = load_json(PRODUCTS_FILE)
    db = load_json(PRICES_DB_FILE)
    for product in products:
        print(f"Verificando: {product['name']}")
        for comp in product["competitors"]:
            print(f"  {comp['store']}...", end=" ", flush=True)
            extracted = extract_price(comp["url"])
            if not extracted:
                print("falhou")
                continue
            current = extracted.get("current_price")
            if not current:
                print("sem preco")
                continue
            print(f"R$ {current:.2f}")
            key = f"{product['id']}::{comp['store']}"
            previous = db.get(key, {}).get("current_price")
            if previous and (previous - current) / previous >= PRICE_DROP_THRESHOLD:
                print(f"  ALERTA: {previous:.2f} -> {current:.2f}")
            db[key] = {**extracted, "url": comp["url"], "store": comp["store"],
                       "checked_at": datetime.now().isoformat()}
    save_json(PRICES_DB_FILE, db)
    print("Ciclo concluido.")

if __name__ == "__main__":
    if "--once" in sys.argv:
        run()
    else:
        from apscheduler.schedulers.blocking import BlockingScheduler
        s = BlockingScheduler()
        s.add_job(run, "interval", hours=1, next_run_time=datetime.now())
        print("Monitor ativo. Ctrl+C para parar.")
        try:
            s.start()
        except KeyboardInterrupt:
            pass

O alerta no Slack

Quando uma queda acima do threshold é detectada, chega uma mensagem assim:

Slack — #monitoramento-precos

🚨 Queda de preço detectada!

Produto: Nike Air Max 270

Concorrente: Concorrente A

Preço anterior: R$ 749,90

Novo preço: R$ 599,90 (20,0% de queda)

Nosso preço: R$ 699,90 (14,3% acima)

Link: concorrente-a.com.br/...

Próximos passos

Histórico completo

Troque prices_db.json por PostgreSQL para guardar todo o histórico e plotar gráficos de variação de preço ao longo do tempo.

Dashboard ao vivo

Página Next.js com tabela de comparação de preços por produto e concorrente, consumindo diretamente o banco.

Monitoramento de categoria

Use /api/map para descobrir todos os produtos de uma categoria do concorrente e registre monitors para cada URL automaticamente.

Cancelar monitors inativos

Chame DELETE /api/monitor/{subscription_id} para cancelar assinaturas de produtos descontinuados sem deixar lixo no servidor.

Comece agora com o MarkUDown

Crie sua conta gratuita, configure os produtos e o monitor está ativo em menos de 30 minutos.