# Wolt.com $0.8💰 URL | City Search | Restaurants and Menus (`abotapi/wolt-restaurants-scraper`) Actor

From $0.8/1K. Scrape Wolt restaurants and full menus at the city scale. Extract 60+ fields, including name, address, GPS, hours, ratings, tags, menus with images and prices, delivery zones, fees, minimum order, and merchant details. Supports city search or URL input with fast, rich output.

- **URL**: https://apify.com/abotapi/wolt-restaurants-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 18 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 Restaurants Scraper

Pull restaurants and full menus from Wolt at city scale. Returns 60+ fields per venue: name, brand, address, GPS, phone, website, opening and delivery hours, ratings, food tags, full menu with images and prices, delivery polygon, fees, service-fee estimate, order minimum, tipping config, and the merchant legal block (DSA-compliant business\_id and registered address). Two modes: search by city name, or paste Wolt URLs (single venue or city pages).

### Why this scraper

- 60+ fields per venue, vs the 18 in the older Wolt scrapers on the Store
- Full menu surface: categories, items, images with blurhashes, original and discounted prices, deal flags, allergen and dietary tags, EU lowest-price disclosures, VAT, allowed delivery methods, weighted-item info, alcohol per mille, age-restriction flags
- Brand identity: brand\_slug, brand\_name, brand\_logo image and blurhash for chain consolidation across cities
- Delivery polygon (full GeoJSON) for each venue, plus separate opening\_times\_schedule vs delivery\_times\_schedule
- Merchant legal block: registered name, business\_id, full registered address, country (DSA-compliant)
- Fast and cheap: very low cost per venue at production scale
- Two modes: search by city or paste URLs, plus filters for cuisine, minimum rating, minimum review count

### Data you get

> Sample shape, values are illustrative placeholders, not from a live listing.

| Field | Example |
|---|---|
| venueId | `00000000000000000000000a` |
| slug | `sample-burger-place` |
| name | `Sample Burger Place` |
| brandSlug | `sample-burger` |
| brandName | `Sample Burger` |
| brandLogoImage | `https://imageproxy.wolt.com/mes-image/00000000-0000-0000-0000-000000000000/00000000-0000-0000-0000-000000000000` |
| brandLogoBlurhash | `LKO2?V%2Tw=w]~RBVZRi};RPxuwH` |
| coverImage | `https://imageproxy.wolt.com/assets/000000000000000000000000` |
| coverBlurhash | `jkSsmKKXhXhq;;KXJAKXHtlmJjKW` |
| description | `Best burgers in town.` |
| address | `Sample Street 1` |
| city | `Helsinki` |
| cityId | `0000000000000000000000aa` |
| citySlug | `helsinki` |
| postCode | `00100` |
| countryCode | `FIN` |
| phone | `+35800000000` |
| website | `https://example.com` |
| woltUrl | `https://wolt.com/en/fin/helsinki/restaurant/sample-burger-place` |
| latitude | `60.0000` |
| longitude | `24.0000` |
| timezone | `Europe/Helsinki` |
| currency | `EUR` |
| deliveryBasePrice | `199` |
| orderMinimum | `1000` |
| serviceFeeMin / Max / Percentage | `45 / 99 / 3` |
| isWoltPlus | `true` |
| ncdAllowed | `true` |
| isPickupFriendly | `false` |
| priceRange | `1` (1-4 wallet icons) |
| foodTags | `["burger", "fries"]` |
| categories | `[{name: "American", slug: "american", primary: true}]` |
| rating / ratingScore / ratingVolume | `3 / 8.0 / 200` |
| workingHours | 7-day array of `{day, formatted_times}` |
| deliveryHours | 7-day array, separate from workingHours |
| deliveryGeoRange | full GeoJSON Polygon |
| tipping | `{currency, tip_amounts, max, min, type}` |
| merchant | `{id, name, business_id, street_address, city, post_code, country}` |
| digitalServicesAct | DSA-mandated legal disclosures |
| menuCategoryCount | `13` |
| menuItemCount | `96` |
| menuCategories | array of `{id, slug, name, image, blurhash, itemCount, subcategoryCount}` |
| menuItems | array of `{id, categoryId, name, image, currentPrice, originalPriceCents, discounted, discountAmount, discountPercent, discountValidFrom, lowestPriceCents, dietaryPreferences, vatPercentage, ...}` |
| primaryLanguage / availableLanguages | `de / [{language, name, autotranslated}]` |
| scrapedAt | `2026-01-01T00:00:00.000Z` |
| changeType | `NEW` (incremental mode only — see "Resume vs Incremental mode" below) |
| changedFields | `["deliveryBasePrice"]` (incremental mode, UPDATED rows only) |
| firstSeenAt | `2026-01-01T00:00:00.000Z` (incremental mode only) |
| lastSeenAt | `2026-01-02T00:00:00.000Z` (incremental mode only) |

### How to use

#### Find restaurants in one city

```json
{
  "mode": "search",
  "cities": ["Helsinki"],
  "fetchMenu": true,
  "maxVenues": 25
}
```

#### Multi-city, cuisine filter, rating floor

```json
{
  "mode": "search",
  "cities": ["Helsinki", "Stockholm", "Berlin"],
  "primaryCategories": ["pizza", "italian"],
  "minRating": 8,
  "minRatingVolume": 50,
  "fetchMenu": true,
  "maxVenuesPerCity": 10,
  "maxVenues": 30
}
```

#### Direct URLs (single venue)

```json
{
  "mode": "url",
  "urls": [
    "https://wolt.com/en/aut/graz/restaurant/kfc-graz",
    "https://wolt.com/en/fin/helsinki/restaurant/sample-burger-place"
  ],
  "fetchMenu": true
}
```

#### Direct URLs (city pages, multi)

```json
{
  "mode": "url",
  "urls": [
    "https://wolt.com/en/aut/graz/restaurants",
    "https://wolt.com/en/fin/helsinki/restaurants"
  ],
  "fetchMenu": false,
  "maxVenues": 100
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| mode | string | `search` | `search` or `url` |
| cities | array of strings | `["Helsinki"]` | City names or free-text places. Wolt's own city directory is matched first, anything else falls back to geocoding. Search mode only. |
| urls | array of strings | (empty) | Wolt venue or city URLs. URL mode only. |
| primaryCategories | array of strings | (empty) | Cuisine slugs (pizza, sushi, vegan, kebab, etc.). Empty = all. |
| minRating | integer 0-10 | (none) | Minimum venue score on the 0-10 scale. |
| minRatingVolume | integer | `0` | Minimum review count to include. |
| fetchMenu | boolean | `true` | Toggle full menu enrichment. Off = SERP-only, ~6x faster. |
| includeReviews | boolean | `true` | Toggle the rating, ratingScore, and ratingVolume fields in output. |
| language | string | `en` | ISO language code passed to Wolt for menu and venue text. |
| maxVenues | integer | `50` | Hard cap on total venues across the run. 0 = unlimited. |
| maxVenuesPerCity | integer | `0` | Per-city cap. 0 = unlimited per city. |
| resumeFromRunId | string | (none) | Continue ONE specific interrupted run — see "Resume vs Incremental mode" below. |
| incrementalMode | boolean | `false` | Cross-run change detection for recurring/scheduled runs — adds `changeType` (NEW/UPDATED/UNCHANGED/REAPPEARED/EXPIRED) to every row. See below. |
| stateKey | string | (auto) | Names an incremental-mode monitoring campaign. Leave empty to derive one automatically from cities/URLs/filters/menu settings. |
| emitUnchanged | boolean | `false` | Incremental mode only. Also return (and bill) venues that haven't changed since the last run. |
| emitExpired | boolean | `false` | Incremental mode only. Also return (and bill) venues no longer found, once a run fully scanned the tracked search. |
| proxyConfiguration | object | Apify default | Apify proxy settings. City search needs a residential exit: if the default proxy is refused, the actor retries that request over Residential, geo-targeted at the city's own country. Selecting Residential up front skips the refused first attempt. |

### Resume vs Incremental mode

Two different things:

**Resume (`resumeFromRunId`)** continues ONE specific interrupted run. Paste a previous run ID or
dataset ID and this run skips venues already collected there, returning only the remaining new ones.

```json
{ "mode": "search", "cities": ["Helsinki"], "maxVenues": 500, "resumeFromRunId": "PREVIOUS_RUN_ID" }
```

**Incremental mode (`incrementalMode`)** is for scheduling this actor daily/weekly against the SAME
search and getting only what changed — the actor remembers the previous run itself, no run ID needed.
The first run returns everything as `NEW`. Later runs return only `NEW`, `UPDATED`, and `REAPPEARED`
venues by default; unchanged venues are suppressed (and not billed).

```json
{ "mode": "search", "cities": ["Helsinki"], "incrementalMode": true }
```

Turn on `emitUnchanged` or `emitExpired` only when you also want those rows returned — both bill extra
rows. State is isolated automatically per city/URL/filter/menu setup; set `stateKey` to name or
deliberately share a monitoring campaign.

Both features can combine: `incrementalMode` + `resumeFromRunId` bootstraps a fresh incremental
baseline from a large resumed pull. This only works when it's a genuinely first run for that state key;
if incremental state already exists, the run fails fast rather than silently mixing the two.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape — the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record — not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Output example

> Sample shape, values are illustrative placeholders, not from a live listing.

```json
{
  "venueId": "00000000000000000000000a",
  "slug": "sample-burger-place",
  "name": "Sample Burger Place",
  "description": "Best burgers in town.",
  "brandSlug": "sample-burger",
  "brandName": "Sample Burger",
  "brandLogoImage": "https://imageproxy.wolt.com/mes-image/00000000-0000-0000-0000-000000000000/00000000-0000-0000-0000-000000000000",
  "brandLogoBlurhash": "LKO2?V%2Tw=w]~RBVZRi};RPxuwH",
  "coverImage": "https://imageproxy.wolt.com/assets/000000000000000000000000",
  "coverBlurhash": "jkSsmKKXhXhq;;KXJAKXHtlmJjKW",
  "address": "Sample Street 1",
  "city": "Helsinki",
  "cityId": "0000000000000000000000aa",
  "citySlug": "helsinki",
  "postCode": "00100",
  "countryCode": "FIN",
  "phone": "+35800000000",
  "website": "https://example.com/",
  "woltUrl": "https://wolt.com/en/fin/helsinki/restaurant/sample-burger-place",
  "latitude": 60.0,
  "longitude": 24.0,
  "timezone": "Europe/Helsinki",
  "currency": "EUR",
  "deliveryMethods": ["homedelivery"],
  "deliveryBasePrice": 199,
  "deliveryBasePriceFormatted": "€1.99",
  "serviceFeeMin": 45,
  "serviceFeeMax": 99,
  "serviceFeePercentage": 3,
  "orderMinimum": 1000,
  "orderMinimumFormatted": "€10.00",
  "deliveryGeoRange": { "type": "Polygon", "coordinates": "..." },
  "isPickupFriendly": false,
  "isWoltPlus": true,
  "ncdAllowed": true,
  "groupOrderEnabled": true,
  "priceRange": 1,
  "foodTags": ["burger", "fries"],
  "categories": [{ "name": "American", "slug": "american", "primary": true }],
  "rating": 3,
  "ratingScore": 8,
  "ratingVolume": 200,
  "workingHours": [
    { "day": "Monday", "formatted_times": "10:00-22:00" },
    { "day": "Tuesday", "formatted_times": "10:00-22:00" }
  ],
  "deliveryHours": [
    { "day": "Monday", "formatted_times": "10:00-22:00" }
  ],
  "tipping": {
    "currency": "EUR",
    "tip_amounts": [100, 200, 500],
    "max_amount": 10000,
    "min_amount": 50,
    "type": "pre_tipping_amount"
  },
  "merchant": {
    "id": "0000000000000000000000ab",
    "name": "Sample Operator GmbH",
    "business_id": "FN 000000 a",
    "street_address": "Sample Address 1",
    "city": "Sample City",
    "post_code": "00000",
    "country": "Sample Country"
  },
  "digitalServicesAct": {
    "name": "Sample Operator GmbH",
    "business_id": "FN 000000 a",
    "address": "Sample Address 1, 00000 Sample City, Sample Country",
    "self_certification": "...",
    "report_item_url": "https://www.example.com/report"
  },
  "assortmentId": "00000000000000000000000b",
  "primaryLanguage": "fi",
  "selectedLanguage": "en",
  "availableLanguages": [
    { "language": "fi", "name": "Finnish", "autotranslated": false },
    { "language": "en", "name": "English", "autotranslated": true }
  ],
  "menuCategoryCount": 13,
  "menuItemCount": 96,
  "menuCategories": [
    {
      "id": "00000000000000000000000c",
      "slug": "burgers-1",
      "name": "Burgers",
      "image": "https://wolt-menu-images-cdn.wolt.com/menu-images/.../sample.jpg",
      "blurhash": "UkSFbBRj.Tx[sRjZW=WX%~odI9R+XAbIn#n$",
      "itemCount": 7,
      "subcategoryCount": 0
    }
  ],
  "menuItems": [
    {
      "id": "00000000000000000000000d",
      "categoryId": "00000000000000000000000c",
      "categoryName": "Burgers",
      "categorySlug": "burgers-1",
      "name": "Sample Burger",
      "description": "Beef patty, lettuce, tomato.",
      "image": "https://wolt-menu-images-cdn.wolt.com/menu-images/.../sample.jpg",
      "blurhash": "UkSFbBRj.Tx[sRjZW=WX%~odI9R+XAbIn#n$",
      "currency": "EUR",
      "currentPrice": "EUR 9.90",
      "currentPriceCents": 990,
      "originalPriceCents": 1090,
      "discounted": true,
      "discountAmount": 100,
      "discountPercent": 9,
      "lowestPriceCents": 990,
      "lowestPriceWindowDays": 30,
      "dietaryPreferences": [],
      "vatPercentage": 14,
      "tags": [],
      "allowedDeliveryMethods": ["homedelivery"],
      "isAlcohol": false,
      "isWoltPlusOnly": false
    }
  ],
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

### Plan requirement

Wolt is open to public requests with no extra credentials needed, but the endpoint behind **city search** refuses datacenter addresses outright, so search mode needs an Apify Residential proxy (Starter plan or higher). The actor still starts on whatever proxy you configure and escalates to Residential only for a request that comes back refused, geo-targeted at the country of the city being searched; selecting Residential in `proxyConfiguration` up front avoids the wasted first attempt. **URL mode** for individual venues, and menus, work on the default proxy. Override any of this via the `proxyConfiguration` input field.

# Actor input Schema

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

Pick how to find venues. Search uses a list of cities or free-text place queries. URL mode pastes ready-made Wolt URLs (single venue or city restaurant page).

## `cities` (type: `array`):

City names or free-text places (e.g. "Helsinki", "Graz, Austria", "Stockholm"). Slugs from Wolt's own city directory are matched first; anything else falls back to geocoding. Leave blank in URL mode.

## `urls` (type: `array`):

Ready-made Wolt URLs. Both single venue (https://wolt.com/<lang>/<country>/<city>/restaurant/<slug>) and city pages (https://wolt.com/<lang>/<country>/<city>/restaurants) are accepted. Multi-URL supported.

## `primaryCategories` (type: `array`):

Filter city listings by primary cuisine tag. Examples: pizza, burgers, sushi, vegan, kebab, asian, italian, breakfast, dessert, bbq, indian. Leave empty to include all.

## `minRating` (type: `integer`):

Minimum Wolt rating score (0-10 scale). Records below this are skipped. Leave empty for no minimum.

## `minRatingVolume` (type: `integer`):

Minimum number of ratings a venue must have to be included. Leave empty or 0 for no minimum.

## `sortBy` (type: `string`):

Order of venues within each city. Wolt's algorithmic default is the venue order Wolt's app shows. Other options sort the SERP client-side using the sortable scores Wolt returns per venue.

## `fetchMenu` (type: `boolean`):

When ON, every venue is enriched with the full menu (categories, items, prices, images, blurhashes, deal flags). Adds ~1 HTTP request per venue. Turn off for fast venue-only runs.

## `includeReviews` (type: `boolean`):

When ON, the rating score, rating bucket (1-5), and review count are populated on every record. Turn off if you don't need any rating data in the output.

## `language` (type: `string`):

ISO language code passed to Wolt for menu and venue text (en, de, fi, sv, fr, es, etc.). Defaults to en.

## `maxVenues` (type: `integer`):

Hard cap on total venues across the whole run. 0 means unlimited.

## `maxVenuesPerCity` (type: `integer`):

Per-city cap. Wolt city pages return 100-200 venues; lower this for fast smoke runs. 0 means unlimited per city.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large crawl of venues without returning or charging for venues already collected there. Use this after an interrupted run, or when continuing a large city/catalogue pull in another run. For recurring daily monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns all matching venues as NEW. Later runs normally return only NEW, UPDATED, and REAPPEARED venues. Turn on "Emit unchanged" or "Emit expired" only when you also want those venues returned (and billed). State is kept separately for each city/URL/filter/menu setup; use State key when you want to name or deliberately share a monitoring campaign. To continue one specific interrupted run instead, use Resume from a previous run above.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently-configured runs. Leave empty to let the actor derive a key automatically from the cities/URLs/filters/menu settings — different searches then never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return venues that have not changed since the last run, marked UNCHANGED. This returns — and bills — extra rows you already have, so leave it off unless you specifically want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return venues that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search — not when Max venues capped it or when Resume was used. This returns — and bills — extra synthetic rows, so leave it off unless you need expiry tracking.

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

City search needs a residential exit — the search endpoint refuses datacenter addresses. Leave this on the default and the actor will retry a refused request over Residential, geo-targeted at the city's own country; select Residential here to start there and skip the wasted attempt. Venue URLs and menus work fine on the default proxy.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "cities": [
    "Helsinki"
  ],
  "urls": [
    "https://wolt.com/en/aut/graz/restaurant/kfc-graz"
  ],
  "minRatingVolume": 0,
  "sortBy": "default",
  "fetchMenu": true,
  "includeReviews": true,
  "language": "en",
  "maxVenues": 50,
  "maxVenuesPerCity": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "cities": [
        "Helsinki"
    ],
    "urls": [
        "https://wolt.com/en/aut/graz/restaurant/kfc-graz"
    ],
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/wolt-restaurants-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": "search",
    "cities": ["Helsinki"],
    "urls": ["https://wolt.com/en/aut/graz/restaurant/kfc-graz"],
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/wolt-restaurants-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 '{
  "mode": "search",
  "cities": [
    "Helsinki"
  ],
  "urls": [
    "https://wolt.com/en/aut/graz/restaurant/kfc-graz"
  ],
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/wolt-restaurants-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/wolt-restaurants-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/G2tsr3xcdcXvQodkL/builds/LSkrgKDKILnyML5FP/openapi.json