Glovo Scraper – Restaurant & Store Data Extractor

Glovo Store Scraper: every restaurant and shop in a city, with phone, legal name and tax ID

Glovo Store Scraper turns Glovo into a lead list and a market map. Name a city and it finds every store Glovo delivers from there, not just the first page: restaurants, supermarkets, pharmacies and shops. Each store comes back as one row with its address, phone number, legal company name, tax ID, opening hours, rating, delivery and service fees, open status and live promotions.

Built for sales teams that sell to restaurants and shops (POS, payments, delivery software, food and packaging suppliers, agencies), delivery platforms mapping their competitors' merchants, market analysts, and AI agents that need Glovo data as a tool.

• The whole city, not one page. Glovo shows any one address only the stores that deliver there, so a single search tops out at a few hundred stores. This Actor searches a grid of locations across Glovo's own delivery area for the city and merges the results: about 4,000 stores for Madrid, 2,700 for Lisbon, 300 for Genoa.
• Ready for outreach. contactPhone, partnerInfo.legalName, partnerInfo.taxId and partnerInfo.hqAddress from the store's legal info. In a 4,051-store Madrid run, 99.9% of stores had a legal name and tax ID, 99.5% a phone number and 100% opening hours. The tax ID lets you match a store to a company and group chains.
• Many cities in one run. List Madrid, Barcelona, Valencia and Milan and get one dataset, city after city.
• Only the stores you sell to. Pick categories (food, groceries, pharmacy, shops) and pay only for those: Madrid's pharmacies are 27 stores, not 4,051.
• Bulk store links. Paste hundreds of Glovo store URLs from any mix of cities. Each one is read for its own city.
• Reliable at volume. Requests are spread over many proxy IPs and paced under Glovo's rate limit. A blocked IP is replaced at once, and a request that keeps failing moves to residential IPs. The Madrid run made 9,067 requests and ended with 0 failed stores. Each run saves a coverage report and request stats so you can check what it found.
• Pay per store, no login. $1 per 1,000 stores plus Apify's start fee. No Glovo account, cookies or proxy setup. Export to JSON, CSV, Excel or Google Sheets.

Scope: This Actor returns one row per store. It does not return menus or product prices.

Contents

• What can you do with it? · How it compares · Quick start
• Ways to run it · Input reference · How city discovery works
• Run at scale · Use through the Apify API · Use it from AI agents (MCP)
• Output · Track stores over time · Cost · FAQ

What can you do with it?

Goal	How
Build a lead list of restaurants	Enter a city. Keep name, contactPhone, address, partnerInfo.legalName, partnerInfo.taxId and filters.
Sell to pharmacies or supermarkets only	Set categories to ["pharmacy"] or ["groceries"]. Only those stores are read and charged.
Size a market	Discover several cities and count stores per category, cuisine (filters) and city.
Find the busiest stores to pitch	Sort by ratingCount: stores with thousands of ratings take the most orders.
Map a competitor's merchants	Discover a city and keep the stores with primeAvailable, active promotions or a low deliveryFee.
Group chains and franchisees	Group rows by partnerInfo.taxId or partnerInfo.legalName: one company, many outlets.
Enrich a list of Glovo links you have	Paste them into Glovo store URLs. Stores from different cities can be mixed.
Monitor fees and promotions	Schedule the same input daily and compare deliveryFee, serviceFee and promotions per storeId.
Spot new and closed stores	Schedule a weekly city run and compare storeIds; watch isOpen, openStatus and closedStatusMessage.
Give an AI agent Glovo data	Connect the Apify MCP server with this Actor as a tool. See AI agents.

How it compares

What you need	Glovo Store Scraper	Category-page Glovo scrapers	Glovo app or website
Stores in a big city	Whole delivery area: ~4,000 in Madrid	One search point: ~50 per category	What delivers to your address
Phone, legal name, tax ID, HQ	Yes, 99.5–99.9% of stores in Madrid	Rarely	One store at a time
Opening hours	Yes, including split shifts	Rarely	One store at a time
Several cities in one run	Yes	Usually one per run	No
Coverage report	Locations searched and stores found per city and category	No	No
Menus and product prices	No	Often	Yes

Quick start

1. Click Try for free and sign in to Apify.
2. Add a city under Cities, for example Valencia. The example store URL in the form is ignored when a city is set.
3. Click Start. The Actor finds the city's stores, then reads each one.
4. Open the Output tab and export the data.

{
    "cities": ["Valencia"]
}

Genoa's ~300 stores take about a minute; Madrid's ~4,000 took 6.5 minutes in our test.

Ways to run it

Every store in a city

{
    "cities": ["Barcelona"],
    "includeInfoScreen": true
}

Use the name of the city or a Glovo city link (https://glovoapp.com/es/es/barcelona). Smaller towns are served by a nearby Glovo city; for example, Albufeira is part of Portimão.

Only some categories

{
    "cities": ["Madrid", "Lisboa"],
    "categories": ["pharmacy", "groceries"]
}

Discovery then reads only those store lists, so the run is faster and you pay only for those stores. pharmacy covers both of Glovo's pharmacy categories ("Pharmacy & Beauty" and "Parapharmacy & Beauty", depending on the country). The filter applies to discovered cities, not to store URLs or IDs you list yourself.

Several cities in one run

{
    "cities": ["Madrid", "Valencia", "Sevilla", "Milan, Italy"],
    "maxDiscoveryStores": 0
}

Cities are discovered and scraped one after another, so the first city's rows arrive while the next one is still being searched. A city that can't be found is skipped and named in the run's status message.

A list of store links

{
    "storeUrls": [
        "https://glovoapp.com/es/es/madrid/stores/carrefour-madrid",
        "https://glovoapp.com/it/it/genova/stores/bowls-e-tartare-gen",
        "https://glovoapp.com/pt/pt/lisboa/stores/burger-king-lis"
    ]
}

Store IDs you already know

{
    "storeIds": ["534401", "68474"],
    "cityCode": "GEN"
}

All IDs must be in one city: Glovo only returns a store for its own city. Set cityCode, or list that one city in cities.

Input reference

Field	Type	Default	Effect
storeUrls	Array of strings	Example store	One or more Glovo store or city URLs, from any cities. One store is a one-item list.
cities	Array of strings	Empty	Cities to discover, such as Barcelona or Milan, Italy. One city is a one-item list. With store IDs, the one city those IDs are in.
categories	Array of strings	All	Only discover these categories: food, groceries, pharmacy, shops, other (tobacco, alcohol and other city-specific ones).
discoverMode	Boolean	false	Discover the city of cityCode and latitude/longitude when no city is listed.
storeIds	Array of strings	Empty	Numeric Glovo store IDs, all in one city.
cityCode	String	Empty	Three-letter Glovo city code, such as BCN. Needed for store IDs unless their city is listed in cities.
latitude/longitude	Number	Empty	Override the city's location. Rarely needed.
includeInfoScreen	Boolean	true	Adds opening hours, contact phone, legal name, tax ID and HQ address. One extra request per store, no extra charge.
maxDiscoveryStores	Integer	0	Stop each city after this many stores. 0 scrapes every store.
maxConcurrency	Integer	10	Stores and locations processed in parallel (1–25). Requests use twice as many proxy IPs.
proxyConfiguration	Object	Apify Proxy	The IPs requests go through. Datacenter is enough; residential is used automatically as a fallback when available.

When you enter a city, the example store URL that the form fills in is ignored, so you don't need to clear it.

How city discovery works

1. The city is looked up on Glovo, which returns its delivery area as a set of map polygons.
2. A grid of locations about 3.3 km apart is laid over that area. For each location, the Actor reads Glovo's full store list for every category (Food, Groceries, Shops, Pharmacy and the others the city offers), page by page, until Glovo's own total is reached.
3. Where a location still found new stores, the grid gets finer (1.7 km, then 0.8 km). A sample of the finer locations is checked first, and the rest are only searched if the sample finds enough new stores.
4. Each store is then read with the location where it was found, so its fees, status and distance are those of a real delivery address in its area.

In Madrid, the first grid of 44 locations found 4,043 stores. Searching every location of the finer grid added only 23 more (0.6%), which is why the finer grid is sampled first.

Each run saves a coverage report in the DISCOVERY_SUMMARY record of its key-value store: locations searched per grid level, stores found per category, requests made, and whether a store limit stopped the search.

Run at scale

• Long country sweeps. The default run timeout is 6 hours, enough for dozens of large cities. For a whole country, split the cities over a few runs or tasks so a failed run is quick to redo.
• Big cities take minutes, not hours. The work runs in parallel over many proxy IPs. A full Madrid run (4,051 stores with extended info) took 6.5 minutes: about 1.5 minutes to search the city and 5 to read the stores. Raise maxConcurrency (up to 25) for faster runs.
• Cap the cost. categories limits discovery to the store types you need, and maxDiscoveryStores stops each city after a number of stores. You can also set Maximum cost per run in the run options (maxTotalChargeUsd in the API).
• Errors don't stop the run. A store that can't be read still gets a row with an error object, and a city or URL that can't be resolved is named in the status message. Requests that hit Glovo's rate limit are retried on another IP.
• Check the run. DISCOVERY_SUMMARY has the coverage per city, and REQUEST_STATS has requests and blocked IPs per proxy tier.
• Join runs on storeId. It is stable across runs; scrapedAt says when each row was read.

Use through the Apify API

Run a small job and get the rows back in one request (synchronous runs time out after 5 minutes, so use it for store lists, not whole cities):

curl "https://api.apify.com/v2/acts/epicscrapers~glovo-store-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"storeUrls": ["https://glovoapp.com/es/es/madrid/stores/carrefour-madrid"]}'

For whole cities, start the run, wait for it, and read the rows and the coverage report:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('epicscrapers/glovo-store-scraper').call({ cities: ['Madrid', 'Valencia'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const coverage = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('DISCOVERY_SUMMARY');
for (const city of coverage.value) console.log(city.city, city.storesFound, city.storesPerCategory);

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("epicscrapers/glovo-store-scraper").call(run_input={"cities": ["Madrid", "Valencia"]})
stores = client.dataset(run["defaultDatasetId"]).list_items().items
coverage = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("DISCOVERY_SUMMARY")["value"]

Use it from AI agents (MCP)

AI assistants and agents (Claude, ChatGPT, Cursor, VS Code, n8n and anything that speaks the Model Context Protocol) can call this Actor as a tool through the Apify MCP server. The agent asks for a city or a list of stores, the Actor returns the rows, and the agent answers with them.

Connect

Hosted server (OAuth sign-in, or an Authorization: Bearer YOUR_APIFY_TOKEN header), with this Actor and the storage tools enabled:

https://mcp.apify.com?tools=epicscrapers/glovo-store-scraper,storage

Claude Code:

claude mcp add --transport http apify "https://mcp.apify.com?tools=epicscrapers/glovo-store-scraper,storage" \
  --header "Authorization: Bearer YOUR_APIFY_TOKEN"

Claude Desktop, Cursor and other clients with a JSON config (runs the server locally):

{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": ["-y", "@apify/actors-mcp-server", "--tools", "epicscrapers/glovo-store-scraper,storage"],
            "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
        }
    }
}

The Actor shows up as the tool epicscrapers-slash-glovo-store-scraper, with this page's input schema as its parameters.

What to ask

• "Find every sushi restaurant on Glovo in Valencia with a rating count above 500. Give me name, phone, legal name and address."
• "How many supermarkets and pharmacies does Glovo list in Lisbon and Porto? Break it down by city."
• "Here are 30 Glovo store links from my CRM. Add the phone number, opening hours and tax ID for each."
• "Which companies run more than three restaurants on Glovo in Madrid? Group the stores by tax ID."

Notes for agent builders

• Smallest useful call: {"storeUrls": ["<store url>"]} for one store, or {"cities": ["<city>"], "maxDiscoveryStores": 50} for a quick sample of a city. A whole big city is thousands of rows; give the agent maxDiscoveryStores or a budget instead of letting it pull everything into its context.
• Filter categories before the run, the rest after. Set categories (for example ["pharmacy"]) so only those stores are read. Cuisine (filters), ratingCount and promotions are filtered on the rows afterwards.
• One call for many stores. Pass every link in one storeUrls array instead of one call per store.
• Where the extra answers are. Per-city counts and coverage are in the DISCOVERY_SUMMARY record of the run's key-value store; with the storage tools enabled the agent can read it without loading every row.
• Empty is not an error. An unknown city or URL ends the run successfully with a status message that says why. Retry with the city's Glovo spelling or a nearby larger city.
• Set a budget. Give the agent a maxTotalChargeUsd per run; 1,000 stores cost about $1.

Output

One row per store. Export as JSON, CSV, Excel, XML or HTML. A real row from a Madrid run (two of its three promotions shown):

{
    "storeId": "2180",
    "scrapedAt": "2026-10-16T21:41:15.162Z",
    "error": null,
    "name": "VIPS",
    "slug": "vips-madrid1",
    "storeUrl": "https://glovoapp.com/en/es/mad/stores/vips-madrid1",
    "category": "RESTAURANT",
    "isOpen": true,
    "openStatus": "OPEN",
    "ratingCount": 167,
    "ratingCardLabel": "95%",
    "deliveryFee": 3.5,
    "serviceFee": 3.5,
    "primeAvailable": false,
    "cashSupported": true,
    "address": "Calle de Méndez Álvaro, 72, 28045 Madrid, España",
    "cityCode": "MAD",
    "countryCode": "ES",
    "distance": "3.1km",
    "phoneNumber": "+34912752113",
    "contactPhone": "+34912752113",
    "partnerInfo": {
        "legalName": "SIGLA S.A.",
        "hqAddress": "Calle de Méndez Álvaro, 72, 28045 Madrid, España",
        "taxId": "A28308484"
    },
    "openingHours": {
        "Monday": "8:00-23:00",
        "Tuesday": "8:00-23:00",
        "Wednesday": "8:00-23:00",
        "Thursday": "8:00-23:00",
        "Friday": "8:00-23:59",
        "Saturday": "9:00-23:59",
        "Sunday": "9:00-23:00"
    },
    "filters": [
        {
            "id": 34835,
            "name": "American",
            "slug": "american"
        },
        {
            "id": 34789,
            "name": "Burgers",
            "slug": "burgers"
        },
        {
            "id": 34819,
            "name": "Sandwich",
            "slug": "sandwich"
        }
    ],
    "promotions": [
        {
            "title": "2 for 1",
            "type": "TWO_FOR_ONE",
            "description": "select items",
            "minimumBasketSizeCents": 0,
            "amountCents": null,
            "promoId": "2004333862"
        },
        {
            "title": "-30%",
            "type": "PERCENTAGE_DISCOUNT",
            "description": "select items",
            "minimumBasketSizeCents": 0,
            "amountCents": null,
            "promoId": "1757396198"
        }
    ]
}

Rows also have internalId, urn, fiscalName, imageUrl, logoImageUrl, isEnabled, isGhostStore, disabledStatus, schedulingEnabled, schedulingPossible, scheduleMessage, closedStatusMessage, nextOpeningTime, lastOrderingTime, ratingValue, deliveryFeeStyle, strategyType, deliveryNotAvailable, deliveryNotAvailableMessage, isFood, cutleryRequestAllowed, allergiesInformationAllowed, description and tags.

Field group	Fields
Identity	storeId, name, slug, storeUrl, category, cityCode, countryCode, fiscalName, urn, internalId, imageUrl, logoImageUrl
Contact & legal	address, contactPhone, phoneNumber, partnerInfo.legalName, partnerInfo.taxId, partnerInfo.hqAddress
Hours & status	openingHours, isOpen, openStatus, closedStatusMessage, nextOpeningTime, lastOrderingTime, isEnabled, disabledStatus, isGhostStore
Reputation	ratingCardLabel, ratingCount, ratingValue
Fees & delivery	deliveryFee, deliveryFeeStyle, serviceFee, distance, strategyType, deliveryNotAvailable, cashSupported, primeAvailable, schedulingEnabled
Offers & tags	promotions (title, type, description, minimumBasketSizeCents, amountCents, promoId), filters (cuisines), tags, description, isFood
Run	scrapedAt, error

Notes on fields

• contactPhone is the store's contact number from its info screen. phoneNumber is the number in the store details; they are often the same.
• partnerInfo is the legal entity behind the store: legalName, taxId (NIF, partita IVA, NIP and so on) and hqAddress. Sole traders' details may be personal data; see the FAQ.
• openingHours looks like { "Monday": "11:00-14:59 & 18:00-23:59", "Tuesday": "Closed" }.
• deliveryFee and serviceFee are numbers in the local currency; countryCode tells you which. They depend on the delivery location, which for discovered stores is the grid location where the store was found.
• ratingCardLabel is the label Glovo shows, such as 86%. ratingCount is the number of ratings, null for stores without enough ratings yet.
• distance is Glovo's text, such as 1.9km, from the delivery location used.
• A store whose details can't be read has error set and most fields null. If only the extended info fails, the row keeps its details and error says what failed.
• Missing values are null or an empty list.

Track Glovo stores over time with scheduled runs

Fees, promotions and opening status change daily, and stores join and leave Glovo every week. Apify can run the same input on a schedule and send the results wherever you need them.

1. Save your input as a task

Open the Actor, set your input, then click Save as a new task. A task is a saved input you can run again with one click or on a schedule.

2. Schedule the task

In Apify Console, go to Schedules, click Create new, choose how often to run (for example daily at 06:00 in your time zone), and add your task. See Schedules and How to create a schedule.

Watch how to schedule an Actor:

Or schedule a saved task:

Common schedules:

Use case	Frequency	Cron expression
Delivery fee and promotion tracking	Daily	0 6 * * *
New and closed stores in a city	Weekly (Monday)	0 6 * * 1
Refresh a lead list	Monthly	0 6 1 * *

3. Send the results to a spreadsheet or CRM

Connect Google in the task's Integrations tab to save every run to Google Sheets or Google Drive automatically, or use Make, Zapier, n8n or a webhook to push rows into your CRM:

4. Compare runs

Every row has storeId and scrapedAt, so runs are easy to join:

• New stores: storeIds that appear for the first time; gone stores: storeIds that no longer appear.
• Fee changes: deliveryFee and serviceFee per storeId.
• Promotions: new or ended entries in promotions, by promoId.
• Reputation: ratingCount and ratingCardLabel over time.
• Availability: isOpen, openStatus and closedStatusMessage per storeId.

Cost

This Actor uses pay-per-event pricing, with no subscription and no proxy bill:

Event	Price	Charged when
Actor start	$0.005	A run starts. One event per GB of memory, at least one.
Result (default item)	$0.001	A store row is saved to the dataset ($1 per 1,000).

Example runs at the default 1 GB of memory:

Run	Cost
1 store	$0.006
Genoa, every store (~300)	$0.31
Madrid, every store (4,051)	$4.06

Searching the city, extended info and proxies are included. The Pricing tab always shows the current prices.

FAQ

Does it really get every store in a city?

It gets every store Glovo lists for the delivery locations it searches, and it searches Glovo's whole delivery area for the city until extra locations stop finding new stores. Stores that are temporarily hidden by Glovo (for example disabled for the day) can be missing from a run and appear in the next one. The DISCOVERY_SUMMARY record shows what was searched.

My city isn't found. What now?

Glovo groups smaller towns under a nearby city (Albufeira is part of Portimão). Try the larger city, add the country (Valencia, Spain), or use a Glovo city link from the website. The status message says why a city wasn't found.

Why do fees and status differ from the app?

Fees, status and promotions depend on the delivery address and the time of day. Each discovered store is read at a location inside its delivery area, which may not be your address.

Why are opening hours or legal details empty for a store?

They come from Glovo's store info screen. Check that includeInfoScreen is on and read the row's error. A few stores have no legal details on Glovo.

Do I need an account, cookies or proxies?

No. The Actor reads Glovo's public data without logging in, and proxies are included.

Is it legal to scrape Glovo?

The Actor collects publicly visible business data. You are responsible for how you use it, including Glovo's terms and laws such as GDPR. Phone numbers, addresses and tax IDs of sole traders can be personal data; check the rules for cold outreach in your country before contacting them.

Support

Report problems or request features in the Issues tab. Include the run ID and a non-sensitive example input. Glovo's responses can change, and a concrete example helps us fix issues quickly.

This Actor is not affiliated with or endorsed by Glovo. "Glovo" is a trademark of its owner.