# 📉 Monitor de Precios Mercado Libre — Alerta de Baja y Stock (`paulovitor18/mercado-libre-monitor-precios`) Actor

El Keepa de Mercado Libre (AR/MX/CL/CO/UY/PE): monitoreo de precios y stock de una watchlist — o de una búsqueda/categoría — con alerta de baja, alza, agotado/repuesto y nueva oferta. No es un scraper de snapshot: entrega solo el DELTA entre ejecuciones. Pagá por cambio, no por barrido.

- **URL**: https://apify.com/paulovitor18/mercado-libre-monitor-precios.md
- **Developed by:** [MoreLock](https://apify.com/paulovitor18) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Monitor de Precios Mercado Libre — Alerta de Baja y Stock

El **Keepa de Mercado Libre** para Latinoamérica. Armás una lista de productos de Mercado Libre y, en cada ejecución, recibís **solo lo que cambió**: bajó el precio, subió el precio, se agotó, volvió a stock, entró o salió de oferta. Nada de raspar el catálogo entero de nuevo cada vez — el monitor guarda el precio anterior de cada producto y te entrega únicamente el **delta**. Es el rastreador de precios e historial de disponibilidad que Mercado Libre no te da.

> **In English:** MercadoLibre price tracker & stock alert for Latin America (AR/MX/CL/CO/UY/PE) — a Keepa-style price monitor that returns only the delta between runs: price drop/rise alerts, out-of-stock/back-in-stock, and new deals. Watch a fixed product list or a whole search/category.

Funciona en **Argentina, México, Chile, Colombia, Uruguay y Perú** — elegís el país en el input y el monitor usa el dominio, el proxy y la moneda correctos.

### Visión general

Elegís el **país (sitio)**, informás una **watchlist** — la URL de cada producto o solo el código `MLA...` / `MLM...` — y agendás la ejecución. La primera vez, el monitor registra el retrato actual de cada producto (el baseline: precio, stock, oferta). En las ejecuciones siguientes, compara el estado de ahora con el de la última vez y emite **solo los cambios reales**:

- **alerta_precio** — el precio cambió (con precio anterior, precio actual, variación % y dirección: baja o alza);
- **cambio_stock** — se agotó o volvió a stock;
- **nueva_oferta / fin_oferta** — el producto entró o salió de promoción/descuento;
- **eliminado** — el anuncio salió del aire (pausado, finalizado o 404).

Si un producto no cambió, no aparece — y no pagás por él. El valor está en la diferencia, no en el barrido.

### Cómo se compara con un scraper de Mercado Libre

Un scraper de Mercado Libre te devuelve un **retrato**: raspa la lista/producto entero cada vez que corre, y pagás por ítem raspado, cambie o no. Este Actor te devuelve el **delta**: lee los mismos productos, pero solo te entrega (y solo cobra) cuando algo de hecho cambió. Para seguir precios a lo largo del tiempo, el delta es más barato y mucho más accionable — recibís una alerta de "bajó 12%", no un archivo con 500 precios iguales a los de ayer para comparar a mano.

Es un monitor **nativo en español**: entiende la página de producto de Mercado Libre en es-AR/MX/CL/CO/UY/PE (precio con el separador de cada país, "de/por" tachado, "sin stock", "publicación pausada", envío gratis) y lee el dato limpio del JSON-LD de la propia página. La **moneda** (ARS/MXN/CLP/COP/UYU/PEN) sale del JSON-LD, no está hardcodeada.

### Países soportados

| Sitio | País | Dominio | Moneda | Prefijo de ID |
|---|---|---|---|---|
| AR | Argentina | mercadolibre.com.ar | ARS | MLA |
| MX | México | mercadolibre.com.mx | MXN | MLM |
| CL | Chile | mercadolibre.cl | CLP | MLC |
| CO | Colombia | mercadolibre.com.co | COP | MCO |
| UY | Uruguay | mercadolibre.com.uy | UYU | MLU |
| PE | Perú | mercadolibre.com.pe | PEN | MPE |

El prefijo del código del ítem ya indica el país (un `MLA...` es de Argentina, un `MLM...` de México). Elegí el `sitio` que coincida con tus productos: define el país del proxy residencial y el dominio de la búsqueda.

### Features

- **Delta entre ejecuciones:** cada run reporta solo lo que cambió — baja/alza de precio, se agotó/volvió, entró/salió de oferta — nunca la lista entera de nuevo.
- **Historial por producto:** el precio y la disponibilidad anteriores quedan guardados; la alerta ya viene con el "de → a" y la variación %.
- **Watchlist que evoluciona:** agregá o quitá productos cuando quieras. Un producto nuevo es solo un retrato inicial (no cobra alerta); uno quitado de la lista sale del estado. Editar la lista **no reinicia** el monitor.
- **Filtro de ruido:** definí una variación mínima (%) para solo ser avisado de bajas/alzas relevantes.
- **Degradación honesta:** si Mercado Libre está bloqueando o fuera del aire, el monitor **preserva el estado** y no cobra nada — un bloqueo nunca se confunde con "el producto desapareció".
- **Agendable:** hecho para correr cada hora o a diario vía Schedules de Apify; la 1ª run es el baseline, las demás son la alerta.

### Dos modos: watchlist y búsqueda

El Actor tiene **dos modos**, y elegís por el input:

- **Modo watchlist (por defecto):** listás productos fijos en el campo `productos` (URLs o códigos `MLA...`) y el monitor vigila exactamente esos productos. Es el modo descrito arriba.
- **Modo búsqueda:** en vez de productos fijos, informás una **búsqueda** en el campo `busqueda` — un término (ej.: `"notebook"`, `"iphone 15"`) o una URL de búsqueda/categoría de Mercado Libre (ej.: `"https://listado.mercadolibre.com.ar/notebook"`). El monitor lee los cards del **tope de los resultados** (hasta el tope `max_productos`) y hace el delta del **conjunto** entre ejecuciones. Además de las mismas alertas de precio/stock/oferta para los productos que siguen apareciendo, reporta:
  - **producto_nuevo** — un producto que **entró** en el recorte de la búsqueda (retrato inicial; no cobra alerta, como el baseline de un ítem nuevo);
  - **producto_salio** — un producto que **salió** del recorte de la búsqueda. Esta alerta solo se emite cuando el monitor vio el **fin real** de la lista de resultados; si la lista fue cortada por el tope, un producto que "desapareció" puede solo haber perdido posición más allá del tope, así que el monitor **preserva el estado** y no emite un "salió" falso.

Dejá `busqueda` **vacío** para usar el modo watchlist. Si `busqueda` está completado, el modo búsqueda tiene prioridad y la watchlist se ignora en esa ejecución. El **estado de los dos modos es separado**. El tope `max_productos` y la `variacion_minima_pct` valen para los dos modos; en el modo búsqueda, el tope también define la **ventana** monitoreada (el top-N de la búsqueda) y forma parte de la identidad del monitor (cambiar el tope reinicia el baseline de esa búsqueda).

> Nota técnica: en el modo búsqueda, el precio viene del **card de la vidriera** de resultados (el mismo que ML muestra en la lista), no de la página de cada producto. Para catálogos con variaciones, el card puede mostrar un precio "desde" que difiere del precio de la variación específica en la página del producto — el monitor usa el precio del card por ser la referencia consistente entre ejecuciones.

### Input example

```json
{
  "sitio": "AR",
  "productos": [
    "https://www.mercadolibre.com.ar/p/MLA22826188",
    "MLA2024331913"
  ],
  "variacion_minima_pct": 5,
  "modo": "auto",
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

### Output example

Alerta de **baja de precio** detectada en el delta:

```json
{
  "change_type": "alerta_precio",
  "item_id": "MLA1401055590",
  "titulo": "Samsung Galaxy A15 128 GB - Azul",
  "url": "https://www.mercadolibre.com.ar/p/MLA1401055590",
  "precio_anterior": 289999.00,
  "precio_actual": 254999.10,
  "variacion_pct": -12.1,
  "direccion": "baja",
  "moneda": "ARS",
  "precio_de": 349999.00,
  "descuento_pct": 27,
  "availability": "InStock",
  "entro_en_oferta": false,
  "nota": "El precio bajó de 289999 a 254999.1 (-12.1%).",
  "detected_at": "2026-07-19T09:00:00.000Z"
}
```

En la **primera ejecución** de una watchlist, cada producto sale como `change_type: "baseline"` (el retrato inicial). Un producto que **se agotó** sale como `cambio_stock` con `agotado: true`; uno que **salió del aire** sale como `eliminado`.

### Parámetros

| Campo | Tipo | Por defecto | Descripción |
|---|---|---|---|
| `sitio` | select | `AR` | País de Mercado Libre: AR/MX/CL/CO/UY/PE. Define dominio, proxy y moneda. |
| `productos` | array | 1 ejemplo | Watchlist: URL del producto o código `MLA...`/`MLM...`. |
| `busqueda` | string | `""` | Modo búsqueda: término o URL de búsqueda/categoría. Vacío = modo watchlist. |
| `variacion_minima_pct` | integer | `0` | Solo emite alerta de precio cuando la variación, en la ejecución, sea ≥ este %. `0` = cualquier cambio. |
| `max_productos` | integer | `90` | Tope de productos renderizados por ejecución (costo/tiempo; cada producto es un render de ~25-30s). |
| `stateStoreName` | string | `""` | Avanzado. Vacío = estado por defecto. Completá solo para correr listas independientes en paralelo. |
| `modo` | select | `auto` | `auto` = baseline en la 1ª, delta después. `baseline` = fuerza rebase del estado actual. |
| `proxy` | object | Residencial | El país del proxy se toma del `sitio`. Mercado Libre exige IP residencial del país para cargar la página. |

### Tips

- **Agendá, no corras a mano.** El valor es la recurrencia: configurá un Schedule (diario, o cada hora para ofertas relámpago). La 1ª ejecución es el baseline automáticamente; las siguientes solo te avisan de lo que cambió.
- **Usá `variacion_minima_pct` para cortar ruido.** En productos que oscilan centavos, poné `5` o `10` para solo ser avisado de bajas que valen la pena.
- **Una watchlist por objetivo.** Para monitorear dos listas independientes, dale a cada agendamiento un `stateStoreName` propio — cada nombre es un monitor aislado.
- **El baseline es gratis de alerta.** La primera ejecución solo cobra la ejecución (no cobra alerta) — es el retrato inicial. El dinero entra cuando un precio de hecho cambia.
- **Un `sitio` por país.** Los productos de tu watchlist deben ser del país elegido; el prefijo del ID (`MLA`, `MLM`, ...) ya indica el país.

### Use cases

- **Alerta de baja de precio (el Keepa de ML):** seguí los productos que querés comprar y te avisamos en el minuto en que el precio baja.
- **Seguimiento de stock:** sabé al instante cuando un producto agotado **vuelve a stock** — útil para lanzamientos e ítems disputados.
- **Monitoreo de competencia de precios (repricing):** vendedor que hace seguimiento de precios de anuncios competidores para reprecificar los suyos.
- **Cazador de ofertas / afiliados:** monitoreá una canasta de productos y capturá las promociones (`nueva_oferta`) apenas entran.
- **Compras / procurement:** seguí insumos y equipos recurrentes y registrá el historial de precio para negociar mejor.
- **Higiene de catálogo:** el `eliminado` marca anuncios que salieron del aire — útil para mantener una lista de referencia limpia.

### FAQ

**¿Qué cambia exactamente entre la 1ª ejecución y las siguientes?** La 1ª ejecución de una watchlist es el **baseline**: registra el precio/stock actual de cada producto y cobra solo la ejecución. De la 2ª en adelante, el monitor compara con el estado anterior y entrega el **delta** — solo los productos cuyo precio, stock u oferta cambió.

**¿Cómo guarda el historial el monitor?** En un almacenamiento nombrado que persiste entre ejecuciones. Guarda el último precio/stock/oferta de cada producto — es contra eso que la próxima ejecución compara. Editar la watchlist no borra el historial de los demás.

**¿Vender una unidad cuenta como cambio?** No. La cantidad vendida es ruido: el monitor solo considera "cambio" el precio, la disponibilidad y la oferta. Vender no dispara alerta (ni cobro).

**Un producto quedó sin stock — ¿el precio queda null?** Sí, y el Actor es honesto: un producto pausado/agotado sale con `availability: "OutOfStock"` y `precio_actual: null` (evento `cambio_stock`, no un falso "precio a cero").

**Si Mercado Libre bloquea la ejecución, ¿el monitor borra todo?** No. Una ejecución bloqueada **preserva el estado** y no cobra — emite un registro `STATUS: NO_DISPONIBLE`. Un bloqueo jamás se lee como "el producto desapareció". Un producto individual que no cargó también se preserva, no se marca como eliminado.

**¿Qué cuenta como `eliminado`?** Solo cuando Mercado Libre responde que el anuncio ya no existe (404) para un producto que estaba en tu monitor — anuncio pausado, finalizado o catálogo eliminado. Un producto nuevo con URL errada sale como `no_encontrado` (informativo, sin cobro).

**¿Por qué necesito proxy residencial?** La página de producto de Mercado Libre solo hidrata (muestra el precio) para un IP residencial del país; datacenter es bloqueado. Es el estándar del Actor y lo que fue medido funcionando; el país se toma del `sitio`.

**¿Puedo monitorear una búsqueda/categoría entera, no una lista?** Sí — usá el **modo búsqueda** (campo `busqueda`): informá un término o URL de búsqueda/categoría y el monitor vigila el **top-N** de los resultados (hasta el tope `max_productos`), avisando cuando un producto entra (`producto_nuevo`), sale (`producto_salio`) o cambia de precio/stock/oferta. Cada producto del recorte cuenta como un `producto_verificado`.

### Pricing

Pagá por resultado (PPE) — pagás la ejecución y el cambio, no el barrido:

| Evento | Cuándo se cobra |
|---|---|
| `monitor_run` | Una vez por ejecución válida (renderiza los productos y apura el delta). Ejecución con la fuente totalmente bloqueada/fuera del aire **no cobra**. |
| `producto_verificado` | Cada producto efectivamente leído en la ejecución (precio, stock y oferta capturados) — en el **modo watchlist**, cada producto de tu lista; en el **modo búsqueda**, cada producto orgánico del recorte (patrocinados y el excedente del tope **no cobran**). Producto bloqueado, inexistente (404) o con URL inválida **no cobra**. |
| `alerta` | Cada cambio real emitido: baja/alza de precio, se agotó/volvió a stock, entró/salió de oferta, producto eliminado, o (en el modo búsqueda) producto que **salió** del recorte. Producto que no cambió **no cobra**; la 1ª ejecución (baseline), un producto nuevo en la lista y un `producto_nuevo` en la búsqueda **no cobran alerta**. |

**No pagás por:** el baseline (solo ejecución + productos leídos), productos que no cambiaron, ejecución totalmente bloqueada/fuera del aire, producto que no se pudo leer (preservado, no cobra el `producto_verificado`), error nuestro, o entrada inválida.

### Actors relacionados

- **[Monitor de Preço Mercado Livre — Brasil](https://apify.com/paulovitor18/mercado-livre-monitor-preco)** — el mismo monitor para Mercado Livre Brasil, en portugués y con proxy residencial BR.
- **[Monitor de Nuevos Negocios en Google Maps](https://apify.com/paulovitor18/google-maps-monitor-nuevos-negocios)** — el mismo motor de delta sobre otra fuente: te avisa solo cuando aparece un negocio nuevo en el mapa.
- **[Reclame Aqui Scraper](https://apify.com/paulovitor18/reclameaqui-scraper)** — si trabajás con proveedores brasileños: reputación de la empresa antes de cerrar.
- **[Consulta CNPJ en Lote](https://apify.com/paulovitor18/cnpj-bulk-lookup)** — registro fiscal brasileño (Receita Federal) en lote, para validar proveedores de Brasil.

### Changelog

- 0.1: primera versión — monitor de precios/stock/oferta de una watchlist de productos de Mercado Libre LatAm (AR/MX/CL/CO/UY/PE), con delta entre ejecuciones (baja/alza de precio, se agotó/volvió, nueva/fin de oferta, eliminado), historial por producto, estado estable a ediciones de la lista y degradación honesta.

### Contacto

Dudas, problemas o pedidos: usá la pestaña Issues del Actor.

# Actor input Schema

## `sitio` (type: `string`):

El país de Mercado Libre a monitorear. Define el dominio (AR mercadolibre.com.ar · MX mercadolibre.com.mx · CL mercadolibre.cl · CO mercadolibre.com.co · UY mercadolibre.com.uy · PE mercadolibre.com.pe), el país del proxy residencial y la moneda de referencia. Los productos de tu watchlist deben ser del país seleccionado (el prefijo del ID ya indica el país: MLA=AR, MLM=MX, MLC=CL, MCO=CO, MLU=UY, MPE=PE).

## `productos` (type: `array`):

Lista de productos de Mercado Libre a monitorear. Pegá la URL del producto (ej.: "https://www.mercadolibre.com.ar/p/MLA22826188") o solo el código del ítem ("MLA...", "MLM...", etc.). En cada ejecución el monitor lee precio, stock y oferta de cada uno y reporta solo lo que CAMBIÓ desde la ejecución anterior.

## `busqueda` (type: `string`):

MODO BÚSQUEDA (alternativa a la watchlist de arriba). En vez de vigilar productos fijos, vigilá el FEED DE RESULTADOS de una búsqueda de Mercado Libre. Informá un TÉRMINO (ej.: "notebook", "iphone 15") O una URL de búsqueda/categoría del sitio seleccionado (ej.: "https://listado.mercadolibre.com.ar/notebook"). El monitor lee los cards del tope de los resultados (hasta el tope de abajo) y reporta solo lo que CAMBIÓ: productos que entraron (producto\_nuevo), salieron (producto\_salio), o tuvieron baja/alza de precio, cambio de stock o de oferta. Dejalo VACÍO para usar el modo watchlist normal. Si está completado, el modo búsqueda tiene prioridad y la watchlist se ignora en esa ejecución (el estado de los dos modos es separado). El tope "Productos por ejecución" y la "Variación mínima" de abajo también valen acá. La búsqueda usa el dominio del sitio elegido arriba.

## `variacion_minima_pct` (type: `integer`):

Filtro de ruido: solo emite alerta\_precio cuando la variación de precio, EN ESA ejecución, sea de al menos este porcentaje (en módulo). 0 = alerta cualquier cambio de precio. Ej.: 5 = solo avisa bajas/alzas de 5% o más. Es un filtro por ejecución (no acumula variaciones pequeñas entre runs).

## `max_productos` (type: `integer`):

Límite de seguridad de cuántos productos de la watchlist se renderizan por ejecución (control de costo/tiempo — cada producto es un render headless de ~25-30s, secuencial). El excedente se ignora en esa ejecución (señalado en el log). Mantenido bajo para caber en la ventana de ejecución; para listas más grandes, dividí en watchlists/agendamientos separados (stateStoreName propio por lista). En el modo búsqueda, el tope también define la ventana monitoreada (el top-N de la búsqueda).

## `stateStoreName` (type: `string`):

Dónde persiste el historial de precios de tu watchlist entre ejecuciones. Dejalo VACÍO para usar el estado por defecto de esta cuenta — tu lista puede crecer/achicarse a voluntad (ítem nuevo = retrato inicial, ítem removido sale del estado; no reinicia el monitor). Completá con un nombre propio SOLO si querés correr LISTAS INDEPENDIENTES en paralelo (una por agendamiento): cada nombre es un monitor aislado.

## `modo` (type: `string`):

auto = la 1ª ejecución es el retrato inicial (baseline) y las siguientes reportan el delta. baseline = fuerza un nuevo retrato inicial (rebase del estado actual, sin cobrar alerta) — usalo para poner en cero el historial de la watchlist.

## `proxy` (type: `object`):

Ruteo de red. El país del proxy residencial se toma del SITIO elegido arriba. Mercado Libre exige IP residencial del país para hidratar la página de producto; no desactives el proxy a menos que sepas lo que hacés.

## `self_test` (type: `boolean`):

No usar en producción. Ignora la watchlist y corre la batería de known-answers del motor de parse (producto InStock, producto sin stock, input inválido, producto inexistente) + la prueba de delta, para probar que el parser y la semántica de cambio siguen correctos.

## Actor input object example

```json
{
  "sitio": "AR",
  "productos": [
    "https://www.mercadolibre.com.ar/p/MLA22826188"
  ],
  "busqueda": "notebook",
  "variacion_minima_pct": 0,
  "max_productos": 90,
  "stateStoreName": "",
  "modo": "auto",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AR"
  },
  "self_test": false
}
```

# Actor output Schema

## `delta` (type: `string`):

Registros apurados en esta ejecución (baseline en la 1ª; alertas de precio/stock/oferta en las siguientes), en el formato descrito en dataset\_schema.json.

## `resumen` (type: `string`):

Contadores de la ejecución: modo (baseline/delta), alertas por tipo, productos vigilados y la cobranza prevista/efectivada.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "productos": [
        "https://www.mercadolibre.com.ar/p/MLA22826188"
    ],
    "busqueda": "notebook",
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "AR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("paulovitor18/mercado-libre-monitor-precios").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "productos": ["https://www.mercadolibre.com.ar/p/MLA22826188"],
    "busqueda": "notebook",
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "AR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("paulovitor18/mercado-libre-monitor-precios").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "productos": [
    "https://www.mercadolibre.com.ar/p/MLA22826188"
  ],
  "busqueda": "notebook",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AR"
  }
}' |
apify call paulovitor18/mercado-libre-monitor-precios --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=paulovitor18/mercado-libre-monitor-precios",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📉 Monitor de Precios Mercado Libre — Alerta de Baja y Stock",
        "description": "El Keepa de Mercado Libre (AR/MX/CL/CO/UY/PE): monitoreo de precios y stock de una watchlist — o de una búsqueda/categoría — con alerta de baja, alza, agotado/repuesto y nueva oferta. No es un scraper de snapshot: entrega solo el DELTA entre ejecuciones. Pagá por cambio, no por barrido.",
        "version": "0.1",
        "x-build-id": "aqoZpxFd5kQnwI6QI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/paulovitor18~mercado-libre-monitor-precios/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-paulovitor18-mercado-libre-monitor-precios",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/paulovitor18~mercado-libre-monitor-precios/runs": {
            "post": {
                "operationId": "runs-sync-paulovitor18-mercado-libre-monitor-precios",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/paulovitor18~mercado-libre-monitor-precios/run-sync": {
            "post": {
                "operationId": "run-sync-paulovitor18-mercado-libre-monitor-precios",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "sitio": {
                        "title": "País / Sitio de Mercado Libre",
                        "enum": [
                            "AR",
                            "MX",
                            "CL",
                            "CO",
                            "UY",
                            "PE"
                        ],
                        "type": "string",
                        "description": "El país de Mercado Libre a monitorear. Define el dominio (AR mercadolibre.com.ar · MX mercadolibre.com.mx · CL mercadolibre.cl · CO mercadolibre.com.co · UY mercadolibre.com.uy · PE mercadolibre.com.pe), el país del proxy residencial y la moneda de referencia. Los productos de tu watchlist deben ser del país seleccionado (el prefijo del ID ya indica el país: MLA=AR, MLM=MX, MLC=CL, MCO=CO, MLU=UY, MPE=PE).",
                        "default": "AR"
                    },
                    "productos": {
                        "title": "Productos a vigilar (watchlist)",
                        "type": "array",
                        "description": "Lista de productos de Mercado Libre a monitorear. Pegá la URL del producto (ej.: \"https://www.mercadolibre.com.ar/p/MLA22826188\") o solo el código del ítem (\"MLA...\", \"MLM...\", etc.). En cada ejecución el monitor lee precio, stock y oferta de cada uno y reporta solo lo que CAMBIÓ desde la ejecución anterior.",
                        "default": [
                            "https://www.mercadolibre.com.ar/p/MLA22826188"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "busqueda": {
                        "title": "Búsqueda a monitorear (modo búsqueda — alternativa a la watchlist)",
                        "type": "string",
                        "description": "MODO BÚSQUEDA (alternativa a la watchlist de arriba). En vez de vigilar productos fijos, vigilá el FEED DE RESULTADOS de una búsqueda de Mercado Libre. Informá un TÉRMINO (ej.: \"notebook\", \"iphone 15\") O una URL de búsqueda/categoría del sitio seleccionado (ej.: \"https://listado.mercadolibre.com.ar/notebook\"). El monitor lee los cards del tope de los resultados (hasta el tope de abajo) y reporta solo lo que CAMBIÓ: productos que entraron (producto_nuevo), salieron (producto_salio), o tuvieron baja/alza de precio, cambio de stock o de oferta. Dejalo VACÍO para usar el modo watchlist normal. Si está completado, el modo búsqueda tiene prioridad y la watchlist se ignora en esa ejecución (el estado de los dos modos es separado). El tope \"Productos por ejecución\" y la \"Variación mínima\" de abajo también valen acá. La búsqueda usa el dominio del sitio elegido arriba.",
                        "default": ""
                    },
                    "variacion_minima_pct": {
                        "title": "Variación mínima de precio para alertar (%)",
                        "minimum": 0,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Filtro de ruido: solo emite alerta_precio cuando la variación de precio, EN ESA ejecución, sea de al menos este porcentaje (en módulo). 0 = alerta cualquier cambio de precio. Ej.: 5 = solo avisa bajas/alzas de 5% o más. Es un filtro por ejecución (no acumula variaciones pequeñas entre runs).",
                        "default": 0
                    },
                    "max_productos": {
                        "title": "Tope de productos por ejecución",
                        "minimum": 1,
                        "maximum": 150,
                        "type": "integer",
                        "description": "Límite de seguridad de cuántos productos de la watchlist se renderizan por ejecución (control de costo/tiempo — cada producto es un render headless de ~25-30s, secuencial). El excedente se ignora en esa ejecución (señalado en el log). Mantenido bajo para caber en la ventana de ejecución; para listas más grandes, dividí en watchlists/agendamientos separados (stateStoreName propio por lista). En el modo búsqueda, el tope también define la ventana monitoreada (el top-N de la búsqueda).",
                        "default": 90
                    },
                    "stateStoreName": {
                        "title": "Nombre del almacenamiento de estado (avanzado)",
                        "type": "string",
                        "description": "Dónde persiste el historial de precios de tu watchlist entre ejecuciones. Dejalo VACÍO para usar el estado por defecto de esta cuenta — tu lista puede crecer/achicarse a voluntad (ítem nuevo = retrato inicial, ítem removido sale del estado; no reinicia el monitor). Completá con un nombre propio SOLO si querés correr LISTAS INDEPENDIENTES en paralelo (una por agendamiento): cada nombre es un monitor aislado.",
                        "default": ""
                    },
                    "modo": {
                        "title": "Modo",
                        "enum": [
                            "auto",
                            "baseline"
                        ],
                        "type": "string",
                        "description": "auto = la 1ª ejecución es el retrato inicial (baseline) y las siguientes reportan el delta. baseline = fuerza un nuevo retrato inicial (rebase del estado actual, sin cobrar alerta) — usalo para poner en cero el historial de la watchlist.",
                        "default": "auto"
                    },
                    "proxy": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Ruteo de red. El país del proxy residencial se toma del SITIO elegido arriba. Mercado Libre exige IP residencial del país para hidratar la página de producto; no desactives el proxy a menos que sepas lo que hacés.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "AR"
                        }
                    },
                    "self_test": {
                        "title": "Modo diagnóstico (regresión del fixture-pack)",
                        "type": "boolean",
                        "description": "No usar en producción. Ignora la watchlist y corre la batería de known-answers del motor de parse (producto InStock, producto sin stock, input inválido, producto inexistente) + la prueba de delta, para probar que el parser y la semántica de cambio siguen correctos.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
