# Glovo Restaurant Scraper (`crawlerbros/glovo-scraper`) Actor

Scrape Glovo restaurant listings across Europe & Africa. Get name, cuisine, rating, delivery fee, ETA and images by city, with cuisine and keyword search filters.

- **URL**: https://apify.com/crawlerbros/glovo-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Glovo Restaurant Scraper

Scrape restaurant listings from [Glovo](https://glovoapp.com) — the on-demand delivery platform covering Spain, Italy, Portugal, Kenya, Nigeria, Uganda, Georgia, Kazakhstan, and Moldova. Get restaurant names, cuisine tags, ratings, delivery fees, estimated delivery times, and menu photos, filtered by city, cuisine, or keyword. No login, no cookies, no residential proxy required.

### What this actor does

- **Two modes:** browse every restaurant Glovo shows for a city, or search restaurants/cuisines by keyword
- **19 cities across 9 countries** — Spain, Italy, Portugal, Kenya, Nigeria, Uganda, Georgia, Kazakhstan, Moldova
- **Filters:** cuisine tag, minimum rating, "currently open only", "top-rated only", "has active promotion only"
- **Real delivery data:** live delivery fee, currency, ETA, and customer satisfaction score straight from Glovo
- **Empty fields are omitted** — every record only contains data Glovo actually returned

### Output per restaurant

- `restaurantId` — Glovo's internal store ID
- `name` — restaurant name
- `cuisine[]` — cuisine tag (in the local language of the city)
- `city`, `country`
- `rating` — customer satisfaction score (0-100)
- `reviewCount` — number of ratings behind the score
- `deliveryFee`, `currency`
- `estimatedDeliveryTime` — e.g. `30-40 min`
- `imageUrl` — restaurant photo
- `restaurantUrl` — direct link to the restaurant's Glovo storefront
- `isOpen` — currently accepting orders
- `isTopRated` — Glovo has flagged this restaurant as top-rated
- `isNew` — flagged as newly added to Glovo
- `isSponsored` — sponsored/paid placement in the listing
- `isSurgePricing` — dynamic (surge) delivery pricing is currently active
- `promotions[]` — active discounts/deals (e.g. `{"benefit": "-10%", "type": "Percentage off products", "description": "en algunos productos", "isPrime": false}`), omitted when the restaurant has no active promotion
- `sourceUrl`, `scrapedAt`, `recordType: "restaurant"`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `restaurants` | `restaurants` (browse) or `search` (keyword) |
| `city` | string | `madrid` | One of 19 supported cities |
| `query` | string | – | Required for `search`; matched against name + cuisine |
| `cuisine` | string | – | Filter by cuisine tag, e.g. `Pizza`, `Sushi`, `Burgers` |
| `minRating` | integer | – | Drop restaurants below this rating (0-100) |
| `onlyOpen` | boolean | `false` | Only currently-open restaurants |
| `onlyTopRated` | boolean | `false` | Only restaurants Glovo flags as top-rated |
| `onlyWithPromotions` | boolean | `false` | Only restaurants with at least one active discount/deal |
| `maxItems` | integer | `20` | Hard cap (1-50) |
| `proxyConfiguration` | object | off | Optional Apify proxy (AUTO datacenter group) |

#### Example: browse American-style restaurants in Madrid

```json
{
  "mode": "restaurants",
  "city": "madrid",
  "cuisine": "Americana",
  "maxItems": 30
}
````

#### Example: search for a chain in Lagos

```json
{
  "mode": "search",
  "city": "lagos",
  "query": "chicken"
}
```

#### Example: only open, highly rated restaurants in Milano

```json
{
  "mode": "restaurants",
  "city": "milano",
  "minRating": 80,
  "onlyOpen": true
}
```

### Use cases

- **Market research** — compare cuisine mix, ratings, and delivery fees across cities
- **Competitor tracking** — monitor a chain's presence and ratings across markets
- **Delivery cost analysis** — compare delivery fees and ETAs city to city
- **Food delivery aggregators** — seed a directory with real restaurant listings
- **Local business intelligence** — see which restaurants are open and how they rank

### FAQ

**Which cities are supported?** Madrid, Barcelona, Valencia, Sevilla, Bilbao, Malaga (Spain); Milano, Roma, Torino, Napoli (Italy); Lisboa, Porto (Portugal); Nairobi (Kenya); Lagos, Abuja (Nigeria); Kampala (Uganda); Tbilisi (Georgia); Almaty (Kazakhstan); Chisinau (Moldova).

**How many restaurants can I get per run?** Up to 50 — the number Glovo's food category page returns per city.

**Why is `cuisine` a free-text field instead of a dropdown?** Glovo shows cuisine tags in the local language of each city (e.g. `Pizza` in Spain, `Jollof` in Nigeria), so the available values differ by city. Type any tag you see in the results, or leave it blank to get every cuisine.

**What does `rating` mean?** Glovo shows a customer satisfaction percentage rather than a 5-star score. `87` means 87% of customers were satisfied.

**Do I need a proxy?** No. Glovo's public listing pages work from Apify's standard datacenter IPs. The proxy option is available for extra reliability if you run into rate limiting.

**Is login required?** No — all data comes from Glovo's public restaurant listing pages.

# Actor input Schema

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

`Browse restaurants` lists every restaurant Glovo shows for the selected city (optionally filtered by cuisine). `Search` additionally filters those restaurants by a keyword matched against the restaurant name and cuisine tag.

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

City to scrape Glovo restaurants for.

## `query` (type: `string`):

Required when mode=search. Matched (case-insensitive) against restaurant name and cuisine tag, e.g. `pizza`, `sushi`, `mcdonald`.

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

Optional. Filter restaurants by cuisine tag (case-insensitive substring match), e.g. `Pizza`, `Sushi`, `Italiana`, `Burgers`. Cuisine tags are shown in the local language of the selected city.

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

Drop restaurants with a customer satisfaction score (0-100) below this value.

## `onlyOpen` (type: `boolean`):

Only return restaurants that are currently open for delivery.

## `onlyTopRated` (type: `boolean`):

Only return restaurants Glovo has flagged as top-rated.

## `onlyWithPromotions` (type: `boolean`):

Only return restaurants that currently have at least one active discount/deal (e.g. percentage off, 2x1).

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

Hard cap on emitted records. Glovo shows up to 50 restaurants per city/food category page.

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

Optional. Glovo does not require a proxy from most locations, but you can enable Apify's free datacenter proxy (AUTO group) for extra reliability.

## Actor input object example

```json
{
  "mode": "restaurants",
  "city": "madrid",
  "query": "pizza",
  "onlyOpen": false,
  "onlyTopRated": false,
  "onlyWithPromotions": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Glovo restaurants.

# 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": "restaurants",
    "city": "madrid",
    "query": "pizza",
    "onlyOpen": false,
    "onlyTopRated": false,
    "onlyWithPromotions": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/glovo-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 = {
    "mode": "restaurants",
    "city": "madrid",
    "query": "pizza",
    "onlyOpen": False,
    "onlyTopRated": False,
    "onlyWithPromotions": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/glovo-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": "restaurants",
  "city": "madrid",
  "query": "pizza",
  "onlyOpen": false,
  "onlyTopRated": false,
  "onlyWithPromotions": false,
  "maxItems": 20
}' |
apify call crawlerbros/glovo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/glovo-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Glovo Restaurant Scraper",
        "description": "Scrape Glovo restaurant listings across Europe & Africa. Get name, cuisine, rating, delivery fee, ETA and images by city, with cuisine and keyword search filters.",
        "version": "1.0",
        "x-build-id": "0P7j3gKPEH2QXUdXs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~glovo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-glovo-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~glovo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-glovo-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~glovo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-glovo-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode",
                    "city"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "restaurants",
                            "search"
                        ],
                        "type": "string",
                        "description": "`Browse restaurants` lists every restaurant Glovo shows for the selected city (optionally filtered by cuisine). `Search` additionally filters those restaurants by a keyword matched against the restaurant name and cuisine tag.",
                        "default": "restaurants"
                    },
                    "city": {
                        "title": "City",
                        "enum": [
                            "madrid",
                            "barcelona",
                            "valencia",
                            "sevilla",
                            "bilbao",
                            "malaga",
                            "milano",
                            "roma",
                            "torino",
                            "napoli",
                            "lisboa",
                            "porto",
                            "nairobi",
                            "lagos",
                            "abuja",
                            "kampala",
                            "tbilisi",
                            "almaty",
                            "chisinau"
                        ],
                        "type": "string",
                        "description": "City to scrape Glovo restaurants for.",
                        "default": "madrid"
                    },
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Required when mode=search. Matched (case-insensitive) against restaurant name and cuisine tag, e.g. `pizza`, `sushi`, `mcdonald`."
                    },
                    "cuisine": {
                        "title": "Cuisine filter",
                        "type": "string",
                        "description": "Optional. Filter restaurants by cuisine tag (case-insensitive substring match), e.g. `Pizza`, `Sushi`, `Italiana`, `Burgers`. Cuisine tags are shown in the local language of the selected city."
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Drop restaurants with a customer satisfaction score (0-100) below this value."
                    },
                    "onlyOpen": {
                        "title": "Only currently open",
                        "type": "boolean",
                        "description": "Only return restaurants that are currently open for delivery.",
                        "default": false
                    },
                    "onlyTopRated": {
                        "title": "Only top-rated",
                        "type": "boolean",
                        "description": "Only return restaurants Glovo has flagged as top-rated.",
                        "default": false
                    },
                    "onlyWithPromotions": {
                        "title": "Only with active promotions",
                        "type": "boolean",
                        "description": "Only return restaurants that currently have at least one active discount/deal (e.g. percentage off, 2x1).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Hard cap on emitted records. Glovo shows up to 50 restaurants per city/food category page.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Glovo does not require a proxy from most locations, but you can enable Apify's free datacenter proxy (AUTO group) for extra reliability.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
