Uber Eats Menus & Reviews Scraper

Search Uber Eats restaurants and export current restaurant details, full menu items, prices, ratings, and public customer review samples.

Use this Actor to collect structured Uber Eats data for menu-price tracking, restaurant-market research, assortment comparisons, and sentiment analysis.

If you are asking is Uber Eats worth it for a restaurant category or market, this scraper gives you the menu, rating, and review evidence needed for a repeatable analysis instead of a manual spot check.

What does Uber Eats Menus & Reviews Scraper do?

The Actor supports two input routes:

1. Search Uber Eats with restaurant, chain, or cuisine queries.
2. Scrape exact public Uber Eats restaurant URLs.

For every accepted restaurant, it saves one structured dataset record containing:

• restaurant identity and URL;
• address and coordinates;
• cuisine labels;
• phone number when public;
• aggregate rating and review count;
• open and orderable status;
• complete menu sections and unique menu items exposed by Uber Eats;
• item descriptions, prices, currency, images, availability, and customization flags;
• a bounded sample of public customer reviews;
• the source query and collection timestamp.

A single restaurant remains one dataset item even when it contains hundreds of menu items and multiple reviews.

That format makes exports easy to join, diff, and archive.

Who is it for?

Restaurant and food-service analysts

Track current menu assortments and compare advertised prices across restaurants.

Consumer brands and suppliers

See how products, meal types, or cuisines appear in delivery menus.

Agencies and reputation teams

Combine aggregate ratings with the public review samples Uber Eats exposes.

Data engineers

Run the Actor through the Apify API and send normalized restaurant records into a warehouse or spreadsheet.

Competitive-intelligence teams

Schedule the same inputs and compare snapshots over time.

The Actor collects current snapshots.

It does not calculate historical changes itself.

Why use this Actor?

• Search and exact URLs: discover stores by query or target known restaurant pages.
• Menu and review context together: receive prices and sentiment signals in the same restaurant record.
• No login required: the supported workflow uses public Uber Eats data surfaces.
• Stable identifiers: restaurant, menu-item, and review UUIDs support repeat-run comparisons.
• Typed JSON output: no raw HTML or browser-debug objects.
• Efficient HTTP extraction: no browser or paid proxy is used in the normal route.
• Bounded runs: control restaurant and review volume directly from input.
• API-ready: schedule, integrate, export, and automate with standard Apify tools.

What Uber Eats fields can I extract?

Field	Meaning
restaurantId	Stable Uber Eats store UUID
name	Restaurant or store name
url	Public Uber Eats restaurant URL
slug, citySlug	Source URL and city slugs when exposed
address	Formatted public restaurant address
latitude, longitude	Restaurant coordinates
phoneNumber	Public phone number when available
cuisines	Uber Eats cuisine labels
rating	Aggregate rating value
reviewCount	Displayed aggregate review count
priceBucket	Source price-level label when available
currencyCode	ISO menu currency
isOpen, isOrderable	Current marketplace status
menuItemCount	Number of unique included menu items
reviewSampleCount	Number of included public review samples
menuItems	Nested menu items with categories and prices
reviews	Nested public review samples
sourceQuery	Query that discovered the restaurant
scrapedAt	Collection timestamp

Menu-item fields include id, name, description, price, priceFormatted, currencyCode, category, imageUrl, isAvailable, isSoldOut, and hasCustomizations.

Review fields include id, authorName, text, createdAt, formattedDate, timeSinceReview, and featured.

Fields can be null when Uber Eats does not expose them for a restaurant.

How do I scrape Uber Eats menus and reviews?

1. Open the Actor input page.
2. Enter one or more restaurant or cuisine names in searchQueries.
3. Optionally add exact restaurant pages in startUrls.
4. Set maxRestaurants to the maximum records you need.
5. Keep includeMenu enabled to collect menu items and prices.
6. Keep includeReviews enabled to collect public review samples.
7. Set maxReviewsPerRestaurant to bound review arrays.
8. Click Start.
9. Open the Restaurants dataset view.
10. Export JSON, CSV, Excel, XML, or another supported format.

The default input searches for McDonald's and is intentionally small enough for a first run.

Input parameters

Parameter	Type	Default	Description
searchQueries	string array	['McDonald\'s']	Restaurant, chain, or cuisine searches; maximum 20
startUrls	request list	empty	Exact public Uber Eats restaurant URLs; maximum 100
locale	string	us	Uber Eats locale code, such as us, gb, ca, or au
maxRestaurants	integer	10	Maximum unique restaurant records; 1–100
includeMenu	boolean	true	Include menu items and prices
includeReviews	boolean	true	Include public review samples
maxReviewsPerRestaurant	integer	20	Review-sample limit per restaurant; 0–200

Provide at least one search query or URL.

The schema's default search is applied when you start the Actor with an empty input in Apify Console.

Search follows Uber Eats' public marketplace context.

Use exact restaurant URLs when location precision is required.

Example inputs

Search a restaurant chain

{
  "searchQueries": ["McDonald's"],
  "maxRestaurants": 2,
  "includeMenu": true,
  "includeReviews": true,
  "maxReviewsPerRestaurant": 10
}

Scrape one exact restaurant

{
  "startUrls": [
    {
      "url": "https://www.ubereats.com/store/mcdonalds-fillmore/P21H_Lf3Se2wSmjGHfoFcQ"
    }
  ],
  "maxRestaurants": 1,
  "includeMenu": true,
  "includeReviews": true,
  "maxReviewsPerRestaurant": 20
}

Monitor two food categories

{
  "searchQueries": ["burgers", "pizza"],
  "maxRestaurants": 4,
  "includeMenu": true,
  "includeReviews": true,
  "maxReviewsPerRestaurant": 10
}

Example output

This shortened record reflects the current output shape:

{
  "type": "restaurant",
  "restaurantId": "3f6d47fc-b7f7-49ed-b04a-68c61dfa0571",
  "name": "McDonald's® (Fillmore)",
  "url": "https://www.ubereats.com/store/mcdonalds-fillmore/P21H_Lf3Se2wSmjGHfoFcQ",
  "address": "1100 Fillmore St, SAN FRANCISCO, CA 94115",
  "latitude": 37.7798997,
  "longitude": -122.4318414,
  "cuisines": ["American"],
  "rating": 4.5,
  "reviewCount": "15000+",
  "currencyCode": "USD",
  "menuItemCount": 208,
  "reviewSampleCount": 20,
  "menuItems": [
    {
      "id": "5daade04-ed06-56a2-a121-6d69572a8520",
      "name": "Medium French Fries",
      "price": 5.69,
      "priceFormatted": "$5.69",
      "category": "Featured items",
      "isAvailable": true,
      "isSoldOut": false
    }
  ],
  "reviews": [
    {
      "id": "dcece822-dbaf-4bc3-957a-1ac5c1bae20f",
      "authorName": "Carolyn C.",
      "text": "Ordered a large decaf coffee & large Diet Coke with extra ice...",
      "createdAt": "2025-08-13T00:00:00Z",
      "featured": true
    }
  ],
  "sourceQuery": null,
  "scrapedAt": "2026-08-11T14:15:00.000Z"
}

The complete dataset item contains every menu item and requested review sample returned for that restaurant.

How much does it cost to scrape Uber Eats restaurant menus?

The Actor uses pay-per-event pricing:

• a one-time Start event per run;
• one Restaurant event per saved restaurant record;
• menu items and review samples inside that restaurant record have no separate charge event.

At the BRONZE rate of $0.00264 per restaurant plus a $0.005 start fee:

The run total is the active start rate plus the active restaurant rate multiplied by the number of saved restaurant records.

For example, a one-record run has one Start event and one Restaurant event; a ten-record run has one Start event and ten Restaurant events.

Apify subscription tiers receive the discounts shown in the Actor pricing tab.

Actual platform billing uses the active tier assigned to your Apify plan.

Choose a smaller restaurant limit for a smaller run.

Schedule menu-price and sentiment monitoring

Apify schedules make recurring snapshots straightforward:

1. Save a Task with exact restaurant URLs or stable search queries.
2. Run it daily, weekly, or monthly.
3. Export each dataset to your storage destination.
4. Join records by restaurantId.
5. Join menu entries by their menu-item id.
6. Compare price, isAvailable, rating, and reviewCount between snapshots.

For review monitoring, compare review id values to identify samples not present in an earlier run.

Uber Eats can rotate which public samples it exposes, so do not treat sample absence as deletion.

Export to spreadsheets and data pipelines

The default dataset can be downloaded as JSON, CSV, Excel, XML, RSS, or HTML through Apify.

Nested menu and review arrays are best preserved in JSON.

For a relational warehouse, flatten the output into:

• a restaurant table keyed by restaurantId;
• a menu table keyed by restaurantId plus menu-item id;
• a review table keyed by restaurantId plus review id.

Useful destinations include:

• Google Sheets through an Apify integration;
• Airtable;
• Make;
• Zapier;
• webhooks;
• Amazon S3;
• a database or warehouse through the Apify API.

Use the Apify API

Replace YOUR_TOKEN with an Apify API token.

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~ubereats-menu-reviews-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["pizza"],"maxRestaurants":4}'

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ubereats-menu-reviews-scraper').call({
    searchQueries: ['pizza'],
    maxRestaurants: 4,
    includeMenu: true,
    includeReviews: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/ubereats-menu-reviews-scraper").call(
    run_input={
        "searchQueries": ["pizza"],
        "maxRestaurants": 4,
        "includeMenu": True,
        "includeReviews": True,
    }
)

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)

Wait for the run to finish before reading its dataset.

Use Uber Eats data through MCP

Claude Code setup

Add the Apify MCP server to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/ubereats-menu-reviews-scraper"

Claude Desktop setup

Add this server entry to the Claude Desktop MCP configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/ubereats-menu-reviews-scraper"
    }
  }
}

Cursor setup

Add the same JSON server entry in Cursor Settings → MCP.

VS Code setup

Add the same HTTP MCP server in your VS Code MCP configuration or through the MCP extension you use.

Example prompts

• “Search Uber Eats for pizza restaurants and return four menus with prices.”
• “Scrape this Uber Eats restaurant URL and summarize its menu categories.”
• “Collect public review samples and identify recurring positive and negative themes.”

The MCP client still uses your Apify account and the Actor's active pricing.

Limits and data availability

• Search results depend on Uber Eats' current public marketplace context.
• Use exact URLs for a precise restaurant or delivery market.
• The Actor does not accept an arbitrary street address or guarantee global search coverage.
• Uber Eats may expose only a sample of customer reviews, not complete review history.
• Some restaurants expose no written reviews even when an aggregate rating exists.
• Menus, prices, availability, hours, ratings, and review samples can change at any time.
• Closed or out-of-range restaurants can still have useful menu data.
• isOrderable reflects the request context and is not a universal availability promise.
• Modifier trees are represented only by hasCustomizations; nested option pricing is not expanded.
• Duplicate menu items are removed by stable menu-item UUID.
• The normal implementation does not use a browser or an automatic paid residential proxy fallback.
• Upstream schema or anti-bot changes can cause an explicit failed run rather than misleading empty data.

Responsible use and legality

This Actor extracts publicly exposed Uber Eats restaurant information.

You are responsible for using the data lawfully and for complying with applicable terms, privacy rules, database rights, and local regulations.

Do not use review author names to identify, profile, harass, or contact individuals.

Collect only the volume you need.

Store personal data for no longer than necessary.

Do not use the Actor to overload Uber Eats or interfere with normal service.

This Actor is not affiliated with, endorsed by, or sponsored by Uber or Uber Eats.

Uber Eats is a trademark of its respective owner.

Troubleshooting

The run found no restaurants

Check the spelling and try a broader restaurant or cuisine query.

Search suggestions vary by Uber Eats marketplace context.

For an exact target, paste its public restaurant URL into startUrls.

A restaurant URL is rejected

Use a public https://www.ubereats.com/store/... URL.

Short links, checkout links, account pages, and non-Uber Eats domains are not supported.

A restaurant has zero reviews

Uber Eats does not expose written samples for every store.

Check rating and reviewCount for aggregate sentiment signals.

A menu item has a null price

Some source entries are informational, unavailable, or represented without a standalone price.

Keep null handling in your downstream pipeline.

The run fails after retries

Inspect the run log for the endpoint and status.

Retry later if Uber Eats returned a transient network, rate-limit, or server error.

Do not blindly repeat challenged runs.

Related restaurant data Actors

• Grubhub Restaurant Menus Scraper — collect Grubhub restaurant and menu records for US delivery-market comparisons.
• Zomato Restaurant Search Scraper — collect Zomato restaurant search records.
• Talabat Restaurant Listings Scraper — collect Talabat country restaurant listings.

Choose the source that matches the marketplace your buyers and restaurants actually use.

FAQ

Is Uber Eats worth it for menu and restaurant research?

This Actor cannot answer that business question automatically, but it supplies current menu prices, assortment, ratings, and public review evidence for a repeatable analysis.

Does this Actor provide an official Uber Eats API?

No.

It is an Apify Actor that returns structured public Uber Eats data through the Apify API.

It is not an official Uber Eats API product.

Can I scrape multiple restaurants in one run?

Yes.

Combine multiple search queries and restaurant URLs, then set maxRestaurants to the total limit.

Does it return every Uber Eats review?

No.

It returns only the public review samples Uber Eats exposes for each restaurant at run time.

Does it return full menus?

It returns all unique standard catalog items exposed by the supported store endpoint at run time.

Modifier-option trees are not expanded.

Can I monitor menu changes?

Yes.

Schedule repeated runs and compare restaurant and menu-item IDs, prices, descriptions, and availability in your own storage or workflow.

Can I use the data commercially?

Your permitted use depends on the source terms, the data involved, and applicable law.

Obtain legal advice for your specific use case when needed.

Where are results stored?

Primary results are stored in the run's default Apify dataset, one record per restaurant.