# Deliveroo Scraper (`thirdwatch/deliveroo-scraper`) Actor

Scrape restaurant and menu data from Deliveroo - names, ratings, delivery times, full menus with prices across UK, UAE, and Europe.

- **URL**: https://apify.com/thirdwatch/deliveroo-scraper.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** Automation, E-commerce, Other
- **Stats:** 90 total users, 12 monthly users, 99.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

> **Thirdwatch portfolio:** 8,800+ users across 140+ public Actors, 2M+ records delivered, >95% run success. [Explore all Thirdwatch Actors](https://apify.com/thirdwatch).

> Scrape restaurants and full menus from Deliveroo across 12 markets in the UK, Europe, Middle East, and Asia Pacific — ratings, delivery times, dietary tags, and item-level prices.

### What you get

Extract restaurant listings from any Deliveroo neighborhood: names, ratings, delivery times, distances, delivery fees, and cover images. Optionally pull the full menu for each restaurant with item names, prices, descriptions, dietary tags, and images. Works on area slugs (UK, France, Italy, Ireland, Belgium, Netherlands) and on address-based markets (UAE, Qatar, Kuwait) using coordinates or a Google Maps URL.

Neighborhood and menu pages are read directly most of the time, which keeps runs fast and cheap. Address and coordinate-based lookups sometimes need a heavier fallback mode, which requires selecting 2048 MB run memory.

#### Scrape a specific list of restaurants (cheapest path)

Already know which restaurants you want? Pass their menu URLs in `restaurantUrls` and the Actor scrapes exactly those pages — no location discovery and **no `browser_start` fee**:

```json
{
    "restaurantUrls": [
        "https://deliveroo.co.uk/menu/London/soho/nandos-soho?day=today&geohash=gcpvhcy10y87&time=ASAP",
        "https://deliveroo.co.uk/menu/London/soho/mcdonalds-1063-shaftesbury-avenue-2?day=today&geohash=gcpvhcy10y87&time=ASAP",
        "https://deliveroo.co.uk/menu/London/leicester-square/10340-kfc-leicester-square?day=today&geohash=gcpvhcy10y87&time=ASAP"
    ]
}
```

You get one dataset row per URL, each with the restaurant details, its full menu in `menu_items`, and a `source_url` field so rows join straight back to your input list. Keep the `?day=`, `&geohash=` and `&time=` parameters — Deliveroo uses them to decide which menu to serve. When `restaurantUrls` is set, `queries`, `address`, `location` and `locationUrl` are ignored, and `maxResults` does not truncate your list.

Billing: this path is the cheapest, so you pay only the per-restaurant `result` event. The $0.15 `browser_start` event is charged **only** if a URL cannot be read directly and a heavier fallback mode has to start (which also requires 2048 MB run memory). A run where every URL succeeds on the fast path never incurs it. Bad or non-Deliveroo URLs are reported per URL and skipped — they never fail the run, and the run only fails if nothing at all could be scraped.

### Output fields (restaurants)

| Field | Description |
|-------|-------------|
| `name` | Restaurant name |
| `rating` | Rating text (e.g., "4.8 Excellent") |
| `rating_count` | Number of ratings (e.g., "500+") |
| `delivery_time` | Estimated delivery time |
| `distance` | Distance from the neighborhood center |
| `image_url` | Cover image URL |
| `restaurant_id` | Restaurant ID |
| `url` | Full Deliveroo URL |
| `city` | City name |
| `neighborhood` | Neighborhood name |
| `cuisines` | Cuisine types |
| `delivery_fee` | Delivery fee |
| `minimum_spend` | Minimum order value |
| `address` | Street address of the branch |
| `currency_code` | ISO currency code |
| `source_url` | The exact URL you supplied in `restaurantUrls` (URL mode only) |
| `menu_items` | Full menu (always in `restaurantUrls` mode; with `scrapeMenu` in location mode) |
| `scraped_at` | Timestamp |

### Output fields (menu items, when enabled)

| Field | Description |
|-------|-------------|
| `name` | Menu item name |
| `description` | Item description |
| `price` | Formatted price (e.g., "12.50 GBP") |
| `price_fractional` | Price in smallest currency unit (1250 for £12.50) |
| `price_currency` | ISO currency code |
| `discounted_price` | Sale price when applicable |
| `popular` | Whether the item is marked as popular |
| `available` | Whether the item is currently available |
| `category` | Menu section (e.g., "Pizzas", "Desserts") |
| `image` | Item image URL |
| `dietary_tags` | Dietary labels (vegetarian, vegan, gluten-free) |

### Example output

```json
{
    "name": "Pizza Express",
    "rating": "4.6 Excellent",
    "rating_count": "500+",
    "delivery_time": "20-30 min",
    "distance": "0.3 mi",
    "image_url": "https://rs-menus-api.roocdn.com/images/...",
    "restaurant_id": 12345,
    "url": "https://deliveroo.co.uk/menu/london/soho/pizza-express",
    "city": "london",
    "neighborhood": "soho",
    "menu_items": [
        {
            "name": "Margherita",
            "description": "Classic tomato sauce, mozzarella, fresh basil",
            "price": "11.95 GBP",
            "price_fractional": 1195,
            "price_currency": "GBP",
            "popular": true,
            "available": true,
            "category": "Pizzas",
            "image": "https://rs-menus-api.roocdn.com/images/...",
            "dietary_tags": ["vegetarian"]
        }
    ],
    "scraped_at": "2026-04-11T10:30:00.000Z"
}
```

### Input parameters

| Parameter | Required | Description |
|-----------|----------|-------------|
| `restaurantUrls` | No | Explicit Deliveroo restaurant menu URLs (e.g. `["https://deliveroo.co.uk/menu/London/soho/nandos-soho?day=today&geohash=gcpvhcy10y87&time=ASAP"]`). Scrapes exactly those restaurants plus their full menus over HTTP, skipping location discovery. No `browser_start` charge on the HTTP path. |
| `queries` | No | Location slugs in `city/neighborhood` format (e.g., `["london/soho", "paris/le-marais"]`). Used for markets with area URLs (UK, FR, IT, IE, BE, NL). |
| `domain` | No | Deliveroo market. One of `co.uk`, `ae`, `fr`, `it`, `ie`, `be`, `nl`, `hk`, `sg`, `au`, `qa`, `kw`. Default `co.uk`. |
| `maxResults` | No | Max restaurants per query. Default `5`, max `500`. |
| `location` | No | Latitude/longitude object for address-based markets: `{"lat": 25.2048, "lng": 55.2708}`. |
| `locationUrl` | No | Google Maps URL containing coordinates (e.g., `https://maps.google.com/?q=25.2048,55.2708`). |
| `address` | No | Human-readable address to type into Deliveroo's address search (e.g., `"Dubai Mall"`). Needed for UAE and similar markets without area URLs. |
| `scrapeMenu` | No | Scrape full menus with prices and dietary tags for each restaurant. Default `false`. |

### Supported markets

| Market | Domain | Example |
|--------|--------|---------|
| United Kingdom | `co.uk` | `london/soho` |
| United Arab Emirates | `ae` | address-based (e.g., Dubai Mall) |
| France | `fr` | `paris/le-marais` |
| Italy | `it` | `milan/centro` |
| Ireland | `ie` | `dublin/dublin-2` |
| Belgium | `be` | `brussels/centre` |
| Netherlands | `nl` | `amsterdam/centrum` |
| Hong Kong | `hk` | `hong-kong/central` |
| Singapore | `sg` | `singapore/orchard` |
| Australia | `au` | `melbourne/cbd` |
| Qatar | `qa` | address-based |
| Kuwait | `kw` | address-based |

### Use cases

- **Food-delivery analysts**: Benchmark restaurant density and rating distribution by neighborhood.
- **Restaurant chains**: Track prices, dietary tags, and availability across cities.
- **Cloud kitchens**: Identify cuisine gaps in a target delivery zone.
- **Dietary-app builders**: Filter for vegetarian, vegan, and gluten-free options at scale.
- **Location planners**: Combine restaurant density with delivery times to score catchment areas.

### Limitations

- Restaurant count varies by neighborhood (typically 150-240 per UK area, less in smaller markets).
- UAE, Qatar, Kuwait require `location`, `locationUrl`, or `address` — they do not have area slugs.
- Menu scraping visits each restaurant and materially increases run time and cost.
- Slug-based runs (city/neighborhood) are the fastest and cheapest path. Address- or coordinate-based lookups need more memory (2048 MB) and run slower.
- Prices shown reflect Deliveroo's consumer view; partner promo pricing may differ.

### Compared to alternatives

- **vs. other Deliveroo scrapers**: No direct Apify Store competitor with this geographic and menu-level coverage at this time.
- **vs. Deliveroo Partner API**: Not publicly available — restricted to registered restaurants and only exposes their own menu. This actor is the public-data alternative.

Pairs well with [Talabat Scraper](https://apify.com/thirdwatch/talabat-scraper?fpr=9m2cd6) and [Noon Food Scraper](https://apify.com/thirdwatch/noon-food-scraper?fpr=9m2cd6) for full MENA food-delivery coverage.

### FAQ

**How do I find the right slug for my city?**
Open any Deliveroo restaurant listings page (e.g., `deliveroo.co.uk/restaurants/london/soho`) and copy the `city/neighborhood` portion of the URL.

**How do I scrape UAE restaurants?**
Set `domain: "ae"` and provide `address` (e.g., `"Dubai Marina"`) or `location`/`locationUrl` — UAE uses an address search, not area URLs.

**Should I enable `scrapeMenu`?**
Yes if you need item-level prices or dietary tags. The run will take longer and cost more.

**Can I scrape a specific list of restaurants instead of a whole area?**
Yes — put the menu URLs in `restaurantUrls`. It scrapes exactly those restaurants with their full menus, skips location discovery, and does not charge the `browser_start` fee.

**Is there a rate limit?**
Each neighborhood returns 150-240 restaurants; use multiple queries to broaden coverage.

Last verified: 2026-04

More scrapers at [thirdwatch.dev](https://thirdwatch.dev).

# Actor input Schema

## `restaurantUrls` (type: `array`):

Paste specific Deliveroo restaurant menu URLs to scrape exactly those restaurants and their full menus. Skips location discovery entirely: when this field is set, 'queries', 'address', 'location', and 'locationUrl' are ignored. This is the cheapest and fastest path — it runs over plain HTTP, so no browser is started and no browser-start fee is charged. Keep the full URL including '?day=', '\&geohash=' and '\&time=' — they decide which menu Deliveroo serves. Example: https://deliveroo.co.uk/menu/London/soho/nandos-soho?day=today\&geohash=gcpvhcy10y87\&time=ASAP

## `queries` (type: `array`):

Ignored when 'restaurantUrls' is set. City and neighborhood pairs to scrape restaurants from. Format: 'city/neighborhood'. Examples: 'london/soho', 'dubai/dubai-marina', 'paris/le-marais'. Find these from any Deliveroo listing page URL.

## `domain` (type: `string`):

Which Deliveroo market to search. Select the country where you want restaurant data.

## `maxResults` (type: `integer`):

Maximum number of restaurants to return per location query. Does not truncate 'restaurantUrls' — an explicit URL list is always scraped in full. Capped to keep exploratory browser runs affordable.

## `location` (type: `object`):

Ignored when 'restaurantUrls' is set. Latitude and longitude for address-based markets (UAE, Qatar, Kuwait, etc.) where area slugs don't work. Provide lat/lng directly OR use locationUrl instead. Example: {"lat": 25.2048, "lng": 55.2708} for Dubai Downtown.

## `locationUrl` (type: `string`):

Ignored when 'restaurantUrls' is set. Google Maps URL to extract coordinates from. Supported formats: 'https://maps.google.com/?q=25.2048,55.2708', 'https://www.google.com/maps/@25.2048,55.2708,15z', or any Google Maps URL with coordinates.

## `address` (type: `string`):

Ignored when 'restaurantUrls' is set. A human-readable address or place name to type into Deliveroo's address search (e.g., 'Dubai Mall', 'Downtown Dubai', 'JBR Beach'). Required for UAE and similar markets that don't have area-based URLs. Used with the location coordinates to set the delivery location.

## `scrapeMenu` (type: `boolean`):

Applies to location-based runs only ('restaurantUrls' always returns the full menu). If enabled, also scrapes the full menu (items, prices, descriptions, dietary tags) for each restaurant. This makes additional HTTP requests, takes longer, and caps each query to 25 restaurants.

## Actor input object example

```json
{
  "restaurantUrls": [],
  "queries": [
    "london/soho"
  ],
  "domain": "co.uk",
  "maxResults": 5,
  "scrapeMenu": 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 = {
    "restaurantUrls": [],
    "queries": [
        "london/soho"
    ],
    "domain": "co.uk",
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/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 = {
    "restaurantUrls": [],
    "queries": ["london/soho"],
    "domain": "co.uk",
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/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 '{
  "restaurantUrls": [],
  "queries": [
    "london/soho"
  ],
  "domain": "co.uk",
  "maxResults": 5
}' |
apify call thirdwatch/deliveroo-scraper --silent --output-dataset

```

## MCP server setup

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