# Barbora Scraper: Lithuania, Latvia & Estonia Groceries (`studio-amba/barbora-lt-scraper`) Actor

Scrape the Barbora online-grocery catalogues of Lithuania (barbora.lt), Latvia (barbora.lv) and Estonia (barbora.ee): product names, EUR prices, AČIŪ / Paldies / 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-lt-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Barbora Scraper: Lithuania, Latvia & Estonia Groceries

Scrape the Barbora online-grocery catalogues of Lithuania (barbora.lt), Latvia
(barbora.lv) and Estonia (barbora.ee): product names, EUR prices, loyalty
offers, per-unit prices, brands, categories and images. Search by keyword or
pull any category. No login, no cookies.

Barbora is the online grocery of the Maxima Group and the reference online
supermarket in all three Baltic states. This actor turns its storefronts into
clean, structured JSON you can drop into a spreadsheet, a price monitor or a
data pipeline.

### Countries

| `country` | Store | Search example | Loyalty programme |
|-----------|-------|----------------|-------------------|
| `LT` (default) | barbora.lt | `pienas` (milk) | AČIŪ |
| `LV` | barbora.lv | `piens` (milk) | Paldies |
| `EE` | barbora.ee | `piim` (milk) | Aitäh |

One run covers one country. Every row carries a `country` field, so you can
merge runs of all three stores into one dataset. All three countries use the
euro, so every price is in EUR.

### Why use this actor?

Grocery prices move constantly, and Barbora is the reference store for the
Baltic market. If you track retail prices, run a competing shop, build a
price-comparison site or do FMCG market research in the Baltics, this actor
gives you the live catalogue of each country on demand.

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

### How to scrape Barbora data

1. Add the actor to your Apify account and open the input form.
2. Pick the country: Lithuania, Latvia or Estonia.
3. Type a search keyword in that country's language (for example `pienas` in
   Lithuania, `piens` in Latvia, `piim` in Estonia), **or** paste a category
   URL from the Barbora store.
4. Set `maxResults` to how many products you want. Barbora returns 52 products
   per page; set it high to pull a whole category.
5. Run the actor. Results stream into the dataset and can be exported as JSON,
   CSV or Excel.

To scrape a specific category, open the category on Barbora and copy the URL,
for example:

- `https://barbora.lt/pieno-gaminiai-kiausiniai-ir-majonezas/pienas`
- `https://barbora.lv/piena-produkti-un-olas/piens`
- `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. A full URL decides the country by
itself: a barbora.lv URL runs on the Latvian store even when `country` is left
on Lithuania.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `country` | String | No | `LT` (default), `LV` or `EE`. |
| `searchQuery` | String | No | Search keyword in the language of the selected country. Defaults to milk (`pienas`, `piens` or `piim`) when nothing is set. |
| `categoryUrl` | String | No | A Barbora category URL or a path on the selected country's store. 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 | No | Optional. Your own Bright Data Web Unlocker API key. Leave empty to use the built-in access. |
| `proxyConfiguration` | Object | No | Proxy settings. Not used for the Barbora pages themselves. |

Leave everything empty and the actor searches for milk (`pienas`) on
barbora.lt, so a bare run still returns data.

#### Example input (Latvia)

```json
{
  "country": "LV",
  "searchQuery": "kafija",
  "maxResults": 50
}
```

### Output

Each result is a flat JSON object:

| Field | Type | Example |
|-------|------|---------|
| `name` | String | `"Piens BALTAIS 2% 1L"` |
| `brand` | String | `"BALTAIS"` |
| `price` | Number | `0.89` |
| `currency` | String | `"EUR"` |
| `country` | String | `"LV"` |
| `originalPrice` | Number | `1.19` |
| `pricePerUnit` | String | `"€0.89/l"` |
| `discount` | String | `"-25% (Paldies loyalty)"` |
| `productId` | String | `"000000000000891999"` |
| `inStock` | Boolean | `true` |
| `category` | String | `"Pieno gaminiai, kiaušiniai ir majonezas > Pienas"` (LT) or `"piena produkti un olas > piens > pasterizets piens"` (LV, EE) |
| `categories` | Array | The same path as a list |
| `countryOfOrigin` | String | `"Latvia"` or `"EU"` |
| `imageUrl` | String | `"https://cdn.barbora.lt/products/….png"` |
| `url` | String | `"https://barbora.lv/produkti/piens-baltais-2-proc-1-l"` |
| `scrapedAt` | String | `"2026-10-15T09:00:00.000Z"` |

Fields the store does not set for a product are left out of that row. A
`discount` only appears on promoted products, and `countryOfOrigin` only when
Barbora flags the product as made in the home country or in the EU.

#### Example output

```json
{
  "name": "UAT pienas FARM MILK, 3,2% rieb., 1 l",
  "brand": "FARM MILK",
  "price": 0.89,
  "currency": "EUR",
  "pricePerUnit": "€0.89/l",
  "productId": "000000000000891999",
  "inStock": true,
  "category": "Pieno gaminiai, kiaušiniai ir majonezas > Pienas > Ilgo galiojimo pienas",
  "categories": ["Pieno gaminiai, kiaušiniai ir majonezas", "Pienas", "Ilgo galiojimo pienas"],
  "imageUrl": "https://cdn.barbora.lt/products/0e6e2845-485a-4c9d-96f2-98e599a919f1_m.png",
  "url": "https://barbora.lt/produktai/uat-pienas-farm-milk-3-2-proc-rieb-1-l",
  "country": "LT",
  "scrapedAt": "2026-10-15T09:00:00.000Z"
}
```

### Access

In Latvia and Estonia the actor reads Barbora's own product API, the same one
the store's website loads its product grid from. That API gives the category
path as URL slugs, so LV and EE categories are lowercase and without accents.

In Lithuania the actor reads the store's listing pages. barbora.lt sits behind a
Cloudflare managed challenge, so those pages are fetched through the Bright Data
Web Unlocker, which exits in Lithuania. When that route does not return a
product list, the run switches to Barbora's product API. Bright Data access is
built in and included in the per-result price. You do not need a Bright Data
account. If you prefer to use your own Web Unlocker zone, enter its API key in
the `brightDataApiKey` field.

### Cost estimate

The price is $0.002 per result ($2 per 1,000 products) plus $0.005 per run
start, for every country. Bright Data access is included in that price.

One page fetch returns 52 products, so a 1,000-product pull needs about 20
page fetches.

A run's usage cost only settles after the run reports SUCCEEDED. Reading the
cost of a run that is still in progress shows a number that is far too low, so
estimate spend from finished runs.

### Pricing note

Barbora prices depend on the delivery region (each fulfilment centre has its
own price and stock). The actor returns the storefront's default-region price,
which matches what most shoppers see. Loyalty member prices (AČIŪ, Paldies,
Aitäh) 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.
- One run covers one country. Run the actor once per country to cover all three.
- 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:

- [Rimi Scraper](https://apify.com/studio-amba/rimi-lv-scraper) — Rimi groceries in Latvia
- [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

# Actor input Schema

## `country` (type: `string`):

Which Barbora store to scrape: Lithuania (barbora.lt), Latvia (barbora.lv) or Estonia (barbora.ee). One run covers one country. Defaults to Lithuania. A full category URL on another Barbora domain switches the run to that domain's country.

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

Search Barbora groceries by keyword, in the language of the selected country. Lithuania: 'pienas' (milk), 'kava' (coffee), 'suris' (cheese). Latvia: 'piens', 'kafija', 'siers'. Estonia: 'piim', 'kohv', 'juust'. Leave empty to search milk in the selected country.

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

A Barbora category to scrape. Full URL (https://barbora.lt/pieno-gaminiai-kiausiniai-ir-majonezas/pienas, https://barbora.lv/piena-produkti-un-olas/piens, https://barbora.ee/piimatooted-ja-munad/piimad) or a path on the selected country's store (pieno-gaminiai-kiausiniai-ir-majonezas/pienas). 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`):

Your own Bright Data Web Unlocker API key. Optional. Leave empty to use the built-in Bright Data access.

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

Proxy settings. Barbora pages are fetched through the Bright Data Web Unlocker, which exits in the selected country; this proxy is not used for those pages.

## Actor input object example

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

# Actor output Schema

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

No description

# 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 = {
    "country": "LT",
    "searchQuery": "pienas",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "LT"
    }
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/barbora-lt-scraper"
        }
    }
}
```

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/kOQhRXybeSFDvBF8d/builds/ABNh6RtUnGRG4My6k/openapi.json