Monitor de precios de competidoresen tiempo real
Dos endpoints de MarkUDown, sin scheduler local, sin navegador que gestionar. /api/monitor crea suscripciones persistentes que disparan un webhook cuando el contenido cambia. /api/extract extrae el precio como número tipado via LLM — independiente del formato de la página.
El escenario
El precio es la variable más sensible del e-commerce. Una diferencia del 5% ya mueve al cliente hacia el competidor. Una promoción relámpago un viernes por la noche puede drenar la demanda del fin de semana antes de que te des cuenta de lo que está pasando.
El problema no es la falta de datos. El precio está ahí — público, visible, en el sitio del competidor. El problema es la velocidad. No puedes monitorear docenas de productos en múltiples competidores de forma continua sin un equipo dedicado o una herramienta cara de SaaS.
El dolor
El enfoque clásico:
- Alguien abre una hoja de cálculo cada lunes por la mañana
- Entra manualmente en cada sitio de competidores
- Anota los precios, compara, actualiza la tabla
- Dos horas de trabajo repetitivo — ciego los otros seis días
Los competidores no esperan el lunes. Cambian precios un jueves por la tarde, un sábado por la mañana. En esas ventanas, estás expuesto. Cada venta perdida es invisible — no sabes lo que no viste.
La solución
Dos endpoints. Sin navegador que configurar. Sin scheduler local.
/api/monitor — suscripciones persistentes
Registra cada URL de competidor una vez. MarkUDown verifica esa página en el intervalo que configuraste y dispara un webhook a tu servidor cuando detecta un cambio de contenido. Sin cron job. Sin servidor en background.
/api/extract — precio como número tipado
Cuando el monitor detecta un cambio, llamas a /api/extract para obtener los campos estructurados. LLM normaliza cualquier formato — "R$ 699,90", "699.90", "6x de 116,65" — y devuelve current_price como float, listo para comparar.
Abrasio incluido — sin configuración
Abrasio — nuestro navegador antidetección con Chromium y fingerprint humano — es la tercera capa interna de MarkUDown. Si las capas más rápidas son bloqueadas por el sitio del competidor, MarkUDown escala automáticamente. No configuras nada.
Cómo 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
Necesitarás una API key de MarkUDown y un servidor con URL pública para el webhook.
Crea tu cuenta y obtén la API key
Accede al dashboard de MarkUDown, crea una cuenta gratuita y copia tu API key. Va como header X-API-KEY en todas las llamadas.
Instala las dependencias
pip install requests python-dotenv fastapi uvicornConfigura el .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=60URL de webhook pública
Configura los productos
products.json define qué productos monitorear y las URLs de cada competidor. Puedes tener tantos productos y competidores como quieras.
[
{
"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"
}
]
}
]Define el schema de extracción
El schema informa a /api/extract qué campos extraer y con qué tipo. El LLM normaliza cualquier formato de precio y devuelve los valores ya tipados — sin regex, sin 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},
]Registra los monitors (ejecuta una vez)
register.py llama a POST /api/monitor para cada URL de competidor y guarda los subscription_id en subscriptions.json. Lo ejecutas una vez — MarkUDown se encarga del scheduling a partir de ahí.
"""
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()Sin scheduler local
Servidor de webhook
webhook.py es un servidor FastAPI que recibe las notificaciones de MarkUDown. Cuando el payload tiene changed: true, llama a /api/extract para obtener el precio actual, compara con el historial y envía la alerta en Slack si la caída supera el 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}Ejecútalo
# 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 8090Listo
Alternativa: polling con /api/extract
Si no tienes un servidor con URL pública para recibir webhooks, usa /api/extract directamente en modo polling — un scheduler local que verifica cada URL cada hora. Menos eficiente (extrae incluso cuando nada cambió), pero funciona sin infraestructura 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:
passLa alerta en Slack
Cuando se detecta una caída sobre el threshold, llega este mensaje:
🚨 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 pasos
Historial completo
Reemplaza prices_db.json con PostgreSQL para guardar todo el historial y graficar la variación de precios en el tiempo.
Dashboard en vivo
Página Next.js con tabla de comparación de precios por producto y competidor, consumiendo directamente de la base de datos.
Monitoreo de categoría
Usa /api/map para descubrir todos los productos de una categoría del competidor y registra monitors para cada URL automáticamente.
Cancelar monitors inactivos
Llama a DELETE /api/monitor/{subscription_id} para cancelar suscripciones de productos descontinuados sin dejar basura en el servidor.
Comienza ahora con MarkUDown
Crea tu cuenta gratuita, configura los productos y el monitor está activo en menos de 30 minutos.