# Just Eat Scraper \[Only $1💰] | Restaurants | Menus | Prices (`ahmed_jasarevic/just-scraper`) Actor

Scrape Just Eat, Lieferando, Thuisbezorgd and Pyszne.pl restaurants and full menus for market research and lead generation: ratings, cuisines, delivery fees, ETAs, addresses and priced menu items.

- **URL**: https://apify.com/ahmed_jasarevic/just-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Just Eat Scraper

Scrape Just Eat Takeaway restaurant listings and full menus across the group's four consumer brands, Just Eat (UK), Lieferando (Germany), Thuisbezorgd (Netherlands) and Pyszne.pl (Poland), for food-delivery market research, restaurant lead generation and menu price monitoring: restaurant name, address, cuisines, rating, delivery cost, minimum order, delivery ETA and every priced menu item.

The actor uses a plain HTTP crawler (no browser, no Cloudflare), reads Just Eat's own discovery JSON API and pulls menus from the public menu CDN, so it can walk hundreds of restaurants per area quickly and cheaply.

### Main Use Cases

- Food-delivery market research across the UK, Germany, the Netherlands and Poland
- Restaurant lead generation and POS, payments or supplier prospecting
- Menu and price monitoring for delivery and takeaway pricing
- Building structured restaurant databases with address, cuisines and delivery data
- Competitor analysis of delivery fees, minimum orders, ETAs and ratings
- Brand and product distribution checks on Lieferando, Thuisbezorgd and Pyszne.pl

### How It Works

Every Just Eat area page is backed by a small JSON discovery API, and every restaurant menu is a JSON file on a public CDN. The actor drives those two surfaces directly with an HTTP crawler:

| Data | Source |
| --- | --- |
| Restaurant listing per area (postcode, place, coordinates or URL) | Just Eat discovery JSON API for the brand domain in the area. |
| Restaurant details (address, cuisines, rating, delivery cost, ETA) | The same discovery payload. |
| Full menu (categories, items, prices, variations, modifier groups, dietary labels) | The public menu CDN referenced by each restaurant. |

The area is read from a bare postcode, a place name (geocoded), a `lat,lng` pair or a pasted Just Eat URL, and the brand is taken from the domain (for example `lieferando.de` or `thuisbezorgd.nl`). No country is assumed unless you set a default with the `country` field.

### Scrape Just Eat, Lieferando And Thuisbezorgd Without An Official API

Just Eat Takeaway publishes an API for its own business partners (the partner and consumer app surfaces), but there is no self-serve endpoint that returns restaurants and menus for a whole area for research purposes. This actor reads the same public discovery routes and menu CDN the site itself loads:

- One area per line in `locations`: a postcode (`EC4M7RF`), a place name (`Manchester`), coordinates (`53.4807,-2.2426`) or a full Just Eat URL.
- The brand is inferred per line: a pasted `lieferando.de` or `pyszne.pl` URL keeps its own country, while bare entries use the `country` default.
- Each area yields up to `maxRestaurantsPerPostcode` restaurants, and each restaurant can carry its full menu when `includeMenus` is on.
- Menu data is joined to the restaurant rows through `uniqueName`, so the two datasets line up cleanly.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `url` | string | No | `https://www.just-eat.co.uk/area/m24ng-manchester` | A single Just Eat Takeaway URL, for example just-eat.co.uk, lieferando.de, thuisbezorgd.nl or pyszne.pl. Scraped first, before the areas. Leave empty to use only the areas. |
| `locations` | string | No | `EC4M7RF` | One location per line. Accepts postcodes / area codes (EC4M7RF, 10115, 00-844), Just Eat URLs, coordinates (lat,lng), or place names. Lines starting with # are ignored. |
| `country` | string | No | `uk` | Default brand and country for entries that do not carry their own: `uk` (Just Eat), `de` (Lieferando), `nl` (Thuisbezorgd) or `pl` (Pyszne.pl). Pasted URLs set their own country. |
| `includeMenus` | boolean | No | `true` | Download each restaurant's full menu (categories, items, prices, variations, modifier groups, dietary labels) from the public menu CDN. Turn off for listing-only runs. |
| `maxRestaurantsPerPostcode` | integer | No | `50` | Maximum restaurants processed per area. Keeps runs small and predictable. |
| `maxRequestsPerCrawl` | integer | No | `1000` | Hard cap on the total number of HTTP requests in a run (discovery plus menu manifests). |
| `proxy` | object | No | Apify Proxy off | Proxy configuration used for the requests. |

### Output Fields

#### Restaurants dataset (default)

One item per restaurant:

- `country`, `postcode`, `area`: the brand country, the area postcode and area name that produced the row.
- `restaurantId`, `name`, `uniqueName`, `url`: restaurant ID, name, slug (join key to the menus dataset) and restaurant URL.
- `address`: address object.
- `cuisines`: array of cuisines.
- `rating`: rating object.
- `deliveryCost`, `minimumDeliveryValue`: delivery fee and minimum order value.
- `deliveryEtaMinutes`: delivery ETA in minutes.
- `isOpenNowForDelivery`, `isOpenNowForCollection`, `isOpenNowForPreorder`: current availability flags.
- `isPremier`, `isNew`, `isTemporarilyOffline`: restaurant status flags.
- `deals`, `tags`: active deals and tags.
- `logoUrl`: logo image URL.

Dataset view: `overview`.

#### Menus dataset (only when `includeMenus` is enabled)

One item per restaurant, joined to the default dataset on `uniqueName`:

- `uniqueName`, `restaurantId`, `name`, `url`: the restaurant the menu belongs to.
- `country`, `area`, `postcode`: the area context.
- `menu`: full menu object with categories, items, prices, variations, modifier groups and dietary labels.

Dataset view: `overview`.

### Example Input And Output

Example input:

```json
{
  "locations": "EC4M7RF\nManchester\n10115\nhttps://www.pyszne.pl/restauracja/example-kitchen",
  "country": "uk",
  "includeMenus": true,
  "maxRestaurantsPerPostcode": 50
}
```

Example Restaurants row:

```json
{
  "country": "uk",
  "postcode": "EC4M7RF",
  "area": "City of London",
  "restaurantId": "123456",
  "name": "Example Kitchen",
  "uniqueName": "example-kitchen-city-of-london",
  "url": "https://www.just-eat.co.uk/restaurants-example-kitchen-city-of-london/menu",
  "cuisines": ["Indian", "Curry"],
  "rating": { "starRating": 5, "count": 812 },
  "deliveryCost": 2.49,
  "minimumDeliveryValue": 10,
  "deliveryEtaMinutes": { "rangeLower": 30, "rangeUpper": 45 },
  "isOpenNowForDelivery": true,
  "isPremier": false,
  "isNew": false,
  "isTemporarilyOffline": false,
  "logoUrl": "https://example-cdn.just-eat.io/logo.jpg"
}
```

Example Menus row:

```json
{
  "uniqueName": "example-kitchen-city-of-london",
  "restaurantId": "123456",
  "name": "Example Kitchen",
  "url": "https://www.just-eat.co.uk/restaurants-example-kitchen-city-of-london/menu",
  "country": "uk",
  "area": "City of London",
  "postcode": "EC4M7RF",
  "menu": {
    "categories": [
      {
        "name": "Starters",
        "items": [
          { "name": "Onion Bhaji", "price": 4.5, "dietaryLabels": ["Vegetarian"] }
        ]
      }
    ]
  }
}
```

### Integrations & Automation

Export results as JSON, CSV or Excel, read them through the Apify API, or forward rows to a CRM, database or BI tool with webhooks, Zapier or Make. For price and menu monitoring, schedule the actor weekly with the same `locations`, or daily for fast-changing delivery fees and ETAs. Recurring runs also help the actor surface better in the Apify Store.

### Related Actors

- [easyapi/just-eat-restaurant-scraper](https://apify.com/easyapi/just-eat-restaurant-scraper)
- [easyapi/just-eat-restaurant-menu-scraper](https://apify.com/easyapi/just-eat-restaurant-menu-scraper)
- [studio-amba/takeaway-scraper](https://apify.com/studio-amba/takeaway-scraper)
- [solidcode/justeat-co-uk-scraper](https://apify.com/solidcode/justeat-co-uk-scraper)
- [piotrv1001/just-eat-scraper](https://apify.com/piotrv1001/just-eat-scraper)

### FAQ

#### Is there an official Just Eat API?

Yes and no. Just Eat Takeaway publishes API documentation for its business partners (uk.api.just-eat.io and the partner hub), but it is built for restaurants, till systems and delivery partners to work with their own stores and orders, not to browse the whole platform's listings and menus. There is no self-serve endpoint for area-wide research, which is what this actor provides.

#### What are the alternatives to this actor for Just Eat and Lieferando data?

Alternatives include the official Just Eat Takeaway partner API (when you qualify as a partner), third-party food-delivery data providers, and other Apify Store actors that focus on Just Eat listings or Just Eat menus. This actor covers all four group brands (Just Eat, Lieferando, Thuisbezorgd, Pyszne.pl) and returns menus joined to listings in a single run.

#### Which countries and brands are supported?

The four consumer brands mapped in the `country` field: `uk` (Just Eat), `de` (Lieferando), `nl` (Thuisbezorgd) and `pl` (Pyszne.pl). The brand is taken from the domain when you paste a URL, so you can mix countries in one run by listing several URLs.

#### Can I mix URLs and postcodes in one run?

Yes. `locations` accepts one entry per line, and the format is detected per line: postcode, place name, coordinates or a full URL. Entries without a country use the `country` default.

#### Do I get full menu prices?

Yes. When `includeMenus` is true, the full menu is written to the `menus` dataset with categories, items, prices, variations, modifier groups and dietary labels, joined to the restaurant rows on `uniqueName`.

#### Do I need a proxy?

No. Just Eat responds to plain HTTP requests from a normal IP, so the actor runs without a proxy by default. You can attach one in `proxy` for very large or repeated runs.

### SEO Keywords

just eat scraper, lieferando scraper, thuisbezorgd scraper, pyszne scraper, just eat api, food delivery data, restaurant menu scraper, restaurant lead generation, takeaway data, restaurant database uk, delivery fees data, menu prices scraper, restaurant market research, lieferando menu prices, thuisbezorgd restaurants, pyszne.pl products, food delivery market research, restaurant competitor analysis, takeaway menu prices, just eat without api, restaurant data germany, netherlands restaurant data, poland restaurant data, delivery eta data, restaurant ratings scraper

### For AI Agents & LLM Apps

Purpose: return Just Eat Takeaway restaurant rows (address, cuisines, rating, delivery cost, ETA) and, optionally, full priced menus, for a set of areas.

Minimal working input:

```json
{ "locations": "EC4M7RF" }
```

Variant mixing a German area with menus off:

```json
{ "locations": "10115\nberlin", "country": "de", "includeMenus": false }
```

Output fields: Restaurants dataset: `country`, `postcode`, `area`, `restaurantId`, `name`, `uniqueName`, `url`, `address`, `cuisines`, `rating`, `deliveryCost`, `minimumDeliveryValue`, `deliveryEtaMinutes`, `isOpenNowForDelivery`, `isOpenNowForCollection`, `isOpenNowForPreorder`, `isPremier`, `isNew`, `isTemporarilyOffline`, `deals`, `tags`, `logoUrl`. Menus dataset: `uniqueName`, `restaurantId`, `name`, `url`, `country`, `area`, `postcode`, `menu`.

Behaviors an agent should know:

- `url` is scraped first, then everything in `locations`; leaving `url` empty uses only `locations`.
- `country` only applies to entries that do not carry their own country; a pasted URL always keeps its own domain's country.
- `includeMenus` defaults to true and adds one billed `menu-scraped` event per menu plus extra CDN requests; set it to false for a cheap listing-only run.
- `maxRestaurantsPerPostcode` caps restaurants per area, and `maxRequestsPerCrawl` is the global request ceiling.
- Non-paying users are capped at 10 restaurants per run regardless of `maxRestaurantsPerPostcode`.

Billing: pay-per-event. `apify-actor-start` (about $0.00005), one `apify-default-dataset-item` per restaurant (about $0.001) and one `menu-scraped` per menu (about $0.001), lower at higher loyalty tiers.

### Legal & Compliance Disclaimer

This actor is independent and is not affiliated with, endorsed by or sponsored by Just Eat Takeaway.com N.V. or any of its brands (Just Eat, Lieferando, Thuisbezorgd, Pyszne.pl). It reads only publicly available pages and the public JSON routes and menu CDN the site itself loads: it does not log in, does not bypass authentication, does not solve CAPTCHAs and does not place orders.

Users are responsible for complying with Just Eat Takeaway's Terms of Service and with applicable data-protection law (for example GDPR or CCPA) in their own jurisdiction. Where the output contains restaurant contact data or other personal data, that data must not be used for unsolicited commercial outreach in violation of applicable law.

# Actor input Schema

## `url` (type: `string`):

A single Just Eat Takeaway URL to scrape — e.g. https://www.just-eat.co.uk/area/m24ng-manchester or https://www.lieferando.de/area/berlin. The country is taken from the domain. Scraped first, before any entries in "Areas to scrape". Leave empty to use only the areas below.

## `locations` (type: `string`):

One location per line. Supported formats:
• Postcode / area code — e.g. EC4M7RF, 10115, 1011, 00-844
• Just Eat URL — e.g. https://www.just-eat.co.uk/area/m24ng-manchester (country is taken from the domain; postcode is read from the slug, or the slug is geocoded)
• Coordinates — lat,lng, e.g. 53.4807,-2.2426
• Place name or address — e.g. Manchester (geocoded to coordinates; works for every country)
Lines starting with # are ignored.

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

Default brand/country for entries in "Areas to scrape" that do not carry their own country (bare postcodes, place names or coordinates). Pasted Just Eat URLs set their own country.

## `includeMenus` (type: `boolean`):

When enabled, the actor also downloads each restaurant's full menu (categories, items, prices, variations, modifier groups, dietary labels) from the public menu CDN. When disabled, only restaurant listing data is returned.

## `maxRestaurantsPerPostcode` (type: `integer`):

Maximum number of restaurants to process for each area (postcode, place or coordinates). Keeps runs small and predictable.

## `maxRequestsPerCrawl` (type: `integer`):

Hard cap on the total number of HTTP requests made by the crawler (discovery + menu manifest requests).

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "url": "https://www.just-eat.co.uk/area/m24ng-manchester",
  "locations": "EC4M7RF\nM24NG",
  "country": "uk",
  "includeMenus": true,
  "maxRestaurantsPerPostcode": 50,
  "maxRequestsPerCrawl": 1000,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `restaurants` (type: `string`):

One item per restaurant with listing data.

## `menus` (type: `string`):

One item per restaurant with the full menu. Present only when includeMenus 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 = {
    "url": "https://www.just-eat.co.uk/area/m24ng-manchester",
    "locations": `EC4M7RF
M24NG`,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/just-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 = {
    "url": "https://www.just-eat.co.uk/area/m24ng-manchester",
    "locations": """EC4M7RF
M24NG""",
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/just-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 '{
  "url": "https://www.just-eat.co.uk/area/m24ng-manchester",
  "locations": "EC4M7RF\\nM24NG",
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/just-scraper --silent --output-dataset

```

## MCP server setup

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