# Barbora.ee Scraper — Estonian Groceries & Prices (`studio-amba/barbora-ee-scraper`) Actor

Scrape the Barbora.ee Estonian online-grocery catalogue: product names, EUR prices, Aitäh loyalty offers, price per unit, brands, categories and images. Search by keyword or scrape any category. No login, no cookies.

- **URL**: https://apify.com/studio-amba/barbora-ee-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

from $4.00 / 1,000 result scrapeds

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

## Barbora.ee Scraper — Estonian Groceries & Prices

Scrape the full Barbora.ee online-grocery catalogue: product names, EUR prices,
Aitäh loyalty offers, per-unit prices, brands, categories and images. Search by
keyword or pull any category. No login, no cookies.

Barbora is the leading online grocery in Estonia (part of the Maxima Group).
This actor turns its storefront into clean, structured JSON you can drop into a
spreadsheet, a price monitor, or a data pipeline.

### Why use this actor?

Grocery prices move constantly, and Barbora is the reference store for the
Estonian market. If you track retail prices, run a competing shop, build a
price-comparison site, or do market research on FMCG in the Baltics, this actor
gives you the live catalogue on demand. Every run returns current shelf prices,
loyalty-card offers and per-unit prices so you can compare like for like.

- Live EUR prices, including Aitäh loyalty (member) pricing and the pre-discount price.
- Per-unit price (for example €0.89/l) so different pack sizes are comparable.
- Full category path, brand, image and product URL for every item.
- No account, no cookies, no login. You give a keyword or a category and get data back.

### How to scrape Barbora.ee data

1. Add the actor to your Apify account and open the input form.
2. Type a search keyword in Estonian (for example `piim` for milk, `kohv`
   for coffee, `juust` for cheese), **or** paste a category URL from barbora.ee.
3. Set `maxResults` to how many products you want. Barbora returns 52 products
   per page; set it high to pull a whole category.
4. Provide a Bright Data Web Unlocker API key (see "Access" below).
5. Run the actor. Results stream into the dataset and can be exported as JSON,
   CSV or Excel.

To scrape a specific category, browse Barbora, open a category, and copy the URL
(for example `https://barbora.ee/piimatooted-ja-munad/piimad`). Paste it into
the `categoryUrl` field. The actor walks every page of that category up to your
`maxResults` limit.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Search keyword in Estonian (e.g. `piim`). Defaults to `piim` when nothing is set. |
| `categoryUrl` | String | No | A Barbora category URL or path. Takes priority over the search query. |
| `maxResults` | Integer | No | Maximum products to return (default 100). |
| `requestDelaySecs` | Integer | No | Pause between page fetches for large runs (default 0). |
| `brightDataApiKey` | String | Yes | Bright Data Web Unlocker API key. Falls back to the `BRIGHT_DATA_API_KEY` environment variable. |
| `proxyConfiguration` | Object | No | Proxy settings for auxiliary requests. |

Leave everything empty and the actor searches for `piim` (milk) so a bare run
still returns data.

### Output

Each result is a flat JSON object:

| Field | Type | Example |
|-------|------|---------|
| `name` | String | `"Piim 2,5% FARMI 1l kiles"` |
| `brand` | String | `"FARMI"` |
| `price` | Number | `0.89` |
| `currency` | String | `"EUR"` |
| `originalPrice` | Number | `1.19` |
| `pricePerUnit` | String | `"€0.89/l"` |
| `discount` | String | `"-25% (Aitäh loyalty)"` |
| `productId` | String | `"000000000000123456"` |
| `inStock` | Boolean | `true` |
| `category` | String | `"Piimatooted ja munad > Piimad > Piimad"` |
| `countryOfOrigin` | String | `"Estonia"` |
| `imageUrl` | String | `"https://cdn.barbora.ee/products/….png"` |
| `url` | String | `"https://barbora.ee/toode/piim-2-5-proc-farmi-1-l-kiles"` |
| `scrapedAt` | String | `"2026-07-07T08:00:00.000Z"` |

#### Example output

```json
{
  "name": "Piim 2,5% FARMI 1l kiles",
  "brand": "FARMI",
  "price": 0.89,
  "currency": "EUR",
  "pricePerUnit": "€0.89/l",
  "inStock": true,
  "category": "Piimatooted ja munad > Piimad > Piimad",
  "imageUrl": "https://cdn.barbora.ee/products/29dff94c-3626-4a4d-9f4b-28d20f50a19a_m.png",
  "url": "https://barbora.ee/toode/piim-2-5-proc-farmi-1-l-kiles",
  "scrapedAt": "2026-07-07T08:00:00.000Z"
}
````

### Access

Barbora sits behind a Cloudflare managed challenge, so the actor fetches pages
through the Bright Data Web Unlocker, which solves the challenge and returns the
rendered page. You need a Bright Data account with a Web Unlocker zone. Provide
the API key in the `brightDataApiKey` input field or set the
`BRIGHT_DATA_API_KEY` environment variable on the actor.

This is the standard, reliable way to reach the site. Without a key the run
stops immediately with a clear message.

### Pricing note

Barbora prices depend on the delivery region (each fulfillment centre has its
own price and stock). The actor returns the storefront's default-region price,
which matches what most shoppers see. Loyalty (Aitäh) member prices are captured
in `price` with the regular price in `originalPrice` and the saving in
`discount`.

### How it works

Barbora renders each listing page server-side with the full product grid, EUR
prices included. The actor reads that data directly, one page at a time (52
products per page), and stops when a category runs out of products or your
`maxResults` limit is reached. Long category walks resume automatically if the
run is migrated between servers, so you never get duplicates or a half-finished
pull.

### Limitations

- Prices are for the storefront's default delivery region.
- A valid Bright Data Web Unlocker key is required.
- Search returns Barbora's own relevance ranking; very broad keywords return a
  lot of products, so set `maxResults` to keep runs focused.
- Ratings and reviews are not exposed on Barbora listing pages, so they are not
  included.

### Related Scrapers

Building a Baltic or European grocery price dataset? Pair this with the other
grocery scrapers in the same family:

- [Barbora.lt Scraper](https://apify.com/studio-amba/barbora-lt-scraper) — Lithuanian groceries
- [Tesco Groceries Scraper](https://apify.com/studio-amba/tesco-scraper) — UK groceries
- [Tesco CZ Scraper](https://apify.com/studio-amba/tesco-cz-scraper) — Czech groceries
- [Rohlik Scraper](https://apify.com/studio-amba/rohlik-scraper) — Czech / German / Austrian groceries
- [Albert Heijn Scraper](https://apify.com/studio-amba/albert-heijn-scraper) — Dutch groceries
- [Lidl Scraper](https://apify.com/studio-amba/lidl-scraper) — pan-European discounter

Barbora runs the same platform in Lithuania (barbora.lt), Latvia (barbora.lv)
and Estonia (barbora.ee); this actor covers the Estonian market.

# Actor input Schema

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

Search Barbora.ee groceries by keyword in Estonian (e.g., 'piim' = milk, 'kohv' = coffee, 'juust' = cheese).

## `categoryUrl` (type: `string`):

A Barbora.ee category to scrape. Full URL (https://barbora.ee/piimatooted-ja-munad/piimad) or a path (piimatooted-ja-munad/piimad). Takes priority over the search query.

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

Maximum number of products to return. Barbora returns 52 products per page; set high (e.g., 5000) to pull a full category.

## `requestDelaySecs` (type: `integer`):

Minimum pause between page fetches. Bright Data rate-limits rapid-fire requests; a delay of 5-15s keeps a large category walk under the limit (slower but reliable). 0 = full speed.

## `brightDataApiKey` (type: `string`):

Bright Data API key for the Web Unlocker zone. Required — Barbora is behind a Cloudflare managed challenge and cannot be reached without it. Falls back to the BRIGHT\_DATA\_API\_KEY environment variable.

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

Proxy settings. Barbora access itself goes through the Bright Data Web Unlocker; this proxy is used for any auxiliary requests.

## Actor input object example

```json
{
  "searchQuery": "piim",
  "maxResults": 20,
  "requestDelaySecs": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "EE"
  }
}
```

# 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": "piim",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "EE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/barbora-ee-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": "piim",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "EE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/barbora-ee-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": "piim",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "EE"
  }
}' |
apify call studio-amba/barbora-ee-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Barbora.ee Scraper — Estonian Groceries & Prices",
        "description": "Scrape the Barbora.ee Estonian online-grocery catalogue: product names, EUR prices, Aitäh loyalty offers, price per unit, brands, categories and images. Search by keyword or scrape any category. No login, no cookies.",
        "version": "0.1",
        "x-build-id": "ZKX0LWMQz2JqThVax"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~barbora-ee-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-barbora-ee-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~barbora-ee-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-barbora-ee-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~barbora-ee-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-barbora-ee-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 Barbora.ee groceries by keyword in Estonian (e.g., 'piim' = milk, 'kohv' = coffee, 'juust' = cheese)."
                    },
                    "categoryUrl": {
                        "title": "Category URL or path",
                        "type": "string",
                        "description": "A Barbora.ee category to scrape. Full URL (https://barbora.ee/piimatooted-ja-munad/piimad) or a path (piimatooted-ja-munad/piimad). Takes priority over the search query."
                    },
                    "maxResults": {
                        "title": "Max Products",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of products to return. Barbora returns 52 products per page; set high (e.g., 5000) to pull a full category."
                    },
                    "requestDelaySecs": {
                        "title": "Delay between requests (seconds)",
                        "minimum": 0,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Minimum pause between page fetches. Bright Data rate-limits rapid-fire requests; a delay of 5-15s keeps a large category walk under the limit (slower but reliable). 0 = full speed.",
                        "default": 0
                    },
                    "brightDataApiKey": {
                        "title": "Bright Data API Key",
                        "type": "string",
                        "description": "Bright Data API key for the Web Unlocker zone. Required — Barbora is behind a Cloudflare managed challenge and cannot be reached without it. Falls back to the BRIGHT_DATA_API_KEY environment variable."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Barbora access itself goes through the Bright Data Web Unlocker; this proxy is used for any auxiliary requests."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
