# Lider.cl Scraper - Productos y Precios Chile (`scraperschile/lider-cl`) Actor

Lider.cl scraper para extraer productos, precios, marcas, disponibilidad, vendedores, URLs e imagenes desde la busqueda publica de Lider.cl Chile. Exporta catalogo de supermercado y marketplace a Dataset, JSON, CSV, Excel o API para monitoreo de precios e inteligencia e-commerce.

- **URL**: https://apify.com/scraperschile/lider-cl.md
- **Developed by:** [Scrapers Chile](https://apify.com/scraperschile) (community)
- **Categories:** E-commerce
- **Stats:** 21 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

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

## Lider.cl Scraper - Productos, Precios y Catálogo Chile

Use this Apify Actor as a **Lider.cl scraper** to extract public product search results from `lider.cl`. It collects structured product data from the Lider Chile catalog, including product names, brands, current prices, list prices, availability, sellers, product URLs, images, ratings, and raw product metadata.

This Actor is useful for workflows such as **scraping Lider.cl products**, **Lider.cl price monitoring**, **Chile supermarket price tracking**, **retail catalog extraction**, **marketplace analysis**, **e-commerce research**, and building a structured **Lider.cl API** through Apify.

**Related searches:** Lider.cl scraper, Lider scraper Chile, Lider.cl API, Lider Chile products, Lider.cl price scraper, Lider.cl product data, Lider catalog scraper, supermarket scraper Chile, Chile grocery prices, retail price monitoring Chile, Apify Lider.cl, Walmart Chile scraper.

### What Can You Extract From Lider.cl?

Each run searches for a product term and saves matching products to the default Apify Dataset. Depending on what Lider.cl returns, each row can include:

| Field | Description |
| --- | --- |
| `name` | Public product name. |
| `brand` | Product brand. |
| `price` | Current numeric price. |
| `price_string` | Current price as displayed by Lider.cl. |
| `was_price` | Previous price when available. |
| `list_price` | List price when available. |
| `availability` | Availability text, for example in stock status. |
| `seller_name` | Seller name, such as Lider or marketplace seller. |
| `seller_type` | Seller type reported by Lider.cl. |
| `average_rating` | Average rating when available. |
| `number_of_reviews` | Number of reviews when available. |
| `url` | Public product URL. |
| `thumbnail` | Main product image. |
| `images` | Additional image URLs when available. |
| `search_term` | Search term used for the extraction. |
| `scraped_at` | Extraction timestamp. |
| `raw_product` | Original product payload serialized as JSON. |

### Typical Use Cases

| Use case | How this Actor helps |
| --- | --- |
| Price monitoring | Track current prices, previous prices, list prices, and promotions for products on Lider.cl. |
| Competitive intelligence | Compare Lider Chile catalog data with other supermarket, marketplace, or retail sources. |
| Product catalog extraction | Build a structured dataset of public product listings for a specific search term. |
| E-commerce analytics | Analyze brand coverage, seller mix, availability, ratings, and product URLs. |
| Grocery and retail research | Collect public Chile supermarket product data for reporting or market studies. |
| API integration | Use Apify API to run Lider.cl searches and pull Dataset items as JSON or CSV. |
| Data enrichment | Enrich internal product lists with public Lider.cl names, URLs, prices, images, and seller fields. |

### Quick Start

1. Open the Actor on Apify.
2. Enter a product search term, for example `leche`, `cafe`, `notebook`, `aceite`, or `detergente`.
3. Choose how many pages to extract.
4. Run the Actor.
5. Download results from the **Dataset** tab as JSON, CSV, Excel, XML, or access them through the Apify API.

Minimal input:

```json
{
  "term": "leche",
  "maxPages": 1
}
````

Example with more pages:

```json
{
  "term": "cafe molido",
  "maxPages": 5,
  "pageSize": 60,
  "delaySecs": 0.5
}
```

### Input Reference

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `term` | string | yes | Product or keyword to search on Lider.cl. Examples: `leche`, `arroz`, `iphone`, `detergente`. |
| `maxPages` | integer | no | Maximum number of result pages to scrape. Each page can return up to 60 products. Default: `1`. |
| `pageSize` | integer | no | Products per page. Lider.cl supports up to 60. Default: `60`. |
| `delaySecs` | number | no | Delay between pages to reduce request pressure. Default: `0.5`. |
| `retries` | integer | no | Retries per page when a request fails. Default: `3`. |
| `timeoutSecs` | integer | no | Timeout per request. Default: `20`. |
| `sort` | string | no | Optional Lider.cl sort value. Leave empty to use the default search order. |

### Output Example

```json
{
  "id": "6dedce73-844d-4423-92d3-ac45e0759178",
  "us_item_id": "00079919256382",
  "name": "4x Leche en Polvo NIDO® Entera 800g",
  "brand": "Nestlé",
  "price": 32190,
  "price_string": "$32,190.00",
  "list_price": 38790,
  "list_price_string": "$38,790.00",
  "availability": "In stock",
  "seller_name": "Nestlé S.A",
  "seller_type": "EXTERNAL",
  "url": "https://www.lider.cl/ip/lacteos/4x-leche-en-polvo-nido-entera-800g/00079919256382",
  "thumbnail": "https://i5.walmartimages.cl/asr/example.png",
  "search_term": "leche",
  "scraped_at": "2026-05-03T13:24:46"
}
```

### Run From The Apify API

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("scraperschile/lider-cl").call(
    run_input={
        "term": "leche",
        "maxPages": 2,
        "pageSize": 60,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["price"], item["url"])
```

#### cURL

```bash
curl -X POST \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <APIFY_API_TOKEN>' \
  -d '{
    "term": "leche",
    "maxPages": 2,
    "pageSize": 60
  }' \
  'https://api.apify.com/v2/acts/scraperschile~lider-cl/runs?waitForFinish=60'
```

### Technical Notes

- Built with the Apify Python SDK.
- Uses the public Lider.cl GraphQL catalog endpoint used by the website search flow.
- Paginates search results with configurable `pageSize` and `maxPages`.
- Deduplicates products by Lider.cl item ID.
- Saves normalized product rows to the default Apify Dataset.
- Stores a run summary in the default key-value store under `OUTPUT`.
- Does not require login and does not collect private account data.

### Responsible Use

This Actor extracts public product listing data from Lider.cl with configurable limits and delays. Use it responsibly, respect Lider.cl terms, Apify terms, and applicable laws. Do not use it to overload the source website, bypass access controls, collect private data, or perform abusive automated activity.

### FAQ

#### Can I scrape Lider.cl prices?

Yes. The Actor extracts current price, list price, previous price when available, and formatted price text from public Lider.cl search results.

#### Can I export Lider.cl product data to CSV?

Yes. Apify Datasets can be downloaded as CSV, JSON, Excel, XML, RSS, or accessed through the Apify API.

#### Does this Actor scrape the Lider.cl supermarket catalog?

It scrapes public search results from Lider.cl, including supermarket and marketplace products returned by the website for your search term.

#### Does it need a Lider.cl account?

No. It uses public catalog search data and does not log in.

#### How many products can one page return?

Lider.cl can return up to 60 products per page. Use `maxPages` to control how many pages the Actor extracts.

#### What happens if Lider.cl changes its API?

If Lider.cl changes the underlying catalog endpoint, headers, fields, or pagination behavior, the Actor may need an update.

# Actor input Schema

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

Producto, marca o texto a buscar en Lider.cl. Ejemplos: leche, cafe, arroz, detergente, notebook.

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

Limite de paginas de resultados de Lider.cl a extraer. Cada pagina contiene hasta 60 productos.

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

Cantidad de productos por pagina. Lider.cl soporta hasta 60.

## `delaySecs` (type: `number`):

Pausa en segundos entre paginas para reducir carga sobre el servicio.

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

Cantidad de reintentos por pagina si falla una solicitud.

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

Tiempo maximo en segundos para cada solicitud.

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

Valor de ordenamiento de Lider.cl para monitoreo o analisis de precios. Dejar vacio para usar el orden por defecto.

## Actor input object example

```json
{
  "term": "leche",
  "maxPages": 1,
  "pageSize": 60,
  "delaySecs": 0.5,
  "retries": 3,
  "timeoutSecs": 20,
  "sort": ""
}
```

# Actor output Schema

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

Items del dataset por defecto con nombre, marca, precio actual, precio lista, disponibilidad, vendedor, URL, imagen y termino de busqueda.

# 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": "leche"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperschile/lider-cl").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": "leche" }

# Run the Actor and wait for it to finish
run = client.actor("scraperschile/lider-cl").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": "leche"
}' |
apify call scraperschile/lider-cl --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lider.cl Scraper - Productos y Precios Chile",
        "description": "Lider.cl scraper para extraer productos, precios, marcas, disponibilidad, vendedores, URLs e imagenes desde la busqueda publica de Lider.cl Chile. Exporta catalogo de supermercado y marketplace a Dataset, JSON, CSV, Excel o API para monitoreo de precios e inteligencia e-commerce.",
        "version": "0.1",
        "x-build-id": "6Jf1LUteTliqeSNut"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperschile~lider-cl/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperschile-lider-cl",
                "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~lider-cl/runs": {
            "post": {
                "operationId": "runs-sync-scraperschile-lider-cl",
                "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~lider-cl/run-sync": {
            "post": {
                "operationId": "run-sync-scraperschile-lider-cl",
                "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 Lider.cl. Ejemplos: leche, cafe, arroz, detergente, notebook."
                    },
                    "maxPages": {
                        "title": "Maximo de paginas",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Limite de paginas de resultados de Lider.cl a extraer. Cada pagina contiene hasta 60 productos.",
                        "default": 1
                    },
                    "pageSize": {
                        "title": "Productos por pagina",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Cantidad de productos por pagina. Lider.cl soporta hasta 60.",
                        "default": 60
                    },
                    "delaySecs": {
                        "title": "Pausa entre paginas",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Pausa en segundos entre paginas para reducir carga sobre el servicio.",
                        "default": 0.5
                    },
                    "retries": {
                        "title": "Reintentos",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Cantidad de reintentos por pagina si falla una solicitud.",
                        "default": 3
                    },
                    "timeoutSecs": {
                        "title": "Timeout",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Tiempo maximo en segundos para cada solicitud.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Ordenamiento",
                        "type": "string",
                        "description": "Valor de ordenamiento de Lider.cl para monitoreo o analisis de precios. Dejar vacio para usar el orden por defecto.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
