# Just Eat & Lieferando Scraper – Restaurants, Menus, Prices,Fees (`lukass/just-eat-takeaway-scraper`) Actor

Restaurants, menus, prices and delivery fees from Just Eat, Lieferando, Thuisbezorgd, Takeaway.com, Pyszne.pl and Bistro.sk in 12 countries. Any address or whole city, full menus, supermarket catalogues with barcodes, monitoring mode, and a live API.

- **URL**: https://apify.com/lukass/just-eat-takeaway-scraper.md
- **Developed by:** [Lukáš Širhal](https://apify.com/lukass) (community)
- **Features:** Limited permissions, Multi-tenant, Server interface
- **Stats:** 2 total users, 2 monthly users, 98.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

### What does Just Eat Takeaway Scraper do?

Just Eat Takeaway Scraper turns Europe's biggest food delivery group into structured data: the restaurants, supermarkets
and convenience stores that deliver to an address or across a whole city, with their full menus and prices. One actor
covers all 12 countries and brands of the group. No account or login needed.

| Country | Platform | Currency |
|---|---|---|
| 🇬🇧 United Kingdom | [Just Eat](https://www.just-eat.co.uk/) | GBP |
| 🇮🇪 Ireland | [Just Eat](https://www.just-eat.ie/) | EUR |
| 🇩🇪 Germany | [Lieferando](https://www.lieferando.de/) | EUR |
| 🇦🇹 Austria | [Lieferando](https://www.lieferando.at/) | EUR |
| 🇳🇱 Netherlands | [Thuisbezorgd](https://www.thuisbezorgd.nl/) | EUR |
| 🇧🇪 Belgium | [Takeaway.com](https://www.takeaway.com/be/) | EUR |
| 🇱🇺 Luxembourg | [Takeaway.com](https://www.takeaway.com/lu/) | EUR |
| 🇨🇭 Switzerland | [Just Eat](https://www.just-eat.ch/) | CHF |
| 🇵🇱 Poland | [Pyszne.pl](https://www.pyszne.pl/) | PLN |
| 🇸🇰 Slovakia | [Bistro.sk](https://www.bistro.sk/) | EUR |
| 🇪🇸 Spain | [Just Eat](https://www.just-eat.es/) | EUR |
| 🇮🇹 Italy | [Just Eat](https://www.justeat.it/) | EUR |

- 📍 **Any address, postcode or coordinates**: every restaurant that delivers there, open or closed - exactly the list
  the app shows, in one go.
- 🏙️ **Whole cities**: the city is covered with a grid of delivery points and every restaurant is returned once.
- 🔗 **Paste restaurant URLs** from any of the 12 sites, mixed.
- 🔎 **Search like in the app**: a brand ("McDonald's"), a dish ("pad thai") or a cuisine. Find **every branch of a
  chain** in a city with one search.
- 🍕 **Full menus**: every dish with description, price, sizes, current discount and discounted price, category,
  calories, photo and sold-out status, plus option groups (sauces, sides, extras) and meal deals.
- 🛒 **Whole supermarket catalogues**: every product of a Co-op, Sainsbury's, Budgens, Spar or REWE store - price,
  member price, offer, **barcode (GTIN)**, pack size, unit price and stock - often 2,000-5,000 products per store.
- 🚚 **Delivery data**: delivery fee, fee bands, minimum order, free-delivery threshold, service and bag fees, delivery
  time, distance, opening hours and next opening.
- ⭐ **Ratings**: average stars, number of ratings and the 5-to-1 star breakdown.
- 🏢 **Business details**: full address and coordinates, phone, email and - where the country publishes it - the
  legal name, registered address, VAT number and company registration number from the restaurant's imprint.
- 🔔 **Monitoring mode**: schedule a run and get only restaurants that are new since the last one.

#### Who uses it

- **Restaurant chains and franchises**: prices, fees and ratings of every branch, and of the competitors around it.
- **Market and location research**: which cuisines are covered or missing in an area, how many places deliver there,
  where a brand is present - compared across 12 countries with the same fields.
- **Price monitoring**: menu and supermarket prices, promotions and fees over time; barcodes make products comparable
  between stores and platforms.
- **Sales and lead generation**: new restaurants in a city as they appear, with address, phone and company details.
- **Food delivery analytics**: compare coverage, fees and delivery times between neighbourhoods, cities and countries.

### How to scrape Just Eat, Lieferando or Thuisbezorgd

1. Click **Try for free**.
2. Pick the country, then enter an address or postcode, or a city.
3. Optionally type a search term, such as a brand, or pick cuisines.
4. Click **Run**.
5. When it finishes, preview or download your data from the **Dataset** tab.

### Input

| Field | What it does |
|---|---|
| **Country** | The market to scrape. Addresses and cities are looked up there. |
| **Delivery addresses** | Addresses, postcodes or `lat,lon` coordinates. Each returns what delivers there. |
| **Whole cities** | City names, covered with a grid of delivery points (**City grid spacing**, default 3 km). |
| **Restaurant URLs** | Restaurant pages from any of the 12 sites. |
| **Search** | Terms as typed into the app. Each runs at every address and city point. |
| **Only restaurants named like the search** | Keeps only one brand's branches. |
| **Category** | Everything, restaurants only, groceries, or gifts (UK). |
| **Cuisines** | "pizza", "sushi", "indian"... matched loosely against the app's cuisine tags. |
| **Order**, **Only open now**, **Minimum rating**, **Only free delivery** | List order and filters. |
| **Output** | One record per restaurant (menu nested) or one record per menu item. |
| **Fetch restaurant details and menu** | Off for a cheaper list of names, ratings, fees and delivery times. |
| **Include item options** | Option groups with prices. |
| **Full grocery catalogue** | Every product of supermarkets and convenience stores. |
| **Menu language** | As written, or English where the restaurant offers a translation. |
| **Max restaurants** | Stop after this many restaurants, split evenly between addresses, cities and searches. |
| **Monitoring mode** | Only restaurants earlier runs of the same search did not list. |

Example - every McDonald's delivering anywhere in London:

```json
{
    "country": "uk",
    "cities": ["London"],
    "searchQueries": ["McDonald's"],
    "onlyNameMatches": true,
    "includeMenuItems": false
}
```

### Output

One record per restaurant (shortened):

```json
{
    "restaurantId": "9646686",
    "name": "Chicken Gang",
    "url": "https://www.lieferando.de/speisekarte/chicken-gang-grossziethen",
    "platform": "Lieferando",
    "storeType": "Restaurant",
    "cuisines": ["Chicken", "Burgers", "100% Halal", "Offers"],
    "rating": 4.4,
    "ratingCount": 1933,
    "address": "Attilastraße 18",
    "postcode": "12529",
    "city": "Schönefeld",
    "latitude": 52.40705,
    "longitude": 13.439599,
    "currency": "EUR",
    "isOpenNow": true,
    "deliveryTimeMin": 30,
    "deliveryTimeMax": 45,
    "distanceKm": 6.28,
    "deliveryFee": 1,
    "minimumOrder": 14.9,
    "openingTimes": { "delivery": { "Monday": "10:45-23:45", "Tuesday": "10:45-23:45" } },
    "offers": ["50% off selected items", "15% off selected items"],
    "legalName": "Chicken Gang",
    "legalAddress": "Attilastraße 18, 12529 Schönefeld",
    "menuItemCount": 63,
    "menuItems": [
        {
            "itemId": "b3118f98-0544-43cc-a38a-e4396f4f5570",
            "name": "Japanese Coleslaw",
            "description": "Japanese coleslaw with carrots, spring onions, sesame, and Japanese mayo",
            "category": "Sides",
            "categories": ["Lieferando 15% Deals", "Sides"],
            "price": 4.9,
            "discountedPrice": 4.17,
            "discountPercent": 15,
            "offer": "15% off selected items",
            "isAvailable": true
        }
    ],
    "searchLocation": "Schönefeld",
    "scrapedAt": "2026-11-11T22:00:00.000Z"
}
```

A supermarket product (one record per item, with **Full grocery catalogue**):

```json
{
    "kind": "menuItem",
    "restaurantName": "Co-op - Tilgate Parade",
    "storeType": "Grocery",
    "category": "Fresh Fruit, Vegetables and Salads > Vegetables and Potatoes",
    "name": "Co-op Grown in Britain Carrots 500g",
    "price": 0.65,
    "loyaltyPrice": 0.44,
    "gtin": "5000128222860",
    "netWeight": "500 g",
    "unitPrice": { "price": 1.3, "per": "kg" },
    "isAvailable": true,
    "currency": "GBP"
}
```

Fields the platform does not publish for a restaurant are left out of its record rather than set to null. Prices are
in the record's `currency`, in units (4.9 = €4.90).

### How much does it cost?

You pay per result, proxy included:

| Event | Price |
|---|---|
| Run start | $0.005 |
| Restaurant record (or menu-item record) | $0.001 |
| Restaurant details and menu | $0.004 per restaurant |
| Full supermarket catalogue | $0.02 per store |

Examples: 100 restaurants with full menus ≈ $0.51; a list of 1,000 restaurants without menus ≈ $1.01; every product of
5 supermarkets as one row each (~20,000 rows) ≈ $20 - use one record per store to pay for 5 records instead.

### Tips

- **Find every branch of a chain**: put the city in **Whole cities**, the brand in **Search** and turn on **Only
  restaurants named like the search**.
- **A cheap overview**: turn off **Fetch restaurant details and menu** - one request per delivery point returns the
  whole list with ratings, fees, delivery times and offers.
- **Closed restaurants are included** with their next opening time; turn on **Only open now** to skip them.
- **Big cities**: one delivery point already returns everything that delivers to it - often 1,000+ restaurants in a
  city centre. A grid is only needed to cover a whole city.
- **Menus in English**: many restaurants in Germany, the Netherlands, Belgium, Switzerland, Poland, Spain and Italy
  offer an English menu; pick it in **Menu language**.

### Live API: answers in seconds

Need an answer for one address right now, from your app, a spreadsheet or an AI agent, instead of a dataset? The Actor
also runs as a live HTTP API (Apify server mode), for all 12 countries. Copy its URL from the Actor's **Server** tab
and call it with your Apify token:

```bash
## Restaurants delivering to an address in Berlin, open now, rated 4.5+, cheapest delivery first
curl -H "Authorization: Bearer $APIFY_TOKEN" \
  "<server URL>/restaurants?location=Alexanderplatz%201,%20Berlin&country=de&openNow=true&minRating=4.5&sort=deliveryFee&limit=10"

## One restaurant with its fees, opening times and full menu
curl -H "Authorization: Bearer $APIFY_TOKEN" \
  "<server URL>/menu?url=https://www.just-eat.co.uk/restaurants-horley-kebab-center-new-surrey/menu"
```

| Endpoint | What it returns | Main parameters |
|---|---|---|
| `GET /restaurants` | Restaurants and shops that deliver to a location, same fields as a run's records | `location` (address, postcode or `lat,lon`), `country`, `query`, `vertical`, `cuisine`, `name`, `minRating`, `maxDeliveryMinutes`, `maxDistanceKm`, `maxDeliveryFee`, `openNow`, `includeSponsored`, `sort` (`bestMatch`, `rating`, `distance`, `deliveryTime`, `deliveryFee`, `minimumOrder`), `limit` (up to 100), `offset` |
| `GET /menu` | One restaurant with details, fees and its menu | `url` from any of the 12 sites, or `seoName` (from `/restaurants`) with `country`; `location`, `includeItems`, `includeModifiers`, `includeCatalog`, `language` |

`GET /` lists every parameter. Parameters can also be sent as a JSON body. A list stays cached for 2 minutes, so paging
through it with `offset` is quick and billed only per restaurant. Each answered call is billed per request plus per
restaurant or menu returned, and per supermarket catalogue with `includeCatalog` (see the Pricing tab); errors are not
billed. Whole cities and monitoring are available in normal runs only.

### FAQ

**Does it need a Just Eat account?** No. It sees what any visitor of the app sees.

**Are customer reviews included?** The star breakdown is. The app no longer shows written reviews.

**Why is a restaurant's delivery fee different on the website?** Fees and delivery times depend on the delivery
address. The record is for the address you gave (`searchPoint`); for pasted URLs without an address, for the
restaurant's own area.

**Is it legal?** The actor collects publicly available business information. Personal data is not collected. Make sure
your use complies with the platforms' terms and the laws that apply to you, such as the GDPR.

# Changelog

This Actor's version history is a separate document: https://apify.com/lukass/just-eat-takeaway-scraper/changelog.md

# Actor input Schema

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

Market to scrape. Addresses and cities are looked up in this country, and prices come in its currency.

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

Addresses, postcodes or coordinates ("51.5072,-0.1276") to deliver to, one per line. Each returns every restaurant that delivers there.

## `cities` (type: `array`):

City names. The city is covered with a grid of delivery points and every restaurant that delivers anywhere in it is returned once.

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

Restaurant pages to scrape directly, from any supported country, e.g. https://www.just-eat.co.uk/restaurants-name/menu or https://www.lieferando.de/speisekarte/name. Details and menu are always fetched.

## `gridSpacingKm` (type: `integer`):

Distance between delivery points when scraping a whole city. Smaller finds more restaurants at the edges of delivery zones, at the cost of more requests.

## `maxPointsPerCity` (type: `integer`):

Caps the grid for very large cities. The points kept are spread evenly over the city.

## `searchQueries` (type: `array`):

Search terms, as typed into the app: a brand ("McDonald's"), a dish ("pad thai") or a cuisine. Each runs at every address and city point. Leave empty to list everything that delivers.

## `onlyNameMatches` (type: `boolean`):

Keep only results whose name contains the search term - to find one brand's branches, since search also returns restaurants that merely serve the dish.

## `nameFilter` (type: `array`):

Keep only restaurants whose name contains one of these (case and punctuation ignored). Applies to every source.

## `vertical` (type: `string`):

Which tab of the app to list.

## `cuisines` (type: `array`):

Only restaurants with one of these cuisines, matched loosely against the app's cuisine tags: "pizza" also matches "Italian style pizza", "sushi", "indian", "burger". Use the local word where the app does ("hamburguesas" in Spain, "cinese" in Italy); the run log lists the cuisines of an area when nothing matches.

## `sortBy` (type: `string`):

Order of the restaurant list - and so which restaurants are kept when Max restaurants cuts it.

## `onlyOpen` (type: `boolean`):

Skip restaurants that are closed for delivery right now. Off by default: closed restaurants are listed too, with their next opening time.

## `minRating` (type: `string`):

Only restaurants rated at least this many stars (out of 5), e.g. 4.5.

## `freeDeliveryOnly` (type: `boolean`):

Only restaurants that deliver for free at their minimum order.

## `includeSponsored` (type: `boolean`):

Restaurants that pay for their place in the list. They are also listed normally, so turning this off removes them altogether.

## `outputMode` (type: `string`):

One record per restaurant (with its menu nested), or one record per menu item - easier for spreadsheets and price comparison.

## `fetchMenu` (type: `boolean`):

A few extra small requests per restaurant for its full address, legal details, opening hours, live delivery fee, service and bag fees, star breakdown and menu. Turn off for a cheaper list of names, ratings, fees and delivery times only.

## `includeMenuItems` (type: `boolean`):

Add every menu item (name, description, price, sizes, discounted price, category, calories, photo, sold out) to each restaurant record.

## `includeModifiers` (type: `boolean`):

Add each item's option groups (sauces, sides, extras) with their prices. Makes records much larger.

## `includeGroceryCatalog` (type: `boolean`):

For supermarkets and convenience stores (Co-op, Sainsbury's, Budgens, REWE, Spar...), return every product - often 2,000-5,000 - with price, member price, offer, barcode (GTIN), pack size, unit price and stock. Billed once per store on top of the menu.

## `menuLanguage` (type: `string`):

Restaurants write their menu in the local language; many also offer an English translation.

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

Stop after this many restaurants. Split evenly between sources (each address, city and search term); a source that runs out early hands its remainder to the others. Leave empty for no limit.

## `monitoringMode` (type: `boolean`):

Return only restaurants that earlier runs of this same search did not list - new openings and places that started delivering to the area. The first run is the baseline: it remembers every restaurant it listed, also those beyond Max restaurants. Changing the addresses, cities, search or filters starts a fresh list.

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

Apify Proxy uses residential IPs from the selected country by default. Proxy costs are included in the price.

## Actor input object example

```json
{
  "country": "uk",
  "locations": [
    "EC2A 4NE"
  ],
  "gridSpacingKm": 3,
  "maxPointsPerCity": 150,
  "onlyNameMatches": false,
  "vertical": "all",
  "sortBy": "bestMatch",
  "onlyOpen": false,
  "freeDeliveryOnly": false,
  "includeSponsored": true,
  "outputMode": "restaurants",
  "fetchMenu": true,
  "includeMenuItems": true,
  "includeModifiers": false,
  "includeGroceryCatalog": false,
  "menuLanguage": "local",
  "maxItems": 50,
  "monitoringMode": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Every record the run produced, in the default dataset.

## `resultsCsv` (type: `string`):

The same records as a CSV file.

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

The dataset's restaurant view, with the most useful columns only.

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

The menu-item view, for runs with one record per menu item.

# 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": [
        "EC2A 4NE"
    ],
    "maxItems": 50,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lukass/just-eat-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 = {
    "locations": ["EC2A 4NE"],
    "maxItems": 50,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lukass/just-eat-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 '{
  "locations": [
    "EC2A 4NE"
  ],
  "maxItems": 50,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call lukass/just-eat-takeaway-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lukass/just-eat-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/FaAmvqNuoH7W0OOjF/builds/Edayw3HkJPvre76hT/openapi.json
