# Rimi.lv Scraper — Latvian Grocery Products & Prices (`studio-amba/rimi-lv-scraper`) Actor

Scrape products, prices, and per-unit prices from Rimi.lv, Latvia's largest online grocery. Search or browse categories. No login or cookies required.

- **URL**: https://apify.com/studio-amba/rimi-lv-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 $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/platform/actors/running/actors-in-store#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

## Rimi.lv Scraper — Latvian Grocery Products & Prices

Extract grocery product data, prices, and per-unit prices from [Rimi.lv](https://www.rimi.lv/e-veikals), Latvia's largest online grocery. Search by keyword or browse any category. No login, no cookies, no account required.

### What is Rimi.lv Scraper?

Rimi.lv Scraper collects structured product data from Rimi Latvia's online grocery store (`rimi.lv/e-veikals`). It reads Rimi's server-rendered product grid and its public category API to deliver clean, flat JSON: product name, price in EUR, per-unit price, category, image, product code, and stock status.

Rimi is part of Rimi Baltic, owned by the Swedish ICA Group, and is one of the largest grocery retailers in the Baltics. Its Latvian online store carries tens of thousands of products across fresh produce, dairy, meat, bakery, pantry, drinks, household, and more. That catalogue is one of the richest, most current grocery data sources in Latvia.

**Popular use cases:**

- **Grocery price monitoring** — Track prices and per-unit prices across the Rimi catalogue. Detect promotions and price shifts over time.
- **Competitor intelligence** — Compare Rimi's range and pricing against Maxima, Rimi's own Baltic siblings, and other Latvian grocers.
- **Market research** — Analyze product availability, assortment, and category structure in the Latvian grocery market.
- **Price comparison sites** — Feed a shopping or price-comparison product with fresh, structured grocery data.
- **FMCG and supplier research** — Study which products and pack sizes are listed, and at what shelf and per-unit prices.

### How to scrape Rimi.lv data

There are two ways to run the actor. Pick one.

#### Option 1: Search by keyword

Set `searchQuery` to any product name or keyword in Latvian. The actor paginates through all search results up to `maxResults`.

**Latvian examples:** `"piens"` (milk), `"maize"` (bread), `"siers"` (cheese), `"gaļa"` (meat), `"kafija"` (coffee), `"olas"` (eggs), `"āboli"` (apples).

#### Option 2: Browse a category

Set `categoryUrl` to any Rimi.lv category page URL. A top-level category URL includes every product in its subcategories, so one URL can return an entire department.

**Example:** `https://www.rimi.lv/e-veikals/lv/produkti/augli-un-darzeni/c/SH-2` (Fruit & vegetables).

You can find category URLs by browsing [rimi.lv/e-veikals](https://www.rimi.lv/e-veikals) and copying the address of any category page. They always end in `/c/SH-...`.

If both `searchQuery` and `categoryUrl` are empty, the actor defaults to searching for `piens` (milk) so a run with empty input still returns data.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Product keyword in Latvian (e.g. `"piens"`). Ignored if `categoryUrl` is set. |
| `categoryUrl` | String | No | A Rimi.lv category page URL to scrape (includes all subcategories). |
| `maxResults` | Integer | No | Maximum number of products to return (default: 100). |
| `proxyConfiguration` | Object | No | Proxy settings. Latvian residential proxies recommended. |

#### Example input

```json
{
    "searchQuery": "piens",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "LV"
    }
}
```

To scrape a whole department instead:

```json
{
    "categoryUrl": "https://www.rimi.lv/e-veikals/lv/produkti/augli-un-darzeni/c/SH-2",
    "maxResults": 1000
}
```

### Output

Each result is a flat JSON object:

| Field | Type | Example |
|-------|------|---------|
| `name` | String | `"Piens Rimi pudele 2% 1l"` |
| `brand` | String | `""` (often empty for grocery/produce) |
| `price` | Number | `0.99` |
| `currency` | String | `"EUR"` |
| `originalPrice` | Number | `1.19` (only on promotions) |
| `pricePerUnit` | String | `"0.99 EUR/l"` |
| `inStock` | Boolean | `true` |
| `productId` | String | `"804139"` |
| `categoryCode` | String | `"SH-11-8-22"` |
| `imageUrl` | String | Primary product image URL |
| `url` | String | Full product page URL on rimi.lv |
| `scrapedAt` | String | ISO 8601 timestamp |

#### Example output

```json
{
    "name": "Piens Rimi pudele 2% 1l",
    "brand": "",
    "price": 0.99,
    "currency": "EUR",
    "pricePerUnit": "0.99 EUR/l",
    "inStock": true,
    "productId": "804139",
    "categoryCode": "SH-11-8-22",
    "imageUrl": "https://rimibaltic-res.cloudinary.com/image/upload/.../MAT_804139_PCE_LV",
    "url": "https://www.rimi.lv/e-veikals/lv/produkti/piena-produkti-un-olas/piens/pasterizets-piens/piens-rimi-pudele-2-1l/p/804139",
    "scrapedAt": "2026-07-06T19:20:58.776Z"
}
```

### Notes on the data

- **Prices are numeric and in EUR.** The per-unit price is a string like `"0.99 EUR/l"` or `"1.19 EUR/kg"`.
- **Brand is frequently empty.** Rimi does not expose a brand field in its product listing, and much of the grocery catalogue (fresh produce, bakery, in-house lines) has no brand at all. Name usually contains the brand where one applies.
- **`originalPrice` only appears on promotions.** Most products are not discounted, so the field is absent for them.
- **`inStock` reflects listing availability.** The Rimi grid only shows purchasable products.

### Cost estimate

This actor uses lightweight HTTP requests (no headless browser). One request returns up to 100 products, so a full catalogue of ~15,000–20,000 products is only ~150–200 requests. Expect thousands of products per US$1 of Apify compute. Pricing is pay-per-result plus a small per-run start fee.

### Proxy and reliability

Rimi.lv sits behind AWS CloudFront with Imperva/Incapsula fingerprinting. Single requests work from most IPs, but back-to-back requests from one datacenter IP can be throttled. The actor paces requests and, with a rotating **Latvian residential proxy** (the default prefill), runs smoothly through large category walks. Residential + country `LV` is recommended for the most reliable results.

### Limitations / known issues

- Brand and detailed nutrition/specs are not part of the listing payload and are not scraped (name carries most of the useful description).
- Ratings and reviews are not available on Rimi.lv.
- Very large full-catalogue runs are paced to stay under anti-bot thresholds, so they take longer than an unpaced scrape (still well under an hour end to end).

### Related Scrapers

Building a Baltic or European grocery price dataset? These pair well with this actor:

- **Rohlik Scraper** — Grocery products and prices from Rohlik.cz, Knuspr.de, and Gurkerl.at (Central Europe).
- **Tesco Scraper** — UK grocery products and prices.
- **Tesco Ireland Scraper** — Irish Tesco groceries.
- **Albert Heijn Scraper** — Dutch grocery products and prices.
- **Auchan Scraper** — French grocery and hypermarket products.
- **Apotheka Latvia Scraper** — Latvian pharmacy products and prices (same market, health vertical).

Rimi Latvia runs the same platform as **Rimi Lithuania (rimi.lt)** and **Rimi Estonia (rimi.ee)** — sibling actors for the other Baltic markets are on the roadmap.

# Actor input Schema

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

Search for products by keyword in Latvian (e.g., 'piens' = milk, 'maize' = bread, 'siers' = cheese). Ignored if a Category URL is provided.

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

A Rimi.lv category page URL to scrape (includes all subcategories). Example: https://www.rimi.lv/e-veikals/lv/produkti/augli-un-darzeni/c/SH-2 . If empty, the actor uses the search query.

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

Maximum number of products to return.

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

Proxy settings. Residential proxies with country code LV are recommended for best reliability.

## Actor input object example

```json
{
  "searchQuery": "piens",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "LV"
  }
}
```

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/aaskxeJHAsZSEjguG/builds/uE75fF3HquiWcyOD2/openapi.json