# Lieferando & Takeaway Scraper — Restaurants, Ratings, Menus (`studio-amba/takeaway-scraper`) Actor

Scrape restaurants from Lieferando.de, Thuisbezorgd.nl, Pyszne.pl and Takeaway.com (Belgium): names, cuisines, ratings, review counts, delivery fees and times, minimum order values, plus full menus with item prices. Search by city or postcode. No login, no cookies.

- **URL**: https://apify.com/studio-amba/takeaway-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 88.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 result 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Lieferando & Takeaway Scraper — Restaurants, Ratings, Menus

Scrape restaurant data from five continental Just Eat Takeaway brands with one actor: **Lieferando.de** (Germany), **Lieferando.at** (Austria), **Thuisbezorgd.nl** (Netherlands), **Pyszne.pl** (Poland) and **Takeaway.com** (Belgium). Get every restaurant delivering to a city or postcode — names, cuisines, ratings, review counts, delivery fees, delivery times and minimum order values — and optionally the full menu of every restaurant with item prices.

No login, no cookies, no session tokens. Pick a country, type a city, run.

### Why use this actor?

Food delivery market data is sold by at least five commercial data services, usually as expensive subscriptions. This actor gives you the same raw data on demand: competitive pricing analysis for restaurants, delivery-fee benchmarking, market-entry research, menu price monitoring, or lead lists of restaurants per city and cuisine. One run on a big city returns 900–1,600 restaurants in under a minute.

### What it covers

| Brand | Country | Input value | Currency |
|-------|---------|-------------|----------|
| Lieferando.de | Germany | `de` | EUR |
| Lieferando.at | Austria | `at` | EUR |
| Thuisbezorgd.nl | Netherlands | `nl` | EUR |
| Pyszne.pl | Poland | `pl` | PLN |
| Takeaway.com | Belgium | `be` | EUR |

All five brands run on the same Just Eat Takeaway platform, so the data model is identical across countries. The same run works the same way in Berlin, Vienna, Amsterdam, Warsaw or Brussels.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `country` | String | No | `de` (Lieferando.de), `nl` (Thuisbezorgd), `pl` (Pyszne), `be` (Takeaway.com) or `at` (Lieferando.at). Default: `de` |
| `location` | String | No | City name (`Berlin`, `München`, `Warszawa`), postcode (`10115`) or literal coordinates (`52.52,13.40`). Default: `Berlin` |
| `serviceType` | String | No | `delivery` (default) or `collection` |
| `maxResults` | Integer | No | Maximum restaurants to return (default: 100) |
| `scrapeMenus` | Boolean | No | Also fetch each restaurant's full menu — one row per menu item (default: `false`) |
| `proxyConfiguration` | Object | No | Proxy settings; the automatic default works fine |

City names are resolved offline against a bundled table of the 50 biggest cities per country (native names and exonyms both work: München/Munich, Den Haag/The Hague, Warszawa/Warsaw, Brussel/Bruxelles/Brussels). Postcodes and smaller towns fall back to OpenStreetMap geocoding automatically.

### Output

One row per restaurant. With `scrapeMenus` enabled, one row per menu item with the restaurant fields repeated on every row — flat rows that load straight into a spreadsheet or database.

| Field | Type | Example |
|-------|------|---------|
| `restaurantId` | String | `"10015773"` |
| `name` | String | `"Burger Vision Schönhauser Allee"` |
| `brand` | String | `"lieferando"` |
| `cuisines` | Array | `["Burgers", "100% Halal"]` |
| `rating` | Number | `4.3` (0–5 scale) |
| `ratingCount` | Integer | `2822` |
| `deliveryFee` | Number | `1.49` |
| `deliveryTimeMinutes` | Integer | `45` |
| `minimumOrderValue` | Number | `10` |
| `currency` | String | `"EUR"` |
| `address` | String | `"Schönhauser Allee 186a"` |
| `city` | String | `"Berlin"` |
| `postcode` | String | `"10119"` |
| `latitude` / `longitude` | Number | `52.529` / `13.409` |
| `isOpen` | Boolean | `true` |
| `url` | String | Public menu page on the brand site |
| `logoUrl` | String | Restaurant logo image |
| `country` | String | `"de"` |
| `scrapedAt` | String | ISO timestamp |

Menu rows add: `menuCategory`, `itemId`, `itemName`, `itemDescription`, `itemPrice`, `itemVariations` (size/option prices when an item has several) and `itemImageUrl`.

### Example output

```json
{
    "restaurantId": "10015773",
    "name": "Burger Vision Schönhauser Allee",
    "brand": "lieferando",
    "cuisines": ["Burgers", "100% Halal"],
    "rating": 4.3,
    "ratingCount": 2822,
    "deliveryFee": 1.49,
    "deliveryTimeMinutes": 45,
    "minimumOrderValue": 0,
    "currency": "EUR",
    "address": "Schönhauser Allee 186a",
    "city": "Berlin",
    "postcode": "10119",
    "latitude": 52.52937,
    "longitude": 13.409462,
    "isOpen": true,
    "url": "https://www.lieferando.de/speisekarte/vb-schnhauser-allee",
    "country": "de",
    "serviceType": "delivery",
    "scrapedAt": "2026-07-11T19:30:48.335Z",
    "menuCategory": "Smash Burger Menü",
    "itemName": "Smash Beyond Cheese Menü",
    "itemDescription": "Beyond Veggie Patty - Vision Potato Buns, mit Käse...",
    "itemPrice": 15.5
}
```

### How to scrape Lieferando data

Lieferando.de is Germany's largest food delivery platform. To scrape it:

1. Set `country` to `de`.
2. Set `location` to any German city (`Berlin`, `Hamburg`, `München`, `Köln`, `Frankfurt`) or a postcode like `10115`.
3. Run. A single Berlin run returns 1,600+ restaurants with ratings, delivery fees and minimum order values.
4. Enable `scrapeMenus` to also get every dish and its price — a typical restaurant has 50–200 menu items.

The same steps work for the other three brands — only the `country` value changes.

### How to scrape Thuisbezorgd.nl data

Set `country` to `nl` and `location` to a Dutch city (`Amsterdam`, `Rotterdam`, `Den Haag`, `Utrecht`) or postcode. Amsterdam returns roughly 950 restaurants. Prices are in EUR.

### How to scrape Pyszne.pl data

Set `country` to `pl` and `location` to a Polish city (`Warszawa`, `Kraków`, `Wrocław`, `Gdańsk`). Warsaw returns roughly 900 restaurants. Prices are in PLN.

### How to scrape Takeaway.com Belgium data

Set `country` to `be` and `location` to a Belgian city (`Brussel`, `Antwerpen`, `Gent`, `Liège` — Dutch and French spellings both work). Brussels returns roughly 900 restaurants. Prices are in EUR.

### How to scrape Lieferando.at (Austria) data

Set `country` to `at` and `location` to an Austrian city (`Wien`/`Vienna`, `Graz`, `Linz`, `Salzburg`, `Innsbruck`) or postcode. Vienna returns 1,300+ restaurants with full menu support (item prices, categories, size variations) — same data depth as Lieferando.de. Prices are in EUR.

### Menu scraping

With `scrapeMenus: true` every restaurant produces one row per menu item: dish name, description, menu category, price and size variations. `maxResults` still caps the number of restaurants, so 20 restaurants with menus typically yields 1,000–3,000 rows. Long menu runs are resumable — if the platform migrates the run to another server, it continues where it left off instead of starting over.

### Use cases

- **Restaurant market analysis** — cuisine mix, ratings distribution and delivery pricing per city
- **Menu price monitoring** — track dish prices across competitors over time
- **Delivery fee benchmarking** — compare fees and minimum order values across neighbourhoods
- **Lead generation** — restaurant lists with addresses and cuisines, filtered by city
- **Market entry research** — measure platform coverage in any German, Dutch, Polish or Belgian city

### Tips

- One run covers one delivery point. For full-city coverage of a large metro, run a few postcodes spread across the city and deduplicate on `restaurantId`.
- `serviceType: "collection"` returns the pickup-oriented view with collection open states.
- Coordinates input (`"52.52,13.40"`) skips geocoding entirely — useful for automated pipelines.
- Empty input works: it defaults to Lieferando.de around Berlin with 100 results.

### Related scrapers

- [Just Eat Scraper](https://apify.com/studio-amba/just-eat-scraper) — restaurants from Just Eat in Ireland, Italy and Spain
- [Wolt Scraper](https://apify.com/studio-amba/wolt-scraper) — restaurants and menus from Wolt across Northern and Eastern Europe
- [Albert Heijn Scraper](https://apify.com/studio-amba/albert-heijn-scraper) — the largest Dutch supermarket
- [Tesco Scraper](https://apify.com/studio-amba/tesco-scraper) — full UK grocery catalogue with prices
- [ASDA Scraper](https://apify.com/studio-amba/asda-scraper) — UK grocery products and prices
- [Waitrose Scraper](https://apify.com/studio-amba/waitrose-scraper) — UK grocery with barcodes
- [Picnic Scraper](https://apify.com/studio-amba/picnic-scraper) — Dutch online supermarket

Browse all our European scrapers on the [Studio AMBA profile](https://apify.com/actors/studio-amba).

### Legal

This actor scrapes publicly available data only. It does not log in, does not access personal data, and respects the platforms' public interfaces. You are responsible for how you use the data — check the applicable terms and laws for your use case.

# Actor input Schema

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

Which brand to scrape: de = Lieferando.de (Germany), nl = Thuisbezorgd.nl (Netherlands), pl = Pyszne.pl (Poland), be = Takeaway.com (Belgium), at = Lieferando.at (Austria).

## `location` (type: `string`):

Where to search. A city name ('Berlin', 'München', 'Warszawa'), a postcode ('10115'), or literal coordinates ('52.52,13.40'). One search returns every restaurant delivering to that point — 900+ in big cities.

## `serviceType` (type: `string`):

Delivery (default) or collection/pickup. Affects which restaurants are returned and their open state.

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

Maximum number of restaurants to return. With 'Scrape menus' enabled this is still the restaurant cap — each restaurant then produces one row per menu item.

## `scrapeMenus` (type: `boolean`):

Also fetch each restaurant's full menu. Output becomes one row per menu item (dish name, description, category, price) with the restaurant fields repeated on every row. Adds two extra requests per restaurant, so runs take longer.

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

Proxy settings. The restaurant and menu APIs are open, so the default automatic proxy is plenty.

## Actor input object example

```json
{
  "country": "de",
  "location": "Berlin",
  "serviceType": "delivery",
  "maxResults": 20,
  "scrapeMenus": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "location": "Berlin",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/takeaway-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 = {
    "location": "Berlin",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/takeaway-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "location": "Berlin",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/takeaway-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/takeaway-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/9JrlT23NdcCoy03ez/builds/YFr1I0KVQcLso2SKp/openapi.json