# Glovo Store & Restaurant Finder (`axlymxp/glovo-store-finder`) Actor

Build a directory of Glovo merchants — restaurants, supermarkets, shops and pharmacies — with ratings, delivery and service fees, address, phone number, category and open status, for any delivery location. Bulk store URLs or automatic city discovery.

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

## Pricing

from $4.00 / 1,000 dataset items

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 & Restaurant Finder

Build a clean **directory of Glovo merchants** — restaurants, supermarkets, shops
and pharmacies — for any city or delivery point. Paste a list of store URLs, or
let the actor **discover merchants automatically** from Glovo's public sitemap by
country and city. Each store comes back as one structured row with **rating,
delivery & service fees, address, phone number, category and open status**.

Because a store is only returned if it actually serves your coordinates, every
row is a real, serviceable merchant for that location.

### Why this finder

- **Merchant contacts, not just menus** — address and **phone number** for every store, ideal for lead generation and outreach.
- **Two ways to build a list** — resolve store URLs you already have, or auto-discover a whole city from the sitemap.
- **Delivery economics** — service fee, delivery fee and currency for fee benchmarking across merchants and cities.
- **Reliable & self-contained** — talks to Glovo's public JSON API directly. No browser, no login, no unblocking subscription, no CAPTCHA.

### Who it's for

- **Lead generation & agencies** — merchant phone numbers, addresses and categories by city for sales pipelines.
- **Market analysts / competitive intelligence** — map which merchants are on Glovo where; benchmark delivery/service fees and ratings.
- **FMCG & retail strategy** — measure retailer coverage and penetration across cities and countries.

### What you get (output fields)

| Field                                                   | Description                                  |
| ------------------------------------------------------- | -------------------------------------------- |
| `name`, `slug`, `category`, `category_id`               | Merchant identity & type                     |
| `rating`, `rating_count`                                | Store rating and number of ratings           |
| `service_fee`, `delivery_fee`, `currency`               | Delivery economics                           |
| `address`, `phone_number`, `distance`                   | Contact & location                           |
| `is_open`, `closed_status_message`, `next_opening_time` | Availability                                 |
| `on_promotion`, `promotion_count`, `promotions`         | Active store promotions (e.g. free delivery) |
| `is_food`, `marketplace`, `image_id`                    | Merchant flags & imagery                     |
| `city_code`, `store_url`                                | Context & source                             |
| `query_latitude`, `query_longitude`, `location_label`   | Delivery point resolved for                  |
| `store_id`, `urn`, `scraped_at`                         | Identifiers & provenance                     |

### Use cases

- **Lead lists** — export merchant name, phone and address by city for B2B outreach.
- **Coverage mapping** — see which supermarkets, chains or restaurants operate on Glovo in a market.
- **Fee benchmarking** — compare delivery and service fees across merchants and cities.
- **Rating analysis** — snapshot rating distribution across a city's merchants.

### Input

| Field                | Type    | Description                                                                           |
| -------------------- | ------- | ------------------------------------------------------------------------------------- |
| `storeUrls`          | array   | Store URLs or bare slugs to resolve.                                                  |
| `sitemapCountry`     | string  | Optional ISO country code (e.g. `ES`) to auto-discover merchants from the sitemap.    |
| `sitemapCityFilter`  | array   | Optional city slugs to keep during discovery (e.g. `madrid`, `barcelona`).            |
| `locations`          | array   | Delivery points. Each item: `label` + `latitude`/`longitude`, or a `location` string. |
| `maxStores`          | integer | Cap on candidate stores resolved per location. Default 200.                           |
| `maxItems`           | integer | Global cap on rows. Default 1000.                                                     |
| `language`           | string  | Content language. Default `en`.                                                       |
| `proxyConfiguration` | object  | Optional. The API is not IP-gated.                                                    |

#### Example input

```json
{
    "sitemapCountry": "ES",
    "sitemapCityFilter": ["madrid"],
    "locations": [
        {
            "label": "Madrid - Centro",
            "latitude": 40.4168,
            "longitude": -3.7038
        }
    ],
    "maxStores": 100,
    "maxItems": 100
}
```

#### Example output row

```json
{
    "store_id": 107,
    "name": "Carrefour",
    "slug": "carrefour-madrid",
    "category": "SUPER-MARKET",
    "rating": "89%",
    "rating_count": 30,
    "service_fee": 1.99,
    "delivery_fee": 1.99,
    "currency": "EUR",
    "is_open": false,
    "address": "Calle de Juan Álvarez Mendizábal 64\n28008 Madrid\nEspaña",
    "phone_number": "+34689345490",
    "distance": "200m",
    "on_promotion": true,
    "promotion_count": 1,
    "city_code": "MAD",
    "location_label": "Madrid - Centro",
    "scraped_at": "2026-08-01T09:00:00Z"
}
```

### Scheduling & integration

Run on a **schedule** to keep a merchant directory fresh, or trigger via
**webhook** or the Apify API. Results export to JSON, CSV, Excel, or push straight
to your CRM or database through Apify integrations (Make, Zapier, Google Sheets,
S3, and more).

### AI assistants (MCP)

Call this actor from AI assistants (Claude, Cursor, ChatGPT) through the Apify MCP
integration — hand it a city and coordinates and get a structured merchant list
back as a tool result.

### FAQ

**How do I discover a whole city?** Set `sitemapCountry` (e.g. `ES`) and add the
city slug to `sitemapCityFilter` (e.g. `madrid`), then set `locations` to
coordinates inside that city. The actor walks the sitemap and resolves each
merchant for your point.

**Why do some stores not appear?** A store is only returned if it serves your
coordinates. Merchants outside the delivery range of your point are skipped — move
the coordinates into the area you want to map.

**Do I get phone numbers?** Yes — Glovo exposes a contact phone and address for
each store, which this actor returns.

**How fresh is the data?** Every run fetches live merchant data at request time,
including current open status and fees.

**Do I need proxies or a login?** No. The actor uses Glovo's public JSON API
directly — no login, no unblocking subscription, no CAPTCHA.

**Is scraping this legal?** You are responsible for how you use the data. Scrape
publicly available information and comply with Glovo's terms and applicable law.

# Actor input Schema

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

Merchants to resolve. Paste full Glovo store URLs or bare store slugs (e.g. carrefour-madrid). Each is resolved for every delivery location below and returned as one directory row.

## `sitemapCountry` (type: `string`):

Optional. ISO country code (e.g. ES, IT, PL) to automatically discover merchants from Glovo's public store sitemap. Combine with 'City filter' to focus on specific cities. Leave empty to only use the store URLs above.

## `sitemapCityFilter` (type: `array`):

Optional. City slugs to keep when discovering by country (e.g. madrid, barcelona). The slug is the city segment of a Glovo store URL. Leave empty to include every city in the country.

## `locations` (type: `array`):

One or more delivery points to resolve merchants for. Each item is an object with an optional 'label' and either 'latitude'+'longitude' or a 'location' string (a known city name or 'lat,lng'). A store is only returned if it serves the given point, so match your coordinates to the city you are mapping.

## `maxStores` (type: `integer`):

Cap on how many candidate stores are resolved per location (each is one lookup). Bounds cost/time when discovering a whole city from the sitemap.

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

Global cap across all locations. The run stops once this many store rows are pushed.

## `language` (type: `string`):

Language code for names/labels (e.g. en, es, it, pt, pl).

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

Optional. The Glovo API is not IP-gated, so proxies are usually unnecessary.

## Actor input object example

```json
{
  "storeUrls": [
    "carrefour-madrid",
    "https://glovoapp.com/es/en/madrid/mercadona-madrid/"
  ],
  "sitemapCountry": "ES",
  "sitemapCityFilter": [
    "madrid",
    "barcelona"
  ],
  "locations": [
    {
      "label": "Madrid",
      "latitude": 40.4168,
      "longitude": -3.7038
    }
  ],
  "maxStores": 200,
  "maxItems": 1000,
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "storeUrls": [
        "carrefour-madrid",
        "100-montaditos-madrid",
        "mcdonalds-gran-via-madrid"
    ],
    "locations": [
        {
            "label": "Madrid - Centro",
            "latitude": 40.4168,
            "longitude": -3.7038
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/glovo-store-finder").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 = {
    "storeUrls": [
        "carrefour-madrid",
        "100-montaditos-madrid",
        "mcdonalds-gran-via-madrid",
    ],
    "locations": [{
            "label": "Madrid - Centro",
            "latitude": 40.4168,
            "longitude": -3.7038,
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/glovo-store-finder").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 '{
  "storeUrls": [
    "carrefour-madrid",
    "100-montaditos-madrid",
    "mcdonalds-gran-via-madrid"
  ],
  "locations": [
    {
      "label": "Madrid - Centro",
      "latitude": 40.4168,
      "longitude": -3.7038
    }
  ]
}' |
apify call axlymxp/glovo-store-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hcV4wckWp4iYWePWt/builds/IDA4mbBFB0WcVZ8K3/openapi.json