# Just Eat Scraper - Restaurants, Menus, Prices & Offers (`scrapesage/just-eat-scraper`) Actor

Scrape Just Eat UK restaurants by postcode: ratings, cuisines, delivery fees, minimum order, ETA, deals, address & geo — plus full menus with item prices, variations, dietary labels, calories and modifiers. Monitoring mode for only-new/changed data. No API key, no browser.

- **URL**: https://apify.com/scrapesage/just-eat-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Agents, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 restaurant 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

## Just Eat Scraper — Restaurants, Menus, Prices, Deals & Delivery Data

Extract **complete Just Eat restaurant data** for any UK postcode — including the fields most scrapers skip: **real item-level menu prices, every size/variation, dietary labels, calories, modifiers, deals/offers, delivery fees, minimum order, ETA and full geo**. One clean row per restaurant, with the full menu nested underneath.

No login, no API key, no browser — fast JSON extraction straight from Just Eat's own public endpoints, with **99%+ reliability**.

### Why this Just Eat scraper?

Most Just Eat scrapers return a restaurant name and a rating and stop there. This actor reads Just Eat's discovery API **and** the public menu CDN, so every row is a complete commercial picture of the restaurant — what it sells, at what price, with which offers, and how it delivers.

| Data | Typical scrapers | This actor |
|---|---|---|
| Restaurant name, rating, cuisines | ✅ | ✅ |
| Full address + **geo (lat/lng)** | partial | ✅ |
| Delivery fee, **minimum order**, ETA | partial | ✅ |
| Deals / offers (with type) | ❌ | ✅ |
| Open-now (delivery & collection), new, premier | ❌ | ✅ |
| **Full menu — every item** | ❌ | ✅ |
| **Item price per size / variation** | ❌ | ✅ |
| Dietary labels (vegan, halal, vegetarian…) | ❌ | ✅ |
| Calories / nutrition per item | ❌ | ✅ |
| Modifier / add-on groups & deal groups | ❌ | ✅ |
| Live fees, badges & throttling status | ❌ | ✅ opt-in |
| Only-new / changed monitoring | ❌ | ✅ |

### Use cases

- **Menu & price intelligence** — track item prices, delivery fees, minimum-order values and offers across competitors in any postcode; spot price changes over time with monitoring mode.
- **Restaurant lead generation** — build prospect lists of restaurants by area, cuisine and rating for POS, marketing, packaging, ingredient-supply or delivery-platform sales (`name`, `firstLine`, `city`, `postalCode`, geo).
- **Market & coverage analysis** — measure how many restaurants serve a postcode, the cuisine mix, average delivery economics and how aggressively venues discount.
- **Catalogue & aggregation** — feed food-discovery apps, price-comparison sites and dashboards with structured restaurant + menu data.
- **New-entrant monitoring** — schedule recurring runs to catch restaurants newly listed in a market, or price/offer changes, without re-paying for unchanged rows.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Just Eat Scraper**, enter one or more UK **postcodes** (e.g. `EC1A 1BB`, `M1 1AE`), and click **Start**.
3. Watch restaurants — each with its full menu — stream into the dataset.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "postcodes": ["EC1A 1BB", "M1 1AE"],
    "maxRestaurants": 100,
    "includeMenu": true,
    "includeModifiers": true,
    "cuisineFilter": "pizza",
    "minRating": 4,
    "openNowOnly": false,
    "monitorMode": false
}
```

- **postcodes** — UK postcodes to scrape. Just Eat lists by delivery area, so a postcode is the way in; each returns every restaurant serving it.
- **startUrls** *(optional)* — Just Eat area URLs like `https://www.just-eat.co.uk/area/ec1a/london` (the postcode is read from the URL).
- **maxRestaurants** *(default 100)* — cap per postcode (a busy postcode can list 2,000+).
- **includeMenu** *(default true)* — fetch the complete menu (items, prices, variations, dietary labels, calories) per restaurant.
- **includeModifiers** *(default true)* — also fetch item modifier/add-on groups and deal groups.
- **includeLiveData** *(default false)* — fetch live granular fees, badges, current rating and throttling/offline status.
- **cuisineFilter / minRating / openNowOnly / deliveryOnly** — filters.
- **monitorMode** *(default false)* — emit only NEW and CHANGED restaurants (see below).

### Output

One record per restaurant (`type: "restaurant"`), with the full menu nested under `menu`:

```json
{
    "type": "restaurant",
    "id": "139485",
    "name": "German Doner Kebab & Grill",
    "uniqueName": "germandonerkebabandgrill-london",
    "url": "https://www.just-eat.co.uk/restaurants-germandonerkebabandgrill-london/menu",
    "firstLine": "68 Cleveland Street",
    "city": "London",
    "postalCode": "W1T 6LX",
    "latitude": 51.521813,
    "longitude": -0.140164,
    "starRating": 5,
    "ratingCount": 242,
    "cuisines": ["Kebab", "Burgers", "Halal"],
    "isDelivery": true,
    "isCollection": true,
    "isOpenNowForDelivery": true,
    "deliveryEtaLowerMinutes": 20,
    "deliveryEtaUpperMinutes": 35,
    "deliveryCost": 3.69,
    "minimumDeliveryValue": 0,
    "driveDistanceMeters": 1975,
    "deals": [{ "description": "Save 20% • Spend £10", "offerType": "Percent" }],
    "dealCount": 1,
    "searchPostcode": "EC1A1BB",
    "searchArea": "City of London",
    "menu": {
        "currency": "GBP",
        "itemCount": 77,
        "minItemPrice": 1.15,
        "maxItemPrice": 38.3,
        "items": [
            {
                "name": "Tuna Lover",
                "description": "Served with mushroom, jalapenos, tuna and sweetcorn.",
                "dietaryLabels": ["vegetarian"],
                "minPrice": 15.5,
                "maxPrice": 15.5,
                "variations": [{ "name": "Medium", "price": 15.5, "calories": "205 kcal" }]
            }
        ],
        "modifierGroupCount": 28
    },
    "scrapedAt": "2026-06-16T23:30:00.000Z"
}
```

### Monitoring — only new & changed restaurants

Turn on **monitorMode** and the actor remembers every restaurant it has seen (in a named key-value store) and, on the next run, emits **only**:

- **new** restaurants that appeared in the postcode, and
- **updated** restaurants whose rating, delivery fee, minimum order, offer count, offline status or menu price range changed (tagged with `changeType`).

This is perfect for tracking a postcode on a schedule without re-paying for unchanged rows — and it works **alongside** [Apify Schedules](https://docs.apify.com/platform/schedules): the schedule decides *when* the run fires, `monitorMode` decides *what* is emitted. Use a different `monitorStoreName` per tracked postcode to keep histories separate.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily/weekly to monitor a postcode's restaurants, prices and offers.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, price-change email) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/just-eat-scraper').call({
    postcodes: ['EC1A 1BB'],
    includeMenu: true,
    maxRestaurants: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} restaurants with menus`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new restaurant leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored postcode gains a restaurant or changes prices.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "list every pizza place delivering to EC1A 1BB with their menu prices" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **food, delivery & local-business intelligence stack**:

- **[Uber Eats Scraper](https://apify.com/scrapesage/ubereats-scraper)** — restaurants, menus, prices and phone leads (US & global).
- **[Zomato Scraper](https://apify.com/scrapesage/zomato-scraper)** — restaurants, menus, ratings and phone leads (India & UAE).
- **[Foodpanda Scraper](https://apify.com/scrapesage/foodpanda-scraper)** — restaurants and menus across APAC.
- **[Fresha Scraper](https://apify.com/scrapesage/fresha-scraper)** — salons, spas & wellness venues with prices and contacts.
- **[Booksy Scraper](https://apify.com/scrapesage/booksy-scraper)** — barbers & beauty pros with services and lead contacts.
- **[Weedmaps Scraper](https://apify.com/scrapesage/weedmaps-scraper)** — dispensaries, menus and product prices.
- **[Craigslist Scraper](https://apify.com/scrapesage/craigslist-scraper)** — local classifieds, services and gigs.

### Tips

- **Big postcodes**: a central-city postcode can list 2,000+ restaurants. Raise `maxRestaurants` to go deeper, or run several postcodes to cover a whole city.
- **Faster, cheaper runs**: turn `includeMenu` off for a listing-only pass (ratings, delivery economics, deals, geo) when you don't need item prices.
- **Cost control**: menus are fetched per restaurant only when `includeMenu` is on, and modifiers only when `includeModifiers` is on.
- **Proxies**: the default datacenter proxy works well; switch to RESIDENTIAL only if you see rate-limiting on very large runs.

### FAQ

**How do I scrape Just Eat for a specific area?** Put one or more UK postcodes in `postcodes` (e.g. `EC1A 1BB`, `M1 1AE`). Just Eat lists restaurants by delivery area, so a postcode returns every restaurant serving it. You can also paste a Just Eat area URL like `https://www.just-eat.co.uk/area/ec1a/london`.

**Does it get real menu prices?** Yes — with `includeMenu` on, the actor pulls each restaurant's full menu (every item, every size/variation, with prices, dietary labels and calories) from Just Eat's public menu source.

**Does it need the Just Eat API or a login?** No. It reads the same public endpoints the Just Eat website uses — no API key, no account, no browser.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new restaurants or price changes automatically?** Turn on `monitorMode` and create a [Schedule](https://docs.apify.com/platform/schedules); each run emits only new and changed restaurants. Add a [webhook](https://docs.apify.com/platform/integrations/webhooks) to push them into your CRM or a Slack channel.

**A field is null — why?** Some restaurants genuinely don't publish a particular field (e.g. no calories on a menu item, or no offers). Fields are `null` only when the data doesn't exist, not because the scraper skipped them.

**Is scraping Just Eat legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (GDPR for personal data) and Just Eat's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `postcodes` (type: `array`):

UK postcodes to scrape. Just Eat lists restaurants by delivery area, so a postcode is the way in — e.g. `EC1A 1BB`, `M1 1AE`, `B1 1AA`, `LS1 1UR`, `EH1 1BB`. Each postcode returns every restaurant that delivers/collects there. Spaces are optional.

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

Just Eat area URLs to scrape instead of / alongside postcodes, e.g. `https://www.just-eat.co.uk/area/ec1a/london`. The outward postcode is taken from the URL. (Single restaurant URLs are not supported here — use the restaurant's postcode in `postcodes`.)

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

Just Eat marketplace to scrape. Currently the United Kingdom (the largest Just Eat market) is supported.

## `maxRestaurants` (type: `integer`):

Cap on restaurants collected per postcode (a busy postcode can list 2,000+). The default keeps runs fast and cheap.

## `includeMenu` (type: `boolean`):

For each restaurant, also fetch its complete menu from Just Eat's public menu CDN: every item with description, price per size/variation, dietary labels, calories and image. This is the headline feature for price monitoring and menu analysis. Turn off for a faster, listing-only run.

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

When menus are included, also fetch the item modifiers/add-on groups (e.g. toppings, sides, choices) and deal groups. One extra request per restaurant.

## `includeLiveData` (type: `boolean`):

Fetch each restaurant's live state: granular delivery/service fees by basket value, current rating, temporary-offline/throttled status and badges. Adds one request per restaurant. Most users don't need this — the listing already has delivery cost, ETA, rating and deals.

## `cuisineFilter` (type: `string`):

Only keep restaurants whose cuisines/tags contain this text, e.g. `pizza`, `indian`, `chinese`, `burgers`, `sushi`, `vegan`, `breakfast`. Leave blank for all.

## `minRating` (type: `integer`):

Only keep restaurants with a star rating at or above this value (0 = keep all).

## `openNowOnly` (type: `boolean`):

Only keep restaurants currently open for delivery or collection.

## `deliveryOnly` (type: `boolean`):

Only keep restaurants that offer delivery (drop collection-only venues).

## `monitorMode` (type: `boolean`):

Remember restaurants seen in previous runs (in a named key-value store) and emit only NEW restaurants and ones whose rating, delivery fee, minimum order, offer count, offline status or menu price range changed (tagged with `changeType`). Perfect for tracking a postcode on a schedule without re-paying for unchanged rows. Works alongside Apify Schedules — schedule the run, this controls what's emitted.

## `monitorStoreName` (type: `string`):

Named key-value store holding the 'already seen' restaurant ids/fingerprints for monitoring mode. Use a different name per tracked postcode/feed to keep histories separate. Lowercase letters, digits and hyphens only.

## `maxConcurrency` (type: `integer`):

Maximum number of restaurant menu/detail requests fetched in parallel.

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

Proxy settings. Apify Proxy is recommended. The default datacenter proxy works well; switch to RESIDENTIAL only if you see rate-limiting on very large runs.

## `urlsFromFile` (type: `string`):

Paste a list of URLs (one per line), OR one link to a .txt/.csv file, Google Sheet or Google Drive file containing them. Lets you import many Start URLs at once instead of typing each. Google Sheet/Drive share links are handled automatically.

## Actor input object example

```json
{
  "postcodes": [
    "EC1A 1BB"
  ],
  "country": "uk",
  "maxRestaurants": 100,
  "includeMenu": true,
  "includeModifiers": true,
  "includeLiveData": false,
  "minRating": 0,
  "openNowOnly": false,
  "deliveryOnly": false,
  "monitorMode": false,
  "monitorStoreName": "just-eat-monitor",
  "maxConcurrency": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped restaurant records in the default dataset (one row per restaurant; the optional full menu is nested under `menu`).

# 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 = {
    "postcodes": [
        "EC1A 1BB"
    ],
    "urlsFromFile": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/just-eat-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 = {
    "postcodes": ["EC1A 1BB"],
    "urlsFromFile": "",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/just-eat-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 '{
  "postcodes": [
    "EC1A 1BB"
  ],
  "urlsFromFile": ""
}' |
apify call scrapesage/just-eat-scraper --silent --output-dataset

```

## MCP server setup

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