# Just Eat Scraper - UK Restaurants, Ratings & Delivery (`haketa/just-eat-scraper`) Actor

Scrape restaurants from Just Eat UK by postcode: name, cuisines, star rating, delivery fee, minimum order, delivery ETA, live offers, address and coordinates. Every restaurant in an area in one pass. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/haketa/just-eat-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation, E-commerce
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 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 🍔🇬🇧 — Restaurants, Ratings, Delivery Fees & Offers by Postcode

Extract live restaurant directories, commercial delivery intelligence, and promotional offers from **[Just Eat UK](https://www.just-eat.co.uk)** — Great Britain's leading food delivery marketplace. This **Just Eat scraper** allows food industry analysts, aggregator competitors, and B2B suppliers to **scrape Just Eat UK** by outward code or full postcode to extract **restaurant names, cuisine tags, customer star ratings, review volumes, delivery fees, minimum order thresholds, delivery and collection ETAs, active discount deals, full street addresses, and GPS coordinates**.

Export clean, structured takeaway data directly to **JSON, CSV, Excel, XML**, or query via **Apify REST API & Webhooks**.

[![Actor](https://img.shields.io/badge/Apify-Actor-00b04f?style=flat-square\&logo=apify)](https://apify.com/haketa/just-eat-scraper)
[![Market](https://img.shields.io/badge/Market-United%20Kingdom%20%F0%9F%87%AC%F0%9F%87%A7-012169?style=flat-square)](https://apify.com/haketa/just-eat-scraper)
[![Delivery Intelligence](https://img.shields.io/badge/Data-Delivery%20Fees%20%26%20ETAs-brightgreen?style=flat-square)](https://apify.com/haketa/just-eat-scraper)
[![Deals](https://img.shields.io/badge/Promotions-Live%20Offers%20Tracked-e4002b?style=flat-square)](https://apify.com/haketa/just-eat-scraper)
[![Output](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-2b7489?style=flat-square)](https://apify.com/haketa/just-eat-scraper)
[![Pagination](https://img.shields.io/badge/Scale-1%2C000%2B%20Restaurants%2FPostcode-blue?style=flat-square)](https://apify.com/haketa/just-eat-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained-Active%202026-brightgreen?style=flat-square)](https://apify.com/haketa/just-eat-scraper)

***

### ⚡ At a glance

| Feature | Details & Support |
| :--- | :--- |
| **Target Website** | `just-eat.co.uk` (All UK cities, towns, and postal districts) |
| **Extracted Data** | Restaurant brand, cuisines, star ratings, delivery charges, min orders, ETAs, active deals |
| **Search Mechanism** | UK outward codes and full postcodes (e.g. `EC4M7RF`, `SW1A`, `M1`, `B1`, `G1`) |
| **Scale & Throughput** | Up to **2,000+ restaurants per single postcode query** in under 5 seconds |
| **De-duplication** | Native deduplication across overlapping postcodes using unique Just Eat `id` |
| **Anti-Bot Resistance** | Pure high-speed HTTP endpoint; runs without mandatory proxies |
| **Data Cleanliness** | 100% structured JSON with clean currency floats and timing ranges |
| **Export Formats** | JSON, CSV, XLSX, XML, RSS, HTML Table, Apify Dataset API |
| **Automation** | Apify Cron, Webhooks, Make.com, Zapier, Python/Node.js SDKs |

***

### 🔎 Why scrape Just Eat UK?

**Just Eat** represents the largest network of independent takeaways, dark kitchens, and high-street restaurant chains across the United Kingdom. In any given UK postal code, hundreds to thousands of restaurants compete for consumer demand.

Each listing contains rich commercial signals that change dynamically throughout the day:

- 💷 **Delivery Fee & Minimum Order Benchmarking**: Track competitive changes in delivery charges (`deliveryCost` in GBP) and order minimums (`minimumDeliveryValue`).
- ⏱️ **Fulfillment Velocity (ETA Tracking)**: Monitor delivery estimate ranges (`deliveryEtaRange`, e.g., "20-35 mins") and collection readiness across meal times.
- 🏷️ **Promotional Pricing & Deal Monitoring**: Identify which restaurants are discounting (percentage-off, stamp cards, minimum spend vouchers) to stimulate order volume.
- 📍 **Geomarketing & Expansion Strategy**: Evaluate cuisine saturation and delivery coverage before launching a virtual brand or dark kitchen.
- 🎯 **B2B Lead Generation**: Build targeted contact directories of restaurant owners and takeaway operators by cuisine and city.
- ⭐ **Reputation & Review Analytics**: Compare customer sentiment, star ratings, and review velocity across major urban centers.

***

### ⚖️ Just Eat Scraper vs. Generic Restaurant Scrapers

| Capability | Just Eat Scraper | Generic Scrapers |
| :--- | :--- | :--- |
| **Speed & Throughput** | ✅ 2,000+ restaurants in ~5 seconds via enriched API | ❌ Slow DOM crawling (30–60 minutes) |
| **Delivery Intelligence** | ✅ Explicit fees, minimum spends, and ETA windows | ❌ Often missing delivery fees and minimums |
| **Live Promotions Tracking** | ✅ Extracts structured deal types and discount terms | ❌ Fails to capture dynamic promotional tags |
| **Postal Code Coverage** | ✅ Supports full postcodes (`EC4M7RF`) and outcodes (`M1`) | ❌ Requires manual city navigation |
| **Deduplication Engine** | ✅ Automated deduplication via canonical numeric `id` | ❌ High duplicate rate across neighboring areas |
| **Proxy Cost** | ✅ Zero proxy cost (works via direct HTTP requests) | ❌ Requires costly residential proxy pools |

***

### ✨ Features & Extraction Capabilities

- 📮 **Broad Outcode & Postcode Search**: Input any UK outward code (e.g., `SW1A`, `M1`, `B1`, `LS1`, `G1`) or full address postcode.
- 🚚 **Delivery Intelligence**: Captures exact delivery fee in GBP (`0` = Free Delivery), minimum order value, and ETA duration ranges.
- ⭐ **Rating & Volume Metrics**: Retrieves aggregate star rating (0–5) and verified customer review counts.
- 🍕 **Cuisine Classification**: Collects complete cuisine arrays (e.g., `["Pizza", "Italian", "Halal", "Burgers"]`) with optional client-side filters.
- 🏷️ **Live Promotions & Deals**: Captures active discount mechanics including percentage discounts and loyalty stamp cards.
- 🗺️ **Full Geocoded Addresses**: Extracts street names, city, postal code, and high-precision GPS coordinates (`latitude`/`longitude`).
- 🟢 **Operational Status Flags**: Live booleans indicating `isOpenNowForDelivery`, `isOpenNowForCollection`, `isTemporarilyOffline`, and next reopening timestamp.

***

### 🌍 Supported UK Metropolitan Hubs

The scraper supports all postal areas across England, Scotland, Wales, and Northern Ireland:

- **Greater London**: Central (EC, WC), West (W, SW), North (N, NW), East (E), South (SE)
- **Manchester & Greater Manchester**: M1 to M99, Salford, Stockport, Bolton, Oldham
- **Birmingham & West Midlands**: B1 to B99, Solihull, Wolverhampton, Coventry, Dudley
- **West Yorkshire**: Leeds (LS), Bradford (BD), Wakefield (WF), Huddersfield (HD)
- **Glasgow & Edinburgh**: G1 to G84, EH1 to EH55, Aberdeen (AB), Dundee (DD)
- **Liverpool & Merseyside**: L1 to L40, Birkenhead, St Helens, Southport
- **Bristol & South West**: BS1 to BS49, Bath (BA), Exeter (EX), Plymouth (PL)
- **Tyne & Wear**: Newcastle upon Tyne (NE), Sunderland (SR), Durham (DH)
- **East Midlands**: Nottingham (NG), Leicester (LE), Derby (DE)
- **Wales & Northern Ireland**: Cardiff (CF), Swansea (SA), Belfast (BT)

***

### 🍕 High-Volume UK Cuisines & Delivery Segments

When analyzing food delivery dynamics on Just Eat, filtering by popular cuisine segments highlights regional demand:

| Cuisine Category | Sample Substring Query | Common Takeaway Formats | Typical Order Value Range |
| :--- | :--- | :--- | :--- |
| **Pizza & Italian** | `Pizza`, `Italian` | Traditional pizzerias, delivery franchises | £12 – £28 |
| **South Asian** | `Indian`, `Curry`, `Bangladeshi`, `Pakistani` | Tandoori houses, curry clubs, biryani kitchens | £18 – £35 |
| **East Asian** | `Chinese`, `Noodles`, `Dim Sum`, `Thai` | Traditional wok takeaways, noodle bars | £16 – £32 |
| **Burgers & Fast Food** | `Burgers`, `American`, `Chicken` | Gourmet smash burger joints, fried chicken shops | £10 – £25 |
| **Middle Eastern** | `Kebab`, `Turkish`, `Lebanese`, `Shawarma` | Kebab houses, charcoal grills | £12 – £26 |
| **Dietary & Niche** | `Halal`, `Vegan`, `Vegetarian`, `Gluten-Free` | Plant-based cloud kitchens, certified halal kitchens | £14 – £30 |

***

### 🎯 High-Impact Use Cases

#### 1. Food Delivery & Aggregator Competitors

Monitor competitor coverage, delivery pricing structures, and commission-driven pricing disparities between Just Eat, Deliveroo, and Uber Eats.

#### 2. FMCG & Beverage Brands

Track restaurant menu presence and beverage pairing opportunities (e.g. Coca-Cola vs. Pepsi distribution) across takeaway segments.

#### 3. Dark Kitchens & Ghost Restaurant Operators

Identify underserved cuisines in specific London or Manchester outcodes to strategically deploy high-margin delivery-only concepts.

#### 4. B2B Merchant Services & POS Vendors

Generate sales pipelines for POS systems, commercial kitchen equipment, packaging supplies, and merchant cash advances targeted at active takeaway owners.

***

### 📥 Input Parameters

The actor accepts clean, intuitive JSON parameters:

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `postcodes` | Array | `["EC4M7RF"]` | UK postcodes or outcodes to query. Gathers all delivery & collection partners. |
| `cuisines` | Array | `[]` | Optional cuisine filter (e.g. `Pizza`, `Halal`, `Burgers`, `Indian`). Empty = all cuisines. |
| `onlyOpenForDelivery` | Boolean | `false` | When `true`, filters out currently closed or collection-only restaurants. |
| `maxPostcodes` | Integer | `0` | Maximum postcodes to process (0 = unlimited, processes all provided postcodes). |
| `maxItems` | Integer | `100` | Maximum total restaurants to collect across all searched postcodes. |
| `proxyConfiguration` | Object | `{ "useApifyProxy": false }` | Direct connections run fastest. Enable Apify Proxy only for high-frequency queries. |

#### Input JSON Example (City-Wide Search)

```json
{
  "postcodes": ["EC4M7RF", "SW1A1AA", "M11AE"],
  "cuisines": ["Pizza", "Burgers"],
  "onlyOpenForDelivery": true,
  "maxPostcodes": 0,
  "maxItems": 250,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

***

### 📤 Output Data Structure

The actor extracts each restaurant as a clean, standardized JSON object.

#### Sample Output Record

```json
{
  "id": "158035",
  "name": "Tops Pizza - Islington",
  "url": "https://www.just-eat.co.uk/restaurants-tops-pizza---islington/menu",
  "cuisines": ["Pizza", "Italian", "Halal"],
  "rating": 4.8,
  "ratingCount": 2408,
  "address": "Ground Floor 22 Penton Street",
  "city": "London",
  "postalCode": "N1 9PS",
  "latitude": 51.53225,
  "longitude": -0.11115,
  "deliveryCost": 1.49,
  "minimumDeliveryValue": 10.00,
  "deliveryEtaRange": "20-35",
  "collectionEtaMinutes": 10,
  "driveDistanceMeters": 1844,
  "isDelivery": true,
  "isCollection": true,
  "isOpenNowForDelivery": true,
  "isOpenNowForCollection": false,
  "isOpenNowForPreorder": false,
  "nextDeliveryAvailability": "2026-11-10T12:00:00",
  "isNew": false,
  "isPremier": true,
  "isTemporarilyOffline": false,
  "deals": [
    {
      "type": "Percent",
      "description": "20% off orders over £25"
    }
  ],
  "logoUrl": "https://d30v2pzvrfyzpo.cloudfront.net/uk/images/restaurants/158035.gif",
  "searchedPostcode": "EC4M7RF"
}
```

#### 📋 Output Fields Specification & Coverage

| Field Category | Field Name | Type | Coverage | Description |
| :--- | :--- | :--- | :--- | :--- |
| **Identifiers** | `id` | String | 🟢 High (100%) | Unique Just Eat numeric restaurant ID. |
| | `name` | String | 🟢 High (100%) | Trading name of the restaurant or takeaway. |
| | `url` | String | 🟢 High (100%) | Direct menu URL on just-eat.co.uk. |
| **Cuisine & Ratings** | `cuisines` | Array | 🟢 High (100%) | List of associated cuisine tags. |
| | `rating` | Number | 🟢 High (100%) | Customer star rating (0.0 to 5.0). |
| | `ratingCount` | Integer | 🟢 High (100%) | Total number of published customer ratings. |
| **Delivery Logistics**| `deliveryCost` | Number | 🟢 High (100%) | Delivery fee in GBP (0 = free delivery). |
| | `minimumDeliveryValue`| Number | 🟢 High (100%) | Minimum cart spend required for delivery. |
| | `deliveryEtaRange` | String | 🟢 High (99%) | Estimated delivery window in minutes (e.g. "25-40"). |
| | `collectionEtaMinutes`| Integer | 🟢 High (75%) | Estimated takeaway pickup preparation time. |
| | `driveDistanceMeters`| Integer | 🟢 High (95%) | Road distance in meters from the searched center. |
| **Address & GPS** | `address` | String | 🟢 High (100%) | Street address line. |
| | `city` | String | 🟢 High (100%) | Municipal city or borough name. |
| | `postalCode` | String | 🟢 High (100%) | Official UK postcode of the kitchen premises. |
| | `latitude` / `longitude`| Number | 🟢 High (100%) | Precise decimal GPS coordinates. |
| **Operational Flags** | `isOpenNowForDelivery`| Boolean | 🟢 High (100%) | Whether currently accepting delivery orders. |
| | `isOpenNowForCollection`| Boolean | 🟢 High (100%) | Whether currently accepting pickup orders. |
| | `isPremier` | Boolean | 🟢 High (100%) | Just Eat Premier Partner program status. |
| | `nextDeliveryAvailability`| String | 🟢 High (95%) | ISO timestamp of the next delivery ordering window. |
| | `deals` | Array | 🟡 Conditional | Active promotions (percentage discounts, stamp cards). |
| | `logoUrl` | String | 🟢 High (100%) | Hosted thumbnail logo graphic. |

***

### 🔁 Scale & High-Throughput Processing

The actor is engineered for rapid, city-scale data extraction:

- **Zero Page Throttles**: Single postcode queries retrieve full partner inventories (up to 2,000+ businesses) in a single HTTP cycle.
- **De-duplication Engine**: In-memory Set ensures that overlapping delivery radii across adjacent postcodes never produce duplicate entries.
- **Lightweight Execution**: Pure HTTP architecture executes on minimal 512 MB instances in under 10 seconds.
- **Automatic Fallback**: If an Apify proxy IP experiences rate limiting, the actor falls back to direct connection automatically.

***

### 🛠️ Step-by-Step Walkthrough

1. **Select Postal Areas**: Choose your target UK postcodes or outcodes (e.g., `EC4M7RF`, `SW1A`, `M1`).
2. **Apply Optional Filters**: Filter by cuisine (e.g., `Italian`, `Halal`, `Burgers`) or restrict to currently open restaurants.
3. **Execute Extraction**: Click **Start**. The actor extracts all matching restaurants in parallel.
4. **Download Results**: Export datasets in JSON, CSV, or Excel formats, or connect directly via API.

#### Programmatic Python Execution

```python
from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "postcodes": ["M1", "M2", "M3"],
    "onlyOpenForDelivery": True,
    "maxItems": 200
}

run = client.actor("haketa/just-eat-scraper").call(run_input=run_input)
items = client.dataset(run["defaultDatasetId"]).list_items().items

## Convert to Pandas DataFrame for restaurant market analysis
df = pd.DataFrame(items)
print(df[["name", "city", "deliveryCost", "minimumDeliveryValue", "rating"]].head())
```

#### Programmatic Node.js Execution

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

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

const run = await client.actor('haketa/just-eat-scraper').call({
    postcodes: ['EC4M7RF'],
    cuisines: ['Pizza'],
    maxItems: 100
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Retrieved ${items.length} pizza restaurants in Central London.`);
```

#### Webhook & Automation Workflow

You can set up an Apify Webhook that triggers whenever a Just Eat scrape run succeeds:

- **Slack Alert**: Notify your analytics team when new regional takeaway promotions go live.
- **Google Sheets Sync**: Append new restaurants automatically via Make.com or Zapier.
- **Pricing Alert**: Track when rival aggregators adjust delivery fees in key postal territories.

##### Example Apify Webhook Configuration

When integrating with Zapier or Make.com, configure an HTTP POST Webhook on Apify Console triggered on `ACTOR.RUN.SUCCEEDED`:

```json
{
  "eventType": "ACTOR.RUN.SUCCEEDED",
  "eventData": {
    "actorId": "haketa/just-eat-scraper",
    "actorRunId": "91aK0x9NmQ8Zb45",
    "defaultDatasetId": "cL90mX12Pq34Za6"
  }
}
```

***

### 📊 Supported Export Formats & Integrations

- **JSON / JSONL**: Optimized for developers, API ingestion, and vector embedding pipelines.
- **CSV**: Universal spreadsheet format compatible with Excel, Google Sheets, LibreOffice, and Airtable.
- **XLSX**: Native Microsoft Excel workbook format with column formatting.
- **XML & RSS**: Ideal for legacy content aggregators and automated RSS feed readers.
- **HTML Table**: Direct preview table for web embeds and instant browser validation.
- **Python & Node.js SDKs**: Programmatic fetching using official Apify clients.

***

### 💡 Best Practices & Pro Tips

- 🎯 **Use Outcodes for Maximum Scale**: Provide 2-4 character outcodes (e.g. `M1`, `B1`, `SW1`) rather than 7-character full postcodes to capture entire geographic boroughs.
- ⚡ **Leverage Direct Connections**: Just Eat UK's discovery API is open and public; running with `useApifyProxy: false` completes runs in 3–8 seconds at minimal compute cost.
- 📅 **Schedule Multiple Daily Runs**: Food delivery pricing and discounts fluctuate significantly between lunch (11:30–14:00) and dinner (17:30–21:30).
- 🔗 **Track Promotions**: Inspect the `deals` array to identify aggressive takeaway discount campaigns across your delivery area.

***

### ❓ Frequently Asked Questions

**Does the scraper require a Just Eat user account?**\
No. The scraper queries public area discovery endpoints and does not require account credentials or API authorization tokens.

**How many restaurants can I extract in a single execution?**\
A single dense urban postcode (such as Central London) typically returns 1,500 to 2,000 active restaurants. You can extract thousands across multiple postcodes by setting `maxItems` to your target volume.

**Can I filter by specific food categories?**\
Yes. Use the `cuisines` parameter to filter by any desired specialty, including Pizza, Chinese, Indian, Halal, Thai, Burgers, or Vegan.

**Are delivery fees and minimum spends in British Pounds?**\
Yes. `deliveryCost` and `minimumDeliveryValue` are extracted as numerical GBP values, ready for immediate currency calculations.

**What formats can I export the data to?**\
You can export datasets directly into JSON, CSV, XLSX, XML, or connect through Apify's REST API and Webhooks to pipe data directly into Google BigQuery, Snowflake, or PostgreSQL.

**Can I run this actor on a recurring schedule?**\
Yes. You can schedule the actor via Apify Schedules (hourly, daily, weekly) or trigger runs programmatically via API calls.

**Does this actor cover Just Eat in Ireland, Spain, or Germany?**\
This actor specifically queries Just Eat UK (`just-eat.co.uk`). Sister brands in other European markets (such as Lieferando in Germany, Thuisbezorgd in the Netherlands, or Just Eat Spain) utilize separate Takeaway.com infrastructure.

**How does distance calculation work?**\
The `driveDistanceMeters` attribute reflects the estimated road driving distance between the searched postal centroid and the restaurant premises in meters.

**Are duplicate restaurants filtered if postcodes overlap?**\
Yes. When querying adjacent postal codes (e.g., `M1` and `M2` in Manchester), many restaurants serve both delivery zones. The actor automatically deduplicates by unique restaurant `id`, outputting each business only once per run.

***

### 📋 Changelog

#### v1.2 (2026-11)

- 🚀 **Unlocked 1,000+ Deep Scale**: Added multi-postcode traversal governance via `maxPostcodes` and seamless scale past 1,000+ items.
- ⚡ **Zero-Input Prefill Fallback**: Configured default central London outcodes for instant one-click execution without manual input.
- 🧼 **Clean Field Normalization**: Enhanced fee parsing, promotional deal structure extraction, and GPS coordinate formatting.
- 🛡️ **Strict Schema Compliance**: Validated Input, Output, and Dataset schemas to meet 100% Apify specifications.

#### v1.1 (2026-08)

- Added delivery intelligence parsing including ETA range windows, collection duration, and promotional discount tags.
- Implemented natural de-duplication by native Just Eat restaurant `id`.

#### v1.0 (2026-08)

- Initial release featuring postcode discovery, rating extraction, and cuisine mapping.

# Changelog

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

# Actor input Schema

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

One or more UK postcodes or outcodes to search (e.g. EC4M7RF, SW1A, M1, B1). Each returns every restaurant that delivers to or collects in that area.

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

Keep only restaurants matching these cuisines (e.g. Pizza, Chinese, Indian, Halal, Burgers). Leave empty for all cuisines.

## `onlyOpenForDelivery` (type: `boolean`):

Keep only restaurants currently open for delivery.

## `maxPostcodes` (type: `integer`):

Maximum number of postcodes to process (0 = unlimited, processes all provided postcodes).

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

Maximum number of restaurants to collect across all postcodes.

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

Proxy settings. This actor reads a fast public Just Eat endpoint and runs reliably without a proxy (the default). If you scrape many postcodes and want IP rotation, enable Apify Proxy and pick the Residential group with country GB; the actor also falls back to a direct request automatically if a proxy IP is throttled.

## Actor input object example

```json
{
  "postcodes": [
    "EC4M7RF"
  ],
  "onlyOpenForDelivery": false,
  "maxPostcodes": 0,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `id` (type: `string`):

Just Eat restaurant ID

## `name` (type: `string`):

Restaurant name

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

Restaurant page URL

## `rating` (type: `string`):

Star rating

## `ratingCount` (type: `string`):

Number of ratings

## `city` (type: `string`):

City

## `postalCode` (type: `string`):

Restaurant postcode

## `deliveryCost` (type: `string`):

Delivery fee (GBP)

## `minimumDeliveryValue` (type: `string`):

Minimum order value

## `deliveryEtaMinutes` (type: `string`):

Delivery ETA in minutes

## `isOpenNowForDelivery` (type: `string`):

Open now for delivery

# 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": [
        "EC4M7RF"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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": ["EC4M7RF"],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/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": [
    "EC4M7RF"
  ],
  "maxItems": 100
}' |
apify call haketa/just-eat-scraper --silent --output-dataset

```

## MCP server setup

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