# Wolt Scraper \[Only $1/1K💰] | Restaurants & Menus | 963 Cities (`ahmed_jasarevic/wolt-scraper`) Actor

Extract Wolt restaurant and grocery data with complete menus and prices — cuisines, ratings, delivery estimates, opening hours, dietary tags and VAT — across 963 Wolt cities in 30+ countries, via Wolt's own public JSON APIs. No browser, no paid anti-bot service.

- **URL**: https://apify.com/ahmed_jasarevic/wolt-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 96.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 venue scrapeds

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?

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

### Wolt Scraper — Restaurant Menus, Prices & Venue Data From 963 Cities

Extract Wolt restaurant and grocery data with complete menus and prices — cuisines, ratings, delivery estimates, opening hours, dietary tags and VAT — across 963 Wolt cities in 30+ countries, via Wolt's own public JSON APIs with no browser and no paid anti-bot service.

#### Main Use Cases

- **Menu-price monitoring** — snapshot full menus with prices and diff scheduled runs to track competitor price changes.
- **Restaurant group & chain audits** — verify menus, opening hours and photos across every branch on Wolt.
- **Ghost kitchen & aggregator benchmarking** — price bands, cuisines and delivery estimates per city before launch.
- **Food delivery market research** — venue counts, cuisine mix, price bands and rating distributions per market.
- **Dietary & allergen data** — merchant-declared dietary preferences and allergen warnings per menu item.
- **Exhaustive city coverage** — geo-grid probes plus Wolt's venue sitemaps reach past the single-delivery-area limit.

#### How the Wolt Scraper Works

Wolt's web app is a JavaScript SPA that reads from **undocumented but fully public JSON APIs**, and its SEO pages are **server-rendered with schema.org JSON-LD embedded in the HTML**. This Actor talks to those surfaces with plain HTTP — **no Playwright, no Puppeteer, no CAPTCHA solving, no paid anti-bot API**:

| # | Purpose | Endpoint | Why this surface |
|---|---|---|---|
| 1 | City index | `GET restaurant-api.wolt.com/v1/cities` | All **963** Wolt cities with slugs, coordinates and country codes — target a city by name. |
| 2 | Venue discovery | `GET consumer-api.wolt.com/v1/pages/front?lat&lon` (+ `…/pages/restaurants` for large runs) | The front-page feed is small, fast and reliable; it returns venues near a point with rating, delivery estimate, currency, cuisines and live `online` flag. The larger restaurants feed supplements it when more venues are requested. |
| 3 | Text search | `POST restaurant-api.wolt.com/v1/pages/search` | Wolt's consumer search by venue (`target: venues`) or by dish (`target: items`). |
| 4 | **Full menu** | `GET consumer-api.wolt.com/consumer-api/consumer-assortment/v1/venues/slug/{slug}/assortment` | The menu the app renders: categories, items and options with prices, dietary tags, VAT and availability windows. **Source of all menu and price data.** |
| 5 | Opening hours & contact | `wolt.com/{lang}/{country}/{city}/restaurant/{slug}` → JSON-LD | Server-rendered `@type: Restaurant` blob carrying `openingHours`, `telephone`, `priceRange`, `servesCuisine` — none of which exist in the JSON APIs. Read with a regex; no JS execution. |

### Build Restaurant Databases and Monitor Menu Prices

Every venue row carries name, slug, URL, cuisines, rating and review count, delivery time estimate, street address with lat/lon, opening hours, live open/online flags, price band and phone — with the full menu nested under `menuCategories`. A second dataset (`menus`) always emits **one row per menu item** with item fields hoisted to the top level, so BI tools read `price`, not `item.price`. Both grains come from a single run.

### How It Works

![Wolt Scraper workflow: from city and cuisine searches to venue records with ratings, delivery estimates and complete menus with dish prices, dietary tags and VAT](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-wolt-scraper.webp)

Looking for a **Wolt scraper** or a practical **restaurant menu data alternative**? Add one or more city slugs, coordinates, cuisine searches or direct venue URLs, then set venue and menu-item limits. The default dataset returns one row per venue with name, URL, city, country, currency, address, coordinates, cuisines, rating, review count, delivery estimate, price range, opening hours, phone and a nested menu; the menus dataset returns one row per dish with category, price, dietary tags, allergens, VAT and availability.

Use the dataset for menu-price monitoring, chain audits, delivery-market sizing and dietary research. Export as JSON, CSV or Excel, or pull results through the Apify API. Pay from $1.00 per 1,000 venues plus $0.20 per 1,000 menu items.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `cities` | string | one of | `berlin` | Comma-separated Wolt city slugs, e.g. `berlin, munich, helsinki`. Resolved against Wolt's own city index. Leave empty to use lat/lon or a search query. |
| `lat` / `lon` | number | no | – | Raw geo point to discover venues around. Used together. |
| `searchQueries` | string | no | `""` | Comma-separated free-text venue searches, e.g. `pizza, sushi, vegan`. |
| `venueUrls` | string | no | `""` | Comma-separated Wolt venue or item URLs, e.g. from `wolt.com/sitemap/venues/{country}-{n}.xml`. |
| `maxVenues` | integer | no | `25` | Max venues per run (max 5000). Free accounts capped at 10. One discovery request returns up to ~2,000 venues for a city, so higher values pay off with `geoGridPoints`. |
| `geoGridPoints` | integer | no | `0` | Extra discovery requests per city, anchored east/south/north/west of the centre. Wolt's listing covers one delivery area, so each probe adds a few hundred venues. `0` = off. |
| `geoGridStepDeg` | number | no | `0.08` | How far each probe sits from the centre, in degrees. `0.08` ≈ 9 km. |
| `maxItemsPerVenue` | integer | no | `250` | Max menu items kept per venue (`0` = no limit). Does not change row count. |
| `includeMenu` | boolean | no | `true` | Fetch full menus. Turn off for a fast metadata-only crawl. |
| `includeOpeningHours` | boolean | no | `true` | Also fetch each venue's SEO page for hours, phone and price range. **Expensive phase** — those pages are ~3 MB each, roughly 10–20× the cost per venue vs menus alone. |
| `hoursConcurrency` | integer | no | `10` | Parallel SEO-page fetches. Pages are fetched directly; lower this if wolt.com starts returning HTTP 429. |
| `flattenMenuItems` | boolean | no | `false` | Rewrite the **default** dataset to one row per menu item (venue fields repeated, item under `item`). Convenient for BI, but you lose the one-row-per-venue view. |
| `proxy` | object | no | prefilled on | **Keep enabled.** Wolt rate-limits Apify's shared Cloud egress IP with HTTP 429, so discovery often returns zero venues without a proxy. The Actor retries rate-limited requests itself. |

### Output: Venues and Menus, Two Grains From One Run

| Dataset | Grain | Rows for 5 venues / 374 items |
|---|---|---|
| `default` | one row per venue, menus nested under `menuCategories` | 5 |
| `menus` | one row per menu item, item fields hoisted to top level | 374 |

Venue fields: `venueId`, `name`, `slug`, `url`, `city`, `country`, `currency`, `address`, `latitude`, `longitude`, `cuisines`, `shortDescription`, `image`, `rating`, `ratingCount`, `ratingStars`, `deliveryEstimateMin` / `Max` / `Range`, `priceRange`, `priceRangeText`, `isOpen`, `isOnline`, `supportsDelivery`, `productLine` (`restaurant` / `grocery` / `gift_card`), `phone`, `openingHours`, `menuCategoryCount`, `menuItemCount`, `scrapedAt`.

Menu item fields: `name`, `description`, `price` (Wolt returns minor units; divided by 100), `currency`, `originalPrice`, `unitPrice`, `soldByWeight`, `image`, `isAvailable`, `unavailableReason`, `availableFrom` / `availableUntil`, `dietaryPreferences`, `allergenWarnings`, `tags`, `vatPercentage`, `alcoholPercentage`, `allowedDeliveryMethods`, `optionNames`, `hasOptions`, `itemUrl`.

Example `default` row (trimmed):

```json
{
  "venueId": "65df270d220b01038977a7c5",
  "name": "Croissant Couture",
  "slug": "croissant-couture",
  "url": "https://wolt.com/en/deu/berlin/restaurant/croissant-couture",
  "city": "berlin",
  "country": "DEU",
  "currency": "EUR",
  "address": "Weinbergsweg 4",
  "latitude": 52.53066696,
  "longitude": 13.40226343,
  "cuisines": ["dessert"],
  "rating": 8.6,
  "ratingCount": 284,
  "deliveryEstimateRange": "45-55",
  "priceRangeText": "€",
  "isOpen": true,
  "isOnline": true,
  "phone": "+493025735205",
  "openingHours": ["Mo 08:00-19:45", "Tu 08:00-19:45"],
  "menuCategoryCount": 8,
  "menuItemCount": 24,
  "scrapedAt": "2026-09-27T07:31:12.482Z",
  "menuCategories": [
    {
      "id": "b544d0b50acffb105bc77824",
      "name": "WOLT SPECIALS",
      "items": [
        {
          "name": "Iced Latte 0,4 l",
          "price": 5.2,
          "currency": "EUR",
          "isAvailable": true,
          "dietaryPreferences": ["vegetarian"],
          "vatPercentage": 7,
          "allowedDeliveryMethods": ["takeaway", "homedelivery"]
        }
      ]
    }
  ]
}
```

Example `menus` row (trimmed):

```json
{
  "venueId": "5f903fb21e968e9b217b43e2",
  "venueName": "Monsieur Vuong",
  "city": "berlin",
  "country": "DEU",
  "category": "VORSPEISEN",
  "id": "60783c0e9b0eaa45f33f76b5",
  "name": "Cha Gio",
  "price": 9,
  "currency": "EUR",
  "isAvailable": true,
  "tags": ["popular"],
  "vatPercentage": 7,
  "itemUrl": "https://wolt.com/en/deu/berlin/venue/monsieur-vuong/monsieur-vuong-itemid-60783c0e9b0eaa45f33f76b5"
}
```

### Example Input

```json
{
  "cities": "berlin, munich",
  "maxVenues": 50,
  "geoGridPoints": 2,
  "maxItemsPerVenue": 0,
  "includeOpeningHours": true
}
```

### Pricing: Lowest Venue Price and $0.20 per 1,000 Menu Items

Wolt's APIs are public and un-walled, so **no paid anti-bot service is required**. The Actor defaults to 512 MB of RAM (the city-discovery response is a few MB per city and parsed as a unit) — still ~8× cheaper than the 4 GB template default.

- **Start:** $0.00005 per run
- **Venue scraped:** **$0.001 — $1.00 per 1,000 venues** ($0.90 on silver and above)
- **Menu item:** **$0.0002 — $0.20 per 1,000 menu items** ($0.19 on gold and above)
- **Free tier:** capped at 10 venues per run.
- **Proxy:** billed only if you enable it; the datacenter group is enough (included in paid plans).

Two things dominate the bill: **opening hours** (a ~3 MB SEO page per venue, roughly 10–20× a menu fetch) and **geo-grid probes** (one cheap discovery request each). Turning off `includeOpeningHours` for a large venue sweep is by far the biggest saving. Because the Actor is billed per venue/menu-item event, what you see in the datasets is exactly what was charged.

### Integrations & Automation

Runs on the Apify platform with **REST API access, webhooks, scheduled runs, dataset exports (JSON, CSV, Excel) and Zapier/Make integrations**. Recommended schedules:

- **Menu-price monitoring:** daily snapshot per city, diff `price` in the `menus` dataset between runs.
- **Chain audits:** weekly per-branch sweep using `venueUrls` from the venue sitemaps.
- **Market sizing:** monthly run per city with `geoGridPoints: 2–4` and `includeOpeningHours: false` to keep it cheap.

### Related Actors

- [**Food Delivery Scraper**](https://apify.com/e-commerce/food-delivery-scraper) (Apify) — cross-platform food delivery data for multi-market comparison.
- [**Wolt Restaurant Menu Scraper**](https://apify.com/needy_hammock/wolt-restaurant-menu-scraper) — Wolt-specific alternative worth benchmarking against.
- [**Wolt Restaurant Menu Scraper (961 cities)**](https://apify.com/teodor_banea/wolt-restaurant-menu-scraper) — another Wolt-focused actor for cross-checking coverage.
- [**Swiggy Delivery Scraper**](https://apify.com/w3crawler/swiggy-delivery-scraper) — adjacent delivery platform for India market data.
- [**eFood Scraper**](https://apify.com/studio-amba/efood-scraper) — adjacent delivery platform for Greece market data.

### FAQ

#### Is there a Wolt API for restaurants and menus — why use this Actor?

Wolt publishes no documented public partner API. This Actor uses the same undocumented public JSON endpoints (`consumer-api`, `restaurant-api`) that Wolt's own web app calls, plus the server-rendered JSON-LD on venue SEO pages for opening hours — the cheapest reliable way to get complete menu data without a browser.

#### Does this need Playwright or a paid anti-bot API?

No. Plain HTTP is sufficient, which is why this Actor is HTTP-only and cheap. It uses the standard **Apify Proxy** option (included in your plan, pre-enabled) — not a separate anti-bot vendor. There is no Cloudflare, Akamai or challenge page on these endpoints.

#### Why did my first run return nothing?

Almost always rate limiting: Wolt answers Apify's shared Cloud egress IP with `HTTP 429`, so discovery comes back empty without a proxy. Check the run log for `rate-limited` and make sure `proxy` is enabled (it is pre-enabled). If you still get nothing, the city slug may not exist in Wolt's city index.

#### How do I get all restaurants in a city, not just one delivery area?

A single discovery request covers one delivery zone (Berlin returns ~2,000 venues). Set `geoGridPoints` to `2`–`4` to probe east/south/north/west as well — in Berlin the first east probe alone added **470** venues for the price of one small request — or feed batches of `wolt.com/sitemap/venues/{country}-{n}.xml` URLs into `venueUrls` for exhaustive coverage.

#### Can I get delivery fees?

No. Wolt computes the delivery fee from the customer's address and basket, and no public endpoint returns it. The Actor returns the delivery **time** estimate (`deliveryEstimateMin` / `Max`) from the same response instead.

#### Are dietary and allergen tags reliable?

They are merchant-supplied and frequently empty — many venues simply do not declare them. Treat a missing tag as "not declared", not "contains none".

#### How often can I run it?

Use Apify scheduling. For price monitoring, daily snapshots are usually plenty. Keep volume reasonable and keep the proxy enabled for large crawls.

### For AI Agents & LLM Apps

**Purpose:** returns one dataset row per Wolt venue (with nested menus) plus a second `menus` dataset with one row per menu item, across 963 Wolt cities.

Minimal working input:

```json
{ "cities": "berlin", "maxVenues": 25 }
```

Variants:

- Full menus + hours across cities: `{ "cities": "berlin, munich", "maxVenues": 50, "includeMenu": true, "includeOpeningHours": true }`
- Cheap metadata-only market sweep: `{ "cities": "helsinki", "maxVenues": 200, "geoGridPoints": 2, "includeMenu": false, "includeOpeningHours": false }`

Output field list (venue): `venueId`, `name`, `slug`, `url`, `city`, `country`, `currency`, `address`, `latitude`, `longitude`, `cuisines`, `shortDescription`, `image`, `rating`, `ratingCount`, `ratingStars`, `deliveryEstimateMin`, `deliveryEstimateMax`, `deliveryEstimateRange`, `priceRange`, `priceRangeText`, `isOpen`, `isOnline`, `supportsDelivery`, `productLine`, `phone`, `openingHours`, `menuCategoryCount`, `menuItemCount`, `scrapedAt`, `menuCategories`.
Output field list (menu item, `menus` dataset): `venueId`, `venueName`, `venueSlug`, `city`, `country`, `categoryId`, `category`, `id`, `name`, `description`, `price`, `currency`, `isAvailable`, `dietaryPreferences`, `tags`, `vatPercentage`, `itemUrl`.

Behaviors an agent should know:

- **Keep the proxy enabled** — without it Apify Cloud runs usually list zero venues (HTTP 429 on the shared egress IP).
- **`maxVenues` above ~2,000 per city needs `geoGridPoints`** — one discovery request only covers a single delivery area.
- **`includeOpeningHours: true` is the expensive phase** (~3 MB page/venue, 10–20× a menu fetch) — turn it off for volume sweeps; use `false` plus `includeMenu: false` for the cheapest metadata crawl.
- **`hoursConcurrency` defaults to 10** — pages are fetched directly; lower it if wolt.com returns HTTP 429.
- **Two datasets per run** (`default` + `menus`) are always written. The `menus` dataset is per-run, not an archive.
- **Prices in the menu API are minor units** — the Actor divides by 100, so `price` is in major currency units.

**Billing:** pay-per-event — start $0.00005, then $0.001 per venue and $0.0002 per menu item ($1/1K venues, $0.20/1K items); free tier caps at 10 venues.

### Legal & Compliance Disclaimer

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Wolt Food Delivery**. It reads only publicly served data — public JSON APIs and server-rendered venue pages — with no login bypass, CAPTCHA solving, or private endpoints. You are responsible for complying with Wolt's Terms of Service and `robots.txt` (Wolt's robots.txt is fully open) and with data-protection law. Output includes business contact data such as venue phone numbers and addresses; handle it in line with GDPR and other applicable rules. This information is not legal advice.

### SEO Keywords

wolt scraper, wolt restaurant data, wolt menu prices, wolt menu scraper, restaurant menu data api, restaurant menu scraping, food delivery price monitoring, menu price monitoring, food delivery market research, wolt api alternative, restaurant competitor pricing, ghost kitchen benchmark, restaurant group branch audit, wolt cities list, opening hours scraping, dietary tags allergen data, delivery time estimate data, restaurant venue metadata, wolt grocery data, wolt germany, wolt netherlands, wolt finland, wolt israel, food delivery aggregator data

# Actor input Schema

## `cities` (type: `string`):

Comma-separated Wolt city slugs to crawl, e.g. "berlin, munich, helsinki". Slugs are resolved against Wolt's own city index. Leave empty to use lat/lon or a search query.

## `lat` (type: `number`):

Latitude for a raw geo point to discover venues around. Used together with "lon".

## `lon` (type: `number`):

Longitude for a raw geo point to discover venues around. Used together with "lat".

## `searchQueries` (type: `string`):

Comma-separated free-text venue searches, e.g. "pizza, sushi, vegan". Uses Wolt's venue search.

## `venueUrls` (type: `string`):

Comma-separated Wolt venue or item URLs, e.g. "https://wolt.com/en/deu/berlin/restaurant/pizza-nostra-ber". Useful with URLs taken from https://wolt.com/sitemap/venues/{country}-{n}.xml

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

Maximum number of venues to scrape per run. Free accounts are capped at 10 venues. The Actor uses a fast city feed that returns a few hundred venues per request, adds geo-grid probes when configured, and automatically asks the larger feed for the remainder on bigger limits.

## `geoGridPoints` (type: `integer`):

Extra discovery requests per city, each anchored a little east/south/north/west of the city centre. Wolt's listing only covers one delivery area, so a city tops out at a single request's worth of venues; each extra probe costs one request and typically adds a few hundred more. 0 = off.

## `geoGridStepDeg` (type: `number`):

How far each geo-grid probe sits from the city centre, in degrees. 0.08 is roughly 9 km and suits most cities; raise it for sprawling ones, lower it for small dense ones.

## `maxItemsPerVenue` (type: `integer`):

Maximum number of menu items to keep per venue (0 = no limit).

## `includeMenu` (type: `boolean`):

Fetch the full menu with categories, prices and images. Disable for a fast venue-metadata-only crawl.

## `includeOpeningHours` (type: `boolean`):

Also fetch each venue's SEO page to read opening hours, phone number and price range. This is the expensive part of a run: those pages are ~3 MB each, so allow roughly 10-20x the cost per venue versus menus alone. Turn it off for large volume scrapes.

## `hoursConcurrency` (type: `integer`):

How many SEO pages to fetch at once. The hours phase runs in parallel with the menu fetch, and pages are requested directly from wolt.com (the proxy is only a fallback), so 10 is a safe default. Lower it if wolt.com starts returning HTTP 429 responses.

## `flattenMenuItems` (type: `boolean`):

When true, emit one dataset row per menu item (venue fields repeated) instead of one row per venue with a nested menuCategories array. Useful for menu-price monitoring and BI tools.

## `proxy` (type: `object`):

Select proxies to be used by your crawler. IMPORTANT for discovery: Wolt rate-limits (HTTP 429) the shared Apify Cloud egress IP, so a cloud run without a proxy can list zero venues and fail. Turn this on for any run started from Apify; the Actor uses a lightweight feed plus automatic retries to stay reliable.

## Actor input object example

```json
{
  "cities": "berlin, munich",
  "lat": 52.52,
  "lon": 13.405,
  "searchQueries": "pizza, doner",
  "venueUrls": "",
  "maxVenues": 25,
  "geoGridPoints": 0,
  "geoGridStepDeg": 0.08,
  "maxItemsPerVenue": 250,
  "includeMenu": true,
  "includeOpeningHours": true,
  "hoursConcurrency": 10,
  "flattenMenuItems": false,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `venues` (type: `string`):

One row per restaurant, with the full menu nested under menuCategories.

## `menus` (type: `string`):

One row per menu item, with price, name, dietary tags and category at the top level plus the venue it belongs to.

# 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 = {
    "cities": "berlin, munich",
    "geoGridPoints": 0,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = {
    "cities": "berlin, munich",
    "geoGridPoints": 0,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/wolt-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 '{
  "cities": "berlin, munich",
  "geoGridPoints": 0,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call ahmed_jasarevic/wolt-scraper --silent --output-dataset

```

## MCP server setup

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