# Chile Supermarket Prices Scraper (`automation-lab/chile-supermarket-price-comparison`) Actor

Search Jumbo and Santa Isabel Chile grocery catalogs and export current CLP prices, brands, availability, product URLs, and normalized cross-store match keys.

- **URL**: https://apify.com/automation-lab/chile-supermarket-price-comparison.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.84 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Chile Supermarket Prices Scraper

Search current **Chile supermarket prices** at Jumbo and Santa Isabel. Supply grocery terms in Spanish and receive typed product records with identity, brand, current CLP price, availability, product URL, and a normalized key for comparing like-named items across the two supported catalogs.

The Actor is designed for scheduled grocery basket snapshots, retail analysis, procurement research, spreadsheet exports, and downstream price-change pipelines. It reads public catalog data; it does not place orders or access customer accounts.

### What does Chile Supermarket Prices Scraper do?

For every query, the Actor searches each selected supermarket and exports current catalog rows.

It can:

- search Jumbo Chile and Santa Isabel Chile in one run;
- accept up to 20 Spanish product terms;
- search either source alone when you need source-specific data;
- extract displayed product identity, brand, CLP prices, and availability;
- include product, source, and image URLs;
- group like-named products through `matchKey`;
- flag identities found in both catalogs with `matchedAcrossStores`;
- limit results per store and query;
- export the default dataset as JSON, CSV, Excel, XML, RSS, or through the Apify API.

Lider and Unimarc are intentionally not supported. Their current extraction routes were not proved for this product, so this Actor does not make unsupported four-chain coverage claims.

### Who is this Chile grocery price data for?

- Retail analysts building recurring Chilean grocery baskets.
- Consumer packaged goods teams checking current assortment and shelf-price signals.
- Procurement teams collecting comparable product snapshots.
- Price-comparison sites importing structured catalog records.
- Data teams loading Chilean supermarket data into warehouses or spreadsheets.
- Developers running scheduled price-change workflows with Apify.

### Why use this Actor?

#### Two supported catalogs in one contract

Jumbo and Santa Isabel rows use the same field names, currency, availability values, and timestamps. You do not need to maintain separate parsers.

#### Comparison-oriented identity

Every record includes a deterministic `matchKey` based on normalized brand and product name. `matchedStores` shows where that identity appeared in the current query.

#### Lightweight public extraction

The Actor reads structured state exposed by each retailer search page. It does not launch a browser, download product media, log in, or require a user-supplied credential.

#### Honest source boundaries

A match key is a candidate grouping aid, not a guaranteed GTIN-level equivalence. Package sizes and title wording should still be reviewed before making automated purchasing decisions.

### What Chile supermarket fields can I extract?

| Field | Description |
| --- | --- |
| `query` | Input product term that found the row |
| `store` | `jumbo` or `santa-isabel` |
| `productId` | Source product or SKU identity |
| `matchKey` | Stable normalized brand/name grouping key |
| `matchedStores` | Selected stores exposing the same match key |
| `matchedAcrossStores` | Whether both stores exposed the key |
| `productName` | Displayed product name |
| `brand` | Displayed brand, or `null` |
| `currentPriceClp` | Current numeric price in Chilean pesos |
| `regularPriceClp` | List/regular CLP price when exposed, otherwise `null` |
| `currency` | Always `CLP` |
| `availability` | `in_stock` or `out_of_stock` |
| `availableQuantity` | Public quantity when exposed, otherwise `null` |
| `productUrl` | Product page on the selected supermarket domain |
| `sourceUrl` | Search page used for extraction |
| `imageUrl` | Public image URL when exposed |
| `scrapedAt` | UTC collection timestamp |

### How much does it cost to compare Chile supermarket prices?

This Actor uses pay-per-event pricing:

- **Start:** $0.0005 once per run.
- **Product item:** tiered by your Apify plan; the BRONZE price is $0.0014 per saved row.

Only valid rows saved to the default dataset receive an item charge. Failed requests and rejected source objects are not charged as items.

BRONZE examples:

| Saved rows | Actor event charge |
| ---: | ---: |
| 10 | $0.0145 |
| 50 | $0.0705 |
| 100 | $0.1405 |

Final live pricing is shown on the Actor page. Apify platform usage may also apply under your plan.

### How to compare Jumbo and Santa Isabel prices

1. Open the Actor input page.
2. Add product terms such as `leche`, `arroz`, and `aceite`.
3. Keep both supermarkets selected.
4. Set the maximum products per store and query.
5. Click **Start**.
6. Open the default dataset and use the `overview` view.
7. Group rows by `query` and `matchKey` to compare current CLP prices.

Example input:

```json
{
  "queries": ["leche", "arroz"],
  "stores": ["jumbo", "santa-isabel"],
  "maxItemsPerStore": 10
}
```

### Input parameters

#### `queries`

Required in practice; defaults to `leche`. Supply one to 20 non-empty Spanish product terms. Duplicate terms are removed.

#### `stores`

Choose `jumbo`, `santa-isabel`, or both. The default selects both for comparison. Any other value fails validation rather than silently switching sources.

#### `maxItemsPerStore`

An integer from 1 to 100. It applies separately to every selected store and query. Jumbo supports multiple 40-item pages. Santa Isabel currently exposes up to 20 items in its public search state, so a higher limit does not invent additional Santa Isabel records.

### Output example

A current row has this shape:

```json
{
  "query": "leche",
  "store": "jumbo",
  "productId": "leche-soprole-natural-1-litro",
  "matchKey": "c68088526c015ae4",
  "matchedStores": ["jumbo"],
  "matchedAcrossStores": false,
  "productName": "Leche Soprole Entera Natural 1 L",
  "brand": "Soprole",
  "currentPriceClp": 1150,
  "regularPriceClp": null,
  "currency": "CLP",
  "availability": "in_stock",
  "availableQuantity": null,
  "productUrl": "https://www.jumbo.cl/leche-soprole-natural-1-litro/p",
  "sourceUrl": "https://www.jumbo.cl/busqueda?ft=leche",
  "imageUrl": "https://jumbocl.vteximg.com.br/arquivos/ids/527740-250-250/Leche-Soprole-Entera-Natural-1-L.jpg",
  "scrapedAt": "2026-08-27T20:30:00.000Z"
}
```

Prices and assortment can change between runs. Treat the example as a field contract, not as a permanent price quote.

### Matching behavior and limitations

`matchKey` normalizes accents, punctuation, casing, brand, title text, and common pack wording before hashing the result.

This approach is useful for repeatable candidate grouping, but it does not prove exact equivalence when:

- package quantities differ;
- one source abbreviates a flavor or size;
- a product title omits the brand;
- retailer bundles use different wording;
- two products share a similar name.

For high-stakes comparisons, review `productName`, `brand`, price, and product URL together. The Actor does not claim barcode matching when a source does not expose a barcode.

### Scheduling recurring grocery snapshots

Use an Apify schedule to run the same basket daily or weekly. Each dataset row includes `scrapedAt`, allowing downstream systems to compare snapshots.

A common workflow is:

1. create a Task with a stable basket input;
2. schedule it at the desired interval;
3. send dataset rows to Google Sheets, Make, Zapier, or a webhook;
4. retain prior snapshots in your warehouse;
5. compare `store`, `matchKey`, and `currentPriceClp` over time.

The Actor returns current observations. It does not maintain a hidden historical database or send alerts by itself.

### Export to spreadsheets and data pipelines

From the dataset page, export CSV or Excel for analyst review. For automated pipelines, use the dataset API or an Apify integration.

Recommended keys:

- deduplicate a snapshot with `store + productId`;
- compare likely equivalents with `query + matchKey`;
- order snapshots with `scrapedAt`;
- preserve `sourceUrl` and `productUrl` for auditability.

### Run through the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~chile-supermarket-price-comparison/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["leche"],"stores":["jumbo","santa-isabel"],"maxItemsPerStore":10}'
```

To wait and receive dataset items:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~chile-supermarket-price-comparison/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["arroz"],"stores":["jumbo"],"maxItemsPerStore":10}'
```

### Use from JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/chile-supermarket-price-comparison').call({
  queries: ['café', 'aceite'],
  stores: ['jumbo', 'santa-isabel'],
  maxItemsPerStore: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use from Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/chile-supermarket-price-comparison').call(run_input={
    'queries': ['pasta'],
    'stores': ['jumbo', 'santa-isabel'],
    'maxItemsPerStore': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Connect through MCP

#### Claude Code setup

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/chile-supermarket-price-comparison"
```

#### Claude Desktop setup

Use this JSON configuration in Claude Desktop:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/chile-supermarket-price-comparison"
    }
  }
}
```

#### Cursor setup

Add the same `mcpServers` JSON to Cursor's MCP settings.

#### VS Code setup

Add the same HTTP server URL to the MCP configuration used by your VS Code AI extension.

Example prompts:

- “Search Jumbo and Santa Isabel for leche and compare current CLP prices.”
- “Export 15 Jumbo arroz products with brand and availability.”
- “Collect a coffee, oil, and pasta basket for my weekly Chile grocery snapshot.”

### Reliability and failure behavior

The Actor validates all inputs before requesting source pages. It retries transient timeouts, 429 responses, and temporary 5xx errors with bounded retries.

A changed or challenged page is treated as a failure, not as a successful empty result. This prevents a storefront change from silently producing misleading zero-row snapshots.

No-result searches finish successfully with no rows for that source. Try a broader Spanish product term when a very specific query has no catalog result.

### Legality and responsible use

The Actor reads publicly accessible product catalog information. You are responsible for complying with applicable law, retailer terms, contractual obligations, and data-use requirements.

Use conservative schedules, request only the records you need, and avoid attempts to access accounts, checkout flows, or non-public endpoints. Do not use price observations as guarantees of in-store fulfillment.

### Troubleshooting

#### Why did Santa Isabel return fewer than my limit?

Its current public search state exposes up to 20 records per query. The Actor reports the useful exposed set and does not duplicate rows to meet a limit.

#### Why is `matchedAcrossStores` false?

The other store may not expose the same normalized brand and title in the returned result window. Search a more specific product term or compare the names manually.

#### Why did the run fail instead of returning zero records?

The Actor fails when a source response no longer has its expected structured catalog shape. That usually indicates a temporary block or storefront change rather than a genuine empty search.

#### Can I scrape Lider or Unimarc?

No. This Actor deliberately supports only Jumbo and Santa Isabel. Unsupported store names fail validation.

#### Does the Actor guarantee in-store stock?

No. Availability reflects the public online offer at collection time and may differ by location or fulfillment context.

### FAQ

#### Does it compare historical prices?

It returns current snapshots. Schedule recurring runs and retain datasets to build history.

#### Can I search more than one product?

Yes. Supply up to 20 terms. Limits apply separately to each query and store.

#### Are prices numeric?

Yes. `currentPriceClp` and available regular prices are numeric CLP values.

#### Does it download product images?

No. It exports the public image URL without downloading image files.

#### Is a proxy required?

No automatic paid proxy mode is used. The current implementation accesses the public structured pages directly.

### Related automation-lab Actors

For non-Chilean grocery analysis, consider [Superstore & No Frills Grocery Prices](https://apify.com/automation-lab/superstore-no-frills-grocery-prices) for Canadian store-scoped products and [ASDA Grocery Products & Prices Scraper](https://apify.com/automation-lab/asda-grocery-products-prices) for UK catalog searches.

# Actor input Schema

## `queries` (type: `array`):

One to 20 grocery product terms in Spanish, such as leche, arroz, café, or aceite.

## `stores` (type: `array`):

Search both supported supermarkets for comparison, or select one source. Lider and Unimarc are not supported.

## `maxItemsPerStore` (type: `integer`):

Stop after this many unique products from each selected supermarket for each query. Santa Isabel currently exposes up to 20 results per search page.

## Actor input object example

```json
{
  "queries": [
    "leche",
    "arroz"
  ],
  "stores": [
    "jumbo",
    "santa-isabel"
  ],
  "maxItemsPerStore": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all valid product observations saved by this run.

# 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 = {
    "queries": [
        "leche",
        "arroz"
    ],
    "stores": [
        "jumbo",
        "santa-isabel"
    ],
    "maxItemsPerStore": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/chile-supermarket-price-comparison").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 = {
    "queries": [
        "leche",
        "arroz",
    ],
    "stores": [
        "jumbo",
        "santa-isabel",
    ],
    "maxItemsPerStore": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/chile-supermarket-price-comparison").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 '{
  "queries": [
    "leche",
    "arroz"
  ],
  "stores": [
    "jumbo",
    "santa-isabel"
  ],
  "maxItemsPerStore": 10
}' |
apify call automation-lab/chile-supermarket-price-comparison --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/chile-supermarket-price-comparison"
        }
    }
}

```

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/7Dle1c15f3HtYnhrf/builds/o5Ou9YECujwh4z1Av/openapi.json