# Glovo Scraper (`antonionduarte/glovo-scraper`) Actor

A Glovo scraper that extracts comprehensive restaurant data and category listings. Designed for seamless automation with retry mechanisms, rate limiting, and structured JSON outputs. Ideal for market analysis, competitive research, and operational optimization.

- **URL**: https://apify.com/antonionduarte/glovo-scraper.md
- **Developed by:** [António](https://apify.com/antonionduarte) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 213 total users, 7 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.

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

## Glovo Scraper

Glovo Scraper is an Apify actor that extracts store listings and product/menu data from the Glovo platform. It supports all Glovo verticals — restaurants, groceries, pharmacies, and shops — across any Glovo-supported city.

### Why scrape Glovo?

Glovo is a leading delivery platform operating across Europe, Africa, and Central Asia. Scraping Glovo data enables:

- **Market analysis**: Compare pricing, delivery fees, and promotions across stores and cities.
- **Competitor research**: Track which stores are active, their ratings, and promotional strategies.
- **Price monitoring**: Monitor product prices and menu changes over time.
- **Category intelligence**: Discover what stores and products are available in specific markets.

### Features

- Scrapes store listings from any Glovo category (food, groceries, pharmacy, shops).
- Extracts detailed product/menu data from individual store pages.
- Auto-discovers available categories when none are specified.
- Works without proxies for standard-volume scraping.
- Outputs data in a single dataset with two filtered views: **Stores** and **Products**.
- Supports all Glovo-supported cities worldwide.

### How much will it cost?

The scraper subscription costs **$20/month** on Apify.

Apify provides **$5 free usage credits** every month on the Free plan. A typical run scraping 5 stores with products takes ~5 seconds and costs minimal CUs. The Starter plan ($49/month) and Scale plan offer higher quotas for professional use.

### Usage

#### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `location` | string | Yes | — | City name (e.g., `Barcelona`, `Lisbon`, `Madrid`) |
| `languageCode` | string | No | `en` | Language for product names/descriptions (e.g., `en`, `es`, `pt`) |
| `categories` | array | No | auto-discover | Category paths to scrape (e.g., `food_1?type=burgers_34789`, `groceries_4`) |
| `storeUrls` | array | No | — | Specific store slugs or full URLs to scrape directly |
| `includeProducts` | boolean | No | `false` | Scrape full product/menu listings for each store |
| `maxStoresPerCategory` | integer | No | `50` | Max stores to collect per category (0 = no limit) |
| `proxyConfiguration` | object | No | none | Apify proxy settings (recommended for high-volume scraping) |
| `maxConcurrency` | integer | No | `10` | Max concurrent HTTP requests |
| `requestDelay` | number | No | `1.0` | Delay in seconds between requests |

#### Category Paths

Categories use Glovo's internal path format. Common examples:

| Path | Description |
|------|-------------|
| `food_1` | All food/restaurants |
| `food_1?type=burgers_34789` | Burgers |
| `food_1?type=pizza_34701` | Pizza |
| `food_1?type=sushi_34702` | Sushi |
| `groceries_4` | Groceries |
| `pharmacy-beauty_3` | Pharmacy & Beauty |
| `shops_22` | Shops |

Leave `categories` empty to auto-discover all available categories for the city.

#### Example Input

```json
{
    "location": "Barcelona",
    "languageCode": "en",
    "categories": [
        "food_1?type=burgers_34789",
        "food_1?type=pizza_34701"
    ],
    "includeProducts": true,
    "maxStoresPerCategory": 10
}
```

#### Scraping Specific Stores

```json
{
    "location": "Barcelona",
    "storeUrls": [
        "burger-king-barcelona",
        "mcdonalds-bcn2"
    ]
}
```

Products are always scraped for directly-specified stores.

### Output

All data is pushed to a single default dataset with a `recordType` field (`store` or `product`) to distinguish record types. The Apify console displays two filtered views: **Stores** and **Products**.

#### Store Fields (`recordType: "store"`)

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Store display name |
| `slug` | string | URL-friendly store identifier |
| `url` | string | Full Glovo store page URL |
| `rating` | string | Rating percentage (e.g., `93%`) |
| `votes` | string | Number of ratings (e.g., `(500+)`) |
| `deliveryFeeBase` | string | Base delivery fee (e.g., `1,99 €`) |
| `deliveryFeeEffective` | string | Actual fee after discounts (e.g., `Free`) |
| `isFreeDelivery` | boolean | Whether delivery is free |
| `eta` | string | Estimated delivery time (e.g., `30-40 min`) |
| `distance` | string | Distance from search location |
| `availability` | string | Status (`OPEN`, `CLOSED`) |
| `promotions` | array | Active promotions with `type`, `benefit`, `description` |
| `tag` | string | Store category tag (e.g., `Burgers`) |
| `isTopRated` | boolean | Top-rated flag |
| `isNew` | boolean | New store flag |
| `category` | string | Category path this store was found in |

#### Product Fields (`recordType: "product"`)

| Field | Type | Description |
|-------|------|-------------|
| `storeSlug` | string | Parent store slug (FK to store records) |
| `storeName` | string | Parent store display name |
| `name` | string | Product name |
| `description` | string | Product description |
| `price` | number | Product price |
| `currency` | string | Currency code (e.g., `EUR`) |
| `priceDisplay` | string | Formatted price (e.g., `13,20 €`) |
| `productId` | string | Glovo product ID |
| `imageUrl` | string | Direct URL to product image |

#### Filtering via API

```bash
## All data
curl "https://api.apify.com/v2/datasets/{DATASET_ID}/items?token={TOKEN}"

## Stores only
curl "https://api.apify.com/v2/datasets/{DATASET_ID}/items?token={TOKEN}&fields=recordType,title,slug,rating,deliveryFeeEffective,promotions"

## Products only
curl "https://api.apify.com/v2/datasets/{DATASET_ID}/items?token={TOKEN}&fields=recordType,storeSlug,storeName,name,price,currency,imageUrl"
```

Apify datasets support export in JSON, CSV, XLSX, XML, and RSS formats.

### Limitations

- The `location` must be a valid city name recognized by GeoNamesCache. Invalid locations will fail.
- Glovo's website structure may vary by region, which can affect data completeness.
- Category paths are Glovo-internal identifiers that may change over time. Use auto-discovery to find current paths.
- Grocery store product extraction may differ from restaurant menus due to different page structures.

### Legal

Scraping data from Glovo must comply with local and international data protection regulations. Avoid scraping personal data and ensure you have a legitimate purpose. Consult legal counsel if you have concerns.

# Actor input Schema

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

A valid city name supported by Glovo (e.g., Barcelona, Lisbon, Madrid). Used to resolve the country and build Glovo URLs.

## `languageCode` (type: `string`):

Language code for the Glovo website (e.g., en, es, pt). Affects product names and descriptions.

## `categories` (type: `array`):

Category page paths to scrape (e.g., 'food_1', 'groceries_4', 'pharmacy-beauty_3', 'shops_22'). Supports sub-types like 'food_1?type=burgers_34789'. Leave empty to auto-discover all categories from the city page.

## `storeUrls` (type: `array`):

Specific store slugs or full URLs to scrape directly (e.g., 'burger-king-barcelona' or 'https://glovoapp.com/en/es/barcelona/stores/burger-king-barcelona'). Products are always scraped for directly-specified stores.

## `includeProducts` (type: `boolean`):

If true, scrape the full product/menu listing for each store found in category results. Increases runtime significantly.

## `maxStoresPerCategory` (type: `integer`):

Maximum number of stores to collect per category page. Set to 0 for no limit. Glovo typically returns up to 50 per page.

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

Proxy settings. The scraper works without proxies for HTML pages, but may need residential proxies for high-volume scraping or to avoid rate limiting.

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent HTTP requests.

## `requestDelay` (type: `number`):

Delay in seconds between requests to avoid rate limiting.

## Actor input object example

```json
{
  "location": "Barcelona",
  "languageCode": "en",
  "categories": [
    "food_1?type=burgers_34789"
  ],
  "includeProducts": false,
  "maxStoresPerCategory": 50,
  "maxConcurrency": 10,
  "requestDelay": 1
}
```

# Actor output Schema

## `defaultDataset` (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 = {
    "location": "Barcelona",
    "languageCode": "en",
    "categories": [
        "food_1?type=burgers_34789"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("antonionduarte/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 = {
    "location": "Barcelona",
    "languageCode": "en",
    "categories": ["food_1?type=burgers_34789"],
}

# Run the Actor and wait for it to finish
run = client.actor("antonionduarte/glovo-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 '{
  "location": "Barcelona",
  "languageCode": "en",
  "categories": [
    "food_1?type=burgers_34789"
  ]
}' |
apify call antonionduarte/glovo-scraper --silent --output-dataset

```

## MCP server setup

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