# Monitorear precios de competidores

> URL: https://foura.ai/es/docs/how-to/monitor-competitor-prices
> Updated: 2026-11-05
> Index: https://foura.ai/llms.txt

Configura la monitorización automatizada de precios en sitios web de la competencia mediante la API de FourA.

## Qué vas a construir

Un script de Python que:
1. Obtiene páginas de productos a partir de una lista de URL de la competencia
2. Extrae los datos de precios del HTML
3. Registra los resultados en un archivo CSV
4. Se ejecuta de forma programada

## Requisitos previos

- Una clave de API de FourA ([consigue una aquí](https://foura.ai/dashboard))
- Python 3.8+
- Los paquetes `requests` y `beautifulsoup4`

```bash
pip install requests beautifulsoup4
```

## Paso 1: Define tus objetivos

Crea una lista de URL de productos para monitorear:

```python
targets = [
    {"name": "Competitor A - Widget", "url": "https://competitor-a.com/widget", "selector": ".price"},
    {"name": "Competitor B - Widget", "url": "https://competitor-b.com/products/widget", "selector": "[data-price]"},
    {"name": "Competitor C - Widget", "url": "https://competitor-c.com/item/123", "selector": ".product-price span"},
]
```

## Paso 2: Obtén páginas mediante FourA

```python
import requests
import time

SINGLE_URL = "https://eu.api.foura.ai/api/single/"
BROWSER_URL = "https://eu.api.foura.ai/api/browser/"
API_KEY = "YOUR_API_KEY"

HEADERS = {
    "X-API-Key": API_KEY,
    "Content-Type": "application/json"
}

# A wait doesn't clear these: they reset with the period (credits, traffic)
# or at midnight UTC (the daily Browser allowance).
STOP_LIMITS = {"plan_limit_credits", "plan_limit_bandwidth", "plan_limit_browser_daily"}

def fetch_page(url, use_browser=False, attempts=3):
    if use_browser:
        endpoint, field = BROWSER_URL, "body"
        payload = {"url": url, "timeout_ms": 15000}
    else:
        endpoint, field = SINGLE_URL, "data"
        payload = {"method": "GET", "url": url, "unblocker": True}
    for _ in range(attempts):
        resp = requests.post(endpoint, headers=HEADERS, json=payload)
        if resp.status_code != 429:
            return resp.json().get(field, "")
        limit = resp.headers.get("X-FourA-Limit")
        if limit in STOP_LIMITS:
            raise RuntimeError(f"Plan limit reached: {limit}")
        time.sleep(int(resp.headers.get("Retry-After", "5")))
    raise RuntimeError(f"Still rate limited after {attempts} attempts: {url}")
```

Un `429` con `plan_limit_credits`, `plan_limit_bandwidth` o `plan_limit_browser_daily` en `X-FourA-Limit` no se solucionará esperando unos segundos, por lo que la función se detiene en lugar de reintentar. Consulta [Rate Limits](https://foura.ai/docs/api/rate-limits) para conocer cada límite y cuándo se restablece.

## Paso 3: Extraer precios

```python
from bs4 import BeautifulSoup
import re

def extract_price(html, selector):
    soup = BeautifulSoup(html, "html.parser")
    element = soup.select_one(selector)
    if not element:
        return None
    # Extract numeric price from text like "$49.99" or "49,99 EUR"
    text = element.get_text(strip=True)
    match = re.search(r'\d[\d,.]*', text)
    if not match:
        return None
    number = match.group().rstrip(',.')
    # The last comma or dot is the decimal mark when exactly two digits follow it.
    whole, mark, cents = number.replace(',', '.').rpartition('.')
    if mark and len(cents) == 2:
        return float(whole.replace('.', '') + '.' + cents)
    return float(number.replace(',', '').replace('.', ''))
```

## Paso 4: Ejecuta y registra los resultados

```python
import csv
from datetime import datetime

def monitor_prices():
    timestamp = datetime.now().isoformat()
    results = []

    for target in targets:
        html = fetch_page(target["url"])
        price = extract_price(html, target["selector"])
        results.append({
            "timestamp": timestamp,
            "name": target["name"],
            "url": target["url"],
            "price": price
        })
        print(f"{target['name']}: {price}")
        time.sleep(1)  # Be polite

    # Append to CSV
    with open("prices.csv", "a", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["timestamp", "name", "url", "price"])
        if f.tell() == 0:
            writer.writeheader()
        writer.writerows(results)

if __name__ == "__main__":
    monitor_prices()
```

## Paso 5: Prográmalo

Ejecuta el script cada hora con cron:

```bash
crontab -e
# Add this line:
0 * * * * cd /path/to/project && python3 monitor.py >> monitor.log 2>&1
```

## Consejos

- **Comienza con el endpoint único**, cambia a browser si las páginas usan renderizado por JavaScript
- **Añade manejo de errores**: los sitios web cambian sus layouts. Registra los fallos por separado.
- **Mantén los selectores actualizados**: cuando un competidor rediseñe su sitio, actualiza el selector CSS
- **Respeta los sitios web**: espacia las requests, evita horas pico y sigue el robots.txt

## Próximos pasos

- [Elegir el endpoint adecuado](https://foura.ai/docs/guides/choosing-task-type): Elige el mejor enfoque
- [Manejo de errores](https://foura.ai/docs/api/errors): Gestiona los fallos de forma adecuada
- [Hacer scraping de un sitio web dinámico](https://foura.ai/docs/how-to/scrape-dynamic-website): Gestiona páginas renderizadas con JavaScript
