# Uber Eats Full Menu Scraper (`solidcode/ubereats-full-menu-scraper`) Actor

\[💰 $2 / 1K] Extract full Uber Eats menus — every item with price, description, photo and add-on options — plus store ratings, reviews, hours, address, cuisines and delivery fees. Scrape by store URL or discover every store around any address.

- **URL**: https://apify.com/solidcode/ubereats-full-menu-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Uber Eats Full Menu Scraper

Pull complete Uber Eats menus and store profiles at scale — every item with its price, description, photo and availability, plus ratings, review samples, opening hours, cuisines, delivery fees and ETAs. Discover stores around any street address or exact coordinates, or paste store links you already have. Built for restaurant chains, food delivery analysts, CPG brands and menu-data teams who need the whole catalog in one clean table without clicking through Uber Eats one aisle at a time.

### Why This Scraper?

- **The complete catalog, not the slice the page shows you** — a supermarket store page loads roughly 75 products in a browser. This scraper walked all 9 catalog pages of one and returned **707 unique products**, deduplicated by item ID so the "Featured items" carousel never double-counts.
- **Two record types in one dataset** — flat `store` rows and flat `menuItem` rows joined by `storeId`. The menu lands ready for Sheets, BI or SQL with no unnesting step, and the Apify Console gives each type its own tab.
- **10 live-verified languages** — English, French, Spanish, Portuguese, Dutch, German, Polish, Swedish, Japanese and Traditional Chinese, each confirmed to return genuinely localized store text and menu section names, not an English page with a flag on it.
- **7 store types, and you only pay for what you keep** — All stores, Restaurants, Grocery, Convenience, Alcohol, Pharmacy and Retail. Store types are resolved before any menu is collected: one run narrowed 97 nearby stores to 78 restaurants, and the 19 excluded stores were never collected or charged for.
- **Delivery and pickup return different data, and both are one setting away** — the same store reported a **170–185 minute** delivery ETA and an **8–18 minute** pickup ETA, with different fees and availability. Run both to compare.
- **Price analytics computed on every store row** — min, max and average item price, plus price coverage, photo coverage and customization coverage ratios, so you can rank a market without post-processing.
- **Full option trees on demand** — sizes, toppings and add-ons with their upcharges, min/max selection rules, sold-out flags and nested child options for items whose choices branch.
- **458 stores found around a single address** — discover by street address, by exact latitude/longitude, by cuisine keyword, or by pasting store links, and mix all four in one run. Duplicate links across country versions of the site collapse to one store.
- **Reviews with author, text and date, at no extra charge** — capped per store and filterable by a "since" date. Reviews arrive with the store profile, so tightening these settings never costs you anything and never slows a run down.

### Use Cases

**Competitive Menu Intelligence**

- Track a competitor's full menu, prices and photo coverage week over week
- Compare identical dishes across every location of a chain in one city
- Spot new item launches, seasonal specials and quiet delisting
- Benchmark average item price and price coverage against a whole neighborhood

**Restaurant & Delivery Analytics**

- Build a census of every store delivering to a postcode, with rating and review counts
- Measure how delivery ETAs and fees vary by time of day and by neighborhood
- Compare delivery versus pickup economics on the same set of stores
- Rank markets by store density, cuisine mix and price tier

**CPG & Retail Product Tracking**

- Pull full grocery, convenience and pharmacy catalogs — hundreds to thousands of SKUs per store
- Monitor shelf presence and pricing of your products across retail partners
- Track sold-out and unavailable flags to detect stockouts
- Capture pack sizes and sold-by-unit rules from item quantity data

**Market Expansion & Site Selection**

- Map cuisine gaps around a candidate address before signing a lease
- Size an addressable market by counting stores and menu items in a radius
- Compare the same brand's pricing across countries using localized store pages
- Identify high-rating, high-review-count operators worth partnering with

**Menu Data & Content Operations**

- Populate menu databases, food apps and recipe tools with structured item data
- Collect item photos and descriptions for catalog enrichment
- Feed nutrition, allergen or dietary tagging pipelines with clean item text
- Keep third-party listings in sync with what a store actually publishes

### Getting Started

#### Simplest — one store, full menu

```json
{
  "startUrls": ["https://www.ubereats.com/store/antons-falafel-house/GgaiuGrKTAWJ-S2dHk9EFQ"]
}
```

#### Discover restaurants around an address

```json
{
  "address": "350 5th Ave, New York",
  "storeType": "RESTAURANTS",
  "maxStores": 25,
  "maxMenuItemsPerStore": 100
}
```

#### Cheap store census — profiles only, no menus

```json
{
  "address": "Brooklyn, NY",
  "storeType": "ALL",
  "maxStores": 0,
  "maxResults": 500,
  "includeMenu": false,
  "includeReviews": true,
  "maxReviewsPerStore": 5
}
```

#### Advanced — localized grocery catalog with options and recent reviews

```json
{
  "latitude": "48.8566",
  "longitude": "2.3522",
  "searchQuery": "supermarché",
  "storeType": "GROCERY",
  "diningMode": "DELIVERY",
  "maxStores": 5,
  "maxResults": 5000,
  "includeMenu": true,
  "maxMenuItemsPerStore": 2000,
  "includeItemCustomizations": true,
  "includeReviews": true,
  "maxReviewsPerStore": 20,
  "reviewsSince": "2025-01-01",
  "language": "fr",
  "maxConcurrency": 5
}
```

### Input Reference

#### Store URLs

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | 1 sample store | Uber Eats store page links, e.g. `https://www.ubereats.com/store/name/abc123`. Works with any country version of the site. Leave empty to discover stores by address instead. |

#### Discover Stores by Location

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `address` | string | `""` | Find stores that deliver to this place, e.g. `Brooklyn, NY` or `350 5th Ave, New York`. |
| `latitude` | string | `""` | Exact latitude of the delivery point, e.g. `40.7128`. Overrides the address. Only works paired with longitude. |
| `longitude` | string | `""` | Exact longitude of the delivery point, e.g. `-74.0060`. Overrides the address. Only works paired with latitude. |
| `searchQuery` | string | `""` | Only find stores matching this cuisine or dish, e.g. `sushi`, `pizza`, `vegan`. Empty returns every store around the address. |
| `storeType` | select | `ALL` | All stores, Restaurants only, Grocery stores, Convenience stores, Alcohol, Pharmacy, or Retail. Excluded stores are never collected or charged for. |
| `diningMode` | select | `DELIVERY` | Delivery or Pickup. Prices, fees and store availability differ between the two. |
| `maxStores` | integer | `3` | How many stores to take from the address search. `0` takes every store found, up to a ceiling of 500 per run. Does not limit pasted store links. |

#### Menu

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeMenu` | boolean | `true` | Collect every menu item with price, description and photo. Turn off for a fast, cheap list of store profiles only. |
| `maxMenuItemsPerStore` | integer | `0` | Stop after this many items per store. `0` collects the complete menu, up to a ceiling of 200 catalog pages (roughly 21,000 items) per store. |
| `includeItemCustomizations` | boolean | `false` | Also collect sizes, toppings, add-ons and their extra charges. Option lookups get up to 4 minutes per store; anything still queued after that is returned without options. Makes runs substantially slower — see Tips before switching it on. |

#### Run Size Limit

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `10000` | Stop the whole run once this many results have been saved, counting store profiles and menu items together. Your spending safety net for large grocery searches. `0` means no limit. As the run approaches the limit the remaining room is shared between the stores still being collected, so the last few can return a shortened menu. |

#### Reviews

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeReviews` | boolean | `true` | Include customer review samples with each store, plus the overall rating and rating count. |
| `maxReviewsPerStore` | integer | `10` | Keep at most this many reviews per store. `0` keeps every review the store page provides. |
| `reviewsSince` | string | `""` | Skip reviews older than this date. Empty keeps all of them. |

#### Language & Speed

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `language` | select | `en` | English, French, Spanish, Portuguese, Dutch, German, Polish, Swedish, Japanese, or Chinese (Traditional). Applies to store text and menu section names. |
| `maxConcurrency` | integer | `5` | How many stores to work through at once. Lower it if you see failures; raise it for faster runs on large store lists. |

### Output

Every run produces flat rows with a `recordType` field: one `store` row per store, and one `menuItem` row per item. Both carry `storeId` and `storeUrl` so you can join them.

#### `store` rows

```json
{
  "recordType": "store",
  "storeId": "1a06a2b8-6aca-4c05-89f9-2d9d1e4f4415",
  "storeSlug": "antons-falafel-house",
  "storeUrl": "https://www.ubereats.com/store/antons-falafel-house/GgaiuGrKTAWJ-S2dHk9EFQ?diningMode=DELIVERY",
  "name": "Anton's Falafel House",
  "description": "Use your Uber account to order delivery from Anton's Falafel House.",
  "storeType": "Restaurant",
  "rating": 4.7,
  "reviewCount": 600,
  "reviewCountText": "600+",
  "priceBucket": "$",
  "priceLevel": 1,
  "cuisines": ["Mediterranean", "Middle Eastern", "Healthy"],
  "phone": "+14155550142",
  "address": {
    "street": "1901 Ocean Ave",
    "city": "San Francisco",
    "region": "CA",
    "postalCode": "94127",
    "country": "US"
  },
  "addressText": "1901 Ocean Ave, San Francisco, CA 94127",
  "latitude": 37.7264,
  "longitude": -122.4677,
  "hours": [
    { "days": "Mon - Fri", "opens": "11:00", "closes": "21:00", "menu": "Main Menu" }
  ],
  "isOpen": true,
  "isOrderable": true,
  "diningMode": "DELIVERY",
  "language": "en",
  "deliveryEtaMinutes": { "min": 20, "max": 35 },
  "deliveryFee": "$0.49 Delivery Fee",
  "imageUrl": "https://tb-static.uber.com/prod/image-proc/processed_images/hero.jpeg",
  "currencyCode": "USD",
  "menuSectionCount": 6,
  "menuItemCount": 31,
  "analytics": {
    "itemCount": 31,
    "priceCoverage": 1.0,
    "imageCoverage": 0.871,
    "customizationCoverage": 0.613,
    "minPrice": 2.5,
    "maxPrice": 18.95,
    "averagePrice": 11.42
  },
  "reviews": [
    {
      "reviewId": "5f2c1d90-3a71-4b02-9f19-77c0a0d4e881",
      "authorName": "Jessica R.",
      "text": "Best falafel in the neighborhood, always hot on arrival.",
      "createdAt": "2024-01-29T18:22:11.000Z"
    }
  ],
  "scrapedAt": "2026-07-31T13:04:22Z"
}
```

##### Store identity & ratings

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `store` for these rows |
| `storeId` | string | Uber Eats store identifier — join key for menu item rows |
| `storeSlug` | string | URL slug of the store |
| `storeUrl` | string | Canonical store page link, including the dining mode used |
| `name` | string | Store name |
| `description` | string | Store summary text from the page |
| `storeType` | string | Merchant category, e.g. `Restaurant`, `Grocery`, `Pharmacy` |
| `rating` | number | Average star rating |
| `reviewCount` | integer | Rating count as a number, parsed from values like `600+` |
| `reviewCountText` | string | The rating count exactly as Uber Eats displays it |
| `priceBucket` | string | Price tier glyphs, e.g. `$$` |
| `priceLevel` | integer | Price tier as a 1–4 number — use this to compare across countries |
| `cuisines` | array | Cuisine tags applied to the store |

##### Location & availability

| Field | Type | Description |
|-------|------|-------------|
| `phone` | string | Store phone number when published |
| `address` | object | `street`, `city`, `region`, `postalCode`, `country` |
| `addressText` | string | Full address as a single line |
| `latitude` | number | Store latitude |
| `longitude` | number | Store longitude |
| `hours` | array | Opening blocks: `days`, `opens`, `closes`, `menu` (24-hour clock) |
| `isOpen` | boolean | Whether the store was open at collection time |
| `isOrderable` | boolean | Whether orders were being accepted |
| `diningMode` | string | `DELIVERY` or `PICKUP` used for this row |
| `language` | string | Language code the store page was read in |
| `deliveryEtaMinutes` | object | `min` and `max` wait in minutes for the selected mode |
| `deliveryFee` | string | Fee badge text, e.g. `$0.49 Delivery Fee` |

##### Menu summary & analytics

| Field | Type | Description |
|-------|------|-------------|
| `imageUrl` | string | Store hero photo |
| `currencyCode` | string | Currency of all prices on this store's items |
| `menuSectionCount` | integer | Number of menu sections found |
| `menuItemCount` | integer | Number of unique items collected for this store |
| `analytics` | object | `itemCount`, `minPrice`, `maxPrice`, `averagePrice`, `priceCoverage`, `imageCoverage`, `customizationCoverage` |
| `reviews` | array | Review samples: `reviewId`, `authorName`, `text`, `createdAt` |
| `scrapedAt` | string | ISO timestamp of collection |

#### `menuItem` rows

```json
{
  "recordType": "menuItem",
  "storeId": "1a06a2b8-6aca-4c05-89f9-2d9d1e4f4415",
  "storeName": "Anton's Falafel House",
  "storeUrl": "https://www.ubereats.com/store/antons-falafel-house/GgaiuGrKTAWJ-S2dHk9EFQ?diningMode=DELIVERY",
  "itemId": "8d31c7f0-51ae-4a6c-b2f8-c0a1e2b39d44",
  "name": "Chicken Shawarma Plate",
  "description": "Marinated chicken with rice, salad, hummus and pita.",
  "sectionName": "Main Menu",
  "subsectionName": "Plates",
  "price": 16.95,
  "priceFormatted": "$16.95",
  "currencyCode": "USD",
  "imageUrl": "https://tb-static.uber.com/prod/image-proc/processed_images/item.jpeg",
  "isAvailable": true,
  "isSoldOut": false,
  "hasCustomizations": true,
  "customizations": [
    {
      "title": "Choose your sauce",
      "minPermitted": 1,
      "maxPermitted": 2,
      "options": [
        { "name": "Garlic Sauce", "price": 0.0, "isSoldOut": false, "defaultQuantity": 1 },
        { "name": "Extra Tahini", "price": 0.75, "isSoldOut": false }
      ]
    }
  ],
  "quantityInfo": { "minPermitted": 1, "maxPermitted": 20, "increment": 1, "soldByUnit": "QUANTITY" },
  "itemUrl": "https://www.ubereats.com/store/antons-falafel-house/GgaiuGrKTAWJ-S2dHk9EFQ?mod=quickView&modctx=...",
  "scrapedAt": "2026-07-31T13:04:22Z"
}
```

##### Item core

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `menuItem` for these rows |
| `storeId` | string | Store identifier — join key back to the store row |
| `storeName` | string | Store name, denormalized for easy filtering |
| `storeUrl` | string | Store page link |
| `itemId` | string | Unique item identifier, used to deduplicate repeated items |
| `itemUrl` | string | Direct link that opens this item's quick view on the store page |
| `name` | string | Item name as written by the merchant |
| `description` | string | Item description as written by the merchant |
| `sectionName` | string | Top-level menu or catalog section |
| `subsectionName` | string | Sub-section or aisle within the section |
| `scrapedAt` | string | ISO timestamp of collection |

##### Price, stock & options

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Item price as a decimal number |
| `priceFormatted` | string | Price exactly as displayed, including currency symbol |
| `currencyCode` | string | Currency of the price |
| `imageUrl` | string | Item photo |
| `isAvailable` | boolean | Whether the item was orderable |
| `isSoldOut` | boolean | Whether the item was marked sold out |
| `hasCustomizations` | boolean | Whether the item has an option tree, even when options were not collected |
| `customizations` | array | Option groups: `title`, `minPermitted`, `maxPermitted`, and `options` with `name`, `price`, `isSoldOut`, `defaultQuantity` and nested `childOptions` |
| `quantityInfo` | object | `minPermitted`, `maxPermitted`, `increment`, `soldByUnit` — how the item is sold |

### Tips for Best Results

- **Cap large catalogs before you run them.** A restaurant returns around 40 items; a supermarket returned **707**. Leave `maxMenuItemsPerStore` at `0` for restaurants, but set a cap for grocery, pharmacy and retail stores unless you genuinely want every SKU.
- **Keep `maxResults` set when you raise `maxStores`.** `maxStores` and `maxMenuItemsPerStore` each cap one dimension; `maxResults` caps the two multiplied together, which is the number you actually pay for. The `10000` default is deliberately generous — lower it for a trial run, and set it to `0` only when you have already measured the store count you are asking for.
- **Leave `includeItemCustomizations` off unless you need option data.** Around 6 in 10 items at a typical restaurant are customizable, and each one has to be looked up individually — it is the single biggest thing that slows a run down.
- **Use `includeMenu: false` for market censuses.** One address search found 458 stores; profiles-only turns that into 458 rows with ratings, addresses, cuisines and fees, instead of hundreds of thousands of item rows.
- **Run the same store twice, once per dining mode.** Delivery and pickup are genuinely different datasets — one store showed a 170–185 minute delivery wait against an 8–18 minute pickup wait, with different fees.
- **Compare price tiers with `priceLevel`, not `priceBucket`.** The glyphs render in the currency of the browsing language, so a US store can display `€€`. The 1–4 number is the portable signal across countries.
- **Item names stay in the merchant's own language.** The language setting translates store text and menu section names; item names and descriptions are merchant-written, and the deeper pages of very large catalogs fall back to English section names.
- **Latitude and longitude only work as a pair.** Supplying one without the other is ignored and the run falls back to the address. Use coordinates when an address is ambiguous or when you want to sample a precise delivery point.
- **Outside the US, give coordinates rather than a typed address.** Uber Eats' own address lookup leans towards places near where the request appears to come from, so a European or Asian street can come back unmatched. A latitude and longitude pair is exact everywhere — `48.8606, 2.3376` puts you on the Rue de Rivoli in Paris. An address that cannot be matched is reported plainly and nothing is collected for it, so you are never charged for the wrong city.
- **Reviews are a recent sample, not full history.** A tight `reviewsSince` date can legitimately return zero reviews for a store that has hundreds of ratings — widen the date before assuming something failed.

### Pricing

**From $2.00 per 1,000 results** — flat pay-per-result, with store rows and menu item rows billed at the same rate. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver and Gold subscribers pay progressively less; the table shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.24 | $0.23 | $0.22 | $0.20 |
| 1,000 | $2.40 | $2.25 | $2.15 | $2.00 |
| 10,000 | $24.00 | $22.50 | $21.50 | $20.00 |
| 100,000 | $240.00 | $225.00 | $215.00 | $200.00 |

A "result" is any row in the output dataset — one per store and one per menu item. Stores excluded by your store type filter are never collected and never billed. Platform fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Custom API integrations
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available store and menu information for legitimate market research, competitive analysis and menu data operations. Users are responsible for complying with applicable laws and Uber Eats' Terms of Service. Review text and reviewer display names are personal data in some jurisdictions — handle them accordingly, and do not use collected data for spam, harassment, price fixing or any illegal purpose.

# Actor input Schema

## `startUrls` (type: `array`):

Uber Eats store page links, e.g. https://www.ubereats.com/store/name/abc123. Works with any country version of the site. Leave empty if you'd rather discover stores by address below.

## `address` (type: `string`):

Find stores that deliver to this place, e.g. 'Brooklyn, NY' or '350 5th Ave, New York'. Leave empty if you pasted store URLs above. Outside the US, use Latitude and Longitude below instead — Uber Eats' address lookup favours places near where the request appears to come from, and an address it cannot match is reported plainly rather than searched somewhere else.

## `latitude` (type: `string`):

Exact latitude of the delivery point, e.g. 40.7128. Use together with Longitude when you need pinpoint accuracy — this overrides the address above. Supplying only one of the two is ignored.

## `longitude` (type: `string`):

Exact longitude of the delivery point, e.g. -74.0060. Use together with Latitude — this overrides the address above. Supplying only one of the two is ignored.

## `searchQuery` (type: `string`):

Only find stores matching this cuisine or dish, e.g. 'sushi', 'pizza', 'vegan'. Leave empty to get every store around the address.

## `storeType` (type: `string`):

Which kind of stores to find around the address. Grocery, convenience, alcohol, pharmacy and retail each come from their own Uber Eats category listing and return a single page of stores. 'Restaurants' is everything in the main listing that is not one of those shop categories — the shop categories are checked first, so stores you filter out are never collected or charged for.

## `diningMode` (type: `string`):

Prices, fees and store availability differ between delivery and pickup. This applies to the store URLs you pasted above as well as to the address search.

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

How many stores to take from the address search. Set to 0 to take every store found, up to a safety ceiling of 500 stores per run. Does not limit the store URLs you pasted above.

## `includeMenu` (type: `boolean`):

Collect every menu item with its price, description and photo. Turn this off for a fast, cheap list of store profiles only.

## `maxMenuItemsPerStore` (type: `integer`):

Stop after this many items per store. Set to 0 for the complete menu, which is collected page by page up to a safety ceiling of 200 catalog pages (roughly 21,000 items) per store. Recommended for supermarkets and pharmacies, which list far more products than restaurants.

## `includeItemCustomizations` (type: `boolean`):

Also collect sizes, toppings, add-ons and their extra charges. WARNING: this makes runs substantially slower and more expensive — every customizable item has to be looked up individually, and at a typical restaurant around 6 in 10 items are customizable. Option lookups for a single store are given up to 4 minutes; on a very large catalog any items still waiting when that time is up are returned complete but without their options. Leave it off unless you specifically need option data.

## `maxResults` (type: `integer`):

Stop the whole run once this many results have been saved, counting store profiles and menu items together. This is your spending safety net: a grocery or supermarket search with the full menu switched on can produce hundreds of thousands of results, and every result is charged for. Set to 0 for no limit. As a run approaches the limit the remaining room is shared out between the stores still being collected, so the last few stores can come back with a shortened menu, and the final count can land a little above this number.

## `includeReviews` (type: `boolean`):

Include customer review samples with each store, along with the overall rating and rating count.

## `maxReviewsPerStore` (type: `integer`):

Keep at most this many reviews per store. Set to 0 to keep every review the store page provides — Uber Eats publishes a sample of recent reviews rather than the full history.

## `reviewsSince` (type: `string`):

Skip reviews older than this date. Leave empty to keep all of them. Reviews come free with the store page, so this never adds requests or cost.

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

Language for store text and menu section names. Applies to the store page and its menu sections. Item names and descriptions are written by each merchant and stay in their original language, and very large catalogs (supermarkets) fall back to English section names on their deeper pages.

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

How many stores to work through in parallel. Lower this if you see failures; raise it for faster runs on large store lists.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.ubereats.com/store/antons-falafel-house/GgaiuGrKTAWJ-S2dHk9EFQ"
  ],
  "storeType": "ALL",
  "diningMode": "DELIVERY",
  "maxStores": 3,
  "includeMenu": true,
  "maxResults": 10000,
  "includeReviews": true,
  "maxReviewsPerStore": 10,
  "language": "en",
  "maxConcurrency": 5
}
```

# Actor output Schema

## `stores` (type: `string`):

Store profiles with rating, review count, cuisines, address, hours, delivery fee and menu size.

## `menuItems` (type: `string`):

Every menu or catalog item with its section, price, photo and availability.

# 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 = {
    "startUrls": [
        "https://www.ubereats.com/store/antons-falafel-house/GgaiuGrKTAWJ-S2dHk9EFQ"
    ],
    "address": "",
    "latitude": "",
    "longitude": "",
    "searchQuery": "",
    "storeType": "ALL",
    "diningMode": "DELIVERY",
    "maxStores": 3,
    "includeMenu": true,
    "maxMenuItemsPerStore": 0,
    "includeItemCustomizations": false,
    "maxResults": 10000,
    "includeReviews": true,
    "maxReviewsPerStore": 10,
    "reviewsSince": "",
    "language": "en",
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/ubereats-full-menu-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 = {
    "startUrls": ["https://www.ubereats.com/store/antons-falafel-house/GgaiuGrKTAWJ-S2dHk9EFQ"],
    "address": "",
    "latitude": "",
    "longitude": "",
    "searchQuery": "",
    "storeType": "ALL",
    "diningMode": "DELIVERY",
    "maxStores": 3,
    "includeMenu": True,
    "maxMenuItemsPerStore": 0,
    "includeItemCustomizations": False,
    "maxResults": 10000,
    "includeReviews": True,
    "maxReviewsPerStore": 10,
    "reviewsSince": "",
    "language": "en",
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/ubereats-full-menu-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": [
    "https://www.ubereats.com/store/antons-falafel-house/GgaiuGrKTAWJ-S2dHk9EFQ"
  ],
  "address": "",
  "latitude": "",
  "longitude": "",
  "searchQuery": "",
  "storeType": "ALL",
  "diningMode": "DELIVERY",
  "maxStores": 3,
  "includeMenu": true,
  "maxMenuItemsPerStore": 0,
  "includeItemCustomizations": false,
  "maxResults": 10000,
  "includeReviews": true,
  "maxReviewsPerStore": 10,
  "reviewsSince": "",
  "language": "en",
  "maxConcurrency": 5
}' |
apify call solidcode/ubereats-full-menu-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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