# Uber Eats Scraper (`alkausari_mujahid/ubereats-scraper`) Actor

Scrape Uber Eats restaurants and shops with full menus: name, address, phone, hours, rating, cuisines, reviews and every menu item with price, photo and options. Paste store, city or cuisine links, or get every store that delivers to an address — any country.

- **URL**: https://apify.com/alkausari_mujahid/ubereats-scraper.md
- **Developed by:** [Alkausari M](https://apify.com/alkausari_mujahid) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 stores

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Uber Eats Scraper** extracts restaurants, shops and their full menus from [Uber Eats](https://www.ubereats.com) — no account, API key or browser needed. One Actor covers five jobs:

- 📍 **Every store that delivers to an address** — in any country, with the delivery time, fee and distance for that address. Type a street address or coordinates; no proxy country to pick. A busy city address returns 300–500 stores.
- 🍽️ **Full menus** — every dish with its section, description, price, photo, popularity (👍 93% of 302), calories and sold-out status, in a ready-made one-row-per-dish view.
- 🧩 **Sizes, sides and extras** — the choices for each dish with their prices, including nested ones (fries → sauce).
- 🏙️ **City and cuisine pages** — paste a city page or "pizza in Chicago" and every page of the list is followed.
- ⚡ **Quick store lists** — names, ratings, delivery times and offers without opening each store: dozens of stores per request.

Paste store links, city or cuisine pages, addresses — or mix them in one run. Stores start arriving within seconds, and results export to CSV, Excel or JSON, or flow into Google Sheets, Zapier and Make.

### Use cases

- 💰 **Menu price research** — compare what the same dish costs across restaurants, chains, cities or countries
- 🗺️ **Market mapping** — list every restaurant that delivers to an area, with cuisines, ratings and price levels
- 📇 **Lead generation** — build restaurant lists with phone numbers, addresses and opening hours
- 📊 **Competitor monitoring** — track menu changes, sold-out dishes, offers and ratings over time

### How to run the Actor

1. Click **Try for free**.
2. Paste Uber Eats links into **Uber Eats links**, or type addresses into **Delivery addresses** — or both.
3. Set **Max stores per page or address** to control how much you scrape.
4. Press **Start**, then open the **Output** tab and export.

Here is what each kind of input gives you:

| Paste                                            | You get                                                                                          |
| ------------------------------------------------ | ------------------------------------------------------------------------------------------------ |
| **Store link** (`…/store/…`)                     | That store with its full details and menu                                                        |
| **City page** (`…/city/chicago-il`)              | The stores Uber Eats lists for that city, page by page — up to about 200                         |
| **Cuisine page** (`…/category/chicago-il/pizza`) | The stores listed for that cuisine in that city                                                  |
| **Delivery address** or coordinates              | Every store that delivers there, each with its delivery time, fee and distance from that address |
| **Any other Uber Eats page**                     | The stores it links to                                                                           |

#### Quick list vs full details

| Mode                            | What you get                                                                                                                                        | Best for                         |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- |
| **Quick list**                  | What the list shows: name, link and photo, plus rating, delivery time and offers for addresses, or cuisines, price level and address for city pages | Mapping an area, counting stores |
| **Full details** *(default)*    | Everything above plus address, phone, opening hours, reviews and the full menu                                                                      | Menus, prices and leads          |
| **Full details + item options** | Everything above plus every dish's sizes, sides and extras with prices                                                                              | Complete menu pricing            |

Turn off **Open each store** for the quick list. Full details opens each store, and item options also
open every dish that has choices, so they take longer.

### Input

| Setting                            | What it does                                                                                     | Default     |
| ---------------------------------- | ------------------------------------------------------------------------------------------------ | ----------- |
| **Uber Eats links**                | Store, city, cuisine or other Uber Eats pages, from any country                                  | —           |
| **Delivery addresses**             | Street addresses or `latitude, longitude` coordinates; every store delivering there is collected | —           |
| **Max stores per page or address** | Stores to save from each city page, cuisine page or address (`0` = all of them)                  | `50`        |
| **Open each store**                | Full details, reviews and menu; turn off for the quick list                                      | On          |
| **Include menus**                  | Every dish on the menu                                                                           | On          |
| **Include item options**           | Each dish's sizes, sides and extras with prices                                                  | Off         |
| **Proxy configuration**            | Leave as default if unsure                                                                       | Apify Proxy |

Write addresses the way you'd type them into Uber Eats, with the city — and the country outside the
US. Store links are always opened in full, even in quick-list mode, since a link alone has no data.

#### Example input

```json
{
    "startUrls": [
        { "url": "https://www.ubereats.com/store/applebees-aberdeen/60q-Mi6tQ_apfwKS66-Rtw" },
        { "url": "https://www.ubereats.com/category/chicago-il/pizza" }
    ],
    "addresses": ["233 S Wacker Dr, Chicago, IL", "10 Downing Street, London, UK"],
    "maxStoresPerSearch": 50
}
```

### Output

One dataset, one row per store, with two ready-made views on the Output tab: **Stores**, and
**Menu items** with one row per dish and the store's name, address and link on every row — ready for
a spreadsheet. Here is a real record from an address search, shortened — the full record also has
the street, postcode, map coordinates, hours for each day and the whole menu:

```json
{
    "input": "233 S Wacker Dr, Chicago, IL",
    "rank": 3,
    "name": "Bowls of Rice (2537 S Wabash Ave)",
    "url": "https://www.ubereats.com/store/bowls-of-rice-2537-s-wabash-ave/fdRl62uAX7i4F_v6yCiixw",
    "rating": 4.7,
    "ratingCount": 5000,
    "priceLevel": 2,
    "cuisines": ["Asian Fusion", "Chinese", "Japanese", "Healthy"],
    "address": "2537 S Wabash Ave, Chicago, IL 60616",
    "phone": "+17738881018",
    "hoursText": "Sunday: 17:15–23:00; Monday - Saturday: 10:00–23:00",
    "openStatus": "Open until 11:00 PM",
    "deliveryTime": "22–40 Min",
    "deliveryFee": "$0 delivery fee (new users)",
    "distance": "2.3 mi",
    "reviews": [{ "author": "Maira M.", "text": "They left a sweet note with my food…", "date": "2025-02-24" }],
    "menuItemCount": 40,
    "menu": [
        {
            "section": "Chicken Rice Bowls",
            "itemName": "Crispy Chipotle Aioli Chicken Rice Bowl",
            "price": 11.95,
            "isSoldOut": false,
            "likePercent": 93,
            "likeCount": 302
        }
    ]
}
```

With **Include item options** on, each dish also lists its choices:

```json
"options": [
    {
        "name": "Add a side?",
        "maxChoices": 2,
        "choices": [
            { "name": "House Salad (v)", "price": 5 },
            { "name": "Sweet Potato Fries (v)", "price": 5.75 }
        ]
    }
]
```

Every record in a run carries the same columns, left empty where a store hasn't filled something in
— so Zapier, Make and Sheets can map them from a single sample.

### Pricing

You pay per store saved, so the bill is simply how many stores you asked for:

| Stores | Quick list | Full details | With item options |
| ------ | ---------- | ------------ | ----------------- |
| 100    | $0.15      | $0.40        | $0.80             |
| 1,000  | $1.50      | $4.00        | $8.00             |
| 10,000 | $15.00     | $40.00       | $80.00            |

Full details adds $2.50 per 1,000 stores for opening each store, and item options add $4.00 per 1,000
stores for opening their dishes — the price is per store, however many dishes it has. **Stores that
can't be read** — closed down or blocked — **are not charged.**

Set a **Maximum cost per run** in the run options and the Actor works out how many stores that pays
for, then stops there — it never fetches stores you won't be billed for.

### Getting every store in an area

**Uber Eats' city and cuisine pages list only about 200 stores**, even in a big city. A **delivery
address** has no such cap: it returns every store that delivers there — usually 300–500 in a big
city. Set **Max stores per page or address** to `0` to get them all.

Each address only reaches the stores that deliver to it, so for a whole city, add several addresses
spread across it:

```json
{
    "addresses": ["Wicker Park, Chicago, IL", "Hyde Park, Chicago, IL", "41.9484, -87.6553"],
    "maxStoresPerSearch": 0
}
```

| Spread by          | When it works well                                  |
| ------------------ | --------------------------------------------------- |
| **Neighbourhoods** | Big cities — name each area with the city           |
| **Postcodes**      | Cities where each postcode covers a small area      |
| **Coordinates**    | Exact coverage — pick points a few kilometres apart |

A store found from two addresses gets a row for each, with its own delivery time and fee. For a list
of unique stores, remove duplicates by the store link.

### Integrations & scheduling

Results don't have to stay on Apify. Without writing any code you can:

- **Send stores to Google Sheets, Airtable or Slack** — pick the integration on the Actor's
  Integrations tab and every run appends its results automatically.
- **Connect anything else via Zapier or Make** — thousands of apps, triggered when a run finishes.
- **Fire a webhook** to your own server the moment a run completes, with a link to the fresh dataset.
- **Pull the data over the API** in JSON, CSV, Excel or XML — one URL, ideal for a script or notebook.

**Run it on a schedule.** Point the Actor at the stores or addresses you follow, run it every morning
and send the output to a sheet — that's a working menu price tracker with no code at all. Every store
and dish carries Uber Eats' own ID, so you can match today's data against yesterday's to spot price
changes, new dishes and sold-out items.

### Tips

- Use coordinates for an exact spot — the log shows which address each entry was matched to.
- Switch the proxy to the RESIDENTIAL group if many requests fail.

### Good to know

- **Menus served right now** — Uber Eats shows the menus a store serves at the time of the run (no
  breakfast menu in the evening), and so does this Actor.
- **Grocery and convenience stores** — their front page shows only a sample of their range, so their
  menus are marked as partial.
- **Delivery details need an address** — delivery time, fee, distance and offers are filled for
  address searches only, since they depend on where the food goes.
- **Delivery fee** — shown as Uber Eats shows it to a visitor who isn't logged in, which is often a
  new-customer offer like "$0 delivery fee (new users)".
- **Addresses** — looked up with [OpenStreetMap](https://www.openstreetmap.org/copyright)
  (© OpenStreetMap contributors), with Uber Eats' own address search as the backup. If a short
  address like a bare postcode lands in the wrong country, add the city and country.
- **Fewer stores than expected** — check **Max stores per page or address**, then the ~200 cap on
  city and cuisine pages above. Store links that no longer exist are skipped and counted in the log.

### 📮 Support

Bugs, feature requests, or custom scraping work — open an issue on Apify, email
alkausarimujahid@gmail.com, or visit my website [ayzalsoft.com](https://ayzalsoft.com).

# Actor input Schema

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

Links from www.ubereats.com, from any country. Mix as you like:<br>• <b>Store pages</b> (…/store/…) — that store with its full menu.<br>• <b>City pages</b> (…/city/chicago-il) — the stores Uber Eats lists for that city, page by page.<br>• <b>Cuisine pages</b> (…/category/chicago-il/pizza) — the stores listed for that cuisine in that city.<br>• Any other Uber Eats page — the stores it links to.

## `addresses` (type: `array`):

Get every store that delivers to an address, like the Uber Eats app shows after you enter it. Write a street address with city (and country outside the US), or coordinates as latitude, longitude. Each store then also gets its delivery time, delivery fee and distance for that address.

## `maxStoresPerSearch` (type: `integer`):

How many stores to save from each city page, cuisine page or delivery address. Set to 0 for all of them (a busy address has 300–500 stores; city and cuisine pages list up to about 200). Store links are always saved.

## `scrapeDetails` (type: `boolean`):

On (default): read each store's full details — address, phone, opening hours, cuisines, rating, reviews and menu. Off: save only what the list shows (name, link, rating, delivery time, image) — much faster, one request per 20–80 stores.

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

Add every menu item with its section, description, price, photo, sold-out flag and popularity. The <b>Menu items</b> output view shows one row per item. Grocery and convenience shops only show a sample of their range on their front page, so their menus are marked partial.

## `includeItemOptions` (type: `boolean`):

Also open every menu item that has options and add its choices — sizes, sides, extras — with their prices. This takes one extra request per item, so runs are slower and cost more.

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

Proxy for all requests. Apify Proxy is the default; if Uber Eats starts refusing requests, switch to the RESIDENTIAL group.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.ubereats.com/store/applebees-aberdeen/60q-Mi6tQ_apfwKS66-Rtw"
    },
    {
      "url": "https://www.ubereats.com/category/chicago-il/pizza"
    }
  ],
  "addresses": [
    "233 S Wacker Dr, Chicago, IL"
  ],
  "maxStoresPerSearch": 50,
  "scrapeDetails": true,
  "includeMenu": true,
  "includeItemOptions": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

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

No description

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

No description

# 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": [
        {
            "url": "https://www.ubereats.com/store/applebees-aberdeen/60q-Mi6tQ_apfwKS66-Rtw"
        },
        {
            "url": "https://www.ubereats.com/category/chicago-il/pizza"
        }
    ],
    "addresses": [
        "233 S Wacker Dr, Chicago, IL"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alkausari_mujahid/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 = {
    "startUrls": [
        { "url": "https://www.ubereats.com/store/applebees-aberdeen/60q-Mi6tQ_apfwKS66-Rtw" },
        { "url": "https://www.ubereats.com/category/chicago-il/pizza" },
    ],
    "addresses": ["233 S Wacker Dr, Chicago, IL"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("alkausari_mujahid/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 '{
  "startUrls": [
    {
      "url": "https://www.ubereats.com/store/applebees-aberdeen/60q-Mi6tQ_apfwKS66-Rtw"
    },
    {
      "url": "https://www.ubereats.com/category/chicago-il/pizza"
    }
  ],
  "addresses": [
    "233 S Wacker Dr, Chicago, IL"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call alkausari_mujahid/ubereats-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alkausari_mujahid/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/CjfB2Dw6bIqU8zPrb/builds/tvUuXTOjEYawVvQ2V/openapi.json