# Glovo Scraper – Restaurant & Store Data Extractor (`epicscrapers/glovo-store-scraper`) Actor

Scrape Glovo restaurants and stores by URL, city, or store ID. Extract ratings, delivery fees, opening hours, promotions, addresses, and availability for food-delivery research, lead generation, and market analysis—no login required.

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

## Pricing

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Store Scraper

Extract structured Glovo restaurant and store data by store URL, city name, or numeric store ID. The Actor returns clean, analysis-ready records with ratings, delivery fees, opening hours, addresses, promotions, contact details, and operational status.

Use it for restaurant research, delivery-market analysis, local business intelligence, lead generation, price and availability monitoring, or building Glovo datasets. No Glovo login or browser cookies are required.

### What you can scrape

- Store identity: name, Glovo store ID, slug, category, fiscal name, images, and description
- Ratings: rating value, rating count, and rating label
- Availability: open/closed status, enabled status, scheduling, and next opening time
- Delivery: delivery fee, service fee, strategy type, cash support, and Prime availability
- Location: address, city code, distance, phone number, and contact phone
- Promotions: promotion title, type, description, amount, and minimum basket size
- Business details: opening hours, legal name, headquarters address, and tax ID when available
- Classification: tags, filters, food flag, and supported store features

### Ways to run the scraper

#### 1. Scrape one Glovo store URL

Paste a Glovo store link. The Actor resolves the city, coordinates, and store ID automatically.

```json
{
  "url": "https://glovoapp.com/it/it/genova/stores/bowls-e-tartare-gen"
}
```

#### 2. Discover stores in a city

Provide a city and enable discovery mode to find nearby Glovo stores before scraping them.

```json
{
  "cityName": "Barcelona",
  "discoverMode": true,
  "maxDiscoveryStores": 100,
  "includeInfoScreen": true
}
```

Set `maxDiscoveryStores` to `0` to process every discovered store.

#### 3. Scrape known store IDs

Use numeric Glovo store IDs directly when you already know them.

```json
{
  "storeIds": ["534401", "3214"],
  "includeInfoScreen": true,
  "maxConcurrency": 5
}
```

### Input options

| Field | Type | Description |
| --- | --- | --- |
| `url` | string | A Glovo store URL. Location and store identifiers are resolved automatically. |
| `cityName` | string | City to search, such as Barcelona, Genova, or Milan, Italy. Use with `discoverMode`. |
| `discoverMode` | boolean | Finds stores from the Glovo store wall before scraping. Default: `false`. |
| `storeIds` | string\[] | Numeric Glovo store IDs to scrape directly. |
| `cityCode` | string | Optional three-letter city-code override if automatic resolution fails. |
| `latitude` | number | Optional latitude override. |
| `longitude` | number | Optional longitude override. |
| `includeInfoScreen` | boolean | Adds opening hours, contact, and partner/legal information. Default: `true`. |
| `maxDiscoveryStores` | integer | Maximum discovered stores to scrape; `0` means all. |
| `maxConcurrency` | integer | Maximum simultaneous requests. Default: `5`. |

You can use any one of `url`, `cityName` with discovery mode, or `storeIds`.

### Output example

Each store is saved as one item in the default Apify dataset and can be exported as JSON, CSV, Excel, XML, or RSS.

```json
{
  "storeId": "534401",
  "scrapedAt": "2026-07-29T10:00:00.000Z",
  "name": "Example Restaurant",
  "slug": "example-restaurant-bcn",
  "category": "RESTAURANT",
  "isOpen": true,
  "openStatus": "OPEN",
  "ratingValue": 4.7,
  "ratingCount": 1250,
  "deliveryFee": 199,
  "serviceFee": 49,
  "address": "Example Street 10",
  "cityCode": "BCN",
  "promotions": [],
  "openingHours": {
    "Monday": "10:00-22:59"
  },
  "partnerInfo": {
    "legalName": "Example Restaurant S.L.",
    "hqAddress": "Example Street 10",
    "taxId": "B00000000"
  },
  "contactPhone": "+34 000 000 000"
}
```

Fields that Glovo does not provide for a store are returned as `null` or an empty list, so downstream pipelines keep a predictable schema.

### Common use cases

- Build a Glovo restaurant or grocery-store directory
- Compare ratings, delivery fees, promotions, and store availability by city
- Enrich local-business and restaurant lead lists
- Monitor opening status and delivery conditions
- Research food-delivery coverage and competitors
- Feed Glovo store data into Google Sheets, databases, BI tools, or APIs

### Performance and reliability

The Actor uses Glovo's public endpoints and does not require authentication. Start with the default concurrency of `5`; lower it if you encounter rate limiting. Discovery availability and returned fields can vary by city, store, and Glovo's current API response.

### Integrations

Run the Actor manually, on a schedule, through the Apify API, or from integrations such as Make, Zapier, webhooks, and Google Sheets. Results remain in the default dataset for convenient export and automation.

### Responsible use

Use this Actor in accordance with applicable laws and Glovo's terms. Do not collect or use data in ways that violate privacy, contractual, or regulatory obligations.

### Support

If a Glovo URL, city, or store ID does not resolve, open an issue on the Actor page and include a non-sensitive example input plus the run ID. API responses can change, and concrete examples help us investigate quickly.

# Actor input Schema

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

Paste a Glovo store URL, for example: https://glovoapp.com/it/it/genova/stores/bowls-e-tartare-gen

## `cityName` (type: `string`):

Enter a city name, for example Barcelona, Genova, or Milan, Italy.

## `discoverMode` (type: `boolean`):

Enable this to find stores for the city above before scraping them. Leave it off when using a store URL or store IDs.

## `storeIds` (type: `array`):

Add one numeric store ID per item, for example 534401. Each store is scraped directly.

## `cityCode` (type: `string`):

Enter Glovo's three-letter city code, for example BCN, MAD, GEN, or MIL.

## `latitude` (type: `number`):

Enter the delivery latitude. Use it together with longitude only when automatic location resolution is unavailable or incorrect.

## `longitude` (type: `number`):

Enter the delivery longitude. Use it together with latitude only when automatic location resolution is unavailable or incorrect.

## `includeInfoScreen` (type: `boolean`):

Fetch opening hours, contact details, and legal information for each store. This makes one extra request per store.

## `maxDiscoveryStores` (type: `integer`):

Set the number of discovered stores to scrape. Use 0 to scrape every discovered store.

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

Set how many stores to process in parallel. Lower this value if Glovo rate-limits requests.

## `session` (type: `object`):

Provide Glovo Perseus session and client identifiers only when needed.

## Actor input object example

```json
{
  "discoverMode": false,
  "includeInfoScreen": true,
  "maxDiscoveryStores": 0,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `storeRecords` (type: `string`):

One normalized Glovo store record per requested or discovered store, including store details, availability, fees, ratings, promotions, and optional extended information. Records with failed requests include an error object.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/glovo-store-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/glovo-store-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 '{}' |
apify call epicscrapers/glovo-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/UhaoxVQx5Wb7R0q91/builds/WKv5Ck0FE9t9oKUQL/openapi.json