# Licitaciones Mercado Público Chile — Chile Government Tenders (`cardumenbip/licitaciones-mercado-publico-chile`) Actor

Licitaciones públicas de Chile en tiempo real desde la API oficial de Mercado Público. Filtra por fecha, estado y palabra clave; incluye detalle con organismo, montos y fechas. Ideal para proveedores del Estado, ventas B2G y consultoras. Fuente de datos: Dirección ChileCompra.

- **URL**: https://apify.com/cardumenbip/licitaciones-mercado-publico-chile.md
- **Developed by:** [Cardumen](https://apify.com/cardumenbip) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Stats:** 3 total users, 0 monthly users, 87.5% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 results

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

## Licitaciones Mercado Público Chile — Chile Government Tenders & Public Procurement Data

Extrae **licitaciones públicas del Estado de Chile** desde la API oficial de Mercado Público (ChileCompra). Filtra por fecha, rango de fechas, estado y palabra clave; opcionalmente enriquece cada licitación con organismo, comuna, ítems, montos y adjudicación. Incluye **modo alertas** para recibir solo las licitaciones nuevas en un Schedule diario.

Get **Chilean government tenders** from the official Mercado Público (ChileCompra) API: filter by date range, status and keyword, enrich with buyer, amounts and awards, and run an "only new tenders" alert mode on a daily schedule. Official public data, no scraping, no login.

---

### Qué datos obtienes / Output fields

#### Siempre (listado diario)

| Campo | Tipo | Descripción |
|---|---|---|
| `codigoExterno` | string | ID oficial de la licitación (ej: `1509-5-L114`) |
| `nombre` | string | Nombre de la licitación |
| `estado` | string | Texto legible: Publicada, Cerrada, Desierta, Adjudicada, Revocada o Suspendida |
| `fechaCierre` | string | Fecha/hora límite para ofertar (ISO) |
| `fechaConsulta` | string | Día del listado en que apareció, formato `yyyy-mm-dd` |
| `urlFicha` | string | Link directo a la ficha oficial en mercadopublico.cl |
| `esNuevo` | boolean | Solo si activas `marcarNuevos`: `true` si no se había visto en corridas anteriores |

#### Con `conDetalle: true`

Cada campo agrega una llamada extra a la API por licitación (más lento).

| Campo | Tipo | Descripción |
|---|---|---|
| `descripcion` | string | Descripción de la licitación |
| `organismo` | string | Organismo comprador |
| `unidad` | string | Unidad de compra |
| `region` | string | Región del organismo |
| `comuna` | string | Comuna del organismo |
| `direccion` | string | Dirección del organismo |
| `tipo` | string | Tipo de licitación (L1, LE, LP, LR, …) |
| `estadoDetalle` | string | Estado según la ficha (texto) |
| `montoEstimado` | number \| null | Monto estimado — **puede venir nulo** (ver Limitaciones) |
| `moneda` | string | Moneda del monto (CLP, CLF/UF, UTM, USD, …) |
| `fechaPublicacion` | string \| null | Fecha de publicación |
| `fechaAdjudicacion` | string \| null | Fecha de adjudicación **programada** en el calendario (puede ser futura) |
| `itemsResumen` | string \| null | Resumen plano de los ítems licitados, deduplicado, máx. 300 caracteres |
| `cantidadItems` | number | Cantidad de ítems licitados |
| `adjudicatarios` | string \| null | Empresas adjudicatarias, separadas por `;` — **solo si ya está adjudicada** |
| `adjudicacionMonto` | number \| null | Monto total adjudicado — solo si ya está adjudicada |
| `adjudicacionFecha` | string \| null | Fecha de adjudicación **efectiva** — solo si ya está adjudicada |
| `items` | array | `[{ nombre, cantidad, unidad }]` — **solo si activas `incluirItemsDetalle`** |

> **Privacidad:** el actor nunca emite nombres, correos ni teléfonos de personas de contacto del organismo, aunque la API los entregue. Solo datos institucionales y nombres de empresas adjudicatarias.

#### Ejemplo de output (con `conDetalle: true`)

```json
{
  "codigoExterno": "1509-5-LE26",
  "nombre": "Servicio de transporte de personal",
  "estado": "Adjudicada",
  "fechaCierre": "2026-08-02T15:00:00",
  "fechaConsulta": "2026-07-23",
  "urlFicha": "https://www.mercadopublico.cl/fichaLicitacion.html?idLicitacion=1509-5-LE26",
  "descripcion": "Contratación de servicio de transporte de personal municipal",
  "organismo": "Municipalidad de Providencia",
  "unidad": "Dirección de Administración",
  "region": "Región Metropolitana de Santiago",
  "comuna": "Providencia",
  "direccion": "Av. Pedro de Valdivia 963",
  "tipo": "LE",
  "estadoDetalle": "Adjudicada",
  "montoEstimado": 25000000,
  "moneda": "CLP",
  "fechaPublicacion": "2026-07-10T09:00:00",
  "fechaAdjudicacion": "2026-08-10T12:00:00",
  "itemsResumen": "Servicio de transporte terrestre de pasajeros (1 Global)",
  "cantidadItems": 1,
  "adjudicatarios": "TRANSPORTES DEL SUR SPA",
  "adjudicacionMonto": 24500000,
  "adjudicacionFecha": "2026-08-10T12:00:00"
}
````

***

### Modo alertas: solo licitaciones nuevas

Activa **`soloNuevos`** y pon el actor en un **Schedule diario**: recuerda qué licitaciones ya entregó y en cada corrida emite **solo las que no habías visto**.

- La memoria se guarda en un *key-value store* nombrado, **particionado por combinación de filtros** (`estado` + `keyword`): cada búsqueda guardada lleva su propia memoria independiente.
- Las licitaciones ya vistas **se descartan antes de pedir el detalle**, así que no gastan tiempo ni disparan el cobro por `detalle`.
- La **primera corrida** entrega toda la ventana y ceba la memoria; **desde la segunda**, solo lo nuevo.

**Cómo montarlo:** guarda una Task con tus filtros (`keyword`, `estado`, `conDetalle`, `soloNuevos: true`) → créale un Schedule diario → conéctale una integración (Slack, email, webhook) para recibir el aviso.

Si prefieres verlo **todo** pero distinguiendo lo nuevo, usa **`marcarNuevos`** en vez de `soloNuevos`: no filtra nada y agrega el campo booleano `esNuevo` a cada fila.

> **Importante:** usa un `maxResults` **mayor o igual** a la cantidad de resultados que esperas. La memoria solo recuerda lo que efectivamente se emitió; si `maxResults` trunca la lista, las licitaciones cortadas reaparecerán como "nuevas" en la próxima corrida.

### Modo activas: licitaciones abiertas por cierre

Usa **`estado: "activas"`** para traer solo las licitaciones cuyo **periodo de ofertas sigue abierto** (fecha de cierre en el futuro) — las que realmente puedes ir a ofertar hoy. Es el filtro base para un proveedor que busca oportunidades vigentes. Otros valores: `publicada`, `cerrada`, `adjudicada`, o `todos` (default).

### Rango de fechas

Por defecto se consulta **un solo día** (hoy, o el que indiques en `fecha`). Con **`desde`** consultas un rango:

| Valor de `desde` | Qué consulta |
|---|---|
| `7d` | Los últimos 7 días, incluyendo hoy |
| `30d` | Los últimos 30 días |
| `2026-07-01` | Desde esa fecha hasta hoy |
| *(vacío)* | Solo hoy, o el día en `fecha` |

La API oficial responde por día: el actor hace **una llamada por jornada** y deduplica por `codigoExterno`. Tope de **31 días por corrida**.

### Vistas del dataset

La pestaña **Output** ofrece dos vistas con etiquetas en español:

- **Resumen** — lo mínimo para evaluar de un vistazo: código, nombre, ¿nueva?, estado, comuna, región, ítems, monto, adjudicatarios, cierre y ficha.
- **Completo** — todos los campos, incluyendo organismo, dirección, tipo, ítems, cantidad y adjudicación.

***

### Trial vs. ticket propio

El actor trae incorporado el **ticket público de pruebas** de ChileCompra, para que puedas **evaluarlo sin registrarte**. Ese ticket es compartido y tiene **límites de uso estrictos**: bajo carga responde con errores de límite (HTTP 429), sobre todo si activas `conDetalle` (que hace muchas llamadas).

Para uso real, solicita tu **ticket propio gratuito** en `api.mercadopublico.cl` (portal de desarrolladores de ChileCompra) y entrégalo de una de estas dos formas:

1. **Campo `ticket`** del input (marcado como secreto), o
2. **Variable de entorno `MP_TICKET`** del actor — recomendado si lo agendas, para no repetir el ticket en cada Task.

Prioridad: `ticket` del input → `MP_TICKET` → ticket de pruebas. Si terminas usando el de pruebas, verás un aviso `WARN` en el log.

### Referencia de inputs

| Input | Tipo | Default | Descripción |
|---|---|---|---|
| `fecha` | string | hoy | Día único `ddmmaaaa`. Se ignora si usas `desde`. |
| `desde` | string | — | Rango: `7d`, `30d` o `yyyy-mm-dd` hasta hoy (máx. 31 días). |
| `estado` | enum | `todos` | `todos`, `activas`, `publicada`, `cerrada`, `adjudicada`. |
| `keyword` | string | — | Substring en el **nombre** de la licitación. |
| `conDetalle` | boolean | `false` | Enriquece con organismo, comuna, montos, ítems y adjudicación. |
| `incluirItemsDetalle` | boolean | `false` | Agrega el array `items` completo (para consumo por API/JSON). |
| `soloNuevos` | boolean | `false` | Modo alertas: solo licitaciones no vistas antes con estos filtros. |
| `marcarNuevos` | boolean | `false` | Agrega `esNuevo` sin filtrar. |
| `maxResults` | integer | `200` | Máximo de licitaciones a emitir tras filtrar. |
| `ticket` | string (secreto) | — | Tu ticket de api.mercadopublico.cl. Vacío = ticket de pruebas. |

### Para quién es / Use cases

- **Proveedores del Estado**: monitorea a diario las licitaciones de tu rubro con `keyword` + `estado: activas` + `soloNuevos`, y llega antes que la competencia.
- **Consultoras y estudios**: análisis de compras públicas por organismo, comuna, región o adjudicatario, con `conDetalle` y un rango de fechas.
- **Equipos de ventas B2G**: alimenta tu CRM con oportunidades frescas cada mañana (Schedule diario + integración).

***

### Limitaciones

Honestidad por delante — conviene conocer estos límites antes de depender del actor:

- **`keyword` filtra solo por el nombre.** Es un substring sobre el título de la licitación, no sobre la descripción ni el rubro. Una licitación relevante cuyo nombre no contenga tu palabra **no aparecerá**. Filtro por código de rubro (UNSPSC) está en el backlog.
- **`montoEstimado` a menudo viene `null`.** Muchos organismos no publican monto estimado, o lo marcan como no visible. No es un error del actor: la API no lo entrega.
- **Montos en monedas mezcladas.** El dataset combina CLP, CLF (UF), UTM y a veces USD en la misma columna `moneda`. **No ordenes ni compares `montoEstimado`/`adjudicacionMonto` directamente** sin normalizar por moneda. Normalización a CLP está en el backlog.
- **Dos fechas de adjudicación con semántica distinta.** `fechaAdjudicacion` = fecha **programada** en el calendario (puede ser futura y existir aunque no haya adjudicación aún). `adjudicacionFecha` = fecha **efectiva**, solo cuando hay adjudicatarios reales.
- **`adjudicatarios` / `adjudicacionMonto` solo en licitaciones adjudicadas.** En una licitación recién publicada vienen `null`.
- **`modalidad` no se emite.** La API la entrega solo como código numérico sin catálogo de texto oficial para traducirla; se omite en vez de mostrar un número sin significado.
- **El detalle es más lento y más frágil con el ticket de pruebas.** Cada licitación con `conDetalle` = una llamada extra; bajo el ticket compartido puede toparse con el límite de la API.
- **Ventana máxima de 31 días** por corrida (una llamada por día).
- **Memoria del modo alertas acotada a 20.000 códigos** (los más recientes) y particionada por `estado` + `keyword` únicamente: cambiar la ventana de fechas o `maxResults` **no** abre una memoria distinta.
- **Alcance:** solo licitaciones (no órdenes de compra, convenios marco ni compra ágil). Datos tal como los publica la API oficial; el actor no corrige ni completa información faltante en la fuente.

### Preguntas frecuentes

**¿De dónde vienen los datos?** De la API oficial y pública de Mercado Público (ChileCompra), consultada en vivo en cada corrida.

**¿Es legal?** Sí: son datos públicos del Estado de Chile, consumidos por su API oficial con ticket. Sin scraping, sin datos personales de contacto.

**¿Con qué frecuencia se actualiza?** Cada ejecución consulta en vivo. Prográmalo diario con `soloNuevos` para monitoreo continuo.

**¿Necesito registrarme para probarlo?** No. Corre con el ticket de pruebas incorporado. Para uso sostenido, consigue tu ticket gratuito de ChileCompra.

# Actor input Schema

## `fecha` (type: `string`):

Día único a consultar, formato ddmmaaaa. Vacío = hoy (hora de Chile). Se ignora si usas 'desde'.

## `desde` (type: `string`):

Consulta un rango en vez de un solo día: relativo como 7d o 30d (incluye hoy), o fecha absoluta yyyy-mm-dd hasta hoy. Máximo 31 días por corrida.

## `estado` (type: `string`):

Filtro de estado de la licitación

## `keyword` (type: `string`):

Filtra por texto en el nombre de la licitación (ej: 'transporte', 'software', 'aseo')

## `conDetalle` (type: `boolean`):

Consulta el detalle de cada licitación filtrada (organismo, fechas, montos). Más lento.

## `incluirItemsDetalle` (type: `boolean`):

Incluye la lista completa de ítems como array — solo para consumo por API/JSON.

## `soloNuevos` (type: `boolean`):

Emite únicamente licitaciones que no viste en corridas anteriores con estos mismos filtros. Las ya vistas se omiten y no se cobran. La primera corrida entrega toda la ventana y ceba la memoria. Ideal con un Schedule diario.

## `marcarNuevos` (type: `boolean`):

Agrega el campo esNuevo a cada licitación sin filtrar ninguna. Útil si quieres ver todo pero distinguir lo nuevo.

## `maxResults` (type: `integer`):

Número máximo de licitaciones a devolver tras aplicar los filtros.

## `ticket` (type: `string`):

Tu ticket de api.mercadopublico.cl. Vacío = ticket público de pruebas (limitado, solo para evaluar el actor).

## Actor input object example

```json
{
  "estado": "todos",
  "conDetalle": false,
  "incluirItemsDetalle": false,
  "soloNuevos": false,
  "marcarNuevos": false,
  "maxResults": 200
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("cardumenbip/licitaciones-mercado-publico-chile").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("cardumenbip/licitaciones-mercado-publico-chile").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 '{}' |
apify call cardumenbip/licitaciones-mercado-publico-chile --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=cardumenbip/licitaciones-mercado-publico-chile",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Licitaciones Mercado Público Chile — Chile Government Tenders",
        "description": "Licitaciones públicas de Chile en tiempo real desde la API oficial de Mercado Público. Filtra por fecha, estado y palabra clave; incluye detalle con organismo, montos y fechas. Ideal para proveedores del Estado, ventas B2G y consultoras. Fuente de datos: Dirección ChileCompra.",
        "version": "0.5",
        "x-build-id": "DcMzSeKI0WEjl5bW8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cardumenbip~licitaciones-mercado-publico-chile/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cardumenbip-licitaciones-mercado-publico-chile",
                "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/cardumenbip~licitaciones-mercado-publico-chile/runs": {
            "post": {
                "operationId": "runs-sync-cardumenbip-licitaciones-mercado-publico-chile",
                "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/cardumenbip~licitaciones-mercado-publico-chile/run-sync": {
            "post": {
                "operationId": "run-sync-cardumenbip-licitaciones-mercado-publico-chile",
                "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": {
                    "fecha": {
                        "title": "Fecha (ddmmaaaa)",
                        "type": "string",
                        "description": "Día único a consultar, formato ddmmaaaa. Vacío = hoy (hora de Chile). Se ignora si usas 'desde'."
                    },
                    "desde": {
                        "title": "Desde (ventana de días)",
                        "type": "string",
                        "description": "Consulta un rango en vez de un solo día: relativo como 7d o 30d (incluye hoy), o fecha absoluta yyyy-mm-dd hasta hoy. Máximo 31 días por corrida."
                    },
                    "estado": {
                        "title": "Estado",
                        "enum": [
                            "todos",
                            "activas",
                            "publicada",
                            "cerrada",
                            "adjudicada"
                        ],
                        "type": "string",
                        "description": "Filtro de estado de la licitación",
                        "default": "todos"
                    },
                    "keyword": {
                        "title": "Palabra clave",
                        "type": "string",
                        "description": "Filtra por texto en el nombre de la licitación (ej: 'transporte', 'software', 'aseo')"
                    },
                    "conDetalle": {
                        "title": "Incluir detalle completo",
                        "type": "boolean",
                        "description": "Consulta el detalle de cada licitación filtrada (organismo, fechas, montos). Más lento.",
                        "default": false
                    },
                    "incluirItemsDetalle": {
                        "title": "Incluir ítems como array",
                        "type": "boolean",
                        "description": "Incluye la lista completa de ítems como array — solo para consumo por API/JSON.",
                        "default": false
                    },
                    "soloNuevos": {
                        "title": "Solo nuevas (modo alertas)",
                        "type": "boolean",
                        "description": "Emite únicamente licitaciones que no viste en corridas anteriores con estos mismos filtros. Las ya vistas se omiten y no se cobran. La primera corrida entrega toda la ventana y ceba la memoria. Ideal con un Schedule diario.",
                        "default": false
                    },
                    "marcarNuevos": {
                        "title": "Marcar cuáles son nuevas",
                        "type": "boolean",
                        "description": "Agrega el campo esNuevo a cada licitación sin filtrar ninguna. Útil si quieres ver todo pero distinguir lo nuevo.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Máximo de resultados",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Número máximo de licitaciones a devolver tras aplicar los filtros.",
                        "default": 200
                    },
                    "ticket": {
                        "title": "Ticket API Mercado Público",
                        "type": "string",
                        "description": "Tu ticket de api.mercadopublico.cl. Vacío = ticket público de pruebas (limitado, solo para evaluar el actor)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
