# Deliveroo Scraper | Menu Data | 12 Markets (`ahmed_jasarevic/deliveroo-scraper`) Actor

Extract Deliveroo restaurant menus, item prices and delivery fees across 12 country markets for restaurant menu price monitoring, competitor price tracking and food delivery market research. One row per menu item.

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

## Pricing

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

## Deliveroo Scraper — Restaurant Menu Data, Prices & Delivery Fees Across 12 Markets

The Deliveroo Scraper extracts Deliveroo restaurants and their complete menus — **35 fields, one dataset row per menu item** — across 12 country markets (`deliveroo.co.uk`, `.fr`, `.ie`, `.it`, `.nl`, `.be`, `.com.au`, `.sg`, `.ae`, `.qa`, `.kw`, `.hk`), built for restaurant menu price monitoring and food delivery market research. It calls the same consumer GraphQL endpoint the Deliveroo web app uses over plain HTTP: no browser, no HTML parsing, no anti-bot API.

### Main Use Cases: Restaurant Menu Price Monitoring, Food Delivery Market Research & Competitor Price Tracking

- **Restaurant menu price monitoring** — every dish arrives with `price`, `priceValue`, `discountedPrice`, `discountedPriceValue`, `offerText`, `available` and `inStock`, so scheduled runs diff cleanly on `itemId` to catch price changes, promotions and sell-outs.
- **Restaurant competitor price tracking / track competitor menu prices** — restaurant facts (`restaurantName`, `restaurantId`, `category`, `rating`, `deliveryFee`) repeat on every row, so side-by-side price tables across chains and branches are a `GROUP BY` away.
- **Food delivery market research** — `cuisines`, `rating`, `ratingCount`, `branchType`, `city`, `area` and `country` (ISO code) structure samples by market and cuisine across all 12 Deliveroo countries.
- **Food delivery price comparison & delivery fee comparison** — `deliveryFee`, `minimumOrder`, `deliveryTime`, `distance` and `availableDeliveryTime` per restaurant for cross-city and cross-platform fee benchmarking.
- **Restaurant data enrichment** — menu items, prices and delivery details keyed by `restaurantSlug` / `restaurantUrl` / `restaurantId` to enrich CRM, BI or analytics records.
- **Deliveroo UK, UAE, Singapore and Australia restaurant data** — pass the market's own URLs (`deliveroo.co.uk`, `.ae`, `.sg`, `.com.au`, …) and every row carries that market's `country` ISO code.

### How The Deliveroo Scraper Works

Deliveroo's `/menu/…` HTML pages sit behind Cloudflare + PerimeterX and return `403 "Just a moment…"` to datacenter IPs, so this actor never loads the website. It POSTs plain JSON to `https://api.deliveroo.com/consumer/menus/graphql/` with the web app's own client headers — two operations per restaurant (`get_menu_meta` for the profile, `get_menu_page` for the header plus the complete menu) — then flattens the menu's UI layout blocks into one dataset row per menu item. Sitemap discovery of restaurant URLs is plain HTTP too.

### Input Parameters

No field is marked required in the input schema; the run's targets come from `startUrls`. **There is no market/country input** — the market is selected by the domain of each URL you pass (the actor sends the matching `X-Roo-Country` ISO header on every request).

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array | No | — (UI prefills 3 example UK URLs) | Restaurant page URLs (`https://deliveroo.co.uk/menu/{city}/{area}/{restaurant}`) and/or Deliveroo sitemap URLs (e.g. `https://deliveroo.co.uk/en/sitemap-menu-landing-pages-1.xml`) used to discover restaurant URLs. The URL domain selects one of the 12 supported markets: `deliveroo.co.uk`, `.fr`, `.ie`, `.it`, `.nl`, `.be`, `.com.au`, `.sg`, `.ae`, `.qa`, `.kw`, `.hk`. |
| `maxRestaurants` | integer | No | `25` | Maximum restaurants to scrape, min 1 / max 1000. Each restaurant yields one dataset row per menu item. Free users are capped at 10 restaurants per run. |
| `deliveryLat` | number | No | — | Optional delivery latitude used for delivery fee / minimum order / distance calculations. Leave empty to use each restaurant's own address (one extra API call per restaurant). |
| `deliveryLon` | number | No | — | Optional delivery longitude used for delivery fee / minimum order / distance calculations. Leave empty to use each restaurant's own address. |
| `proxy` | object | No | `{ "useApifyProxy": false }` | Standard Apify proxy picker. Turn it on if Deliveroo starts rate-limiting your IP. |

### Output Fields

**35 dataset fields — one row per menu item**, with the restaurant's facts repeated on every row. The default table view **Menu Items** shows `restaurantName`, `itemName`, `category`, `price`, `available`, `rating`, `deliveryFee`, `deliveryTime`.

| Group | Fields |
|---|---|
| Restaurant | `restaurantName`, `restaurantId`, `restaurantSlug`, `restaurantUrl`, `address`, `city`, `area`, `country`, `branchType` |
| Rating | `rating` (number), `ratingCount` (number) |
| Cuisines | `cuisines` (array) |
| Delivery | `deliveryTime`, `deliveryFee`, `minimumOrder`, `distance`, `openingStatus`, `deliversToLocation` (boolean), `availableDeliveryTime`, `menuDisabled` (boolean) |
| Menu item | `itemId`, `itemName`, `itemDescription`, `category`, `price`, `priceValue` (number), `priceCurrency`, `discountedPrice`, `discountedPriceValue` (number), `available` (boolean), `dietaryTags` (array), `offerText`, `popular` (boolean), `inStock` (number) |
| Meta | `scrapedAt` |

Paired fields: `price` is the formatted string (`"£4.20"`), `priceValue` the number (`4.2`); same for `discountedPrice` / `discountedPriceValue`. `country` is the ISO code of the market, `availableDeliveryTime` is the next available delivery time, `scrapedAt` is the run timestamp.

### Example Input And Output

Direct restaurant URLs with delivery coordinates priced:

```json
{
  "startUrls": [
    { "url": "https://deliveroo.co.uk/menu/london/enfield/prezzo-enfield" },
    { "url": "https://deliveroo.co.uk/menu/sheffield/london-road/the-hong-kong-cafe-sheffield" }
  ],
  "maxRestaurants": 25,
  "deliveryLat": 51.6564,
  "deliveryLon": -0.0823
}
```

Sitemap-driven discovery (10,000 restaurant URLs per sitemap file):

```json
{
  "startUrls": [
    { "url": "https://deliveroo.co.uk/en/sitemap-menu-landing-pages-1.xml" }
  ],
  "maxRestaurants": 100
}
```

One dataset row (real output shape):

```json
{
  "restaurantName": "Prezzo Italian - Pasta & Pizza - Enfield",
  "address": "The Coach House, London, EN26LU",
  "rating": 4.5,
  "ratingCount": 500,
  "cuisines": ["Italian", "Pizza", "Pasta"],
  "deliveryFee": "£1.99",
  "minimumOrder": "£10.00",
  "deliveryTime": "ASAP",
  "category": "Starters",
  "itemName": "Garlic Bread",
  "itemDescription": "Toasted ciabatta with garlic butter and parsley",
  "price": "£4.20",
  "priceValue": 4.2,
  "priceCurrency": "GBP",
  "available": true,
  "dietaryTags": ["Vegetarian"]
}
```

### Build Deliveroo Menu Data Without Official API Access

The Deliveroo website itself is **not** scrapeable from a datacenter IP: every `/menu/…` HTML page is served behind Cloudflare + PerimeterX and returns a `403 "Just a moment…"`. Rendering those pages in a browser would be expensive and fragile — so this actor does not touch the website at all. Instead it calls the **same consumer GraphQL endpoint the Deliveroo web app uses**:

```
POST https://api.deliveroo.com/consumer/menus/graphql/
```

Two operations return everything the dataset needs:

1. `get_menu_meta(options)` — restaurant profile (name, address, coordinates, category list) using an **uname lookup** (`restaurant_id` = the slug from the URL, plus `city_uname` / `neighborhood_uname` from the URL path).
2. `get_menu_page(options)` — the restaurant header (rating + review count, cuisine tags, delivery fee, minimum order, distance, opening hours) and the **complete menu**.

The endpoint is protected by a light WAF check rather than by Cloudflare, and it accepts a plain JSON POST as long as the request carries the web app's own client headers — this is the whole bypass:

```
User-Agent: <browser UA> (deliveroo/consumer-web-app; browser)
X-Roo-Client: consumer-web-app
X-Roo-Platform: web
X-Roo-Country: <iso>
X-Roo-Guid / X-Roo-Session-Guid / X-Roo-Sticky-Guid: <uuids>
Origin / Referer: <market origin>
```

**Menu layout note.** `get_menu_page` exposes the menu as UI layout blocks (`ui_layout_groups → ui_layouts → ui_blocks`) rather than as a flat item list. Each `UIMenuItemCard.properties` (or `UITallMenuItemCard`) is one menu item, and its block sits inside the layout whose `header` is the category name. The union of those block ids matches `meta.categories[].item_ids` exactly (verified: 102/102 ids, 83 unique items for a McDonald's branch), so nothing is missed — including the "Popular" carousel, which just repeats items that also appear in categories.

No browser, no HTML parsing, no anti-bot API is required. Sitemap discovery (`sitemap-menu-landing-pages-*.xml`, 10,000 restaurant URLs per file) is plain HTTP as well.

#### Request budget & safety limits

- `maxRestaurants` caps the run; the internal request budget is `maxRestaurants × 2 + sitemap fetches` (hard ceiling 2,000).
- `maxConcurrency = 2`, `maxRequestRetries = 3`, 60 s per-request timeout.
- Free accounts (`APIFY_USER_IS_PAYING` != 1) are limited to 10 restaurants per run.

#### Known limitations

- `deliveryTime` is whatever Deliveroo publishes for the restaurant at request time: a time range when the API returns one, otherwise the `next_available_delivery_time` (e.g. `"ASAP"`). The exact minute-range ETA is only rendered by the website for a validated postal address, so it is often `ASAP`.
- Closed restaurants return their status as `openingStatus` (e.g. `"Closes at 10:45"`) and may have `deliversToLocation: false`.
- Restaurant lookup is by slug + city/area from the URL. If a slug is ambiguous across two cities, pass the full `…/menu/{city}/{area}/{slug}` URL — the city and area are always sent with the lookup.

### Run Deliveroo Scraper From The Apify API, Console Or Schedule

Start runs from the Console or through the API:

```bash
curl -X POST "https://api.apify.com/v2/acts/n1z2QMh8CPrGMsxnK/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://deliveroo.co.uk/menu/london/enfield/prezzo-enfield"}],"maxRestaurants":25}'
```

Then poll `GET /v2/actor-runs/<runId>` and read rows from `GET /v2/datasets/<datasetId>/items?format=json`. The dataset UI exports JSON, CSV, Excel; Google Sheets via Zapier / Make.

**Pay-per-event billing:**

| Event | Price |
|---|---|
| `result` | $0.0045 per result (dataset row) |
| `Actor Start` | $0.00005 per run |

**Runtime profile:** 256 MB memory (512 MB max) — plain HTTP GraphQL, no browser. `maxRestaurants` is the main cost lever: a run's request budget is `maxRestaurants × 2 + sitemap fetches`.

### Integrations & Automation

- **Apify API** — start, poll and read results programmatically (curl example above).
- **Webhooks** — fire on `actor.succeeded` / `actor.failed` to push rows into a warehouse, Google Sheets or Slack.
- **Zapier / Make** — turn a new dataset item into a price-alert email or a CRM record without code.
- **Schedules** — run **daily** (e.g. cron `0 6 * * *`) for restaurant menu price monitoring or **weekly** for a food delivery market research digest; keep `maxRestaurants` stable so dataset diffs stay meaningful.

### Related Actors

- [thirdwatch/deliveroo-scraper](https://apify.com/thirdwatch/deliveroo-scraper)
- [memo23/deliveroo-scraper](https://apify.com/memo23/deliveroo-scraper)
- [parseforge/deliveroo-restaurants-scraper](https://apify.com/parseforge/deliveroo-restaurants-scraper)
- [studio-amba/deliveroo-scraper](https://apify.com/studio-amba/deliveroo-scraper)
- [axlymxp/deliveroo-menu-items-scraper](https://apify.com/axlymxp/deliveroo-menu-items-scraper)

### FAQ

#### Does Deliveroo have a public API for menu data?

No public menu API for general use — the official Deliveroo API is restricted to restaurant/retail partners, so there is nothing an analyst or developer can sign up for to pull menus and prices. This actor instead calls the same consumer GraphQL endpoint the public Deliveroo web app uses (`POST https://api.deliveroo.com/consumer/menus/graphql/`): no partner contract, no API key, no login.

#### Why use this actor instead of the official API?

Because there is no official public menu API to use — the partner-restricted one is unavailable for market research, price monitoring or enrichment workflows. This actor needs no credentials and no browser: two plain-HTTP GraphQL operations per restaurant (`get_menu_meta`, `get_menu_page`), 256 MB of memory, no Cloudflare/PerimeterX `403`, and output is flat one-row-per-menu-item data with restaurant facts repeated on every row — ready for diffing and joins.

#### Is it legal to scrape Deliveroo menu data?

The actor only touches publicly visible restaurant and menu data served to anonymous visitors — no login, no account credentials, no personal data. Whether and how you may use the resulting dataset at scale is your responsibility: review Deliveroo's Terms of Service and applicable data-protection law before commercial redistribution (see the disclaimer below).

#### How do I monitor competitor restaurant menu prices?

Pass the competitors' `…/menu/{city}/{area}/{slug}` URLs (or a market sitemap URL with `maxRestaurants`) as `startUrls`, schedule the run daily or weekly, then diff datasets on `restaurantId` + `itemId` + `priceValue` + `discountedPriceValue` + `available` + `offerText`. Because restaurant facts repeat on every menu-item row, rows drop straight into a competitor price table.

#### How do I get restaurant menu data for market research?

Feed one or more Deliveroo sitemap URLs (`sitemap-menu-landing-pages-*.xml`, 10,000 restaurant URLs per file) as `startUrls`, cap with `maxRestaurants`, and export JSON/CSV/Excel from the Apify dataset. Rows carry `cuisines`, `rating`, `ratingCount`, `deliveryFee`, `minimumOrder`, `distance`, plus per-item prices, categories and `dietaryTags` — the raw material for food delivery market research, restaurant pricing strategy and ghost kitchen market research, structured by `city`, `area` and `country`.

#### Which countries does Deliveroo operate in?

Twelve markets, all supported by this actor: `deliveroo.co.uk` (United Kingdom), `deliveroo.fr` (France), `deliveroo.ie` (Ireland), `deliveroo.it` (Italy), `deliveroo.nl` (Netherlands), `deliveroo.be` (Belgium), `deliveroo.com.au` (Australia), `deliveroo.sg` (Singapore), `deliveroo.ae` (UAE), `deliveroo.qa` (Qatar), `deliveroo.kw` (Kuwait) and `deliveroo.hk` (Hong Kong). The market follows the domain of your `startUrls`; each row carries the matching `country` ISO code.

#### Can I scrape a whole city of Deliveroo restaurants at once?

Yes — pass as many of that city's `…/menu/{city}/{area}/{slug}` URLs as you have (or a sitemap URL for URL discovery) and set `maxRestaurants` (up to 1000). Budget `maxRestaurants × 2` GraphQL requests plus sitemap fetches (hard ceiling 2,000); free accounts are limited to 10 restaurants per run. For a whole-market sweep, start from a sitemap file and raise `maxRestaurants`.

#### What are the alternatives to this actor?

For cross-platform food delivery data, scrape **Uber Eats**, **Just Eat** and **DoorDash** alongside Deliveroo (useful for a Deliveroo vs Uber Eats vs Just Eat price comparison — join rows on city, cuisine and dish). For Deliveroo specifically, Store alternatives include `thirdwatch/deliveroo-scraper`, `memo23/deliveroo-scraper`, `parseforge/deliveroo-restaurants-scraper`, `studio-amba/deliveroo-scraper` and `axlymxp/deliveroo-menu-items-scraper` (see Related Actors).

### SEO Keywords

deliveroo scraper, deliveroo api, deliveroo restaurant data, deliveroo menu data, food delivery api, menu scraping api, restaurant menu data, restaurant menu scraping, restaurant menu price monitoring, restaurant competitor price tracking, track competitor menu prices, food delivery market research, food delivery price monitoring, ghost kitchen market research, food delivery market, deliveroo vs uber eats vs just eat, restaurant pricing strategy, compare delivery prices, food delivery price comparison, delivery fee comparison, restaurant data enrichment, deliveroo data scraping uk, deliveroo uae data, singapore food delivery data, deliveroo australia data

### For AI Agents & LLM Apps

**Purpose:** scrape Deliveroo restaurants and their complete menus into 35-field dataset rows (one row per menu item) from menu or sitemap URLs across 12 markets, via Deliveroo's consumer GraphQL endpoint over plain HTTP — no browser.

Minimal input:

```json
{ "startUrls": [{ "url": "https://deliveroo.co.uk/menu/london/enfield/prezzo-enfield" }] }
```

Variant — sitemap discovery:

```json
{ "startUrls": [{ "url": "https://deliveroo.co.uk/en/sitemap-menu-landing-pages-1.xml" }], "maxRestaurants": 100 }
```

Output fields: `restaurantName`, `restaurantId`, `restaurantSlug`, `restaurantUrl`, `address`, `city`, `area`, `country`, `branchType`, `rating`, `ratingCount`, `cuisines`, `deliveryTime`, `deliveryFee`, `minimumOrder`, `distance`, `openingStatus`, `deliversToLocation`, `availableDeliveryTime`, `menuDisabled`, `itemId`, `itemName`, `itemDescription`, `category`, `price`, `priceValue`, `priceCurrency`, `discountedPrice`, `discountedPriceValue`, `available`, `dietaryTags`, `offerText`, `popular`, `inStock`, `scrapedAt`.

Behaviors an agent should know:

- There is no market input: the market is the domain of `startUrls` — `deliveroo.co.uk`, `.fr`, `.ie`, `.it`, `.nl`, `.be`, `.com.au`, `.sg`, `.ae`, `.qa`, `.kw`, `.hk` — and the matching `X-Roo-Country` ISO header is sent per request.
- `startUrls` accepts a mix of restaurant page URLs and sitemap URLs in one array; with no URLs there are no targets.
- `maxRestaurants` defaults to `25` (min 1, max 1000); free accounts (`APIFY_USER_IS_PAYING` != 1) are hard-capped at 10 restaurants per run regardless of input.
- Restaurant lookup is slug + city/area from the URL — pass the full `…/menu/{city}/{area}/{slug}` URL when a slug is ambiguous across cities.
- `deliveryLat` / `deliveryLon` are optional; when unset, each restaurant's own address is used (one extra API call per restaurant).
- Request budget = `maxRestaurants × 2 + sitemap fetches` (hard ceiling 2,000); `maxConcurrency` 2, `maxRequestRetries` 3, 60 s per-request timeout.
- Every row repeats the restaurant's facts; `deliveryTime` is often `"ASAP"`; closed restaurants may show `openingStatus` and `deliversToLocation: false`.
- Proxy is off by default (`useApifyProxy: false`); enable only if Deliveroo rate-limits the IP.

Billing: pay-per-event — `result` $0.0045 per result + `Actor Start` $0.00005 per run.

### Legal & Compliance Disclaimer

This Actor is an independent project and is **not affiliated with, endorsed by or sponsored by** Deliveroo or its operators.

It accesses only publicly available restaurant and menu data through the same unauthenticated consumer GraphQL endpoint the public Deliveroo web app calls — no login, no account credentials, no login bypass, and no personal data of Deliveroo users is collected.

You are responsible for complying with Deliveroo's Terms of Service and applicable data-protection law (including UK/EU GDPR where relevant) before commercial redistribution or large-scale reuse; respect rate limits and local rules. The output contains restaurant and menu data only — no personal contact details.

# Actor input Schema

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

Deliveroo restaurant page URLs (https://deliveroo.co.uk/menu/{city}/{area}/{restaurant}) and/or Deliveroo sitemap URLs (e.g. https://deliveroo.co.uk/en/sitemap-menu-landing-pages-1.xml) used to discover restaurant URLs.

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

Maximum number of restaurants to scrape (each restaurant yields one dataset row per menu item). Free users are capped at 10 restaurants per run.

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

Select proxies to be used by your crawler.

## `deliveryLat` (type: `number`):

Optional delivery latitude used for delivery fee / minimum order / distance calculations. Leave empty to use each restaurant's own address.

## `deliveryLon` (type: `number`):

Optional delivery longitude used for delivery fee / minimum order / distance calculations. Leave empty to use each restaurant's own address.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://deliveroo.co.uk/menu/london/enfield/prezzo-enfield"
    },
    {
      "url": "https://deliveroo.co.uk/menu/sheffield/london-road/the-hong-kong-cafe-sheffield"
    },
    {
      "url": "https://deliveroo.co.uk/menu/london/enfield/12131-starbucks-enfield-church-st"
    }
  ],
  "maxRestaurants": 25,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://deliveroo.co.uk/menu/london/enfield/prezzo-enfield"
        },
        {
            "url": "https://deliveroo.co.uk/menu/sheffield/london-road/the-hong-kong-cafe-sheffield"
        },
        {
            "url": "https://deliveroo.co.uk/menu/london/enfield/12131-starbucks-enfield-church-st"
        }
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/deliveroo-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 = {
    "startUrls": [
        { "url": "https://deliveroo.co.uk/menu/london/enfield/prezzo-enfield" },
        { "url": "https://deliveroo.co.uk/menu/sheffield/london-road/the-hong-kong-cafe-sheffield" },
        { "url": "https://deliveroo.co.uk/menu/london/enfield/12131-starbucks-enfield-church-st" },
    ],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/deliveroo-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 '{
  "startUrls": [
    {
      "url": "https://deliveroo.co.uk/menu/london/enfield/prezzo-enfield"
    },
    {
      "url": "https://deliveroo.co.uk/menu/sheffield/london-road/the-hong-kong-cafe-sheffield"
    },
    {
      "url": "https://deliveroo.co.uk/menu/london/enfield/12131-starbucks-enfield-church-st"
    }
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/deliveroo-scraper --silent --output-dataset

```

## MCP server setup

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