# Paris Chile Scraper - Productos, Precios y Ofertas (`scraperschile/paris`) Actor

Scraper de Paris Chile para obtener productos, precios, descuentos, stock, marcas, categorías, vendedores, imágenes y enlaces. Exporta resultados a Dataset, JSON, CSV, Excel o API para comparar catálogos, monitorear ofertas y analizar retail.

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

## Pricing

from $3.00 / 1,000 producto extraidos

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraperschile/paris"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/kfQFzCplvdS2Cb7jj/builds/dCuZ1VrSsHmLnW0iQ/openapi.json