# Mercadona Scraper — Spanish Supermarket Prices (`studio-amba/mercadona-scraper`) Actor

Scrape products, prices, unit prices, brands, and promotions from Mercadona.es — Spain's largest supermarket chain. Search by keyword or scrape the catalog. No login required.

- **URL**: https://apify.com/studio-amba/mercadona-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Mercadona Scraper — Spanish Supermarket Products & Prices

Scrape products, prices, unit prices, brands, and promotions from
[Mercadona.es](https://www.mercadona.es), Spain's largest supermarket chain.
Search the full online catalog by keyword and get structured product data back
as JSON, CSV, or Excel. No login, no cookies, no browser automation required.

Mercadona runs more than 1,600 stores across Spain and Portugal and is the
country's market leader by revenue. Its online shop (`tienda.mercadona.es`)
exposes a clean product catalog of roughly 4,000+ items per region, all of
which this Actor can read directly.

### What this Actor does

- Searches the Mercadona online catalog for any keyword (e.g. `leche`,
  `aceite de oliva`, `pasta`, `hacendado`).
- Returns every matching product with its current price, unit price, pack
  size, brand, category, image, and stock status.
- Detects products currently on offer (promotion / price drop).
- Pulls regional pricing from a configurable warehouse (default: Madrid).
- Paginates automatically up to your requested `maxResults`.

### How to scrape Mercadona data

1. Open the Actor and set a **Search Query** — for example `leche`, `pan`,
   `aceite`, or a brand like `hacendado`. Leave it empty and the Actor falls
   back to a default search so you always get data.
2. Set **Max Results** to how many products you want (default 50).
3. (Optional) Set a **Warehouse index** if you need a specific region's
   prices. The default `4315` returns Madrid pricing, which is representative
   for most use cases.
4. (Optional) Adjust **Proxy Configuration**. The default Apify datacenter
   proxy works because the Mercadona product API has no geo-lock.
5. Click **Start**. When the run finishes, open the **Dataset** tab and export
   to JSON, CSV, Excel, or pull it via the Apify API.

The Actor reads Mercadona's public product search API directly, so it is fast
and reliable — there is no headless browser, no scrolling, and no captcha
solving involved.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Keyword to search for. Defaults to `leche` if empty. |
| `maxResults` | integer | Maximum number of products to return (1–5000). Default 50. |
| `warehouse` | string | Warehouse index for regional pricing. Default `4315` (Madrid). |
| `proxyConfiguration` | object | Proxy settings. Default Apify datacenter proxy. |

#### Example input

```json
{
  "searchQuery": "aceite de oliva",
  "maxResults": 50,
  "warehouse": "4315",
  "proxyConfiguration": { "useApifyProxy": true }
}
````

Empty input also works — `{}` returns a default sample of products.

### Output

Each item in the dataset looks like this:

```json
{
  "name": "Leche semidesnatada Hacendado",
  "brand": "Hacendado",
  "ean": null,
  "sku": "10381",
  "price": 5.04,
  "currency": "EUR",
  "unit": "6 x 6 l",
  "unitPrice": "0.84/L",
  "promotionPrice": null,
  "category": "Huevos, leche y mantequilla",
  "url": "https://tienda.mercadona.es/product/10381/leche-semidesnatada-hacendado-pack-6",
  "imageUrl": "https://prod-mercadona.imgix.net/images/b9613b9354f8b0705f998b2201ffe443.jpg?fit=crop&h=300&w=300",
  "inStock": true,
  "scrapedAt": "2026-06-24T10:00:00.000Z"
}
```

#### Output fields

| Field | Description |
|-------|-------------|
| `name` | Product display name. |
| `brand` | Brand (Mercadona's own brand is `Hacendado`). |
| `ean` | EAN barcode if available (often null in search results). |
| `sku` | Mercadona internal product id. |
| `price` | Total price of the sold item, in EUR. |
| `currency` | Always `EUR`. |
| `unit` | Pack / size description (e.g. `6 x 6 l`, `1 kg`). |
| `unitPrice` | Reference price per standard unit (e.g. `0.84/L`). |
| `promotionPrice` | Current price when the product is on offer, else null. |
| `category` | Top-level Mercadona category. |
| `url` | Direct link to the product page. |
| `imageUrl` | Product thumbnail. |
| `inStock` | Whether the product is currently available. |
| `scrapedAt` | ISO timestamp of when the item was scraped. |

### Why prices are regional

Mercadona sets prices per logistics warehouse, so the same product can cost
slightly more or less depending on the region. This Actor defaults to the
Madrid warehouse (index `4315`), which is a good national reference. If you
need a different region, change the `warehouse` input to that region's
warehouse index.

### Common use cases

- **Price monitoring** — track Mercadona prices over time for specific
  products or whole categories.
- **Competitive intelligence** — compare Mercadona prices against other
  Spanish supermarkets.
- **Market research** — analyze the assortment, brands, and pack formats in a
  category.
- **Promotion tracking** — find products currently on offer.
- **Catalog enrichment** — pull product names, images, and categories for your
  own database.

### Tips

- Use specific keywords for precise results (`leche desnatada` rather than
  `leche`).
- Increase `maxResults` to capture an entire category. The Actor paginates
  automatically.
- Run the Actor on a schedule (Apify Schedules) to build a price history.
- Combine multiple runs with different `searchQuery` values to cover your full
  product list.

### Frequently asked questions

#### Do I need a Mercadona account?

No. This Actor reads the public product catalog. No login, cookies, or
credentials are required.

#### Is a proxy required?

A proxy is recommended for reliability and is enabled by default. The Mercadona
product API has no country lock, so the standard Apify datacenter proxy is
enough. Switch to residential Spanish proxies only if you hit rate limits on
very large runs.

#### How fresh is the data?

Prices and availability are read live from Mercadona at the moment of the run,
for the selected warehouse.

#### Can I get all products at once?

Yes. Leave a broad `searchQuery` and raise `maxResults`. To cover the whole
catalog, run several searches across categories and merge the datasets.

### Legal

Use this Actor responsibly and in accordance with Mercadona's terms of service
and applicable law. Scrape only publicly available data and respect reasonable
request rates. You are responsible for how you use the data you collect.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for products by name or keyword (e.g., 'leche', 'pasta', 'hacendado', 'aceite de oliva'). Leave empty to scrape a sample of products from the catalog.

## `maxResults` (type: `integer`):

Maximum number of products to return.

## `warehouse` (type: `string`):

Mercadona warehouse index used to resolve regional prices. Prices vary slightly by region. The default (4315, Madrid) works for most use cases. Leave as-is unless you specifically need another region's prices.

## `proxyConfiguration` (type: `object`):

Proxy settings. The Mercadona product API has no geo-lock, so the default Apify datacenter proxy (no country) works fine. Use Spanish residential proxies only if you hit rate limits.

## Actor input object example

```json
{
  "searchQuery": "leche",
  "maxResults": 20,
  "warehouse": "4315",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchQuery": "leche",
    "maxResults": 20,
    "warehouse": "4315",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/mercadona-scraper").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 = {
    "searchQuery": "leche",
    "maxResults": 20,
    "warehouse": "4315",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/mercadona-scraper").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 '{
  "searchQuery": "leche",
  "maxResults": 20,
  "warehouse": "4315",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/mercadona-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercadona Scraper — Spanish Supermarket Prices",
        "description": "Scrape products, prices, unit prices, brands, and promotions from Mercadona.es — Spain's largest supermarket chain. Search by keyword or scrape the catalog. No login required.",
        "version": "0.1",
        "x-build-id": "fRpcRg4c6g2sR6y0a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~mercadona-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-mercadona-scraper",
                "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/studio-amba~mercadona-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-mercadona-scraper",
                "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/studio-amba~mercadona-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-mercadona-scraper",
                "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",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by name or keyword (e.g., 'leche', 'pasta', 'hacendado', 'aceite de oliva'). Leave empty to scrape a sample of products from the catalog."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 50
                    },
                    "warehouse": {
                        "title": "Warehouse index (price region)",
                        "type": "string",
                        "description": "Mercadona warehouse index used to resolve regional prices. Prices vary slightly by region. The default (4315, Madrid) works for most use cases. Leave as-is unless you specifically need another region's prices.",
                        "default": "4315"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. The Mercadona product API has no geo-lock, so the default Apify datacenter proxy (no country) works fine. Use Spanish residential proxies only if you hit rate limits."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
