# Wolt Scraper — Restaurants, Menus & Market Prices with EAN (`studio-amba/wolt-scraper`) Actor

Scrape Wolt across 30 countries: venue directories with ratings and delivery estimates, full restaurant menus, and Wolt Market grocery catalogues with EAN barcodes and unit prices. Works by city name or coordinates. No login, no cookies.

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

## Wolt Scraper — Restaurants, Menus & Market Prices with EAN

Scrape Wolt (wolt.com) in any of its 30 countries: complete venue directories with ratings and delivery estimates, full restaurant menus with prices, and Wolt Market / partner grocery catalogues with EAN barcodes and comparative unit prices. Works from a city name (959 supported cities) or raw coordinates. No login, no cookies.

### Why use this actor?

Wolt is the dominant food-delivery and quick-commerce platform across the Nordics, Baltics, CEE and Israel (owned by DoorDash). Its listings are a live feed of three valuable datasets:

- **Market intelligence for restaurants and delivery**: who delivers where, at what rating, delivery fee and speed — per city, refreshed on every run.
- **Menu and price monitoring**: full menus with item prices for any venue, useful for competitor tracking, price benchmarking and menu engineering.
- **Grocery price data with EAN codes**: Wolt Market and partner supermarkets (K-Market, K-Supermarket and others) expose barcoded, unit-priced grocery items — matchable against any other retailer's catalogue by EAN.

One actor covers all 30 Wolt countries. Point it at Helsinki, Berlin, Prague, Riga, Tel Aviv or any of the 959 supported cities.

### Modes

| Mode | What it returns | Scale |
|------|-----------------|-------|
| `venues` (default) | Every venue delivering in the city: name, rating, delivery estimate, cuisine tags, price range, address, coordinates | Hundreds of venues in 1-2 requests |
| `menus` | Full menu of each venue (from `venueSlugs` or discovered in the city): dishes with prices, descriptions and menu sections | ~150 items per venue |
| `market` | Grocery items from Wolt Market / partner stores: EAN barcode, price, unit price, category path | Thousands of items per store |

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `mode` | String | No | `venues` (default), `menus` or `market` |
| `city` | String | No | City name or Wolt slug, e.g. `Helsinki`, `Berlin`, `Riga` (default: `Helsinki`) |
| `country` | String | No | ISO2 code (`FI`, `DE`, `GR`, ...) to disambiguate duplicate city names |
| `lat` / `lon` | String | No | Explicit coordinates — override the city lookup |
| `venueSlugs` | Array | No | Venue slugs (from a `venues` run or a Wolt URL) to fetch menus/markets directly |
| `maxResults` | Integer | No | Max records to push (default 100; set high for full catalogues) |
| `proxyConfiguration` | Object | No | Apify proxy settings (default: automatic proxy) |

Running with completely empty input returns the first 100 Helsinki venues.

### Output

All records share `recordType`, `name`, `url`, `city`, `country`, `currency` and `scrapedAt`. Mode-specific fields:

| Field | Type | Modes | Example |
|-------|------|-------|---------|
| `recordType` | String | all | `"venue"`, `"menuItem"`, `"marketItem"` |
| `name` | String | all | `"Avokado syöntikypsä irto, 150 g"` |
| `rating` | Number | venues | `8.4` (Wolt's 0-10 scale) |
| `ratingCount` | Integer | venues | `372` |
| `cuisineTags` | Array | venues | `["burger", "street food"]` |
| `priceRange` | Integer | venues | `2` (1 = cheap, 4 = expensive) |
| `deliveryEstimate` | String | venues | `"15-25"` (minutes) |
| `deliveryFee` | Number | menus/market | `1.89` |
| `address` / `latitude` / `longitude` | — | venues | `"Mannerheimintie 8"` |
| `online` | Boolean | venues | `true` (open and delivering now) |
| `price` | Number | menus/market | `12.9` |
| `originalPrice` | Number | menus/market | `14.9` (when discounted) |
| `unitPrice` | String | market | `"8.33 EUR/kg"` |
| `ean` | String | market | `"06405940761143"` |
| `category` | String | menus/market | `"Hedelmät > Banaanit, trooppiset hedelmät"` |
| `itemDescription` | String | menus/market | `"irtotuote"` |
| `venueId` / `venueSlug` / `venueName` | String | all | `"wolt-market-kamppi"` |
| `imageUrl` | String | all | Venue cover or product photo |

### Example output

Venue record (`mode: "venues"`):

```json
{
    "recordType": "venue",
    "name": "Hesburger Helsinki Mannerheimintie 8",
    "venueId": "67c4a9c677a5e428040a59f1",
    "venueSlug": "hesburger-helsinki-mannerheimintie-8",
    "cuisineTags": ["burger", "dessert", "hamburger"],
    "rating": 7.8,
    "ratingCount": 372,
    "priceRange": 1,
    "deliveryEstimate": "15-25",
    "address": "Mannerheimintie 8",
    "latitude": 60.1673104,
    "longitude": 24.9418069,
    "online": true,
    "currency": "EUR",
    "url": "https://wolt.com/en/fin/helsinki/venue/hesburger-helsinki-mannerheimintie-8",
    "city": "Helsinki",
    "country": "FIN",
    "scrapedAt": "2026-07-11T19:25:21.742Z"
}
```

Grocery item (`mode: "market"`):

```json
{
    "recordType": "marketItem",
    "name": "Avokado syöntikypsä irto, 150 g",
    "price": 1.25,
    "unitPrice": "8.33 EUR/kg",
    "currency": "EUR",
    "ean": "06405940761143",
    "itemDescription": "irtotuote",
    "category": "Hedelmät > Banaanit, trooppiset hedelmät",
    "venueName": "Wolt Market Kamppi",
    "venueSlug": "wolt-market-kamppi",
    "deliveryFee": 1.89,
    "city": "Helsinki",
    "country": "FIN",
    "scrapedAt": "2026-07-11T19:40:02.101Z"
}
```

### How to scrape Wolt data

1. **Pick a mode.** Start with `venues` to see what delivers in your city.
2. **Name the city.** Any of the 959 Wolt cities works — `Helsinki`, `Stockholm`, `Berlin`, `Prague`, `Bratislava`, `Riga`, `Tel Aviv`, `Tbilisi`. Add `country` if the name is ambiguous, or pass `lat`/`lon` for an exact point.
3. **Run it.** The default input returns Helsinki venues in under a minute.
4. **Go deeper.** Take `venueSlug` values from the venue records and feed them into `venueSlugs` with `mode: "menus"` (restaurants) or `mode: "market"` (grocery stores) for full item-level data.
5. **Scale up.** For a full Wolt Market catalogue set `maxResults` to 20000+. The actor walks every leaf category with resume-safe state, so long runs survive platform migrations without duplicates.

#### Scrape a whole country

Wolt discovery is coordinate-based. Loop the actor over the cities of one country (e.g. all 109 Finnish cities) with a scheduler or a meta-run, one run per city, and merge the datasets by `venueId` or `ean`.

### Cost estimate

The actor uses plain HTTP requests through Apify's automatic proxy — no browser, no residential proxy premium:

- `venues`: an entire city costs 2 requests. Practically free.
- `menus`: one request per venue (~150 menu items each).
- `market`: one request per leaf category page (10-60 items each). A full Wolt Market store (~5,000 items) is roughly 300-400 requests, done in 6-8 minutes at the built-in 1 req/s pacing.

### Limitations

- **Delivery-point coverage**: discovery returns venues delivering **to the city-centre point**. That captures the bulk of a city; for exhaustive coverage of very large cities run extra points via `lat`/`lon`.
- `deliveryFee` is only exposed on venues fetched directly by slug (menus/market modes), not in city discovery.
- Some grocery leaf categories are legitimately empty (seasonal or campaign shelves) — the actor skips them.
- Prices are the in-app Wolt prices, which can differ from the store shelf price.
- EAN barcodes are present on Wolt Market and most partner-store grocery items, not on restaurant dishes.

### Related Scrapers

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

- [Barbora.lt Scraper](https://apify.com/studio-amba/barbora-lt-scraper) — Lithuanian groceries
- [Barbora.lv Scraper](https://apify.com/studio-amba/barbora-lv-scraper) — Latvian groceries
- [Barbora.ee Scraper](https://apify.com/studio-amba/barbora-ee-scraper) — Estonian groceries
- [Rimi.lv Scraper](https://apify.com/studio-amba/rimi-lv-scraper) — Latvian groceries
- [Rimi.lt Scraper](https://apify.com/studio-amba/rimi-lt-scraper) — Lithuanian groceries
- [Rimi.ee Scraper](https://apify.com/studio-amba/rimi-ee-scraper) — Estonian groceries
- [Bilka Scraper](https://apify.com/studio-amba/bilka-scraper) — Danish groceries
- [Tesco Groceries Scraper](https://apify.com/studio-amba/tesco-scraper) — UK groceries
- [Waitrose Scraper](https://apify.com/studio-amba/waitrose-scraper) — UK groceries

### FAQ

**Do I need a Wolt account?**
No. The actor reads Wolt's public consumer API — no login, no cookies, no app.

**Which countries does it cover?**
All 30 Wolt markets, including Finland, Sweden, Denmark, Norway, Germany, Greece, Czechia, Slovakia, Hungary, Poland, the Baltics, Croatia, Serbia, Israel, Georgia, Kazakhstan and more.

**How fresh is the data?**
Every run fetches live data. Venue availability (`online`) reflects the moment of the run.

**Can I get every product of a Wolt Market store?**
Yes — `mode: "market"` with the store's slug in `venueSlugs` and a high `maxResults` walks the entire category tree, including pagination.

**Is this legal?**
The actor only collects publicly available data that anyone can see in the Wolt app or website. You are responsible for how you use the data — respect local regulations.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. 'venues' lists every venue delivering in the city (ratings, delivery estimates, cuisine tags). 'menus' pulls the full menu of each venue. 'market' walks Wolt Market / grocery stores category by category and returns items with EAN barcodes and unit prices.

## `city` (type: `string`):

City name or Wolt city slug, e.g. 'Helsinki', 'Berlin', 'Riga', 'Tel Aviv'. Wolt serves 959 cities in 30 countries; the actor resolves the name against Wolt's own city index. Ignored when Latitude/Longitude are set.

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

Optional two-letter country code (FI, DE, GR, SK, DK, HU, CZ, NO, SE, ...) to disambiguate city names that exist in more than one Wolt country.

## `lat` (type: `string`):

Optional explicit latitude (decimal, e.g. '60.1699'). When both latitude and longitude are set they override the city lookup — Wolt discovery is coordinate-based, so any point works.

## `lon` (type: `string`):

Optional explicit longitude (decimal, e.g. '24.9384'). Must be set together with latitude.

## `venueSlugs` (type: `array`):

Optional list of Wolt venue slugs (the last part of a venue URL, e.g. 'wolt-market-kamppi' or 'bastard-burgers-kamppi'). In 'menus' and 'market' mode these venues are fetched directly, skipping city discovery.

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

Maximum number of items to push to the dataset. Default 100. For a full Wolt Market catalogue set this high (e.g. 20000) — the actor walks every leaf category with resume-safe state.

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

Proxy settings. Wolt's public API is not geo-locked and Apify datacenter proxies pass, so the default automatic proxy is enough.

## Actor input object example

```json
{
  "mode": "venues",
  "city": "Helsinki",
  "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 = {
    "mode": "venues",
    "city": "Helsinki",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dLmQ7r3toerX8v3IS/builds/EzcdwnbcC1CZp3Gx1/openapi.json