# 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:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/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 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, discountValidFrom, lowestPriceCents, dietaryPreferences, vatPercentage, ...}` |
| primaryLanguage / availableLanguages | `de / [{language, name, autotranslated}]` |
| scrapedAt | `2026-01-01T00:00:00.000Z` |

### 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. |
| proxyConfiguration | object | Apify default | Apify proxy settings. Datacenter is fine; residential is recommended for high volume. |

### 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,
      "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. The Apify Free plan works on small runs. For high volume or repeated runs, switch the proxy to Apify Residential (Starter or higher). The actor uses the standard Apify proxy by default; override 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.

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

Apify default datacenter works fine. Residential is recommended only for high-volume or repeated runs.

## 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,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "cities": [
        "Helsinki"
    ],
    "urls": [
        "https://wolt.com/en/aut/graz/restaurant/kfc-graz"
    ],
    "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 = {
    "cities": ["Helsinki"],
    "urls": ["https://wolt.com/en/aut/graz/restaurant/kfc-graz"],
    "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("💾 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 '{
  "cities": [
    "Helsinki"
  ],
  "urls": [
    "https://wolt.com/en/aut/graz/restaurant/kfc-graz"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/wolt-restaurants-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wolt.com $0.8💰 URL | City Search | Restaurants and Menus",
        "description": "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.",
        "version": "1.0",
        "x-build-id": "zF1jFQS9JNosZPUpu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~wolt-restaurants-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-wolt-restaurants-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/abotapi~wolt-restaurants-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-wolt-restaurants-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/abotapi~wolt-restaurants-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-wolt-restaurants-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "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).",
                        "default": "search"
                    },
                    "cities": {
                        "title": "Cities",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "Wolt URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "primaryCategories": {
                        "title": "Cuisine filter",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter city listings by primary cuisine tag. Examples: pizza, burgers, sushi, vegan, kebab, asian, italian, breakfast, dessert, bbq, indian. Leave empty to include all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minRating": {
                        "title": "Min rating score",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum Wolt rating score (0-10 scale). Records below this are skipped. Leave empty for no minimum."
                    },
                    "minRatingVolume": {
                        "title": "Min review count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of ratings a venue must have to be included. Leave empty or 0 for no minimum.",
                        "default": 0
                    },
                    "sortBy": {
                        "title": "Sort venues by",
                        "enum": [
                            "default",
                            "rating",
                            "delivery-price",
                            "delivery-estimate",
                            "distance",
                            "preparation-estimate"
                        ],
                        "type": "string",
                        "description": "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.",
                        "default": "default"
                    },
                    "fetchMenu": {
                        "title": "Fetch full menu",
                        "type": "boolean",
                        "description": "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.",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include rating fields",
                        "type": "boolean",
                        "description": "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.",
                        "default": true
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "ISO language code passed to Wolt for menu and venue text (en, de, fi, sv, fr, es, etc.). Defaults to en.",
                        "default": "en"
                    },
                    "maxVenues": {
                        "title": "Max venues",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total venues across the whole run. 0 means unlimited.",
                        "default": 50
                    },
                    "maxVenuesPerCity": {
                        "title": "Max venues per city",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-city cap. Wolt city pages return 100-200 venues; lower this for fast smoke runs. 0 means unlimited per city.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify default datacenter works fine. Residential is recommended only for high-volume or repeated runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
