# Uber Eats Menu Compare — Competitive Intelligence (`jsonjoestar/ubereats-menu-compare`) Actor Compare menus, prices, and coverage across multiple Uber Eats restaurants. Fuzzy item matching, price ranking, unique items detection, winner analysis. The only competitive intelligence tool for Uber Eats. - **URL**: https://apify.com/jsonjoestar/ubereats-menu-compare.md - **Developed by:** [JSONJoestar](https://apify.com/jsonjoestar) (community) - **Categories:** E-commerce, AI, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing Pay per usage This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage ## 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 ## Uber Eats Menu Comparison Actor -- Restaurant Price Comparison and Competitive Intelligence Compare menus and prices across multiple Uber Eats restaurants side by side 🍴 This Actor delivers instant price rankings, common item detection, unique menu items, and category overlap analysis in a single run -- built for restaurant price comparison 💰 and menu price monitoring at scale 📊 --- ### 🔍 How do your Uber Eats prices compare to your competitors? Checking manually means opening every competitor's Uber Eats page, scrolling through every category, and writing down prices in a spreadsheet. **This Uber Eats menu comparison Actor automates the entire process.** Paste 2 or more restaurant URLs, hit Run, and in seconds you get a point-in-time snapshot with: - 💰 Which restaurant is cheapest overall - ⚖️ Item-by-item price differences for shared menu items - 🔍 Items your competitors have that you don't (and vice versa) - 🧩 Category overlap and gaps - 📈 Rating and coverage comparisons 🛡️ No login. No cookies. No browser emulation. Pure API-based extraction. --- ### ⚡ Key Features | Feature | Description | |---|---| | **Multi-restaurant comparison** | Compare 2, 5, 10, or more restaurants in a single Actor run | | **Fuzzy item matching** | Finds common items even when names differ slightly ("Chicken Burger" vs "Poulet Burger") | | **Price ranking** | Instant cheapest-to-most-expensive ranking by average price | | **Common items with price diff** | See exactly how much more (or less) each restaurant charges for the same dish | | **Unique items detection** | Discover menu items exclusive to each restaurant | | **Category overlap analysis** | Compare menu sections across restaurants (Burgers, Desserts, Drinks, etc.) | | **Winner analysis** | Auto-picks winners: cheapest, best rated, most items, best image coverage | | **12 locale support** | Works in France, US, UK, Germany, Spain, Portugal, Netherlands, Japan, Taiwan, Australia, Canada, Mexico | | **No login required** | Uses publicly available Uber Eats data -- no account, no cookies, no browser | | **Concurrent fetching** | All restaurants fetched in parallel via async HTTP -- fast even with 10+ URLs | | **Pay per event** | No monthly subscription. You pay per Actor run based on Apify platform compute. | --- ### 🎯 Use Cases #### 🏷️ 1. Competitive Intelligence for Food Delivery You run a restaurant on Uber Eats. Your three closest competitors are within 1 km. Are you priced too high? Too low? Paste all four URLs and get an instant restaurant price comparison with item-level price differences. **Who uses this:** Restaurant owners, franchise managers, food delivery consultants. #### ✅ 2. Franchise Audit and Compliance You manage 50 McDonald's locations. Corporate sets the prices, but are all locations actually following the pricing guide? Compare multiple locations of the same chain to find pricing inconsistencies. **Who uses this:** Franchise operations managers, QA teams, brand compliance officers. #### 🧩 3. Menu Gap Analysis You want to launch a new pizza restaurant on Uber Eats. What do existing pizza places in your area offer? What categories do they all have? What's missing? Compare 5-10 competitors to find the menu gap you can fill. **Who uses this:** Entrepreneurs, restaurant consultants, ghost kitchen operators. #### 🔄 4. Menu Price Monitoring Over Time Run this Actor daily or weekly via Apify Scheduler to track how competitor prices change over time. Export to Google Sheets or a database and build your own price trend dashboard. **Who uses this:** Data analysts, pricing teams, market researchers. #### 📊 5. Market Research for Food Delivery Studying the food delivery market in a specific city? Compare restaurants across cuisines (burgers vs. sushi vs. pizza) to understand pricing tiers, menu sizes, and category structures. **Who uses this:** Market researchers, investment analysts, food-tech startups. #### 🍴 6. Ghost Kitchen Menu Optimization You operate a ghost kitchen with multiple virtual brands. Compare your brands against each other and against competitors to optimize pricing and menu composition. **Who uses this:** Ghost kitchen operators, virtual brand managers. #### 🌍 7. Cross-Cuisine Pricing Benchmark Compare restaurants across different cuisines (burgers vs. sushi vs. pizza) in the same area to understand how retail pricing tiers differ by food category on Uber Eats. **Who uses this:** Entrepreneurs evaluating which cuisine segment to enter, pricing consultants. --- ### 🚀 Why Use This Uber Eats Menu Comparison Actor? #### The problem The food delivery market is intensely competitive. Restaurants adjust their Uber Eats prices weekly -- sometimes daily. If you don't know what your competitors charge for similar items, you are flying blind: - **Price too high?** Customers order from the cheaper competitor. You lose volume. - **Price too low?** You leave money on the table. Your margins shrink. - **Missing a popular category?** Competitors offer desserts or drinks you don't. They get the full-basket orders. There is no built-in tool on Uber Eats for restaurant price comparison. The alternative is to manually open each competitor, scroll through every section, and copy prices into a spreadsheet. For 5 competitors, that takes 30-60 minutes. Every. Single. Day. #### The solution This Actor does it in seconds. Paste your URLs, hit Run, and get structured comparison data in the default dataset. Price rankings, common items with exact price differences, unique items per restaurant, category gaps, and automatic winner selection. Most Uber Eats scrapers on the Apify Store extract data from a single restaurant at a time. This Actor is designed specifically for Uber Eats menu comparison: it answers not "what's on the menu?" but "how does this menu compare to competitors?" --- ### 📥 Input Parameters | Parameter | Type | Required | Default | Description | |---|---|---|---|---| | `urls` | Array of strings | Yes | -- | 2 or more Uber Eats restaurant URLs to compare. Supports all Uber Eats country domains. | | `locale` | String (enum) | No | `fr-FR` | Language and region for the API response. Affects menu language and currency. | #### 🌍 Supported Locales | Locale | Country | Currency | |---|---|---| | `fr-FR` | France | EUR | | `en-US` | United States | USD | | `en-GB` | United Kingdom | GBP | | `de-DE` | Germany | EUR | | `es-ES` | Spain | EUR | | `pt-PT` | Portugal | EUR | | `nl-NL` | Netherlands | EUR | | `ja-JP` | Japan | JPY | | `zh-TW` | Taiwan | TWD | | `en-AU` | Australia | AUD | | `en-CA` | Canada | CAD | | `es-MX` | Mexico | MXN | #### Example Input ```json { "urls": [ "https://www.ubereats.com/fr/store/mcdonalds-avon/nOGcJSUbXpqAqm_kPdhyOA", "https://www.ubereats.com/fr/store/burger-king-fontainebleau/abc123", "https://www.ubereats.com/fr/store/kfc-melun/def456" ], "locale": "fr-FR" } ```` *** ### 📤 Output Format The Actor pushes a single JSON object to the default dataset. Here is the full structure: #### Top-Level Fields | Field | Type | Description | |---|---|---| | `restaurants` | Array | Summary data for each restaurant (without individual items, to keep the comparison compact) | | `comparison` | Object | The core comparison analysis: price ranking, common items, unique items, category overlap, winners | | `errors` | Integer | Number of restaurants that failed to fetch (0 = all succeeded) | | `locale` | String | The locale used for this run | | `processedAt` | String (ISO 8601) | UTC timestamp of when the comparison was generated | | `status` | String | `"success"` (all OK), `"partial"` (some failed), or `"error"` (all failed) | #### Restaurant Summary Fields Each entry in the `restaurants` array contains: | Field | Type | Description | |---|---|---| | `name` | String | Restaurant name as displayed on Uber Eats | | `chain` | String or null | Parent chain name (e.g., "McDonald's") if applicable | | `cuisines` | Array of strings | Cuisine tags (e.g., \["Burgers", "Fast Food"]) | | `totalItems` | Integer | Total number of menu items | | `avgPrice` | Float | Average item price in local currency | | `minPrice` | Float | Cheapest item price | | `maxPrice` | Float | Most expensive item price | | `priceCoverage` | Integer (0-100) | Percentage of items that have a listed price | | `imageCoverage` | Integer (0-100) | Percentage of items that have an image | | `ratingValue` | Float or null | Restaurant rating (e.g., 4.5) | | `sections` | Array of strings | Menu section names (e.g., \["Burgers", "Desserts", "Boissons"]) | #### Comparison Object Fields | Field | Type | Description | |---|---|---| | `priceComparison.cheapest` | Object | `{name, avgPrice}` of the cheapest restaurant | | `priceComparison.mostExpensive` | Object | `{name, avgPrice}` of the most expensive restaurant | | `priceComparison.ranking` | Array | All restaurants sorted from cheapest to most expensive | | `commonItems` | Array | Items found in multiple restaurants with price differences | | `uniqueItems` | Object | `{restaurantName: [item names]}` -- items exclusive to each restaurant | | `categoryOverlap.shared` | Array | Menu sections/categories present in ALL restaurants | | `categoryOverlap.perRestaurant` | Object | All sections for each restaurant | | `winners.cheapestOverall` | String | Restaurant name with lowest average price | | `winners.bestImageCoverage` | String | Restaurant with highest % of items with images | | `winners.mostItems` | String | Restaurant with the largest menu | | `winners.bestRated` | String | Restaurant with the highest rating | #### Full Output Example ```json { "restaurants": [ { "name": "McDonald's Avon", "chain": "McDonald's", "cuisines": ["Burgers", "Fast Food"], "totalItems": 87, "avgPrice": 7.45, "minPrice": 1.50, "maxPrice": 24.90, "priceCoverage": 95, "imageCoverage": 100, "ratingValue": 4.3, "sections": [ "En ce moment", "Menus Best Of", "Menus Maxi Best Of", "Salades", "Desserts", "Boissons", "McCafe" ] }, { "name": "Andiamo Pizza", "chain": null, "cuisines": ["Pizza", "Italian"], "totalItems": 42, "avgPrice": 11.20, "minPrice": 3.50, "maxPrice": 18.90, "priceCoverage": 100, "imageCoverage": 85, "ratingValue": 4.6, "sections": [ "Pizzas Classiques", "Pizzas Speciales", "Desserts", "Boissons" ] } ], "comparison": { "priceComparison": { "cheapest": { "name": "McDonald's Avon", "avgPrice": 7.45 }, "mostExpensive": { "name": "Andiamo Pizza", "avgPrice": 11.20 }, "ranking": [ { "name": "McDonald's Avon", "avgPrice": 7.45 }, { "name": "Andiamo Pizza", "avgPrice": 11.20 } ] }, "commonItems": [ { "item1": { "restaurant": "McDonald's Avon", "name": "Coca-Cola", "price": 3.50 }, "item2": { "restaurant": "Andiamo Pizza", "name": "Coca Cola", "price": 3.00 }, "priceDiff": 0.50 }, { "item1": { "restaurant": "McDonald's Avon", "name": "Tiramisu", "price": 4.90 }, "item2": { "restaurant": "Andiamo Pizza", "name": "Tiramisu Maison", "price": 5.50 }, "priceDiff": -0.60 } ], "uniqueItems": { "McDonald's Avon": [ "Big Mac", "McFlurry Oreo", "Filet-O-Fish", "McNuggets x20" ], "Andiamo Pizza": [ "Pizza 4 Fromages", "Calzone Royale", "Bruschetta" ] }, "categoryOverlap": { "shared": ["Desserts", "Boissons"], "perRestaurant": { "McDonald's Avon": ["En ce moment", "Menus Best Of", "Menus Maxi Best Of", "Salades", "Desserts", "Boissons", "McCafe"], "Andiamo Pizza": ["Pizzas Classiques", "Pizzas Speciales", "Desserts", "Boissons"] } }, "winners": { "cheapestOverall": "McDonald's Avon", "bestImageCoverage": "McDonald's Avon", "mostItems": "McDonald's Avon", "bestRated": "Andiamo Pizza" } }, "errors": 0, "locale": "fr-FR", "processedAt": "2026-03-30T14:22:01.123456+00:00", "status": "success" } ``` *** ### 🔧 How to Use #### Option 1: Run on Apify Console (No Code) 1. Go to the [Uber Eats Menu Compare](https://apify.com/your-username/ubereats-menu-compare) Actor page on the Apify Store. 2. Click **"Start"**. 3. Paste 2 or more Uber Eats restaurant URLs in the **"Restaurant URLs to compare"** field. 4. (Optional) Change the locale if your restaurants are not in France. 5. Click **"Run"**. 6. View results in the **"Dataset"** tab when the run finishes. #### Option 2: Apify API ```bash ## Replace with your Actor ID from the Apify Store URL curl -X POST "https://api.apify.com/v2/acts/username~uber-eats-menu-compare/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "urls": [ "https://www.ubereats.com/fr/store/mcdonalds-avon/nOGcJSUbXpqAqm_kPdhyOA", "https://www.ubereats.com/fr/store/andiamo-pizza/FBe4vLkyX5C-kp0pYF5h0w" ], "locale": "fr-FR" }' ``` #### Option 3: Apify Python Client ```bash pip install apify-client ``` ```python from apify_client import ApifyClient client = ApifyClient("YOUR_API_TOKEN") ## Replace with your Actor ID from the Apify Store URL, e.g. "username/actor-name" run = client.actor("username/uber-eats-menu-compare").call(run_input={ "urls": [ "https://www.ubereats.com/fr/store/mcdonalds-avon/nOGcJSUbXpqAqm_kPdhyOA", "https://www.ubereats.com/fr/store/andiamo-pizza/FBe4vLkyX5C-kp0pYF5h0w", ], "locale": "fr-FR", }) dataset = client.dataset(run["defaultDatasetId"]).list_items().items comparison = dataset[0] ## Print price ranking for entry in comparison["comparison"]["priceComparison"]["ranking"]: print(f"{entry['name']}: avg {entry['avgPrice']} EUR") ## Print common items with price differences for match in comparison["comparison"]["commonItems"]: diff = match["priceDiff"] sign = "+" if diff > 0 else "" print(f" {match['item1']['name']}: {match['item1']['price']} vs {match['item2']['price']} ({sign}{diff})") ``` #### Option 4: Apify JavaScript Client ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_API_TOKEN' }); // Replace with your Actor ID from the Apify Store URL, e.g. "username/actor-name" const run = await client.actor('username/uber-eats-menu-compare').call({ urls: [ 'https://www.ubereats.com/fr/store/mcdonalds-avon/nOGcJSUbXpqAqm_kPdhyOA', 'https://www.ubereats.com/fr/store/andiamo-pizza/FBe4vLkyX5C-kp0pYF5h0w', ], locale: 'fr-FR', }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); const result = items[0]; console.log('Cheapest:', result.comparison.priceComparison.cheapest.name); console.log('Most expensive:', result.comparison.priceComparison.mostExpensive.name); console.log('Common items found:', result.comparison.commonItems.length); ``` #### Option 5: Run Locally (No Apify Account) The Actor runs standalone without the Apify SDK: ```bash pip install httpx python src/main.py \ "https://www.ubereats.com/fr/store/mcdonalds-avon/nOGcJSUbXpqAqm_kPdhyOA" \ "https://www.ubereats.com/fr/store/andiamo-pizza/FBe4vLkyX5C-kp0pYF5h0w" \ --locale fr-FR ``` Output is printed as JSON to stdout. *** ### 🔄 Scheduling and Automation #### Daily Competitor Menu Price Monitoring Set up an Apify Schedule to run this Actor daily and track price changes over time: 1. Go to **Schedules** in Apify Console. 2. Create a new schedule with a cron expression (e.g., `0 8 * * *` for 8 AM daily). 3. Link it to this Actor with your competitor URLs as input. 4. Use an **Apify integration** (webhook, Google Sheets, Slack) to get notified of new results. Each run produces a standalone point-in-time snapshot. There is no built-in comparison between runs. To track changes over time, export results to Google Sheets or a database after each run and compare externally. #### Webhook Integration Configure a webhook on run completion to push results to your own API: ```json { "eventTypes": ["ACTOR.RUN.SUCCEEDED"], "requestUrl": "https://your-api.com/webhook/ubereats-compare", "payloadTemplate": "{\"datasetId\": {{resource.defaultDatasetId}}}" } ``` *** ### 💰 Pricing This Actor uses **Pay per event** pricing -- you pay only for what you use. No monthly fee. No commitment. #### Cost Estimate Costs depend on Apify platform compute pricing, which is based on memory allocation and run duration. This Actor uses the default Apify memory allocation and typical runs complete in seconds. | Component | Notes | |---|---| | Actor event fee | Based on number of restaurants compared | | Apify platform compute | Billed per compute unit (see [Apify pricing](https://apify.com/pricing) for current rates) | This Actor uses Apify's pay per event pricing. You pay only for compute resources used during a run. Check the Actor's pricing tab on the Apify Store for current rates. *** ### 🧩 Integrations #### Export Formats Results from this Actor can be exported in: - 📥 **JSON** -- default, structured, ready for API consumption - 📥 **CSV** -- via Apify dataset export (flattened) - 📥 **Excel** -- via Apify dataset export - 📥 **XML** -- via Apify dataset export #### Apify Integrations This Actor works with all Apify platform integrations: | Integration | Use Case | |---|---| | **Google Sheets** | Auto-export comparison results to a spreadsheet for tracking over time | | **Slack** | Get notified when a comparison run completes | | **Webhooks** | Push results to your own API or database | | **Zapier** | Connect to 5000+ apps (Airtable, Notion, HubSpot, etc.) | | **Make (Integromat)** | Build complex automation workflows | | **GitHub Actions** | Trigger comparisons from CI/CD pipelines | | **Apify API** | Full programmatic control from any language | #### MCP Server (AI Agent Compatible) This Actor can be called from AI agents via the Apify MCP server. Compatible with Claude, GPT, and other LLM-based agent frameworks that support the Model Context Protocol. *** ### ⚖️ Why This Actor Over Other Uber Eats Scrapers Most Uber Eats scrapers on the Apify Store extract data from a single restaurant at a time. **This Actor is designed specifically for cross-restaurant menu comparison**: not "what's on the menu?" but "how does this menu compare to competitors?" No other Uber Eats scraper on the Apify Store offers: - 📊 **Cross-restaurant comparison** with price ranking in a single run - 🔍 **Fuzzy common item matching** across restaurants - 🎯 **Unique items detection** per restaurant - 🧩 **Category overlap analysis** - 🏆 **Automatic winner selection** (cheapest, best rated, most items, best image coverage) - 🌍 **12 locale support** for international coverage - ⚡ **Concurrent fetching** for fast results even with many restaurants - 🛒 **Grocery store support** - 💰 **Pay per event pricing** -- no monthly subscription *** ### ❓ FAQ #### How many restaurants can I compare in a single run? There is no hard limit. The Actor fetches all restaurants concurrently, so comparing 2 or 20 takes roughly the same amount of time. Practically, comparing 2-10 restaurants is the most common use case. For very large batches (50+), consider increasing memory allocation in the run configuration. #### What Uber Eats URLs are supported? Any valid Uber Eats store URL works. The Actor extracts the store UUID from the URL automatically. Supported URL formats include: - `https://www.ubereats.com/store/restaurant-name/BASE64ID` - `https://www.ubereats.com/fr/store/restaurant-name/BASE64ID` - `https://www.ubereats.com/de/store/restaurant-name/UUID` - URLs with or without query parameters and trailing slashes The country prefix in the URL (e.g., `/fr/`, `/de/`) is automatically stripped. Use the `locale` parameter to control the language of the response. #### How does fuzzy item matching work? The Actor uses word-level fuzzy matching to find common items across restaurants. It normalizes text (lowercase, remove accents and punctuation), splits into words, and checks if the overlap between two item names exceeds a 60% threshold. This means: - "Coca-Cola 33cl" matches "Coca Cola" - "Big Mac" matches "Big Mac Menu" (shared words exceed threshold) - "Tiramisu Maison" matches "Tiramisu" - "Pizza Margherita" does NOT match "Salade Caesar" (zero word overlap) **Examples of matches that FAIL:** - "Classic Burger" vs "Hamburger Classic" -- shared words: "classic" (1/2 = 50%) -- BELOW 60% threshold -- NO MATCH - "Coca" vs "Coca-Cola Zero" -- shared words: "coca" (1/1 = 100%) -- MATCH - "Frites" vs "French Fries" -- shared words: none (0/1 = 0%) -- NO MATCH (different language) This approach works well for common beverage and dessert names across restaurants, and for comparing different locations of the same chain. #### Do I need an Uber Eats account? No. This Actor uses publicly available Uber Eats data, which does not require authentication. No login, no cookies, no account needed. #### What does `priceCoverage` mean? It is the percentage of menu items that have a listed price. Some Uber Eats items show "Price varies" or require customization to see the price. A `priceCoverage` of 95% means 95% of items have an explicit price. Restaurants with 0% price coverage are excluded from price rankings (since their average price would be meaningless). #### What does `imageCoverage` mean? It is the percentage of menu items that have a product image on Uber Eats. Higher image coverage generally correlates with better conversion on the platform. The `winners.bestImageCoverage` field identifies which restaurant has the most complete visual menu. #### Can I use this for non-food stores (grocery, convenience)? The Actor parses menu data generically for all store types, so it should work with grocery and convenience stores the same way it works with restaurants. However, grocery stores often have much larger catalogs, which may increase memory usage and run time. #### What happens if one URL fails? The Actor uses a graceful degradation model: - **All succeed** (`status: "success"`) -- full comparison produced. - **Some fail** (`status: "partial"`) -- comparison is produced with the restaurants that succeeded. The `errors` field shows how many failed. - **All fail** (`status: "error"`) -- no comparison possible. Check the `errors` field and Actor run logs for details. Failed URLs do not crash the Actor run or affect the data quality of successful restaurants. #### Can I compare restaurants from different countries? Yes, but the `locale` parameter applies to all restaurants in the run. If you compare a French McDonald's with a German Burger King, use whichever locale is appropriate. The prices will be in the currency of each restaurant's country regardless of locale. #### How often does Uber Eats update their menus? Restaurant owners can update menus in real-time via the Uber Eats Merchant Portal. In practice, most restaurants update prices weekly to monthly. Running this Actor daily gives you full visibility into any changes. #### Is there a rate limit? The Actor sends one API request per restaurant, all concurrently. For typical runs (2-10 restaurants), rate limiting is not an issue. For large-scale runs (50+ restaurants per minute), consider spacing out your runs to avoid IP-based throttling. #### How is `priceDiff` calculated? For each pair of common items, `priceDiff` is calculated as `item1.price - item2.price`. A positive value means the first restaurant charges more. A negative value means the second restaurant charges more. For example: ```text item1 (McDonald's): Coca-Cola = 3.50 EUR item2 (Pizza Hut): Coca-Cola = 3.00 EUR priceDiff = +0.50 (McDonald's is 0.50 EUR more expensive) ``` #### Can I filter the output to only show price differences above a threshold? The Actor returns all common items regardless of price difference. To filter, process the output in your code: ```python ## Only show items with > 1 EUR price difference big_diffs = [m for m in result["comparison"]["commonItems"] if abs(m["priceDiff"]) > 1.0] ``` #### What is the `chain` field? If a restaurant belongs to a franchise (McDonald's, Burger King, KFC, Domino's, etc.), Uber Eats stores the parent chain name. The Actor extracts this automatically. For independent restaurants, `chain` is `null`. This is useful for filtering franchise vs. independent comparisons. #### Does this work with Uber Eats grocery stores? The Actor uses the same Uber Eats public web API for all store types, so it should work with grocery stores (Carrefour, Monoprix, etc.) and convenience stores. However, grocery catalogs tend to be much larger than restaurant menus, which increases memory usage and comparison time. Consider increasing memory for large catalogs. #### How do I find restaurant URLs to compare? There are several ways to find Uber Eats store URLs: 1. **Browse Uber Eats directly** -- search for restaurants in your area and copy the URLs from your browser. 2. **Use our Restaurant Search Actor** -- search by query and GPS coordinates to get a list of store URLs programmatically. 3. **Google search** -- search `site:ubereats.com "store" "your city"` to find restaurant pages indexed by Google. #### What currencies are supported? The Actor does not convert currencies. Each restaurant's prices are in the local currency of that restaurant's country: - France, Germany, Spain, Portugal, Netherlands: EUR - United States: USD - United Kingdom: GBP - Japan: JPY - Taiwan: TWD - Australia: AUD - Canada: CAD - Mexico: MXN When comparing restaurants from the same country, all prices are in the same currency. When comparing across countries, be aware that the `priceDiff` will be in mixed currencies (which is usually not meaningful). #### Can AI agents call this Actor? Yes. This Actor is compatible with the Apify MCP (Model Context Protocol) server. AI agents built with Claude, GPT, or other LLM frameworks can call it programmatically to perform competitive analysis as part of an autonomous workflow. The structured JSON output is designed to be easily parsed by LLMs. *** ### 🛡️ Troubleshooting #### "HTTP 403" or "HTTP 429" errors Uber Eats may temporarily block requests from datacenter IPs. Solutions: 1. **Wait and retry** -- temporary blocks usually resolve within minutes. 2. **Reduce concurrency** -- compare fewer restaurants per run. 3. **Space out runs** -- avoid running multiple comparisons in rapid succession. #### "Invalid JSON" error This usually means Uber Eats returned an HTML error page instead of JSON. Causes: - The restaurant URL is invalid or the store no longer exists. - Uber Eats is experiencing temporary issues. - IP is temporarily blocked (wait and retry). #### No common items found If `commonItems` is empty, it means the fuzzy matching threshold (60% word overlap) did not find matches. This is expected when comparing restaurants with very different cuisines (e.g., sushi vs. burgers). Common items are most often found in: - Beverages (Coca-Cola, Sprite, water) - Desserts (Tiramisu, Brownie, ice cream) - Same-chain locations (identical menus) #### "Need at least 2 restaurants to compare" The `urls` input must contain at least 2 valid Uber Eats store URLs. Check that your URLs are complete and point to actual store pages (not search results or category pages). #### Run succeeds but `priceCoverage` is 0% Some restaurants on Uber Eats don't expose prices through the API (prices require customization selections). The Actor correctly reports this as 0% price coverage and excludes these restaurants from price rankings. This is not a bug -- it reflects the actual data available from Uber Eats. #### High memory usage with many restaurants Each restaurant's full menu is loaded into memory for comparison. The default Apify memory allocation handles 10-20 restaurants comfortably. For 50+ restaurants, consider increasing memory in the run configuration. *** ### ⚠️ Limitations - **No historical data** -- each run is a point-in-time snapshot. For trend analysis, schedule recurring runs and store results in a dataset externally. - **No item customization options** -- the Actor extracts base menu items and prices but not sub-options like sizes, sauces, or toppings (these require a separate API call per item). - **Fuzzy matching is approximate** -- the 60% word-overlap threshold works well for common cases but may miss matches for very short item names (1-2 words) or produce false positives for very generic names. - **Locale applies globally** -- you cannot set different locales for different restaurants in the same run. - **Prices are base prices** -- delivery fees, service fees, and promotions are not included in the comparison. - **Restaurant must be on Uber Eats** -- this Actor only works with Uber Eats. It does not support DoorDash, Deliveroo, Grubhub, or other platforms. - **No geocoding** -- you must provide direct restaurant URLs. The Actor does not search by address or GPS coordinates (use the Restaurant Search Actor for that step). *** ### 🔧 Technical Details | Property | Value | |---|---| | Runtime | Python 3.12 on Apify platform | | Dependencies | `httpx` (async HTTP), `apify` SDK | | Memory | Varies by run size (default Apify memory allocation) | | Typical run time | Typically completes quickly for 2-5 restaurants | | Data source | Uber Eats public web API (no auth required) | | Concurrency | All restaurants fetched in parallel (async) | | Standalone mode | Runs without Apify SDK via CLI | *** ### ⚙️ How the Actor Works Internally Understanding the internal pipeline helps you make the most of the dataset output. #### Step 1: URL Parsing Each input URL is parsed to extract the Uber Eats store UUID. The Actor handles multiple URL formats: - Base64-encoded UUIDs (the default on ubereats.com) - Standard UUID format (hex with dashes) - URLs with or without locale prefixes (`/fr/`, `/de/`, etc.) - URLs with query parameters and trailing slashes The locale prefix in the URL is stripped -- the `locale` input parameter controls the API language. #### Step 2: Concurrent API Fetching All restaurants are fetched in parallel using async HTTP. This means comparing 2 restaurants takes the same wall-clock time as comparing 10. #### Step 3: Menu Parsing For each restaurant, the Actor extracts: - Restaurant metadata (name, chain, cuisines, rating) - All menu sections with their titles - Individual items with name, description, price, image URL, and section assignment - Computed analytics: total items, average/min/max price, price coverage %, image coverage % #### Step 4: Fuzzy Comparison The comparison engine runs three analyses: 1. **Common items** -- every item in restaurant A is compared against every item in restaurant B (and C, D, etc.) using word-level fuzzy matching. Text is normalized (lowercased, accents removed, punctuation stripped) and split into words. If the word overlap between two item names is 60% or higher (relative to the shorter name), they are considered a match. 2. **Unique items** -- any item that does NOT fuzzy-match against any item in any other restaurant is flagged as unique to that restaurant. 3. **Category overlap** -- menu section names are compared across all restaurants. Sections present in every restaurant are listed as "shared". Each restaurant's full section list is also provided. #### Step 5: Winner Selection The Actor automatically selects winners in four categories: - **Cheapest overall** -- lowest average item price (excluding restaurants with 0% price coverage) - **Best image coverage** -- highest percentage of items with product images - **Most items** -- largest menu by item count - **Best rated** -- highest Uber Eats rating (only among restaurants with ratings) #### Step 6: Output The full result is pushed to the Apify default dataset as a single JSON object. The `status` field indicates whether all requests succeeded, some failed, or all failed. You can view and export the dataset from the Apify Console after each run. *** ### 📋 Changelog #### v1.0 (2026-03-30) - Initial release - Multi-restaurant menu fetching with concurrent async HTTP - Fuzzy item matching for cross-restaurant comparison - Price ranking (cheapest to most expensive) - Common items detection with price differences - Unique items per restaurant - Category overlap analysis - Winner analysis (cheapest, best rated, most items, best image coverage) - 12 locale support - Standalone CLI mode (runs without Apify SDK) *** ### 📍 Real-World Examples #### Example 1: Fast-Food Chain Price Comparison (France) Compare McDonald's, Burger King, and KFC in the same city to see who is cheapest: ```json { "urls": [ "https://www.ubereats.com/fr/store/mcdonalds-avon/nOGcJSUbXpqAqm_kPdhyOA", "https://www.ubereats.com/fr/store/burger-king-fontainebleau/EXAMPLE_ID", "https://www.ubereats.com/fr/store/kfc-melun/EXAMPLE_ID" ], "locale": "fr-FR" } ``` **What you learn:** - Which chain has the lowest average price - How Big Mac, Whopper, and Zinger prices compare - Which chain offers drinks, desserts, and sides that others don't - Which chain has the best image coverage (visual menu quality) #### Example 2: Local Pizza Restaurants Compare 5 independent pizza restaurants in your delivery zone: ```json { "urls": [ "https://www.ubereats.com/fr/store/pizza-one/ID1", "https://www.ubereats.com/fr/store/pizza-two/ID2", "https://www.ubereats.com/fr/store/pizza-three/ID3", "https://www.ubereats.com/fr/store/pizza-four/ID4", "https://www.ubereats.com/fr/store/pizza-five/ID5" ], "locale": "fr-FR" } ``` **What you learn:** - The average pizza price in your area (benchmark) - Common items across all 5 (Margherita, 4 Fromages, Calzone) and their price spread - Unique items that differentiate each restaurant - Whether adding a dessert or drink menu would fill a gap #### Example 3: Same Chain, Different Locations (Franchise Audit) Compare 3 McDonald's in different cities to check pricing consistency: ```json { "urls": [ "https://www.ubereats.com/fr/store/mcdonalds-paris-17/ID1", "https://www.ubereats.com/fr/store/mcdonalds-lyon-2/ID2", "https://www.ubereats.com/fr/store/mcdonalds-marseille-1/ID3" ], "locale": "fr-FR" } ``` **What you learn:** - Whether all locations follow the same pricing - Menu items available in one city but not another (regional specials) - Image coverage differences (some locations maintain menus better than others) *** ### 🔗 Related Actors Looking for more Uber Eats data tools? Check out our complete restaurant intelligence suite: - **Uber Eats Menu Scraper** -- Extract full menu data, analytics, ratings, legal info, and reviews from a single restaurant. Ideal when you need deep data on one specific store. - **Uber Eats Restaurant Search** -- Find restaurants by search query and GPS coordinates across multiple locales. Use it to discover competitor URLs, then feed them into this Menu Compare Actor. - **Uber Eats Price Checker** -- Find the cheapest price for any specific dish across multiple restaurants. Ask "who has the cheapest Margherita pizza in Paris?" and get an instant answer. #### 🚀 Recommended Workflow For maximum competitive intelligence for food delivery, combine these Actors: 1. **Search** -- Use Restaurant Search to find all burger restaurants within 5 km of your location. 2. **Compare** -- Feed the top 10 URLs into Menu Compare to see price rankings and menu gaps. 3. **Deep Dive** -- Use Menu Scraper on the top 3 competitors for full analytics, reviews, and legal data. 4. **Monitor** -- Schedule Menu Compare to run weekly and track price changes over time. *** ### 💬 Support Having issues or feature requests? Open an issue on the Actor's Apify Store page or contact us through the Apify platform. *** ### 📈 About Uber Eats Menu Comparison and Competitive Intelligence Uber Eats Menu Compare is a competitive intelligence Actor for food delivery on the Apify Store. For restaurant owners, franchise operators auditing pricing compliance, ghost kitchen operators, food delivery consultants, and market researchers, understanding competitive pricing on Uber Eats is essential for profitability. This Actor is built for automated restaurant price comparison and menu price monitoring. While most Uber Eats scrapers on the Apify Store extract data from a single restaurant at a time, this Actor compares restaurants against each other -- producing price rankings, common item detection, unique item analysis, and category overlap reports. The Actor fetches restaurant menus concurrently from publicly available Uber Eats data. It requires no login, no cookies, no browser emulation, and no Uber Eats account. It supports 12 locales covering France, the United States, the United Kingdom, Germany, Spain, Portugal, the Netherlands, Japan, Taiwan, Australia, Canada, and Mexico. The fuzzy item matching algorithm normalizes text, removes accents and punctuation, and uses word-level overlap detection to find common items even when names differ across restaurants. Whether you are tracking how your competitors price their burgers, auditing franchise pricing compliance across 50 locations, researching the food delivery market in a new city, or optimizing your ghost kitchen menu, this Uber Eats menu comparison Actor delivers structured, actionable data in seconds. Pay per event, no monthly subscription. Schedule it daily for continuous menu price monitoring. Export to Google Sheets, Slack, or your own database via Apify integrations. Try it now with the pre-filled example input and see the competitive intelligence you have been missing. # Actor input Schema ## `urls` (type: `array`): 2 or more Uber Eats restaurant URLs to compare. ## `locale` (type: `string`): Language and region code (e.g. fr-FR, en-US). Affects menu language and currency formatting. ## `proxy` (type: `object`): Proxy configuration for Apify platform. ## `proxy_url` (type: `string`): Custom proxy URL. Use this if you have your own proxy instead of Apify Proxy. ## Actor input object example ```json { "urls": [ "https://www.ubereats.com/fr/store/mcdonalds-avon/nOGcJSUbXpqAqm_kPdhyOA", "https://www.ubereats.com/fr/store/andiamo-pizza/FBe4vLkyX5C-kp0pYF5h0w" ], "locale": "fr-FR" } ``` # 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 = { "urls": [ "https://www.ubereats.com/fr/store/mcdonalds-avon/nOGcJSUbXpqAqm_kPdhyOA", "https://www.ubereats.com/fr/store/andiamo-pizza/FBe4vLkyX5C-kp0pYF5h0w" ] }; // Run the Actor and wait for it to finish const run = await client.actor("jsonjoestar/ubereats-menu-compare").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 = { "urls": [ "https://www.ubereats.com/fr/store/mcdonalds-avon/nOGcJSUbXpqAqm_kPdhyOA", "https://www.ubereats.com/fr/store/andiamo-pizza/FBe4vLkyX5C-kp0pYF5h0w", ] } # Run the Actor and wait for it to finish run = client.actor("jsonjoestar/ubereats-menu-compare").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 '{ "urls": [ "https://www.ubereats.com/fr/store/mcdonalds-avon/nOGcJSUbXpqAqm_kPdhyOA", "https://www.ubereats.com/fr/store/andiamo-pizza/FBe4vLkyX5C-kp0pYF5h0w" ] }' | apify call jsonjoestar/ubereats-menu-compare --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=jsonjoestar/ubereats-menu-compare", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Uber Eats Menu Compare — Competitive Intelligence", "description": "Compare menus, prices, and coverage across multiple Uber Eats restaurants. Fuzzy item matching, price ranking, unique items detection, winner analysis. The only competitive intelligence tool for Uber Eats.", "version": "1.0", "x-build-id": "y443Zcmxqneib3hd7" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/jsonjoestar~ubereats-menu-compare/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-jsonjoestar-ubereats-menu-compare", "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/jsonjoestar~ubereats-menu-compare/runs": { "post": { "operationId": "runs-sync-jsonjoestar-ubereats-menu-compare", "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/jsonjoestar~ubereats-menu-compare/run-sync": { "post": { "operationId": "run-sync-jsonjoestar-ubereats-menu-compare", "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": [ "urls" ], "properties": { "urls": { "title": "Restaurant URLs to compare", "minItems": 2, "type": "array", "description": "2 or more Uber Eats restaurant URLs to compare.", "items": { "type": "string" } }, "locale": { "title": "Locale", "enum": [ "fr-FR", "en-US", "en-GB", "de-DE", "es-ES", "pt-PT", "nl-NL", "ja-JP", "zh-TW", "en-AU", "en-CA", "es-MX" ], "type": "string", "description": "Language and region code (e.g. fr-FR, en-US). Affects menu language and currency formatting.", "default": "fr-FR" }, "proxy": { "title": "Proxy", "type": "object", "description": "Proxy configuration for Apify platform." }, "proxy_url": { "title": "Custom proxy URL", "type": "string", "description": "Custom proxy URL. Use this if you have your own proxy instead of Apify Proxy." } } }, "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 } } } } } } } } } } ```