PlaybookMarkUDown
MarkUDownPythonE-commerceWebhooksIntermedio

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.

30 de abril de 202615 min de lecturaPor Scrape Technology

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.

1

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.

2

Instala las dependencias

terminal
pip install requests python-dotenv fastapi uvicorn

Configura el .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

URL de webhook pública

El WEBHOOK_URL necesita ser accesible desde internet — es donde MarkUDown enviará las notificaciones de cambio. En desarrollo, usa ngrok http 8090 para exponer tu servidor local.
3

Configura los productos

products.json define qué productos monitorear y las URLs de cada competidor. Puedes tener tantos productos y competidores como quieras.

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

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.

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

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

Después de ejecutar register.py, no necesitas mantener ningún proceso en background para los checks de monitoreo. MarkUDown verifica las URLs en el intervalo configurado y llama a tu webhook cuando algo cambia.
6

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

Ejecútalo

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

Listo

MarkUDown comienza a verificar las URLs en el intervalo configurado. Cuando detecta un cambio, llama al /webhook. El servidor extrae el precio y alerta.

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

La alerta en Slack

Cuando se detecta una caída sobre el threshold, llega este mensaje:

Slack — #monitoreo-precios

🚨 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.