# Wolt Scraper (`solidcode/wolt-scraper`) Actor

\[💰 $1.0 / 1K] Extract restaurants and grocery venues from Wolt. Get name, cuisines, rating, review count, price range, delivery ETA and fees, address and coordinates. Turn on menus to also collect every item with its price. Search by city, coordinates, or paste Wolt URLs.

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

## Pricing

from $1.00 / 1,000 venues

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/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.md):

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

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

## Wolt Scraper

Pull restaurants and grocery venues from Wolt across 30 European, Nordic, Baltic, Caucasus, and Israeli markets — ratings, delivery ETA, fees, minimum order, cuisines, coordinates, opening hours, and full restaurant menus with real-currency prices. Built for food-delivery market researchers, restaurant and grocery competitive-intelligence teams, restaurant-SaaS lead generators, and menu-and-price monitoring analysts who need the complete Wolt catalogue without stitching together dozens of city pages by hand.

### Why This Scraper?

- **30 live Wolt markets in one actor** — Finland, Germany, Sweden, Norway, Denmark, Greece, Israel, Georgia, Azerbaijan, Kazakhstan, and 20 more, searchable by name or auto-detected from the city you type.
- **Full restaurant menus with prices in real currency** — every restaurant menu item as its own row with category, name, description, image, and price already converted to euros, lari, shekels, or the market's currency (never raw cents).
- **Restaurants and Wolt Market grocery in the same run** — pull a neighborhood's takeaway spots and its grocery stores side by side, each tagged by product line (`restaurant` vs `grocery`) so you can split them downstream. Grocery entries return full store profiles — name, rating, delivery economics, address, coordinates; store-wide product catalogs are best-effort and may be limited on grocery venues.
- **Delivery economics on every venue** — delivery ETA plus its min–max range, delivery fee, and minimum order value together, so you can model true cost-to-doorstep, not just a menu price.
- **Rating score and review volume** — the 0–10 Wolt score, the out-of-5 rating, and the underlying review count per venue for quality benchmarking.
- **Three ways to target a location** — search by city name, drop exact latitude/longitude for precise neighborhood coverage, or paste ready-made Wolt discovery and venue URLs.
- **Live availability signals** — `isOnline` and `delivers` flags plus opening-hours schedules tell you which venues are actually taking orders right now.
- **Precise coordinates and full addresses** — latitude, longitude, street address, city, and country on every venue for mapping and territory analysis.
- **Per-venue item cap for predictable cost** — a per-venue menu-item limit keeps any large menu or product list from ballooning a run, so budgets stay predictable.

### Use Cases

**Market Research**
- Map restaurant and grocery density by city or exact coordinates across 30 markets
- Compare cuisine mix and price ranges between neighborhoods or countries
- Benchmark delivery ETAs and fees across competing venues in the same area
- Track which venues are online and delivering during peak hours

**Menu & Price Intelligence**
- Monitor competitor menu prices item-by-item in real currency
- Detect new dishes, discontinued items, and price changes over time
- Compare pricing for the same product across venues and cities
- Build category-level price indexes across restaurant menus in a cuisine

**Lead Generation**
- Build prospect lists of restaurants and grocery venues for restaurant-SaaS, POS, and delivery tooling
- Segment leads by rating, review volume, cuisine tags, and product line
- Prioritize outreach to high-rated or high-review venues in a target market

**Grocery & Retail Analytics**
- Map Wolt Market and grocery-store presence, ratings, and delivery economics by city and market
- Compare grocery-store coverage, opening hours, and delivery reach across neighborhoods
- Build store-level profiles of grocery venues alongside the restaurants around them

**Location Intelligence**
- Feed venue coordinates and addresses into mapping and territory tools
- Analyze delivery coverage and opening hours by district
- Identify underserved areas by cross-referencing venue counts against population

### Getting Started

#### Search a City

The simplest run — one city, a handful of venues to test:

```json
{
    "search": ["Helsinki"],
    "maxResults": 10
}
````

#### Search a Specific Market

Narrow the search to one country so a city name that exists in several markets resolves correctly:

```json
{
    "search": ["Tallinn"],
    "country": "est",
    "includeMenu": false,
    "maxResults": 50
}
```

#### Search by Exact Coordinates

Target a precise neighborhood instead of a whole city:

```json
{
    "search": ["restaurants"],
    "latitude": "60.1699",
    "longitude": "24.9384",
    "includeMenu": true,
    "maxMenuItemsPerVenue": 200,
    "maxResults": 100
}
```

#### Paste Wolt URLs

Use discovery pages or individual venue links directly — search filters are ignored for URLs:

```json
{
    "startUrls": [
        "https://wolt.com/en/fin/helsinki/restaurants",
        "https://wolt.com/en/fin/helsinki/restaurant/vapiano"
    ],
    "includeMenu": true,
    "maxMenuItemsPerVenue": 150,
    "maxResults": 200
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `["https://wolt.com/en/fin/helsinki/restaurants"]` | Wolt discovery pages or individual venue URLs. When supplied, the search filters below are ignored. |

#### Search Filters

Only apply when `startUrls` is empty.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `search` | string\[] | `["Helsinki"]` | Cities or areas to search, one per entry. Each is searched separately. |
| `country` | select | `Auto-detect` | Which Wolt market to search in. Choose Auto-detect to let the city name decide, or pick one of 30 markets (Finland, Germany, Sweden, Israel, Georgia, and more). |
| `latitude` | string | null | Exact latitude to search around (e.g. `60.1699`). Use with Longitude for a precise location instead of a city. |
| `longitude` | string | null | Exact longitude to search around (e.g. `24.9384`). Use with Latitude for a precise location. |

#### Detail & Extras

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeMenu` | boolean | `true` | Visit each venue and return every menu item as its own row (category, name, description, price, image). Turn off to keep only venue summary rows. |
| `maxMenuItemsPerVenue` | integer | `0` | Cap on menu items collected per venue. `0` collects every item. Keeps large grocery venues from exploding a run. Ignored when menus are off. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum venues to collect across all URLs and searches. `0` collects as many as possible. Menu items are additional to this count. |

### Output

Every row carries a `recordType` field — `venue` or `menuItem` — so you can filter cleanly downstream. The Overview tab holds every record; the Venues and Menu Items tabs are type-filtered subsets of the same run.

#### Venue (`recordType: "venue"`)

```json
{
    "recordType": "venue",
    "id": "5b7e3f9c2a1d4e0012345678",
    "slug": "vapiano-helsinki",
    "name": "Vapiano",
    "productLine": "restaurant",
    "franchise": "Vapiano",
    "address": "Kampinkuja 2",
    "city": "Helsinki",
    "country": "FIN",
    "latitude": 60.1690,
    "longitude": 24.9310,
    "rating": 4.2,
    "ratingScore": 8.4,
    "reviewCount": 500,
    "priceRange": 2,
    "currency": "EUR",
    "isOnline": true,
    "delivers": true,
    "deliveryEta": 25,
    "deliveryEtaRange": "20-30",
    "deliveryFee": 2.90,
    "minimumOrder": 12.00,
    "tags": ["Italian", "Pasta", "Pizza"],
    "shortDescription": "Fresh Italian, made to order.",
    "openingHours": [{ "day": "monday", "formatted_times": "11:00–22:00" }],
    "imageUrl": "https://images.wolt.com/venue/vapiano.jpg",
    "menuItemCount": 95,
    "url": "https://wolt.com/en/fin/helsinki/restaurant/vapiano-helsinki",
    "scrapedAt": "2026-07-02T14:30:00Z"
}
```

##### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"venue"` |
| `id` | string | Wolt venue identifier |
| `slug` | string | URL slug |
| `name` | string | Venue name |
| `productLine` | string | `"restaurant"`, `"wolt-market"` (grocery), etc. |
| `franchise` | string | Franchise or brand name, when applicable |
| `tags` | string\[] | Cuisine and food-type tags |
| `shortDescription` | string | Short venue description |
| `imageUrl` | string | Brand or logo image URL |
| `menuItemCount` | number | Number of menu items collected for this venue |
| `url` | string | Canonical Wolt venue page URL |
| `scrapedAt` | string | ISO timestamp of extraction |

##### Location

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Street address |
| `city` | string | City |
| `country` | string | Country code |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |
| `postalCode` | string | Postal code, when available |
| `openingHours` | object\[] | Opening-hours schedule by day, when available |

##### Delivery Economics

| Field | Type | Description |
|-------|------|-------------|
| `isOnline` | boolean | Whether the venue is currently accepting orders |
| `delivers` | boolean | Whether delivery is available |
| `priceRange` | number | Price tier, 1 (€) to 4 (€€€€) |
| `currency` | string | Currency code for all prices |
| `deliveryEta` | number | Delivery time estimate in minutes |
| `deliveryEtaRange` | string | Delivery time window, e.g. `"20-30"` |
| `deliveryFee` | number | Delivery fee in currency units |
| `minimumOrder` | number | Minimum order value in currency units |

##### Ratings

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | Rating out of 5 |
| `ratingScore` | number | Wolt score out of 10 |
| `reviewCount` | number | Number of reviews behind the rating |

#### Menu Item (`recordType: "menuItem"`)

Emitted only when `includeMenu` is on. Each item links back to its parent venue.

```json
{
    "recordType": "menuItem",
    "venueId": "5b7e3f9c2a1d4e0012345678",
    "venueName": "Vapiano",
    "venueSlug": "vapiano-helsinki",
    "category": "Pasta",
    "name": "Spaghetti Bolognese",
    "description": "Slow-cooked beef ragù, parmesan.",
    "price": 13.90,
    "currency": "EUR",
    "imageUrl": "https://images.wolt.com/menu/spaghetti.jpg",
    "venueUrl": "https://wolt.com/en/fin/helsinki/restaurant/vapiano-helsinki"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"menuItem"` |
| `venueId` | string | Parent venue identifier |
| `venueName` | string | Parent venue name |
| `venueSlug` | string | Parent venue slug |
| `category` | string | Menu category the item belongs to |
| `name` | string | Item name |
| `description` | string | Item description, when present |
| `price` | number | Item price in currency units (already converted from cents) |
| `currency` | string | Currency code |
| `imageUrl` | string | Item image URL, when present |
| `venueUrl` | string | Parent venue page URL |

### Tips for Best Results

- **Start small to test.** Set `maxResults` to 10 on your first run to confirm the data matches your needs, then scale to hundreds or thousands.
- **Cap large menus.** Menus with hundreds of items each return as separate rows. Set `maxMenuItemsPerVenue` (e.g. 200) before a big pull to keep costs predictable — a restaurant rarely exceeds 150 items, so a modest cap covers most runs comfortably.
- **Turn off menus for a venue census.** Set `includeMenu` to false when you only need the venue list — ratings, delivery economics, cuisines, and coordinates — for a much lighter, cheaper run.
- **Use coordinates for neighborhood precision.** A city name centers on the city; exact latitude and longitude let you target a specific district, campus, or catchment area.
- **Pick the market when a city name is ambiguous.** Set `country` (e.g. `est` for Estonia) so a common city name resolves to the right Wolt market instead of auto-detecting the wrong one.
- **Paste URLs when you have already built a search on the site.** Filters in a pasted Wolt URL are used exactly as-is, so what you see on wolt.com is what you get.
- **Budget for the split.** Venues are the parent rows; menu items are extra. A run of 100 restaurants at ~80 items each is 100 venues plus ~8,000 menu items — plan `maxResults` and the menu cap accordingly.

### Pricing

**From $1.00 per 1,000 venues** — richer than contact-only Wolt scrapers, with full menus, delivery economics, ratings, and coordinates in every run. You are charged per venue and per menu item collected, plus a small fixed per-run start fee. Loyalty-tier discounts (Bronze, Silver, Gold) apply automatically on the Apify Console.

#### Per venue

| Venues | No discount | Bronze | Silver | Gold |
|--------|-------------|--------|--------|------|
| 100 | $0.12 | $0.11 | $0.11 | $0.10 |
| 1,000 | $1.20 | $1.13 | $1.07 | $1.00 |
| 10,000 | $12.00 | $11.30 | $10.70 | $10.00 |
| 100,000 | $120.00 | $113.00 | $107.00 | $100.00 |

#### Per menu item

Menu items are billed at a flat **$0.20 per 1,000 items** at every tier. Turn menus off, or set `maxMenuItemsPerVenue`, to control this cost.

#### Example run costs

Using Gold rates ($1.00 per 1,000 venues + $0.20 per 1,000 menu items):

| Run | Venue cost | Menu-item cost | Total |
|-----|------------|----------------|-------|
| 10 restaurants, ~80 items each (800 items) | $0.01 | $0.00 | ~$0.01 |
| 100 restaurants, ~80 items each (8,000 items) | $0.10 | $0.00 | ~$0.10 |
| 500 venues, ~80 items each (40,000 items) | $0.50 | $0.01 | ~$0.51 |

No compute or time-based charges — you pay per venue and per menu item collected, plus a small fixed per-run start fee. As the example table shows, menus drive most of the row volume, so the per-item rate is deliberately low. Platform fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, competitive intelligence, menu and price monitoring, and lead generation. Users are responsible for complying with applicable laws and Wolt's terms of service, including making reasonable-rate requests. Do not use extracted data for spam, harassment, or any illegal purpose. </content> </invoke>

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more Wolt URLs. Accepts city or discovery pages (e.g. https://wolt.com/en/fin/helsinki/restaurants) or individual venue pages (e.g. https://wolt.com/en/fin/helsinki/restaurant/example). Filters in the URL are used as-is, so the Search Filters below are ignored for these URLs. Use this when you already built a search on the site.

## `search` (type: `array`):

Cities or areas to search, one per line (e.g. 'Helsinki', 'Berlin', 'Stockholm'). Each entry is searched separately. Leave empty when you are pasting URLs above or using exact coordinates.

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

Which Wolt market to search in. Choose 'Auto-detect' to let the city name decide.

## `latitude` (type: `string`):

Optional. Exact latitude to search around (e.g. '60.1699'). Use together with Longitude for a precise location instead of a city name.

## `longitude` (type: `string`):

Optional. Exact longitude to search around (e.g. '24.9384'). Use together with Latitude for a precise location instead of a city name.

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

Visit each venue to collect its full menu and return every item as its own result row (category, name, description, price, image). A restaurant typically has 40-120 items; a grocery venue can have 500-3000+, and each item collected is returned and billed as a separate result. Turn off to keep only the venue summary rows (name, rating, delivery info, cuisines, coordinates).

## `maxMenuItemsPerVenue` (type: `integer`):

Cap on the number of menu items collected per venue. Set to 0 to collect every item (up to a built-in safety cap of 5,000 items per venue). Useful to keep costs predictable on large grocery venues that can list thousands of products. Ignored when 'Include Menu Items' is off.

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

Maximum number of venues to collect across all URLs and searches. Set to 0 for as many as possible (up to a built-in safety cap of 5,000 venues). Menu items are additional to this count. The box starts at 10 so a first test run finishes quickly — raise it to collect hundreds or thousands.

## Actor input object example

```json
{
  "startUrls": [
    "https://wolt.com/en/fin/helsinki/restaurants"
  ],
  "search": [
    "Helsinki"
  ],
  "country": "auto",
  "includeMenu": true,
  "maxMenuItemsPerVenue": 200,
  "maxResults": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Every record from the run in one place — venues and menu items — distinguished by `recordType`.

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

Venues only, with name, cuisines/tags, rating, review count, price range, delivery ETA and fees, address, and coordinates.

## `menuItems` (type: `string`):

Menu items only, each linked to its venue, with category, name, description, price, and image. Present only when 'Include Menu Items' is enabled.

# 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 = {
    "startUrls": [
        "https://wolt.com/en/fin/helsinki/restaurants"
    ],
    "search": [
        "Helsinki"
    ],
    "country": "auto",
    "includeMenu": true,
    "maxMenuItemsPerVenue": 200,
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "startUrls": ["https://wolt.com/en/fin/helsinki/restaurants"],
    "search": ["Helsinki"],
    "country": "auto",
    "includeMenu": True,
    "maxMenuItemsPerVenue": 200,
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "startUrls": [
    "https://wolt.com/en/fin/helsinki/restaurants"
  ],
  "search": [
    "Helsinki"
  ],
  "country": "auto",
  "includeMenu": true,
  "maxMenuItemsPerVenue": 200,
  "maxResults": 10
}' |
apify call solidcode/wolt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wolt Scraper",
        "description": "[💰 $1.0 / 1K] Extract restaurants and grocery venues from Wolt. Get name, cuisines, rating, review count, price range, delivery ETA and fees, address and coordinates. Turn on menus to also collect every item with its price. Search by city, coordinates, or paste Wolt URLs.",
        "version": "1.0",
        "x-build-id": "NJFCWaXFkYNkFdiiR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~wolt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-wolt-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/solidcode~wolt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-wolt-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/solidcode~wolt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-wolt-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": {
                    "startUrls": {
                        "title": "Wolt URLs",
                        "type": "array",
                        "description": "Paste one or more Wolt URLs. Accepts city or discovery pages (e.g. https://wolt.com/en/fin/helsinki/restaurants) or individual venue pages (e.g. https://wolt.com/en/fin/helsinki/restaurant/example). Filters in the URL are used as-is, so the Search Filters below are ignored for these URLs. Use this when you already built a search on the site.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "search": {
                        "title": "Cities or Areas",
                        "type": "array",
                        "description": "Cities or areas to search, one per line (e.g. 'Helsinki', 'Berlin', 'Stockholm'). Each entry is searched separately. Leave empty when you are pasting URLs above or using exact coordinates.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country / Market",
                        "enum": [
                            "auto",
                            "alb",
                            "aut",
                            "aze",
                            "bgr",
                            "hrv",
                            "cyp",
                            "cze",
                            "dnk",
                            "est",
                            "fin",
                            "geo",
                            "deu",
                            "grc",
                            "hun",
                            "isl",
                            "isr",
                            "kaz",
                            "xkx",
                            "lva",
                            "ltu",
                            "lux",
                            "mlt",
                            "mkd",
                            "nor",
                            "pol",
                            "rou",
                            "srb",
                            "svk",
                            "svn",
                            "swe"
                        ],
                        "type": "string",
                        "description": "Which Wolt market to search in. Choose 'Auto-detect' to let the city name decide.",
                        "default": "auto"
                    },
                    "latitude": {
                        "title": "Latitude",
                        "type": "string",
                        "description": "Optional. Exact latitude to search around (e.g. '60.1699'). Use together with Longitude for a precise location instead of a city name."
                    },
                    "longitude": {
                        "title": "Longitude",
                        "type": "string",
                        "description": "Optional. Exact longitude to search around (e.g. '24.9384'). Use together with Latitude for a precise location instead of a city name."
                    },
                    "includeMenu": {
                        "title": "Include Menu Items",
                        "type": "boolean",
                        "description": "Visit each venue to collect its full menu and return every item as its own result row (category, name, description, price, image). A restaurant typically has 40-120 items; a grocery venue can have 500-3000+, and each item collected is returned and billed as a separate result. Turn off to keep only the venue summary rows (name, rating, delivery info, cuisines, coordinates).",
                        "default": true
                    },
                    "maxMenuItemsPerVenue": {
                        "title": "Max Menu Items Per Venue",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on the number of menu items collected per venue. Set to 0 to collect every item (up to a built-in safety cap of 5,000 items per venue). Useful to keep costs predictable on large grocery venues that can list thousands of products. Ignored when 'Include Menu Items' is off.",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max Venues",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of venues to collect across all URLs and searches. Set to 0 for as many as possible (up to a built-in safety cap of 5,000 venues). Menu items are additional to this count. The box starts at 10 so a first test run finishes quickly — raise it to collect hundreds or thousands.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```