# REMA 1000 Denmark Scraper — Groceries & EAN (`studio-amba/rema1000-dk-scraper`) Actor

Scrape the REMA 1000 Denmark discount-grocery chain by keyword: product names, prices in DKK, unit prices, categories, images and EAN barcodes. No login or cookies.

- **URL**: https://apify.com/studio-amba/rema1000-dk-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 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## REMA 1000 Denmark Scraper

Scrape REMA 1000 (rema1000.dk), Denmark's largest discount-grocery chain, by keyword and get clean, structured product data: names, prices in DKK, unit prices, categories, images and EAN barcodes.

REMA 1000 runs its own public product-search API. This actor calls it directly, so you get fast, reliable grocery data without a login, cookies or a browser — and every result already carries its EAN barcode, no extra product-page fetch required.

### Why use this actor?

If you track Danish grocery prices, match products by barcode, build a price-comparison tool, or feed a market-research dataset, you need structured product data you can rely on. This actor turns any REMA 1000 search into a table of products with current prices in DKK, unit prices and EAN barcodes.

Typical users:

- Price-intelligence and price-comparison platforms tracking Danish retail.
- Brands and suppliers matching their catalogue by EAN barcode.
- Market researchers and analysts building Nordic grocery datasets.
- Developers who need a clean product feed instead of scraping HTML themselves.

### How to scrape REMA 1000 data

1. Open the actor in the Apify Console.
2. Enter a **search query** in Danish — for example `mælk`, `kylling`, `øl` or `brød`. Leave it empty to browse the full catalogue.
3. Set **maxResults** to how many products you want.
4. Leave the proxy on the default Apify setting and click **Start**.
5. When the run finishes, download the results as JSON, CSV, Excel or feed them to an API.

The actor calls REMA 1000's own search API directly, walks the pagination for your query at 200 products per request, and writes one clean record per product — including the EAN barcode, which comes back in the same response as the price, so there's no separate detail-page fetch.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Keyword to search in Danish (default: `mælk`) |
| `maxResults` | Integer | No | Maximum products to return (default: 100) |
| `proxyConfiguration` | Object | No | Apify proxy settings (default Apify proxy works) |

#### Example input

```json
{
    "searchQuery": "mælk",
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": true }
}
````

### Output

Each result contains:

| Field | Type | Example |
|-------|------|---------|
| `name` | String | `"Sødmælk 3,5%"` |
| `brand` | String | `"Arla"` |
| `price` | Number | `7.95` |
| `currency` | String | `"DKK"` |
| `pricePerUnit` | String | `"15.9 kr/ltr"` |
| `size` | String | `"0.5 LTR. / ARLA"` |
| `discount` | String | `"campaign"` |
| `campaignEndsAt` | String | `"2026-07-18T00:00:00+00:00"` |
| `ean` | String | `"5700426101026"` |
| `sku` | String | `"20302"` |
| `productId` | String | `"20302"` |
| `category` | String | `"Mejeri > Mælk m.v."` |
| `imageUrl` | String | Primary product image URL |
| `url` | String | Full product page URL |
| `scrapedAt` | String | ISO 8601 timestamp |

`discount` and `campaignEndsAt` are present only when a product is on a running weekly offer ("kampagne"). `brand` is a best-effort read of REMA 1000's free-text size/description field and is not always available — some products only carry an origin tag (e.g. "DANSK") instead of a brand name, in which case `brand` is omitted.

### Example output

```json
{
    "name": "Sødmælk 3,5%",
    "brand": "Arla",
    "price": 7.95,
    "currency": "DKK",
    "pricePerUnit": "15.9 kr/ltr",
    "size": "0.5 LTR. / ARLA",
    "ean": "5700426101026",
    "sku": "20302",
    "productId": "20302",
    "category": "Mejeri > Mælk m.v.",
    "imageUrl": "https://rema-product-images.digital.rema1000.dk/20302/1-large-kAonyAjPx8.webp",
    "url": "https://shop.rema1000.dk/varer/20302",
    "scrapedAt": "2026-07-14T19:00:00.000Z"
}
```

### Notes and limitations

- Prices are the current online prices in DKK, matched to today's date against REMA 1000's own price-validity windows (so you always get the price that's actually active, campaign or not).
- The `shop.rema1000.dk` website itself is geo-blocked outside Denmark, but the underlying product API this actor calls is not — no residential proxy needed.
- REMA 1000's full catalogue is around 3,900 SKUs. A broad or empty search query walks the whole catalogue at 200 products per request.
- `brand` is best-effort only — REMA 1000's API does not expose a clean, dedicated brand field.
- Some products carry more than one barcode (multi-pack variants); this actor returns the first one as `ean`.

### Cost

Pricing is pay-per-result. Because the actor calls a JSON API directly (no browser, no per-product detail fetch), a run of a few hundred products typically finishes in well under a minute.

### Related Scrapers

Build a complete view of European grocery retail with these sibling scrapers from Studio AMBA:

- **[Continente Portugal Scraper](https://apify.com/studio-amba/continente-pt-scraper)** — Portuguese supermarket products, prices and EAN (continente.pt).
- **[Dia ES Scraper](https://apify.com/studio-amba/dia-es-scraper)** — Spanish supermarket products and prices (dia.es).
- **[BILLA Austria Scraper](https://apify.com/studio-amba/billa-at-scraper)** — Austrian supermarket products and promotions (shop.billa.at).
- **[Esselunga IT Scraper](https://apify.com/studio-amba/esselunga-it-scraper)** — Italian supermarket products and discounts (esselunga.it).
- **[Mercadona Scraper](https://apify.com/studio-amba/mercadona-scraper)** — Spain's largest supermarket (mercadona.es).
- **[Colruyt Scraper](https://apify.com/studio-amba/colruyt-scraper)** — Belgian grocery prices (colruyt.be).
- **[Delhaize Scraper](https://apify.com/studio-amba/delhaize-scraper)** — Belgian supermarket products (delhaize.be).
- **[Tesco Scraper](https://apify.com/studio-amba/tesco-scraper)** — UK groceries and Clubcard offers (tesco.com).

# Actor input Schema

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

Keyword to search the REMA 1000 catalogue in Danish (e.g. 'mælk', 'kylling', 'øl'). Leave empty to browse the full catalogue.

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

Maximum number of products to return across all result pages.

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

Apify proxy settings. The default Apify (datacenter) proxy works — the REMA 1000 API is not geo-locked, unlike the shop.rema1000.dk website itself.

## Actor input object example

```json
{
  "searchQuery": "mælk",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "REMA 1000 Denmark Scraper — Groceries & EAN",
        "description": "Scrape the REMA 1000 Denmark discount-grocery chain by keyword: product names, prices in DKK, unit prices, categories, images and EAN barcodes. No login or cookies.",
        "version": "0.1",
        "x-build-id": "2rHSvtgRG3yBlaVRC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~rema1000-dk-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-rema1000-dk-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~rema1000-dk-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-rema1000-dk-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~rema1000-dk-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-rema1000-dk-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": "Keyword to search the REMA 1000 catalogue in Danish (e.g. 'mælk', 'kylling', 'øl'). Leave empty to browse the full catalogue."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of products to return across all result pages.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings. The default Apify (datacenter) proxy works — the REMA 1000 API is not geo-locked, unlike the shop.rema1000.dk website itself."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
