# Wolt Restaurants & Venues by Delivery Location (`superslowsloth/wolt-restaurants`) Actor

Every restaurant Wolt lists around any latitude/longitude, one flat row each: name, cuisine tags, rating score and count, price tier, delivery-time estimate, open-now and delivers-here flags, address, coordinates, menu price previews, page URL. Deduplicated across locations.

- **URL**: https://apify.com/superslowsloth/wolt-restaurants.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 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.

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 Restaurants & Venues by Delivery Location

Give this actor a latitude and longitude and it returns every restaurant
[Wolt](https://wolt.com) lists for that delivery point, one flat row per venue:
name, cuisine tags, rating score and number of ratings, price tier, delivery-time
estimate, whether it is open and delivering right now, address, coordinates,
images, a sample of dish prices, and the Wolt page URL. Use it as a **restaurant
directory per city**, a **competitor and market map** for delivery operators, or a
**what is open now** feed. Add several points to cover a metro area; a venue that
more than one point returns is emitted once.

No account, no API key, no login, no browser. One request per location.

### Input

| Field | Notes |
|---|---|
| `locations` | One or more points as `latitude,longitude`, one per line, dot decimals: `60.1699,24.9384` (Helsinki), `52.52,13.405` (Berlin). Latitude first. Required. A point can also be written with a space or semicolon between the numbers. |
| `maxItems` | Rows to return for the **whole run** (default 100), after the filters and after duplicates are dropped. Each row is one billable event, so this is also your spending cap. |
| `onlineNowOnly` | Keep only venues Wolt shows as open and delivering to the point right now. Default off. |
| `tag` | Keep only venues with a cuisine or dish tag containing this text (`pizza`, `sushi`, `vegan`). Tags are matched in English. |
| `proxyConfiguration` | Apify datacenter proxy by default. |

Wolt sends a point's whole list in a single response (about 700 to 2,000 venues
for a large city, 1.5 to 4 MB), so a low `maxItems` makes a run cheaper, not
faster. Locations are read in the order given, and once `maxItems` is reached the
remaining ones are not fetched at all.

### Output

One row per venue. Null means Wolt did not give the value; it never means zero.

| Field | Meaning |
|---|---|
| `venue_id`, `name`, `slug`, `url` | Wolt's id, name, URL slug and page link. |
| `search_latitude`, `search_longitude`, `search_city` | The input point that first returned this venue, and Wolt's city slug for it. |
| `country`, `currency` | ISO alpha-3 country (`FIN`) and ISO 4217 currency of the venue's prices. |
| `address`, `latitude`, `longitude` | The venue's street address and position. |
| `price_range` | Wolt's price tier, 1 (cheapest) to 4. Null when Wolt sends 0, which means not set. |
| `rating_score`, `rating_count` | Wolt's score on a **0 to 10** scale and the number of ratings. **Null when the venue has fewer than 10 ratings**: Wolt publishes no score below that, and a missing score is not a score of 0. About one venue in eight has none. |
| `tags`, `badges`, `short_description` | Cuisine and dish tags, card badges (`New`, `ONLY ON WOLT`), the venue's one-line description. |
| `is_online`, `delivers_to_location`, `status_text` | Wolt's open flag, whether it delivers to the searched point right now, and the card label (`Closed`, `Temporarily offline`) when it is not open. |
| `delivery_estimate_minutes`, `delivery_estimate_min_minutes`, `delivery_estimate_max_minutes` | Wolt's delivery-time estimate in minutes and the range behind it (`10-15`). |
| `image_url`, `brand_image_url` | Venue photo and logo. |
| `menu_preview` | Up to ten sample dishes shown on the list card: `name`, `price_minor_units`, `original_price_minor_units`. **Prices are integers in the currency's minor unit** (`1950` with `EUR` is 19.50 euro); divide by 100 for euro, zloty, shekel or lari. Empty for most venues (Wolt sends it for about one in twenty-five), and a sample, not the menu. |
| `product_line` | Wolt's product line for the row (`restaurant`). |

### Pricing

Pay per event: **$0.0007 per venue** returned plus a **$0.002 actor-start**
fee. A full 1,000-venue city list is $0.70. A run that returns nothing, for a
point Wolt does not serve, costs only the start fee.

### Limits and notes

- **No delivery fee or minimum order.** Wolt's list does not carry them (checked
  across 10,785 venues in eight cities); they appear only on each venue's own
  page. The only prices here are `menu_preview`.
- **Coverage is Wolt's.** A point outside Wolt's delivery areas (mid-ocean, central
  Tokyo when checked) returns no rows and a log line naming the point.
- **Open and closed change by the hour.** In the early morning up to three quarters
  of a city is closed. Compare runs taken at the same local time of day.
- **Rate limits.** Wolt's CDN answers an address with an empty HTTP 429 after
  several large downloads in a minute. The actor retries from a fresh proxy
  address; the log counts the retries.
- Public listing data only; no personal data is collected.

# Actor input Schema

## `locations` (type: `array`):

Delivery points to list restaurants for, one per line, as latitude,longitude with a dot for decimals - for example 60.1699,24.9384 for central Helsinki or 52.52,13.405 for Berlin. Latitude comes first; a longitude outside -180..180 or latitude outside -90..90 is refused before anything is charged. Wolt returns every restaurant it lists around a point in one response (700 to 2,000 for a big city), so one point covers a city centre and a second point is only worth adding across town. A point Wolt does not serve (mid-ocean, many cities in countries it has not launched in) is reported in the log and costs nothing but the actor start fee.

## `maxItems` (type: `integer`):

Most rows to return for the whole run, after the filters and after duplicates are dropped. Each row is one billable event, so this is also a spending cap. Wolt sends a point's whole list in one 1.5-4 MB response, so a low cap does not make the run faster, only cheaper. Locations are read in the order given and later ones are skipped once the cap is reached.

## `onlineNowOnly` (type: `boolean`):

Off by default. When on, keep only venues Wolt shows as open and delivering to the searched point at the moment of the run. Closed venues can be three quarters of a city's list in the early morning, so leave this off for a full venue directory and on for a what-can-I-order-now feed.

## `tag` (type: `string`):

Optional. Keep only venues with a cuisine or dish tag containing this text, case-insensitive: pizza, burger, sushi, vegan, breakfast. Matches Wolt's own tags (shown in English), not the venue name.

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

Apify datacenter proxy by default, which Wolt's list API answered from the platform on 2026-10-11. Wolt sits behind CloudFront, which rate-limits an address with an empty HTTP 429 after several 2-4 MB downloads in a minute; a refused or timed-out request is retried from a fresh exit address.

## Actor input object example

```json
{
  "locations": [
    "60.1699,24.9384"
  ],
  "maxItems": 100,
  "onlineNowOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (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 = {
    "locations": [
        "60.1699,24.9384"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/wolt-restaurants").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 = {
    "locations": ["60.1699,24.9384"],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/wolt-restaurants").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 '{
  "locations": [
    "60.1699,24.9384"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call superslowsloth/wolt-restaurants --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,superslowsloth/wolt-restaurants"
        }
    }
}
```

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/he8EclRemxHWUfXlF/builds/lCcwKR1LRgbWw7dwV/openapi.json