# Glovo Scraper — Restaurants, Supermarkets, Shops (`gooyer.co/glovo-scraper`) Actor Scrape any Glovo URL in any country — restaurant menus with every dish + price, and full 360° catalog for supermarkets, shops, and pharmacies (every SKU, not just featured carousels). Browser-free, public JSON API. Per-event billing — pay for what you scrape. - **URL**: https://apify.com/gooyer.co/glovo-scraper.md - **Developed by:** [Gooyer](https://apify.com/gooyer.co) (community) - **Categories:** E-commerce, Developer tools, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks - **User rating**: No ratings yet ## Pricing from $0.50 / 1,000 category store 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 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 Scraper Pull structured data from any Glovo URL — restaurant menus, supermarket catalogs, shop listings, pharmacy lineups — in any of the 25+ countries Glovo operates in. Built for competitive price intelligence, grocery-retail market research, food-delivery analytics, and anyone who needs Glovo data at volume without babysitting a browser. This is the only scraper on the Apify Store with **full 360° supermarket coverage**. Competitors stop at Glovo's featured-carousels landing page (~40 products per store). This one recursively walks Glovo's own content-node API and returns **every SKU** — verified: **1,299 products from SuperGlovo Madrid in 42 seconds**. ### What you can scrape Paste any of these URL types into **Start URLs** — the scraper classifies each one and runs the right handler: | URL shape | What you get | | ------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `glovoapp.com////categories/` | One record per store in the category — name, slug, PDP URL, rating + review count, "Top Rated" flag, promo badges, Prime flag, delivery fee, open/closed state | | `glovoapp.com////stores/` (restaurant) | One record with the full menu — every section with every dish, price + original price (if discounted), tags, description, image, plus store-level rating, delivery fee, min-order info, promo badges | | `glovoapp.com////stores/` (supermarket / shop / pharmacy) | One record with the **full catalog** — every SKU with `externalId`, name, price, original price, currency, image, EAN barcode, category UUID, collection group, promotion type + promoId, sponsored flag, out-of-stock flag | The same scraper works in every country Glovo operates — Spain, Portugal, Italy, France, Morocco, Georgia, Ukraine, Armenia, Bulgaria, Romania, Poland, Czech Republic, Serbia, Croatia, Bosnia, Kazakhstan, Kyrgyzstan, and more. Paste a URL with any language prefix (`/en`, `/fr`, `/es`, `/pl`...) and it routes correctly. ### Optional enrichments - **`storePage`** — on a `/categories/` URL, enqueue each store as a full PDP scrape so you get menu/catalog data in the same run - **`shopCatalogDepth`** (default `2`) — how deep to walk Glovo's category tree on supermarket + shop PDPs. `0` = featured carousels only (~40 products). `1–2` = expanded collections (~200–1,500 products — recommended default). `3–5` = exhaustive. Deeper = more HTTP calls = higher cost. - **`menuItems`** — emit one flat dataset row per individual product (in addition to the nested per-store row). Useful for BI tools that prefer flat tables. Bills at `$0.0001` per product. Defaults are conservative. A run without enrichments stays on the commodity rate. ### Why this scraper beats the alternative | Alternative | Where it falls short | | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **The existing Glovo scraper on Apify** | No reviews. No published benchmarks. Generic `$0.003-per-result` pricing means a single restaurant menu with 71 dishes costs **$0.22** — this scraper costs **$0.023** for the same menu (nested, one row). On supermarkets the gap is larger: their flat-per-result model bills $0.003 per product × 1,300+ products = **$3.90+**. This scraper nests the full catalog in one row and bills the API walk per-call — total **$0.072** for the same SuperGlovo Madrid crawl. **~54× cheaper on a real supermarket, ~10× cheaper on a restaurant.** | | **Glovo Partner API** | Invite-only. Requires a business relationship with Glovo. Partners get delivery-partner access, not market-research access. | | **Browser-based scrapers** | 3–10× slower per store, 2–3× more expensive to run, fragile against Glovo's React hydration model (Next.js App Router with streamed RSC chunks). | | **DIY from scratch** | You'd need to reverse-engineer Glovo's `/v4/stores//addresses//content/main` content-node API, discover that the root endpoint returns HTTP 400 without a `link` param (you have to seed the BFS from the SSR hydration payload), handle both `CAROUSEL` and `GRID` block types, filter out section-anchor slugs that also return 400, and bypass browser-CORS rules by calling the API server-side. This scraper does all of that. | ### Sample output — real record, trimmed From `glovoapp.com/en/es/madrid/stores/superglovo-mad` with `shopCatalogDepth: 2`: ```json { "type": "store-pdp", "url": "https://glovoapp.com/en/es/madrid/stores/superglovo-mad", "language": "en", "country": "es", "city": "madrid", "slug": "superglovo-mad", "fromCategory": "groceries_4", "fromCategoryUrl": "https://glovoapp.com/en/es/madrid/categories/groceries_4", "layout": "TILE", "storeId": "21033", "addressId": "249456", "store": { "name": "El Súper de Glovo", "rating": 0.87, "ratingCount": 500, "ratingCountCapped": true, "deliveryFee": { "label": "1,99 €", "free": false, "amount": 1.99, "currency": "EUR" }, "deliveryFeeOriginal": { "label": "1,99 €", "free": false, "amount": 1.99, "currency": "EUR" }, "promoBadges": ["-10% selection"], "primeBadges": [], "prime": true, "minOrderInfo": "Reach 10,00 € to avoid an extra fee of 1,50 €" }, "products": [ { "externalId": "LMC3AJ", "storeProductId": "LMC3AJ", "name": "Dr. Oetker Ristorante Piccola Pizza Margarita Airfryer 2u", "price": 3.95, "originalPrice": 7.9, "currency": "EUR", "imageUrl": "https://glovo.dhmedia.io/image/global-catalog-glovo/...", "tags": [], "promotion": { "type": "TWO_FOR_ONE", "title": "2 for 1", "promoId": "1333945124" }, "ean": "04001724038818", "categoryId": "fab3f3df-83a7-4c39-b27f-37b48a4bd5c0", "collectionGroupId": "52085513", "collectionGroupName": "Mega Packs", "sponsored": false, "outOfStock": false } /* ...1,298 more products, same shape */ ], "__metadata": { "scrapedAt": "2026-04-22T12:47:15.123Z", "sourceUrl": "https://glovoapp.com/en/es/madrid/stores/superglovo-mad", "recordType": "store-pdp", "storeLayout": "TILE", "productCount": 1299, "apiCallCount": 94, "shopCatalogDepth": 2, "fromCategoryUrl": "https://glovoapp.com/en/es/madrid/categories/groceries_4" } } ```` Every dataset record ships a `__metadata` sidecar so you can trace any row back to its origin — what URL scraped it, when, which record type, which rank within its parent listing, and (when the record came from a category-page enqueue) the category URL that seeded the run. This makes it trivial to join records across runs, filter by freshness, or rank menu items by their on-page position. Restaurant PDPs emit the same top-level shape with `layout: "ROW"` and a nested `menu.sections[]` tree instead of a flat `products[]`. Category-page records emit one row per store card with `type: "category-store-card"` — name, rating, rating count (with `ratingCountCapped: true` when Glovo displays "500+"), structured `deliveryFee`, promo + Prime badges. ### Pricing Per-event billing. You pay only for what you extract. | Event | Price | Fires | | ---------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `apify-actor-start` | $0.02 | Once per run | | `category-store-item` | $0.0005 | Per store card returned from a `/categories/` page | | `restaurant-pdp-item` | $0.003 | Per restaurant PDP with the full menu (all sections + dishes nested) | | `shop-pdp-item` | $0.005 | Per supermarket / shop / pharmacy PDP — store header + featured carousels from the SSR page | | `shop-collection-call` | $0.0005 | Per Glovo content-node API call made during the recursive catalog walk (only fires when `shopCatalogDepth >= 1`). Scales with the shop's category tree — typical supermarket at depth=2 fires ~90 calls; depth=5 on a large hypermarket can fire 200+ | | `restaurant-menu-item` | $0.0001 | Per dish when `menuItems: true` (flat-row mode, on top of the nested record) | | `shop-product-item` | $0.0001 | Per product when `menuItems: true` (flat-row mode, on top of the nested record) | The shop pricing is deliberately split so you pay for the depth you actually walk. A `shopCatalogDepth: 0` run (featured carousels only, no API calls) costs just $0.005 per shop. The default `shopCatalogDepth: 2` unlocks the full catalog but bills only for the work Glovo's API actually does. **Real budgets:** | Use case | Config | Cost | | -------------------------------------------------------------------------------------------- | ----------------------------------------------------------- | ----------- | | One restaurant menu (71 dishes) | 1 restaurant PDP | **$0.023** | | Full city food scan | 50 category cards + 50 restaurant PDPs | **$0.195** | | Supermarket, featured carousels only (~40 SKUs) | 1 shop PDP, `shopCatalogDepth: 0` | **$0.025** | | Full supermarket catalog (1,329 SKUs, depth=2, 94 API calls — verified on SuperGlovo Madrid) | 1 shop PDP at `shopCatalogDepth: 2` | **$0.072** | | Exhaustive hypermarket catalog (depth=5, ~250 API calls) | 1 shop PDP at `shopCatalogDepth: 5` | **~$0.15** | | Grocery-retail competitive sweep | 3 category pages + 30 shop PDPs at depth=1 (~20 calls each) | **$0.47** | | Monthly grocery-category snapshot — one city | 200 shop PDPs at `shopCatalogDepth: 2` | **~$11.40** | | Daily price-intel on 10 supermarkets (flat-row mode for BI) | 10 shop PDPs at depth=2 + 10,000 product rows | **$1.56** | Set a `maxTotalChargeUsd` cap on any run and the scraper stops cleanly once the budget lands. No surprise invoices. ### Inputs | Field | What it does | | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------- | | **startUrls** (required) | Array of Glovo URLs. Mix category and store URLs freely — they're classified automatically | | **storePage** | Enqueue a full PDP scrape for every store returned by a category URL | | **shopCatalogDepth** | How deep to walk the category tree on supermarket / shop / pharmacy PDPs (default `2`, max `5`) | | **menuItems** | Also emit one dataset row per individual product, flat (in addition to the nested per-store row) | | **proxyUrls** | Proxy configuration. **Datacenter proxy is sufficient** — Glovo has no bot defense. Residential is available but unnecessary | ### How it works - **No browser.** The scraper parses Glovo's server-rendered HTML with Cheerio and calls Glovo's own content-node JSON API directly. Roughly 5–10× faster per store than browser-based scrapers on the Apify Store. - **Layout auto-detection.** Every store PDP gets a layout probe against the HTML (`ItemRow_*` for restaurants, `ItemTile_*` for shops) and routes to the right extractor automatically. You never need to tell the scraper what kind of store you're scraping. - **Recursive catalog walk.** On supermarket, grocery, shop, and pharmacy PDPs, the scraper reads `storeId` + `addressId` from Glovo's SSR hydration payload, seeds a BFS from the SSR products already on the page, then walks category deep-links via `api.glovoapp.com/v4/stores//addresses//content/main?nodeType=DEEP_LINK&link=` up to `shopCatalogDepth` levels. Products are deduped by `externalId`. - **CSS-module-proof selectors.** Glovo's Next.js build rotates CSS module class hashes on every deploy (`ItemRow_priceContainer__G5B13` → `ItemRow_priceContainer__9pQr_`). This scraper targets via class **prefix** (`[class*="ItemRow_priceContainer"]`), so redeploys don't break extraction. - **Resilient to rate-limiting.** Each Crawlee session persists cookies through its lifetime. On HTTP 429 from the content API, the session retires and the work picks up on a fresh IP. You won't see failed requests in normal operation. ### FAQ **Does the 360° catalog walk really cover every SKU?** It walks every carousel and category deep-link the Glovo app's own navigation exposes on the store's landing, up to `shopCatalogDepth` levels. Depth `2` hit 1,299 unique SKUs on SuperGlovo Madrid during verification; depth `5` would go exhaustive. For a typical supermarket, depth `2` is ≥95% coverage. **Why is `shopCatalogDepth` capped at 5?** Each deeper layer adds ~20 HTTP calls per store on average. Depth `5` on a Mercadona or Carrefour Hyper can fire hundreds of requests. The cap is a courtesy to Glovo's infrastructure and your budget. Depth `2` is the sweet spot — full coverage without runaway costs. **What countries does this work in?** Every country Glovo operates in. URL parsing is country-agnostic: `/en/ma/tanger/stores/...`, `/es/es/madrid/stores/...`, `/fr/fr/paris/stores/...` — all work. The content-node API is regionalized via the `glovo-location-country-code` header, which the scraper sets from the URL automatically. **What's the difference between `type: "category-store-card"` and `type: "store-pdp"`?** Category-card records come from parsing a `/categories/` listing page — they're lightweight (name, rating, delivery fee, promo badges) and map 1:1 to what's visible on Glovo's store-picker grid. Store-PDP records come from scraping a single store's page and contain either the full menu (restaurants) or full catalog (shops). When you set `storePage: true`, a category-URL run emits both types to the same dataset. **Does it work on free Apify plans?** Yes. Glovo has no bot defense, so the default Apify datacenter proxy is sufficient. Free-tier accounts get $5 monthly credit — enough for ~1,000 full supermarket catalogs at depth `2`, or ~16,000 restaurant menus. **How is the data kept fresh?** Each run hits Glovo's live endpoints. No caching, no intermediate storage. A product listed five seconds before your run appears if Glovo's CDN has flushed. **Is this legal?** Only public delivery-app data — no user accounts, no private orders, no seller-only dashboards. Same public surface Glovo's own web frontend serves anonymously without login. **What if Glovo changes their API?** The scraper pins the current `glovo-app-version` string. If Glovo starts returning 403 on that version, we ship an updated pin. The `/v4/stores/.../content/main` endpoint schema has been stable through multiple Glovo frontend deploys. **How do I export the data?** Dataset → **Export** in the Apify Console. CSV, JSON, JSONL, or XLSX with one click. Programmatically, fetch `/v2/datasets/{id}/items` to stream records, or push to BigQuery, Snowflake, or S3 via Apify's built-in integrations. **Can I run this on a schedule?** Yes. Schedule the actor from the Apify Console (cron / hourly / daily). Combined with a `maxTotalChargeUsd` cap per run, you get predictable monthly spend with per-SKU granularity — useful for price-change alerting, out-of-stock monitoring, or promotion-calendar analytics. **Can I request a custom field?** Yes. Open an issue via the **Issues** tab in the Apify Console. Simple field additions usually ship within a week. ### Support Open an issue via the **Issues** tab in the Apify Console, or message the actor owner directly. ### Keywords Glovo scraper, Glovo API, Glovo data export, food delivery data, grocery retail intelligence, supermarket catalog scraper, Glovo restaurants, Glovo menus, Glovo products, Glovo prices, competitive price intelligence, grocery SKU data, EAN barcode data, food delivery market research, Glovo Spain, Glovo Morocco, quick commerce data, last-mile delivery data, Glovo JSON export, Glovo categories, Glovo supermarkets. # Actor input Schema ## `startUrls` (type: `array`): Glovo URLs to scrape. Supported shapes (any country, any city, any category): ////categories/ (e.g. /en/es/barcelona/categories/food\_1) or ////stores/ (e.g. /en/es/madrid/stores/superglovo-mad). Mix and match. ## `storePage` (type: `boolean`): When on, every store a /categories/ URL returns is queued as a /stores/ scrape for its full menu or catalog. Bills at restaurant-pdp-item ($0.003) or shop-pdp-item ($0.005) per store, in addition to category-store-item ($0.0005) for the initial hit. Leave off if you only need store-card data. ## `shopCatalogDepth` (type: `integer`): How many levels of the category tree to walk on a supermarket or shop PDP. 0 = root carousels only (~40 products, no API calls — $0.005 per shop). 2 = full catalog via ~90 API calls — recommended default (~$0.05 per shop). 3-5 = exhaustive (every SKU, 200+ API calls per store). Each API call is billed at $0.0005 via the shop-collection-call event — deeper walks cost proportionally more. ## `menuItems` (type: `boolean`): By default, each store emits one nested dataset row with its menu/products embedded. Turn on to additionally emit one flat row per product (with store data denormalized onto every row). Useful for BI tools that prefer flat tables. Bills at restaurant-menu-item or shop-product-item ($0.0001) per product. ## `proxyUrls` (type: `object`): Datacenter proxy is sufficient — Glovo has no DataDome-style defenses. Residential is available if you want belt-and-braces, but unnecessary. ## Actor input object example ```json { "startUrls": [ { "url": "https://glovoapp.com/en/es/barcelona/categories/food_1" } ], "storePage": false, "shopCatalogDepth": 2, "menuItems": false, "proxyUrls": { "useApifyProxy": true } } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "startUrls": [ { "url": "https://glovoapp.com/en/es/barcelona/categories/food_1" } ], "proxyUrls": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("gooyer.co/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "startUrls": [{ "url": "https://glovoapp.com/en/es/barcelona/categories/food_1" }], "proxyUrls": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("gooyer.co/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 '{ "startUrls": [ { "url": "https://glovoapp.com/en/es/barcelona/categories/food_1" } ], "proxyUrls": { "useApifyProxy": true } }' | apify call gooyer.co/glovo-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=gooyer.co/glovo-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Glovo Scraper — Restaurants, Supermarkets, Shops", "description": "Scrape any Glovo URL in any country — restaurant menus with every dish + price, and full 360° catalog for supermarkets, shops, and pharmacies (every SKU, not just featured carousels). Browser-free, public JSON API. Per-event billing — pay for what you scrape.", "version": "1.0", "x-build-id": "ocujxBaHb5Rk58c77" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/gooyer.co~glovo-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-gooyer.co-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/gooyer.co~glovo-scraper/runs": { "post": { "operationId": "runs-sync-gooyer.co-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/gooyer.co~glovo-scraper/run-sync": { "post": { "operationId": "run-sync-gooyer.co-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": [ "startUrls", "proxyUrls" ], "properties": { "startUrls": { "title": "Start URLs", "minItems": 1, "uniqueItems": true, "type": "array", "description": "Glovo URLs to scrape. Supported shapes (any country, any city, any category): ////categories/ (e.g. /en/es/barcelona/categories/food_1) or ////stores/ (e.g. /en/es/madrid/stores/superglovo-mad). Mix and match.", "items": { "type": "object", "required": [ "url" ], "properties": { "url": { "type": "string", "title": "URL of a web page", "format": "uri" } } } }, "storePage": { "title": "Enqueue full store PDP for every category-page hit", "type": "boolean", "description": "When on, every store a /categories/ URL returns is queued as a /stores/ scrape for its full menu or catalog. Bills at restaurant-pdp-item ($0.003) or shop-pdp-item ($0.005) per store, in addition to category-store-item ($0.0005) for the initial hit. Leave off if you only need store-card data.", "default": false }, "shopCatalogDepth": { "title": "Supermarket / shop catalog depth", "minimum": 0, "maximum": 5, "type": "integer", "description": "How many levels of the category tree to walk on a supermarket or shop PDP. 0 = root carousels only (~40 products, no API calls — $0.005 per shop). 2 = full catalog via ~90 API calls — recommended default (~$0.05 per shop). 3-5 = exhaustive (every SKU, 200+ API calls per store). Each API call is billed at $0.0005 via the shop-collection-call event — deeper walks cost proportionally more.", "default": 2 }, "menuItems": { "title": "Also emit one dataset row per product", "type": "boolean", "description": "By default, each store emits one nested dataset row with its menu/products embedded. Turn on to additionally emit one flat row per product (with store data denormalized onto every row). Useful for BI tools that prefer flat tables. Bills at restaurant-menu-item or shop-product-item ($0.0001) per product.", "default": false }, "proxyUrls": { "title": "Proxy configuration", "type": "object", "description": "Datacenter proxy is sufficient — Glovo has no DataDome-style defenses. Residential is available if you want belt-and-braces, but unnecessary." } } }, "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 } } } } } } } } } } ```