# Just Eat UK Restaurant Search & Menu Extractor (`vexaloom-labs/just-eat-uk-restaurant-search-and-menu-extractor`) Actor

Search Just Eat UK restaurants by postcode or city with cuisine, rating, and open-now filters, and fetch full restaurant menus with categories, items, variations, and prices.

- **URL**: https://apify.com/vexaloom-labs/just-eat-uk-restaurant-search-and-menu-extractor.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 UK Restaurant Search & Menu Extractor

Just Eat UK returns more than 1,700 delivery restaurants for a busy postcode, each with its own menu, pricing, and delivery terms. This actor pulls the complete restaurant result set for any UK postcode or city, filters and pages through it, and can also fetch full menus — categories, items, sizes, and add-ons — for specific restaurants.

### What this actor does

- Pulls the **whole** restaurant result set for a UK postcode/outcode or a major city name (not just the first page of ten).
- Filters by cuisine, minimum star rating, and open-now-for-delivery, then sorts by relevance, rating, delivery time, or real distance from the searched area.
- Pages through results with `offset` + `maxItems`, so a large area can be collected in chunks across runs.
- Fetches a restaurant's complete menu from its menu URL, slug, or numeric ID: categories, item descriptions, prices, size variations, add-on groups, dietary labels, energy information, and item images.
- Reports delivery ETA ranges, delivery fee, minimum order value, coordinates, distance, and current open status.
- Leaves out any field that Just Eat doesn't publish for a given restaurant or item; no nulls or placeholders.

### Output per restaurant (search mode)

| Field | Description |
|---|---|
| `restaurantId`, `uniqueName` | Identifiers used to build the restaurant's menu URL |
| `name` | Restaurant name |
| `address` | `{firstLine, city, postcode, latitude, longitude}` |
| `cuisines` | List of cuisine names |
| `rating` | `{count, starRating, userRating}` where published |
| `deliveryEtaMinutes` | `{rangeLowerMinutes, rangeUpperMinutes, approximateMinutes}` |
| `deliveryCost`, `minimumOrderValue` | In GBP |
| `distanceMeters` | Straight-line-ish drive distance returned by Just Eat |
| `isOpenNow`, `isOpenNowForDelivery`, `isOpenNowForCollection`, `isOpenNowForPreorder` | Current availability |
| `offersDelivery`, `offersCollection`, `isFreeDelivery`, `isHalal`, `isNew`, `isPremier`, `isTemporarilyOffline` | Service and status flags |
| `logoUrl`, `tags` | Logo image and public listing tags |
| `restaurantUrl` | Canonical Just Eat menu page |
| `recordType` | Always `restaurant` for search-mode records |
| `scrapedAt` | UTC timestamp of the scrape |

### Output per menu (menu mode)

One record per restaurant, with nested categories and items:

| Field | Description |
|---|---|
| `restaurantId`, `name`, `description` | Restaurant identity |
| `currency` | Currency code for all prices (`GBP`) |
| `menuVersion` | Just Eat's menu revision identifier |
| `categories` | List of `{categoryId, name, description, preview, items}`, where each item has: |
|   `itemId`, `name`, `description`, `type` | Item identity and description |
|   `price` | Normal selling price (deal-only bundle prices excluded) |
|   `priceRange` | `{min, max}` when the item has multiple paid sizes |
|   `variationNames` | Size/variation names, e.g. `["Regular", "Large"]` |
|   `labels` | Dietary labels, e.g. `vegetarian`, `vegan` |
|   `energyContent` | Energy label, e.g. `282 kcal` |
|   `imageUrl` | Item image URL |
|   `modifierGroups` | Add-on groups with each option's extra cost |
| `itemCount` | Number of resolved items across categories |
| `sourceUrl` | Canonical menu page URL |
| `recordType` | Always `menu` for menu-mode records |
| `scrapedAt` | UTC timestamp of the scrape |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (restaurants near a postcode/city) or `menu` (full menus). |
| `location` | string | – | UK postcode/outcode or major UK city name. In `menu` mode, optional but needed to resolve numeric restaurant IDs. |
| `cuisine` | string | `Any` | Restrict results to one of the listed cuisine categories; restaurants with no cuisine data always pass through. |
| `sortBy` | string | `relevance` | `relevance`, `rating`, `deliveryTime`, or `distance`. |
| `openNowOnly` | boolean | `false` | Keep only restaurants currently open for delivery. |
| `minRating` | integer | – | Drop restaurants below this star rating (1-5); restaurants with no rating always pass through. |
| `restaurantIds` | array | `[]` | Menu URLs, restaurant slugs, or numeric IDs. Numeric IDs also need `location`. |
| `offset` | integer | `0` | Skip this many matching restaurants before emitting records. |
| `maxItems` | integer | `20` | Maximum number of records to emit (1-500). |
| `proxyConfiguration` | object | automatic | Optional override. The actor automatically uses Apify's included AUTO proxy when a direct request is blocked. |

#### Example: pizza near a postcode, nearest first

```json
{
  "mode": "search",
  "location": "SW1A 1AA",
  "cuisine": "Pizza",
  "sortBy": "distance",
  "maxItems": 30
}
```

#### Example: open-now restaurants above a rating threshold

```json
{
  "mode": "search",
  "location": "Manchester",
  "openNowOnly": true,
  "minRating": 4,
  "maxItems": 25
}
```

#### Example: page through a large area

```json
{
  "mode": "search",
  "location": "EC4M",
  "sortBy": "rating",
  "offset": 100,
  "maxItems": 100
}
```

#### Example: full menus by URL, slug, or ID

```json
{
  "mode": "menu",
  "restaurantIds": [
    "https://www.just-eat.co.uk/restaurants-pretamanger-paternostersquarelondon/menu",
    "grain-mediterranean-london"
  ],
  "maxItems": 5
}
```

Numeric IDs still work when you also pass a `location`:

```json
{
  "mode": "menu",
  "location": "EC4M",
  "restaurantIds": [114934]
}
```

### Use cases

- **Market research** — compare cuisine mix, ratings, fees, and distance across postcodes.
- **Menu intelligence** — track competitor menu items, prices, sizes, and add-ons over time.
- **Delivery benchmarking** — compare ETAs, delivery fees, and minimum order values across an area.
- **Partnership outreach** — find restaurants in a postcode by cuisine for supplier or aggregator outreach.
- **Local directory enrichment** — add live ratings, coordinates, and menu data to a restaurant listing.

### Limitations

- **UK only.** Just Eat's other country sites run on separate stacks and aren't covered.
- **Numeric menu IDs need a location.** The public API has no restaurant-ID lookup; without `location` the actor cannot map an ID to the menu slug. Pass a menu URL or slug instead for exact targeting.
- **Paging is local.** Just Eat's endpoint accepts a result `limit` but ignores `offset`/`page`, so the actor fetches the area result set and slices it with `offset`.
- **Some competitor fields aren't published.** Hygiene ratings, phone numbers, reviews, and opening hours are not in the public consumer payload; they are omitted rather than guessed.
- **City names come from a curated list.** Any UK postcode or outcode works; outside the supported city list, use a postcode.

### FAQ

**Is this an official Just Eat tool?**
No. This actor reads Just Eat's own public restaurant and menu data and isn't affiliated with or endorsed by Just Eat.

**Do I need a login or API key?**
No.

**Do I need to configure a proxy?**
No. The actor tries a direct request first and automatically switches to Apify's included AUTO proxy if Just Eat's bot protection blocks it.

**Why did my search return no restaurants?**
Either there's no Just Eat coverage for that postcode/city, the offset is past the end of the result set, or the cuisine/rating/open-now combination filtered everything out. Try widening the filters or lowering `offset`.

**How many restaurants can one run return?**
A busy London outcode currently has about 1,700 delivery restaurants. Increase `maxItems` (up to 500) and use `offset` to collect the rest in further runs.

**What's the difference between `price` and `priceRange` on a menu item?**
`price` is the item's normal selling price; deal-only bundle prices are excluded. `priceRange` appears when the item has more than one paid size.

**Why would a restaurant be missing a fee, rating, or logo?**
Just Eat doesn't publish every field for every restaurant, and some are collection-only. Fields with nothing to report are left off the record instead of showing a placeholder.

**How fresh is the data?**
Every run reads Just Eat's live data at request time, so ratings, open status, fees, and menu prices reflect what's current when the actor runs.

# Actor input Schema

## `mode` (type: `string`):

Search restaurants near a location, or fetch full menus for specific restaurants.

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

A UK postcode/outcode (e.g. `EC4M`, `SW1A 1AA`) or a major UK city name (e.g. `London`, `Manchester`). In menu mode, an optional location used to resolve numeric restaurant IDs.

## `cuisine` (type: `string`):

Only emit restaurants whose cuisines include this. Restaurants with no cuisine data always pass through.

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

How to order emitted restaurants.

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

Only emit restaurants currently open for delivery.

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

Drop restaurants below this star rating (1-5). Restaurants with no rating data always pass through.

## `restaurantIds` (type: `array`):

Restaurant menu URLs (https://www.just-eat.co.uk/restaurants-<slug>/menu), slugs, or numeric IDs. Numeric IDs also need `location` so they can be resolved to a slug.

## `offset` (type: `integer`):

Skip this many matching restaurants before emitting records. Combine with `maxItems` to page through the whole search result set.

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

Maximum number of records to emit.

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

Just Eat's search API uses Cloudflare bot management. The actor automatically falls back to the included Apify AUTO proxy, so you don't need to configure anything. Supply a proxy only if you want to override that automatic choice.

## Actor input object example

```json
{
  "mode": "search",
  "location": "London",
  "cuisine": "Any",
  "sortBy": "relevance",
  "openNowOnly": false,
  "restaurantIds": [],
  "offset": 0,
  "maxItems": 3
}
```

# Actor output Schema

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

Dataset containing all scraped Just Eat restaurant and menu records.

# 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 = {
    "mode": "search",
    "location": "London",
    "cuisine": "Any",
    "sortBy": "relevance",
    "openNowOnly": false,
    "restaurantIds": [],
    "offset": 0,
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/just-eat-uk-restaurant-search-and-menu-extractor").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 = {
    "mode": "search",
    "location": "London",
    "cuisine": "Any",
    "sortBy": "relevance",
    "openNowOnly": False,
    "restaurantIds": [],
    "offset": 0,
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/just-eat-uk-restaurant-search-and-menu-extractor").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 '{
  "mode": "search",
  "location": "London",
  "cuisine": "Any",
  "sortBy": "relevance",
  "openNowOnly": false,
  "restaurantIds": [],
  "offset": 0,
  "maxItems": 3
}' |
apify call vexaloom-labs/just-eat-uk-restaurant-search-and-menu-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/just-eat-uk-restaurant-search-and-menu-extractor"
        }
    }
}
```

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/Jk4VsNN2SGncWEM4k/builds/DKKkRdcn0bTxSHUyH/openapi.json
