# ABC Chile Scraper - Productos y Precios (`scraperschile/abc-cl`) Actor

Scraper rapido de ABC Chile para extraer productos, precios, descuentos, marcas, categorias, imagenes y URLs desde abc.cl. Ideal para monitoreo de precios, comparacion de retail, inteligencia ecommerce y analisis del mercado chileno.

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

## Pricing

$3.00 / 1,000 producto extraidos

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

### ABC Chile Scraper for product prices, offers, and ecommerce catalog data

Extract public product data from `abc.cl` search results and export it as structured data from Apify. This ABC Chile scraper collects product names, prices, normal prices, discounts, brands, categories, product URLs, images, and availability from ABC's online catalog.

Use it as an ABC Chile product prices API for price monitoring, retail analytics, ecommerce catalog tracking, product matching, competitive intelligence, promotion monitoring, and recurring checks of public ABC.cl search results.

Also known as: ABC Chile scraper, ABC.cl scraper, ABC product price API, ABC retail scraper, Chile ecommerce scraper, scraping ABC Chile, productos ABC Chile, ofertas ABC Chile, ABC La Polar catalog data.

### What can this ABC.cl scraper do?

- Search ABC Chile by any product term such as `notebook`, `televisor`, `refrigerador`, `lavadora`, or a brand name.
- Save clean product rows to the default Apify Dataset.
- Export results as JSON, CSV, Excel, XML, RSS, or through the Apify API.
- Include price, normal price, discount, brand, category, image, URL, and availability when ABC publishes them.
- Run fast targeted searches with configurable result limits.
- Charge only per saved product result.

### Pricing

This Actor uses pay-per-result pricing. Each product saved to the dataset costs USD 0.003. Use `maxItems` to control the maximum number of charged results in each run.

### Data returned

Each dataset row can include:

| Field | Description |
| --- | --- |
| `product_id` | ABC product identifier. |
| `sku` | SKU or product identifier. |
| `name` | Product name shown by ABC. |
| `brand` | Product brand when available. |
| `price` | Current price in CLP. |
| `normal_price` | Normal or previous price when available. |
| `card_price` | Card or special price when available. |
| `discount_amount` | Discount amount when reported. |
| `discount_percentage` | Discount percentage when reported or calculated. |
| `currency` | Currency, usually `CLP`. |
| `is_available` | Whether the product appears available. |
| `availability` | Normalized availability state. |
| `category`, `category2`, `category3` | Product categories when available. |
| `seller_name` | Seller or marketplace when available. |
| `url` | Public product URL. |
| `image` | Product image URL. |
| `attributes` | Visible product attributes when available. |
| `page` | Result page where the product appeared. |
| `position` | Global product position in the run. |
| `source_url` | Search result URL used for extraction. |
| `search_term` | Search term used for the run. |
| `scraped_at` | Extraction timestamp. |

Example dataset item:

```json
{
  "product_id": "123456",
  "sku": "123456",
  "name": "Notebook 15.6 Intel Core i5",
  "brand": "Lenovo",
  "price": 399990,
  "normal_price": 499990,
  "discount_percentage": 20,
  "currency": "CLP",
  "is_available": true,
  "category": "Computacion",
  "url": "https://www.abc.cl/notebook-15-6-intel-core-i5/p",
  "search_term": "notebook"
}
````

### Quick start

1. Open the Actor on Apify.
2. Enter a search term in `term`, for example `notebook`.
3. Set `maxItems` to control how many products to save.
4. Start the run.
5. Open the Dataset tab to download products as CSV, JSON, Excel, XML, or consume them through the API.

Minimal input:

```json
{
  "term": "notebook",
  "maxItems": 20
}
```

Price-low-to-high search:

```json
{
  "term": "televisor",
  "maxItems": 50,
  "sort": "price-low-to-high"
}
```

### Input reference

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `term` | string | yes | Product, brand, category, or keyword to search on ABC.cl. |
| `maxItems` | integer | no | Maximum number of products to save. Default: `20`. |
| `pageSize` | integer | no | Products requested per page. Default: `24`. Maximum: `60`. |
| `maxPages` | integer | no | Optional maximum number of result pages. |
| `sort` | string | no | Sort order. Default: `relevantesparati`. |
| `concurrency` | integer | no | Pages processed in parallel. Default: `4`. |
| `retries` | integer | no | Request retries per page. Default: `2`. |
| `timeoutSecs` | integer | no | Request timeout in seconds. Default: `15`. |
| `failOnNoResults` | boolean | no | Fail the run when no products are found. Default: `false`. |

### Use cases

| Use case | How this Actor helps |
| --- | --- |
| ABC Chile price monitoring | Track current prices, normal prices, and discounts over time. |
| Chile retail analytics | Build datasets of ecommerce products, categories, brands, and offers. |
| Catalog matching | Match your products against ABC.cl names, SKUs, images, and URLs. |
| Promotion tracking | Capture discounted products and compare changes across scheduled runs. |
| Competitive intelligence | Compare public ABC pricing against other Chilean ecommerce stores. |
| Scheduled reports | Run the Actor on a schedule and export fresh product data to BI tools or spreadsheets. |

### How to run from API

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("scraperschile/abc-cl").call(
    run_input={
        "term": "notebook",
        "maxItems": 20,
        "pageSize": 24,
    }
)

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": "notebook",
    "maxItems": 20,
    "pageSize": 24
  }' \
  'https://api.apify.com/v2/acts/scraperschile~abc-cl/runs?waitForFinish=60'
```

### Reliability and limitations

This Actor reads public ABC.cl search results in real time. Prices, promotions, stock, categories, and availability can change at any moment and can differ from what a shopper sees later in the browser.

For large monitoring jobs, use reasonable `maxItems` values and schedules.

### Responsible use

This Actor extracts public product and catalog information. It does not collect credentials, private customer data, carts, orders, or account information. Use the data responsibly and follow Apify terms, ABC.cl terms, and applicable laws.

### FAQ

#### Can I scrape ABC Chile prices?

Yes. Enter a product or brand in `term`, and the Actor returns current prices plus normal prices and discounts when ABC publishes them.

#### Can I export ABC products to CSV?

Yes. Results are saved to the Apify Dataset, where you can download CSV, JSON, Excel, XML, RSS, or access items through the API.

#### Does this scrape all ABC.cl products?

It scrapes search result pages for the term you provide, up to your configured limits. It is optimized for targeted product, category, and brand monitoring.

#### Does it require an ABC account?

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

# Actor input Schema

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

Producto, marca o texto a buscar en ABC.cl. Ejemplos: notebook, televisor, refrigerador, zapatillas.

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

Limite de productos a guardar. Usalo para controlar costo y mantener corridas rapidas.

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

Cantidad de productos solicitados por pagina al sitio.

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

Limite opcional de paginas. Si se omite, se calcula desde maxItems y pageSize.

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

Ordenamiento publico disponible en ABC.cl.

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

Paginas procesadas en paralelo. El valor por defecto prioriza velocidad con bajo riesgo de bloqueo.

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

Reintentos por pagina si el sitio demora o corta temporalmente la respuesta.

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

Tiempo maximo en segundos para cada pagina de resultados.

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

Si esta activo, la corrida falla cuando no hay productos. Si esta apagado, termina con dataset vacio y OUTPUT no\_results.

## Actor input object example

```json
{
  "term": "notebook",
  "maxItems": 20,
  "pageSize": 24,
  "sort": "relevantesparati",
  "concurrency": 4,
  "retries": 2,
  "timeoutSecs": 15,
  "failOnNoResults": false
}
```

# Actor output Schema

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

Items del dataset por defecto con nombre, marca, precio, descuento, categoria, imagen y URL.

# 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": "notebook",
    "maxItems": 20,
    "pageSize": 24,
    "concurrency": 4
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperschile/abc-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": "notebook",
    "maxItems": 20,
    "pageSize": 24,
    "concurrency": 4,
}

# Run the Actor and wait for it to finish
run = client.actor("scraperschile/abc-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": "notebook",
  "maxItems": 20,
  "pageSize": 24,
  "concurrency": 4
}' |
apify call scraperschile/abc-cl --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ABC Chile Scraper - Productos y Precios",
        "description": "Scraper rapido de ABC Chile para extraer productos, precios, descuentos, marcas, categorias, imagenes y URLs desde abc.cl. Ideal para monitoreo de precios, comparacion de retail, inteligencia ecommerce y analisis del mercado chileno.",
        "version": "0.1",
        "x-build-id": "6bR4Q7NxcZfb6Ecte"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperschile~abc-cl/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperschile-abc-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~abc-cl/runs": {
            "post": {
                "operationId": "runs-sync-scraperschile-abc-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~abc-cl/run-sync": {
            "post": {
                "operationId": "run-sync-scraperschile-abc-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 ABC.cl. Ejemplos: notebook, televisor, refrigerador, zapatillas."
                    },
                    "maxItems": {
                        "title": "Maximo de productos",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Limite de productos a guardar. Usalo para controlar costo y mantener corridas rapidas.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "Productos por pagina",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Cantidad de productos solicitados por pagina al sitio.",
                        "default": 24
                    },
                    "maxPages": {
                        "title": "Maximo de paginas",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Limite opcional de paginas. Si se omite, se calcula desde maxItems y pageSize."
                    },
                    "sort": {
                        "title": "Ordenamiento",
                        "enum": [
                            "relevantesparati",
                            "new-arrivals",
                            "price-low-to-high",
                            "price-high-to-low",
                            "most-popular",
                            "mejor-evaluados"
                        ],
                        "type": "string",
                        "description": "Ordenamiento publico disponible en ABC.cl.",
                        "default": "relevantesparati"
                    },
                    "concurrency": {
                        "title": "Concurrencia",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Paginas procesadas en paralelo. El valor por defecto prioriza velocidad con bajo riesgo de bloqueo.",
                        "default": 4
                    },
                    "retries": {
                        "title": "Reintentos",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Reintentos por pagina si el sitio demora o corta temporalmente la respuesta.",
                        "default": 2
                    },
                    "timeoutSecs": {
                        "title": "Timeout por solicitud",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Tiempo maximo en segundos para cada pagina de resultados.",
                        "default": 15
                    },
                    "failOnNoResults": {
                        "title": "Fallar si no hay resultados",
                        "type": "boolean",
                        "description": "Si esta activo, la corrida falla cuando no hay productos. Si esta apagado, termina con dataset vacio y OUTPUT 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
