# Uber Eats Scraper - Restaurants, Menus, Prices & Phone Leads (`scrapesage/ubereats-scraper`) Actor

Scrape Uber Eats restaurants & stores by city or URL: names, cuisines, ratings, price tier, full menus with prices, hours, geo-coordinates, delivery ETA and contact phone numbers. Includes a monitoring mode for only-new / changed data. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/scrapesage/ubereats-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Agents, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 restaurant scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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 Scraper — Restaurants, Menus, Prices & Phone Leads

Extract **complete Uber Eats restaurant & store data** — names, cuisines, ratings, review counts, price tier, **full menus with prices**, opening hours, exact geo-coordinates, and the field most scrapers leave empty: the **restaurant's contact phone number**. Search a whole city (or paste store URLs), filter to the venues you want, and turn every restaurant into a ready-to-contact lead.

No login, no cookies, no browser — fast direct-to-API extraction straight from Uber Eats' own internal endpoints.

### Why this Uber Eats scraper?

Most Uber Eats scrapers either need a slow headless browser (or a paid Firecrawl key), return listing cards only, or skip the data that matters for sales and pricing intelligence. This actor hits Uber Eats' internal JSON API directly and ships the **richest record in the category**:

| Data | Typical scrapers | This actor |
|---|---|---|
| Restaurant **contact phone** | ❌ often null | ✅ direct (E.164) |
| Rating + review count | partial | ✅ |
| Price tier ($–$$$$) | partial | ✅ |
| **Full menu** (sections, items, prices, photos) | partial / extra cost | ✅ |
| Full address + **lat/lng** | ❌ | ✅ |
| Opening hours (per day) | ❌ | ✅ |
| Cuisines, chain / independent | partial | ✅ |
| Lead score (0–100) | ❌ | ✅ |
| **Monitoring** — only new / changed venues | ❌ | ✅ |
| No browser / no Firecrawl key | ❌ | ✅ pure HTTP |

### Use cases

- **Lead generation** — restaurants and ghost kitchens are active buyers: they need POS systems, delivery tech, food distributors & suppliers, packaging, marketing agencies, and reputation tools. Get the **phone number, address, cuisine, rating and menu size** for every venue in a city and prospect them directly. Filter with `onlyWithPhone` and sort by `leadScore`.
- **Menu & price intelligence** — pull full menus with item-level prices to benchmark pricing, track menu changes, and analyse a market or a competitor.
- **Market research** — map the food-delivery landscape of any city: how many venues per cuisine, price-tier mix, rating distribution, chain vs independent.
- **Competitor & price monitoring** — schedule recurring runs with monitoring mode to watch a city for **newly listed restaurants** and **price/rating/menu changes** — only new data, every run.
- **Aggregation & apps** — feed restaurant directories, food apps and dashboards with clean, structured JSON.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Uber Eats Scraper**, enter a city (e.g. `Austin, TX`) or paste Uber Eats URLs, and click **Start**.
3. Watch restaurants stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "city": "Austin, TX",
    "cuisines": ["pizza", "sushi", "mexican"],
    "maxStores": 100,
    "includeStoreDetails": true,
    "includeMenu": true,
    "onlyWithPhone": true,
    "minRating": 4
}
```

- **city** — `City, ST` (e.g. `Austin, TX`, `Chicago, IL`, `Los Angeles, CA`) or an Uber Eats city slug (`austin-tx`, `new-york-city`).
- **cities** — additional cities to scrape in the same run.
- **cuisines** — target specific cuisine categories (`american`, `pizza`, `sushi`, `mexican`, `breakfast-and-brunch`, `dessert`, `vegan`, …). Leave empty to auto-discover every cuisine listed for the city (max coverage).
- **startUrls** — Uber Eats store pages (`/store/<slug>/<id>`), city pages (`/city/austin-tx`) or category pages (`/category/austin-tx/american`).
- **maxStores** *(default 60)* — cap on restaurants output for the whole run (0 = no limit).
- **maxCuisineCategories** *(default 16)* — how many cuisine pages to crawl per city for discovery (more = broader coverage).
- **includeStoreDetails** *(default true)* — open each store for phone, geo, hours, rating, price tier and cuisines (the lead-gen wedge).
- **includeMenu** *(default true)* — attach the full menu (sections → items with names, descriptions, prices, images).
- **includeReviews** *(default false)* — attempt to attach review text (best-effort; the rating value and review count are always included).
- **minRating / priceBuckets / openOnly / onlyWithPhone** — filters to target exactly the venues you want.
- **monitorMode** *(default false)* — emit only NEW and CHANGED restaurants across runs (see below).

### Output

One record per restaurant/store (`type: "restaurant"`), with the full menu nested:

```json
{
    "type": "restaurant",
    "storeUuid": "21bbaea5-76fe-4a2f-829a-e7f43e5fa6b1",
    "name": "Wow Poke (E. Cesar Chavez)",
    "url": "https://www.ubereats.com/store/wow-poke-e-cesar-chavez/21bbaea5-76fe-4a2f-829a-e7f43e5fa6b1",
    "phone": "+19292175198",
    "rating": 4.8,
    "reviewCount": 312,
    "priceBucket": "$",
    "priceTier": 1,
    "currency": "USD",
    "cuisines": ["Poke", "Hawaiian", "Healthy"],
    "isChain": false,
    "parentChainName": null,
    "address": "1620 E Cesar Chavez St, Austin, TX 78702",
    "city": "Austin",
    "region": "TX",
    "postalCode": "78702",
    "country": "US",
    "latitude": 30.2585,
    "longitude": -97.7281,
    "isOpen": true,
    "isOrderable": true,
    "supportedDiningModes": ["DELIVERY", "PICKUP"],
    "workingHoursTagline": "Open until 9:30 PM",
    "hours": [{ "day": "Monday - Sunday", "hours": ["11:00 AM–9:30 PM"] }],
    "menuItemCount": 33,
    "menu": [
        {
            "section": "House Poke Bowls",
            "itemCount": 6,
            "items": [
                { "name": "Spicy Tuna Bowl", "description": "Tuna, sriracha aioli, …", "price": 13.95, "priceText": "$13.95", "imageUrl": "https://…", "isSoldOut": false, "hasCustomizations": true }
            ]
        }
    ],
    "leadScore": 92,
    "scrapedAt": "2026-06-16T22:40:00.000Z"
}
```

Prices are returned in the store's currency. When a venue is added or changes in monitoring mode, the record is tagged with `changeType: "new"` or `"updated"`.

### Monitoring mode — only new & changed restaurants

Turn on **monitorMode** to track a city without re-paying for rows you already have. The actor remembers every restaurant it has seen (in a named key-value store) and, on each run, emits only:

- **New** restaurants that appeared since last time (`changeType: "new"`), and
- restaurants whose **rating, review count, price tier or menu size changed** (`changeType: "updated"`).

This pairs perfectly with **[Apify Schedules](https://docs.apify.com/platform/schedules)** — the schedule triggers the run on your cadence (hourly/daily/weekly); monitoring mode controls *what gets emitted and charged*. Use a distinct `monitorStoreName` per city/feed to keep histories separate.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly to monitor a city for new restaurants and price changes; perfect for lead pipelines and price trackers.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, sheet append) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/ubereats-scraper').call({
    city: 'Austin, TX',
    maxStores: 200,
    onlyWithPhone: true,
    includeMenu: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} Uber Eats restaurants & leads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new restaurant leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored city gets new restaurants.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find the top-rated sushi restaurants in Austin on Uber Eats and list their phone numbers" and let it run this scraper.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **local-business & food lead-gen stack**:

- **[Zomato Scraper](https://apify.com/scrapesage/zomato-scraper)** — restaurants, menus, ratings & phone leads (India & UAE).
- **[Foodpanda Scraper](https://apify.com/scrapesage/foodpanda-scraper)** — restaurants, menus & prices across Asia.
- **[Thumbtack Scraper](https://apify.com/scrapesage/thumbtack-scraper)** — home-service pro leads, reviews & hire data.
- **[Booksy Scraper](https://apify.com/scrapesage/booksy-scraper)** — beauty & wellness business leads.
- **[Fresha Scraper](https://apify.com/scrapesage/fresha-scraper)** — salons, spas & barbers with contact details.
- **[Weedmaps Scraper](https://apify.com/scrapesage/weedmaps-scraper)** — dispensary listings, menus & licenses.
- **[Craigslist Scraper](https://apify.com/scrapesage/craigslist-scraper)** — classifieds, housing, services & gigs.
- **[Google News Scraper](https://apify.com/scrapesage/google-news-scraper)** — articles, real URLs & monitoring.

### Tips

- **Max coverage**: leave `cuisines` empty and raise `maxCuisineCategories` — the actor crawls the city page plus each cuisine category, surfacing several hundred unique restaurants per city.
- **Lead-gen runs**: set `onlyWithPhone: true` and `includeMenu: false` for the fastest, cheapest contact list; sort by `leadScore`.
- **Price tracking**: keep `includeMenu: true` and use monitoring mode on a daily schedule to capture menu/price changes.
- **Proxies**: the default datacenter proxy works well. If you see blocks on very large runs, switch `proxyConfiguration` to RESIDENTIAL (US).
- **Cost control**: turn off `includeStoreDetails` for a listing-only pass, or cap with `maxStores`.

### FAQ

**How do I scrape Uber Eats restaurants for a specific city?** Put it in `city` as `City, ST` (e.g. `Austin, TX`) or an Uber Eats slug (`austin-tx`, `new-york-city`). Add `cuisines` to target categories, or leave it empty to auto-discover all of them.

**Does it get phone numbers?** Yes — Uber Eats publishes a contact phone on most store pages, returned in the `phone` field (E.164). Use `onlyWithPhone` to keep only venues that have one.

**Can I get full menus with prices?** Yes — keep `includeMenu` on and each record includes a `menu` array of sections → items with names, descriptions, prices and images.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new restaurants automatically?** Turn on `monitorMode`, then create a [Schedule](https://docs.apify.com/platform/schedules). Each run emits only new/changed venues; add a [webhook](https://docs.apify.com/platform/integrations/webhooks) or [Zapier zap](https://docs.apify.com/platform/integrations/zapier) to push them into your CRM.

**Is scraping Uber Eats legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (GDPR/CCPA for personal data) and Uber Eats' terms.

**A field is null — why?** Some venues genuinely don't publish a phone, price tier, or coordinates. Fields are `null` only when the data doesn't exist, not because the scraper skipped them.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `city` (type: `string`):

City to scrape (the lead-gen workhorse). Use `City, ST` (e.g. `Austin, TX`, `Chicago, IL`, `Miami, FL`, `Los Angeles, CA`) or an Uber Eats city slug (`austin-tx`, `new-york-city`). The scraper crawls the city page plus its cuisine categories to gather a broad set of restaurants/stores.

## `cities` (type: `array`):

Additional cities to scrape in the same run, each crawled fully (e.g. `Seattle, WA`, `Denver, CO`).

## `cuisines` (type: `array`):

Limit / target the cuisine categories crawled per city, e.g. `american`, `mexican`, `pizza`, `sushi`, `chinese`, `italian`, `breakfast-and-brunch`, `dessert`, `fast-food`, `vegan`. Leave empty to auto-discover every cuisine listed for the city (recommended for max coverage).

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

Uber Eats URLs to scrape directly. Store pages (`https://www.ubereats.com/store/<slug>/<id>`) are scraped as full restaurant records; city pages (`/city/austin-tx`) and category pages (`/category/austin-tx/american`) are crawled for their store listings.

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

Maximum number of restaurants/stores to output across the whole run (0 = no limit). A big city can surface several hundred via the cuisine categories.

## `maxCuisineCategories` (type: `integer`):

How many cuisine category pages to crawl per city for discovery (each adds ~20 mostly-unique restaurants). Higher = broader coverage, more requests.

## `includeStoreDetails` (type: `boolean`):

For each restaurant, open its store page to capture the contact phone number, exact GPS coordinates, full address, opening hours, rating + review count, price tier and cuisines. This is the lead-gen wedge. Turn off for a faster, listing-only run.

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

Attach the full menu (sections → items with names, descriptions, prices and images) to each restaurant record. Great for price/menu intelligence. Charged once per restaurant that has a menu.

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

Attempt to attach customer reviews to each restaurant. Uber Eats exposes review TEXT inconsistently; the rating value and review count are always included regardless. No extra charge.

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

When reviews are included, the maximum number of reviews to keep per restaurant.

## `minRating` (type: `integer`):

Only keep restaurants with a rating at or above this value (0 = keep all). Useful to target highly-rated venues.

## `priceBuckets` (type: `array`):

Only keep restaurants in these price tiers. Use `$`, `$$`, `$$$` or `$$$$`. Leave empty to keep all.

## `openOnly` (type: `boolean`):

Drop restaurants that are currently closed.

## `onlyWithPhone` (type: `boolean`):

Drop restaurants where Uber Eats does not publish a contact phone number (lead-gen focus).

## `monitorMode` (type: `boolean`):

Remember restaurants seen in previous runs (in a named key-value store) and emit only NEW restaurants and ones whose rating, review count, price or menu size changed (tagged with `changeType`). Perfect for tracking a city on a schedule without re-paying for unchanged rows. Works alongside Apify Schedules — the schedule triggers the run, this controls what's emitted.

## `monitorStoreName` (type: `string`):

Named key-value store holding the 'already seen' store ids/fingerprints for monitoring mode. Use a different name per tracked city/feed to keep histories separate. Lowercase letters, digits and hyphens only.

## `localeCode` (type: `string`):

Uber Eats locale code for the API (default `en-US`). Uber Eats operates in 30+ countries.

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

Maximum number of store pages fetched in parallel.

## `proxyConfiguration` (type: `object`):

Proxy settings. Apify Proxy is required. The default (datacenter) works well; if you see blocks on large runs, switch to RESIDENTIAL (US).

## `urlsFromFile` (type: `string`):

Paste a list of URLs (one per line), OR one link to a .txt/.csv file, Google Sheet or Google Drive file containing them. Lets you import many Start URLs at once instead of typing each. Google Sheet/Drive share links are handled automatically.

## Actor input object example

```json
{
  "city": "Austin, TX",
  "maxStores": 60,
  "maxCuisineCategories": 16,
  "includeStoreDetails": true,
  "includeMenu": true,
  "includeReviews": false,
  "maxReviewsPerStore": 20,
  "minRating": 0,
  "openOnly": false,
  "onlyWithPhone": false,
  "monitorMode": false,
  "monitorStoreName": "ubereats-monitor",
  "localeCode": "en-US",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped restaurant/store records in the default dataset.

# 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 = {
    "city": "Austin, TX",
    "urlsFromFile": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/ubereats-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 = {
    "city": "Austin, TX",
    "urlsFromFile": "",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/ubereats-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "city": "Austin, TX",
  "urlsFromFile": ""
}' |
apify call scrapesage/ubereats-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapesage/ubereats-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/uro7mecAy49b9ge6Q/builds/PPa9Ls0abDjG3iIDq/openapi.json