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.
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.
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.
Instale as dependências
pip install requests python-dotenv fastapi uvicornConfigure o .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=60Webhook URL pública
Configure os produtos
O products.json define quais produtos monitorar e as URLs de cada concorrente. Você pode ter quantos produtos e concorrentes quiser.
[
{
"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"
}
]
}
]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.
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},
]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 — 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
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 — 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}Execute
# 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 8090Pronto
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 — 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:
passO alerta no Slack
Quando uma queda acima do threshold é detectada, chega uma mensagem assim:
🚨 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.