# Paris (`scraperschile/paris`) Actor

Scraper de Paris Chile para extraer productos, precios, descuentos, marcas, categorias, stock, imagenes y URLs desde paris.cl. Usa el backend JSON publico del sitio para busquedas rapidas, paginacion completa, monitoreo de precios y retail intelligence.

- **URL**: https://apify.com/scraperschile/paris.md
- **Developed by:** [Scrapers Chile](https://apify.com/scraperschile) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Paris Chile Scraper

Extrae productos desde la busqueda publica de [Paris.cl](https://www.paris.cl/) usando el backend JSON del sitio. El Actor recibe un termino de busqueda, recorre la paginacion disponible y guarda un dataset listo para monitoreo de precios, comparacion de productos, retail intelligence y analisis del ecommerce chileno.

El scraper esta pensado para usuarios que necesitan datos accionables de Paris: precios actuales, precio normal, precio con tarjeta, descuento, marca, categoria, vendedor, disponibilidad, URL del producto, imagen e identificadores originales para trazabilidad.

### Que hace

- Busca productos en Paris Chile por termino ingresado por el usuario.
- Recorre automaticamente la paginacion completa cuando hay mas resultados.
- Permite limitar la ejecucion con `maxItems`, `maxPages`, `pageSize` y `concurrency`.
- Normaliza campos clave para analisis de datos y BI.
- Conserva el producto crudo serializado en `raw_product` para auditoria y enriquecimiento posterior.
- Entrega un resumen completo en `OUTPUT` con paginas recorridas, total reportado, facets, breadcrumbs y metadata de busqueda.

### Como usarlo

Configura el input con un termino de busqueda. Para una prueba rapida:

```json
{
  "term": "televisor",
  "maxItems": 100
}
````

Para recorrer mas resultados con control de paginacion:

```json
{
  "term": "notebook",
  "maxPages": 5,
  "pageSize": 100,
  "concurrency": 4,
  "sort": "price asc"
}
```

Para una ejecucion acotada de monitoreo:

```json
{
  "term": "zapatillas mujer",
  "maxItems": 50,
  "sort": "best-discount desc"
}
```

### Inputs disponibles

| Campo | Tipo | Descripcion |
| --- | --- | --- |
| `term` | string | Termino principal de busqueda. Requerido. |
| `maxItems` | integer | Maximo de productos a guardar. Util para controlar costos y pruebas. |
| `maxPages` | integer | Maximo de paginas a recorrer. Si se omite, usa toda la paginacion disponible o se detiene al llegar a `maxItems`. |
| `pageSize` | integer | Productos solicitados por pagina. El maximo validado es 200. |
| `concurrency` | integer | Paginas procesadas en paralelo. |
| `sort` | string | Ordenamiento: `relevance`, `price desc`, `price asc`, `best-discount desc`, `created-at desc`, `rating desc`. |
| `retries` | integer | Reintentos por pagina. |
| `timeoutSecs` | integer | Timeout por solicitud al backend. |
| `failOnNoResults` | boolean | Si esta activo, falla cuando Paris no devuelve productos. |

### Output

Cada item del dataset representa un producto encontrado en Paris.cl.

| Campo | Descripcion |
| --- | --- |
| `product_id` | ID original del producto en Paris. |
| `sku` | SKU principal del producto. |
| `name` | Nombre publico del producto. |
| `brand` | Marca. |
| `price` | Precio oferta o precio principal en CLP. |
| `normal_price` | Precio regular o precio anterior. |
| `card_price` | Precio con tarjeta Cencosud u otro metodo informado. |
| `discount_percentage` | Descuento porcentual respecto del precio normal. |
| `currency` | Moneda del precio. |
| `is_available` / `availability` | Disponibilidad normalizada. |
| `category` / `category_id` | Categoria principal inferida desde la busqueda. |
| `department_id`, `subdepartment_id`, `class_id` | Codigos originales de clasificacion. |
| `seller_name`, `sellers`, `is_marketplace` | Datos de vendedor y marketplace. |
| `url` | URL publica del producto. |
| `image` | Imagen principal. |
| `rating`, `reviews_count` | Senales de valoracion cuando Paris las informa. |
| `page`, `position` | Ubicacion aproximada en la busqueda. |
| `raw_product` | Producto original serializado como JSON para trazabilidad. |
| `search_term`, `scraped_at` | Termino usado y fecha de extraccion. |

### Casos de uso

- Monitoreo de precios de productos y categorias en Paris Chile.
- Comparacion de precios entre retailers chilenos.
- Seguimiento de descuentos y precios con tarjeta.
- Retail intelligence para marcas, marketplaces y equipos comerciales.
- Analisis de surtido, disponibilidad, vendedores y presencia de marca.
- Datasets para dashboards, modelos de pricing, alertas y reportes periodicos.

### Beneficios

- Usa una via backend JSON rapida y estable en vez de depender del render visual del sitio.
- Reduce tiempo de ejecucion y consumo de recursos frente a un scraper de navegador completo.
- Entrega datos normalizados y datos crudos en la misma ejecucion.
- Permite controlar volumen y costo con limites configurables.

### Limitaciones conocidas

- Los precios, descuentos, stock y disponibilidad pueden cambiar sin aviso en Paris.cl.
- El sitio puede aplicar limites temporales o bloqueos si se ejecuta con demasiada concurrencia.
- Algunos campos dependen de que Paris los informe en la respuesta de busqueda; si no existen, el Actor los deja vacios o `null`.
- La categoria principal se infiere desde breadcrumbs o facets de la busqueda, no desde una ficha de producto individual.
- Paris puede devolver resultados sugeridos o aproximados para terminos con pocas coincidencias.

### Notas tecnicas

El Actor consulta el endpoint de busqueda usado por Paris:

`https://be-paris-backend-cl-ms-search.ccom.paris.cl/products/`

Playwright fue usado solo para descubrir el flujo de red. La ejecucion productiva usa HTTP directo con `requests`, paginacion concurrente y reintentos.

# Actor input Schema

## `term` (type: `string`):

Producto, marca o texto a buscar en Paris.cl. Ejemplos: televisor, notebook, zapatillas, perfume, lavadora.

## `maxItems` (type: `integer`):

Limite opcional de productos a guardar. Util para pruebas rapidas, presupuestos controlados o monitoreos acotados.

## `maxPages` (type: `integer`):

Limite opcional de paginas a recorrer. Si se omite, el Actor recorre toda la paginacion disponible o hasta alcanzar maxItems.

## `pageSize` (type: `integer`):

Cantidad de productos solicitados por pagina al backend de Paris. Valores altos reducen llamadas; baja este valor si el sitio limita la respuesta.

## `concurrency` (type: `integer`):

Cantidad de paginas procesadas en paralelo. Baja este valor si Paris responde lento o bloquea solicitudes.

## `sort` (type: `string`):

Ordenamiento aceptado por Paris.

## `retries` (type: `integer`):

Cantidad de reintentos por pagina si Paris demora, corta o bloquea una solicitud.

## `timeoutSecs` (type: `integer`):

Tiempo maximo en segundos para cada llamada al backend de busqueda.

## `failOnNoResults` (type: `boolean`):

Si esta activo, la ejecucion falla cuando Paris no devuelve productos. Si esta apagado, guarda OUTPUT con estado no\_results.

## Actor input object example

```json
{
  "term": "televisor",
  "maxItems": 100,
  "pageSize": 100,
  "concurrency": 4,
  "sort": "relevance",
  "retries": 3,
  "timeoutSecs": 30,
  "failOnNoResults": false
}
```

# Actor output Schema

## `results` (type: `string`):

Items del dataset con nombre, marca, precios, descuento, disponibilidad, categoria, vendedor, URL e imagen.

## `summary` (type: `string`):

Registro OUTPUT con estado, paginas recorridas, metadata de busqueda y productos crudos agregados.

# 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 = {
    "term": "televisor",
    "maxItems": 100,
    "pageSize": 100,
    "concurrency": 4
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperschile/paris").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 = {
    "term": "televisor",
    "maxItems": 100,
    "pageSize": 100,
    "concurrency": 4,
}

# Run the Actor and wait for it to finish
run = client.actor("scraperschile/paris").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 '{
  "term": "televisor",
  "maxItems": 100,
  "pageSize": 100,
  "concurrency": 4
}' |
apify call scraperschile/paris --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Paris",
        "description": "Scraper de Paris Chile para extraer productos, precios, descuentos, marcas, categorias, stock, imagenes y URLs desde paris.cl. Usa el backend JSON publico del sitio para busquedas rapidas, paginacion completa, monitoreo de precios y retail intelligence.",
        "version": "0.1",
        "x-build-id": "y3xavFtbf78xcKtRb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperschile~paris/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperschile-paris",
                "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/scraperschile~paris/runs": {
            "post": {
                "operationId": "runs-sync-scraperschile-paris",
                "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/scraperschile~paris/run-sync": {
            "post": {
                "operationId": "run-sync-scraperschile-paris",
                "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",
                "required": [
                    "term"
                ],
                "properties": {
                    "term": {
                        "title": "Termino de busqueda",
                        "type": "string",
                        "description": "Producto, marca o texto a buscar en Paris.cl. Ejemplos: televisor, notebook, zapatillas, perfume, lavadora."
                    },
                    "maxItems": {
                        "title": "Maximo de productos",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Limite opcional de productos a guardar. Util para pruebas rapidas, presupuestos controlados o monitoreos acotados.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Maximo de paginas",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Limite opcional de paginas a recorrer. Si se omite, el Actor recorre toda la paginacion disponible o hasta alcanzar maxItems."
                    },
                    "pageSize": {
                        "title": "Productos por pagina",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Cantidad de productos solicitados por pagina al backend de Paris. Valores altos reducen llamadas; baja este valor si el sitio limita la respuesta.",
                        "default": 100
                    },
                    "concurrency": {
                        "title": "Concurrencia",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Cantidad de paginas procesadas en paralelo. Baja este valor si Paris responde lento o bloquea solicitudes.",
                        "default": 4
                    },
                    "sort": {
                        "title": "Ordenamiento",
                        "enum": [
                            "relevance",
                            "price desc",
                            "price asc",
                            "best-discount desc",
                            "created-at desc",
                            "rating desc"
                        ],
                        "type": "string",
                        "description": "Ordenamiento aceptado por Paris.",
                        "default": "relevance"
                    },
                    "retries": {
                        "title": "Reintentos",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Cantidad de reintentos por pagina si Paris demora, corta o bloquea una solicitud.",
                        "default": 3
                    },
                    "timeoutSecs": {
                        "title": "Timeout por solicitud",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Tiempo maximo en segundos para cada llamada al backend de busqueda.",
                        "default": 30
                    },
                    "failOnNoResults": {
                        "title": "Fallar si no hay resultados",
                        "type": "boolean",
                        "description": "Si esta activo, la ejecucion falla cuando Paris no devuelve productos. Si esta apagado, guarda OUTPUT con estado no_results.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
