# Uber Eats Scraper \[Only $2/1K💰] | Menus | Restaurant Data (`ahmed_jasarevic/ubereats-scraper`) Actor

Scrape Uber Eats restaurant data — full menus with prices, ratings, cuisines, hours and delivery info via Uber's internal JSON API. No browser, no API key. $0.002/restaurant.

- **URL**: https://apify.com/ahmed_jasarevic/ubereats-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 4 total users, 3 monthly users, 95.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 1,000 restaurants

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

Scrape **Uber Eats restaurant data** — full menus with prices, restaurant details, cuisines, ratings, delivery info, opening hours and review samples — by calling Uber Eats' own internal JSON API directly. No browser, no DOM scraping. Built for restaurant groups, ghost kitchens, food-delivery aggregators, hospitality VCs and menu price-monitoring teams.

**$0.002 per restaurant** — the cheapest verified Uber Eats scraper on the Apify Store — with menu items billed at $0.00005 and reviews at $0.00005.

### Main Use Cases

- **Restaurant lead generation** — structured restaurant lists with phone, address, hours, cuisine and ratings per city
- **Menu price monitoring** — track item prices across competitors and over time, per location and dining mode
- **Food delivery market research** — cuisines, price buckets, ratings, delivery fees and ETAs across markets
- **Ghost kitchen / hospitality data** — identify restaurant chains, parent chains and store types (including grocery and alcohol)
- **Competitor restaurant analysis** — compare ratings, menu coverage, item counts and price levels

### How It Works

Uber Eats' web app does not server-render its data — the Next.js front end hydrates from a private JSON API. This actor calls those endpoints directly (`getFeedV1` for restaurant search/browse, `getStoreV1` for restaurant + full menu in one response), using Crawlee's `CheerioCrawler` with a browser TLS/HTTP2 fingerprint that clears Cloudflare's managed challenge. **No browser is launched**, which makes runs dramatically cheaper and faster than browser-based alternatives. The proxy is enabled by default to rotate egress IPs, since sustained runs from one datacenter IP earn a bare HTTP 403 once Uber decides the IP is hot.

### Build Restaurant Databases Without an Official API

Uber's official Uber Eats API requires partnership approval. This actor reads the same endpoints the website uses — no approval, no API key. Output is delivered as three separate datasets (restaurants, menu items, reviews), each billed under its own event, so you only pay for the data you actually consume.

### Extract Full Restaurant Menus With Prices

With `includeMenu: true` (default), every restaurant is expanded into `menuSections` and `menuItems` — name, description, price (integer minor units, e.g. `1299` = $12.99), image, availability status and customizations flag. Items are deduplicated by UUID (Uber repeats the same item across promotional carousels), and every other section an item appeared in is kept in `alsoInSections`. A per-store `analytics` rollup reports price/image/description coverage plus min/max/average price.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `address` | string | No | `New York, NY` | Free-text place to search, e.g. `Chicago, IL`, `Berlin`. Geocoded via Open-Meteo. Ignored when latitude + longitude are supplied |
| `latitude` / `longitude` | number | No | – | Supply both to skip geocoding |
| `addressCountry` | string | No | `us` | Two-letter country code to disambiguate the geocoded address |
| `searchQuery` | string | No | `""` | Single keyword search, e.g. `sushi`. Empty = plain location feed |
| `searchQueries` | array | No | `[]` | Several keyword searches in one run. Takes precedence over `searchQuery` |
| `startUrls` | array | No | `[]` | Direct store URLs, e.g. `https://www.ubereats.com/store/...`. When set, search inputs are ignored |
| `excludeStores` | array | No | `[]` | Store UUIDs/URLs to skip even if they appear in results |
| `storeType` | string | No | `""` | Restrict the feed, e.g. `uber_eats`, `grocery`, `alcohol` |
| `maxItems` | integer | No | `20` | Hard cap on restaurants. Free users capped at 10 |
| `includeMenu` | boolean | No | `true` | Expand each restaurant into `menuSections`/`menuItems` + per-store analytics |
| `maxMenuItemsPerStore` | integer | No | `250` | Cap on menu items kept per restaurant |
| `maxFeedPages` | integer | No | `1` | Feed pages per query (~80 restaurants each); Uber caps a location feed at 500 |
| `includeReviews` | boolean | No | `true` | Collect the public review sample into a separate reviews dataset |
| `maxReviews` | integer | No | `0` | Cap on reviews per restaurant (`0` = no cap), applied after `reviewsSince` |
| `reviewsSince` | string | No | `""` | Only reviews with `createdAt >=` this ISO date — cheap incremental scheduled runs |
| `locale` | string | No | `us` | Uber Eats locale code, e.g. `us`, `gb`, `de`, `fr`, `au`, `ca` |
| `diningMode` | string | No | `DELIVERY` | `DELIVERY` or `PICKUP` — controls ETA/fee context |
| `maxConcurrency` / `minConcurrency` | integer | No | `4` / `1` | Autoscaled parallelism range |
| `maxRequestRetries` | integer | No | `3` | Retries before a store is skipped |
| `proxy` | object | No | on | Apify proxy picker — **on by default** (see anti-bot notes) |

### Output — Three Datasets

Each row is as small as its own grain; runs never pile up in a shared store (every run writes its own fresh instance of all three).

| Dataset | Grain | Billed as | Price |
|---|---|---|---|
| `restaurants` (default) | 1 row per restaurant | `apify-default-dataset-item` | $0.002 |
| `menuItems` | 1 row per distinct menu item | `menu-items` | $0.00005 |
| `reviews` | 1 row per review | `reviews` | $0.00005 |

#### Restaurant row (lean — menus and reviews are counted, not nested)

Identity: `storeUuid, storeId, shopId, shopName, name, title, storeSlug, url, originalUrl, restaurantUrl, source (search|browse|startUrl), sourceQuery, citySlug, locale, currencyCode`
Location: `latitude, longitude, geo, address (schema.org PostalAddress), addressText, locationType, distanceText`
Classification: `cuisineList, categories, priceBucket, merchantType`
Rating: `ratingValue, reviewCount, ratingCountExact, ratingAccessibilityText`
Delivery: `isOpen, isOrderable, deliveryFeeText, serviceFeeText, etaRange, etaMinutes, isDeliveryAvailable, isPickupAvailable, supportedDiningModes, promotion`
Store detail: `phoneNumber, workingHoursTagline, image, heroImageUrls, hours, parentChain`
Counts & derived: `hasMenu, menuItemCount, menuSectionCount, catalogItemCount, reviewCountReturned, itemCustomizationsEnabled, customizationItemsCount, faqCount, analytics, scrapedAt`

#### Menu item row

`itemUuid, name, description, priceDecimal ("12.99"), priceFormatted ("$12.99"), currency, imageUrl, hasImage, isSoldOut, isAvailable, availabilityState, hasCustomizations, section, sectionUuid, subsection, subsectionUuid, alsoInSections, endorsementRating, endorsementNumRatings` + denormalized `storeUuid, storeName, storeUrl, runId, scrapedAt`

#### Review row

`reviewUuid` (Uber's stable `contentUUID` — dedup key across runs), `text, author, createdAt, formattedDate, timeSinceReview, source, rating` + denormalized store aggregates and `runId, scrapedAt`

> **Honest limitations (confirmed, not guessed):** reviews are a sample (often 1–3, up to ~28 on busy US stores) — not the `reviewCount` total, and there is no paginated review feed. There is no per-review star rating (Uber publishes only store-level aggregates), so `rating` is usually `null`. `deliveryFeeText` is often `null` because the real fee requires a cart round-trip.

### Collect Food Delivery Market Data — Example Input

```json
{
  "address": "Chicago, IL",
  "searchQuery": "sushi",
  "maxItems": 20,
  "includeMenu": true,
  "includeReviews": true,
  "locale": "us"
}
```

Minimal run (restaurants only, cheapest):

```json
{
  "address": "Berlin",
  "maxItems": 50,
  "includeMenu": false,
  "includeReviews": false
}
```

### Example Output — Restaurant Row

```json
{
  "storeUuid": "657c9027-28b4-5d3b-a4f9-16425d8bc99b",
  "name": "Tarallucci e Vino Union Square",
  "source": "search",
  "citySlug": "new-york",
  "currencyCode": "USD",
  "address": { "@type": "PostalAddress", "streetAddress": "15 E 18th St", "addressLocality": "New York", "addressRegion": "NY", "postalCode": "10003", "addressCountry": "US" },
  "cuisineList": ["Breakfast and Brunch", "Italian", "Comfort Food"],
  "ratingValue": 4.8,
  "reviewCount": "33",
  "etaRange": "21-38 Min",
  "phoneNumber": "+12122285400",
  "menuItemCount": 55,
  "catalogItemCount": 61,
  "analytics": { "totalItems": 55, "itemsWithPrice": 55, "priceCoverage": 100, "minPrice": 325, "maxPrice": 3100, "averagePrice": 1273.91 }
}
```

### Integrations & Automation

- **API** — run and fetch via the Apify REST API, or call it from AI agents through the Apify MCP server
- **Scheduling** — daily/weekly runs per city for menu price monitoring and market research
- **Incremental reviews** — set `reviewsSince` to last run's date so scheduled runs only collect new reviews and you are never re-charged for data you already have
- **Webhooks** — push each finished run's datasets to your warehouse or BI tool
- **Export** — JSON, CSV, Excel, XML, HTML per dataset

**Recommended schedule**: weekly per city for market research; daily with `reviewsSince` for review monitoring; daily for price monitoring on a fixed location.

### Related Actors

- [Uber Eats Scraper](https://apify.com/memo23/uber-eats-scraper) — `memo23/uber-eats-scraper` — $0.0025/restaurant + additional-data fees for lead scoring
- [Uber Eats Restaurant Scraper](https://apify.com/natanielsantos/uber-eats-scraper) — `natanielsantos/uber-eats-scraper` — $0.004/store + $0.0005/menu item (10x our menu price)
- [UberEats Reviews Scraper](https://apify.com/e-commerce/ubereats-reviews-scraper) — `e-commerce/ubereats-reviews-scraper` — independent review-focused actor, $0.0003/review
- [Uber Eats Scraper - Restaurants, Menus, Prices & Phone Leads](https://apify.com/scrapesage/ubereats-scraper) — `scrapesage/ubereats-scraper` — $0.005/restaurant + $0.003 menu fee

### FAQ

#### Why use this actor instead of the official Uber Eats API?

There is no public Uber Eats API — the official integration requires partner approval. This actor calls Uber's own internal `www` JSON endpoints (`getFeedV1`, `getStoreV1`) with a TLS fingerprint that passes Cloudflare's managed challenge, so it needs no API key, no browser and no paid anti-bot service.

#### What are alternatives to this actor for Uber Eats food delivery data?

Store alternatives for restaurant data: [borderline/uber-eats-scraper-ppr](https://apify.com/borderline/uber-eats-scraper-ppr) ($0.005/restaurant — 2.5x our price), [natanielsantos/uber-eats-scraper](https://apify.com/natanielsantos/uber-eats-scraper) ($0.004/store), [datacach](https://apify.com/datacach) ($0.00499), [jdtpnjtp](https://apify.com/jdtpnjtp/uber-eats-restaurant-scraper) ($0.0022 listing + $0.007 full detail). Ours is the cheapest per restaurant at $0.002 with menu items billed 5-10x cheaper than any competitor.

#### How can I scrape Uber Eats menus and prices?

Runs use `getStoreV1` — one POST returns the restaurant record *and* its entire menu. Set `includeMenu: true`, point the actor at an address (or pass `startUrls`), and each restaurant row plus its `menuItems` dataset rows are produced in one pass.

#### Uber Eats vs DoorDash for restaurant market research?

This actor covers Uber Eats only. For food delivery market research across platforms, pair it with a DoorDash scraper — this actor's per-restaurant price keeps multi-city research affordable.

#### Why did my run return zero restaurants?

Usually one of: the proxy was disabled and Uber 403'd the datacenter IP (re-enable the default proxy), or `Accept-Language`/`Content-Type` headers were missing on feed paging. The actor reports Cloudflare challenges explicitly rather than failing silently.

#### How much does it cost?

$0.002 per restaurant, $0.00005 per menu item, $0.00005 per review, $0.0005 actor start. Turning off `includeMenu`/`includeReviews` bills nothing for that data. `maxTotalChargeUsd` is respected — the run stops crawling once the budget is spent.

### For AI Agents & LLM Apps

- **Purpose**: given an address (or store URLs) returns one row per Uber Eats restaurant with ratings, cuisines, hours, phone, delivery ETA/fees, plus optional full menus (1 row per menu item) and a review sample (1 row per review) in separate datasets.
- **Minimal working input**:

```json
{ "address": "Chicago, IL", "maxItems": 5, "includeMenu": false, "includeReviews": false }
```

- **Variant inputs**: direct stores — `{ "startUrls": ["https://www.ubereats.com/store/jessies-breakfast/UAVHGNSBQCeqhKzEtis3SQ"] }`; menus — `{ "address": "Berlin", "includeMenu": true, "includeReviews": false }`; incremental reviews — add `"reviewsSince": "2026-01-01"`.
- **Output fields** — `restaurants`: `storeUuid, name, shopName, url, address, geo, cuisineList, priceBucket, ratingValue, reviewCount, etaRange, deliveryFeeText, phoneNumber, hours, parentChain, menuItemCount, analytics, source` (+ many more). `menuItems`: `itemUuid, name, description, priceDecimal, priceFormatted, currency, imageUrl, isSoldOut, section, alsoInSections`. `reviews`: `reviewUuid, text, author, createdAt, rating`.
- **Behaviors an agent should know**: `startUrls` overrides all search inputs. `searchQueries` takes precedence over `searchQuery`; both are capped by `maxItems` in total. `includeMenu`/`includeReviews` are on by default — turn them off if you only need restaurant rows (they add billed rows to separate datasets). Prices are integer minor units in `price` and `analytics.*` (divide by 100); use `priceDecimal`/`priceFormatted` for display. `reviewsSince` only keeps reviews newer than the date — set it on scheduled runs to avoid re-billing. `maxItems` caps restaurants only, not menu/review rows. The proxy input is on by default and its traffic is billed separately by Apify — disabling it risks empty runs from datacenter IPs.
- **Billing**: pay-per-event — $0.002/restaurant, $0.00005/menu item, $0.00005/review, $0.0005 start; only rows actually stored are billed.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Uber, Uber Eats, or any of their affiliates. It accesses only publicly available data through the same endpoints Uber Eats' website uses; it does not bypass login walls or access private account data. You are responsible for complying with Uber's Terms of Service and applicable law, including data-protection rules (e.g. GDPR, CCPA) if you process restaurant or review data of identifiable persons, and you must not use any personal contact data for unsolicited commercial outreach in violation of applicable law (e.g. CAN-SPAM, GDPR, TCPA).

### SEO Keywords

uber eats scraper, restaurant menu data, uber eats menu scraper, food delivery market research, restaurant lead generation, menu price monitoring, ghost kitchen data, restaurant ratings data, delivery fee data, uber eats api alternative, restaurant reviews data, food delivery aggregator data, hospitality market research, restaurant price tracking, competitor restaurant analysis, uber eats store data, cuisine list data, restaurant opening hours data, restaurant discovery api, uber eats pickup delivery data

# Actor input Schema

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

Free-text place to search, e.g. "Chicago, IL", "Berlin", "Soho, London". Geocoded to coordinates via Open-Meteo. Ignored when latitude and longitude are both supplied.

## `latitude` (type: `number`):

Explicit latitude. Provide together with longitude to skip geocoding.

## `longitude` (type: `number`):

Explicit longitude. Provide together with latitude to skip geocoding.

## `addressCountry` (type: `string`):

Two-letter country code used to disambiguate the geocoded address, e.g. "us", "gb", "de".

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

Keyword restaurant search, e.g. "sushi". Leave empty to browse the plain location feed.

## `searchQueries` (type: `array`):

Run several keyword searches in one run, e.g. \["sushi", "pizza"]. These take precedence over Search query and are all capped by maxItems in total.

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

Direct restaurant URLs to scrape, e.g. https://www.ubereats.com/store/jessies-breakfast/UAVHGNSBQCeqhKzEtis3SQ. When set, the search inputs are ignored.

## `excludeStores` (type: `array`):

Store UUIDs or full store URLs to skip, even if they appear in search results. Useful to avoid re-scraping stores you already have.

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

Restrict the feed to a store type, e.g. "uber_eats", "grocery", "alcohol". Leave empty for all types.

## `maxItems` (type: `integer`):

Hard cap on restaurants returned. Free users are capped at 10 regardless of this value.

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

Expand each restaurant into menuSections and menuItems (name, description, price, image, availability), plus a per-store analytics block.

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

Cap on menu items kept per restaurant. Duplicate items across promotional carousels are deduplicated.

## `maxFeedPages` (type: `integer`):

How many pages of the search feed to fetch per search query. Each page yields roughly 80 restaurants. Uber Eats itself caps the feed at 500 results per location.

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

Collect the public review sample and write it to a separate per-run reviews dataset, one row per review. Uber Eats only exposes a small sample of reviews (often 1-3, occasionally up to ~28 on some US stores) - this is not the total ratings count.

## `maxReviews` (type: `integer`):

Cap on reviews kept per restaurant, applied after the reviewsSince filter. Set to 0 for no cap.

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

Only return reviews with createdAt >= this date, e.g. "2025-01-01". Use it for cheap incremental scheduled runs so you are not re-charged for reviews you already have. Leave empty for all reviews.

## `locale` (type: `string`):

Uber Eats locale code, e.g. "us", "gb", "de", "fr", "au", "ca".

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

DELIVERY or PICKUP. Controls the ETA and fee context returned by the store endpoint.

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

Maximum number of restaurants fetched in parallel. Lower this if you hit rate limits.

## `minConcurrency` (type: `integer`):

Lower bound of the autoscaled concurrency range.

## `maxRequestRetries` (type: `integer`):

How many times a failed request is retried before the store is skipped.

## `proxy` (type: `object`):

Proxy configuration for outgoing requests. Enabled by default: Uber frequently returns HTTP 403 to repeatedly-used datacenter IPs, which produces empty results. Proxy usage is billed separately by Apify at a small fraction of the per-restaurant price. Disable it only if you accept that runs may come back empty.

## Actor input object example

```json
{
  "address": "New York, NY",
  "addressCountry": "us",
  "searchQuery": "",
  "searchQueries": [],
  "startUrls": [],
  "excludeStores": [],
  "storeType": "",
  "maxItems": 20,
  "includeMenu": true,
  "maxMenuItemsPerStore": 250,
  "maxFeedPages": 1,
  "includeReviews": true,
  "maxReviews": 0,
  "reviewsSince": "",
  "locale": "us",
  "diningMode": "DELIVERY",
  "maxConcurrency": 4,
  "minConcurrency": 1,
  "maxRequestRetries": 3,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `restaurants` (type: `string`):

One item per scraped Uber Eats restaurant: name, PostalAddress, opening hours, aggregate rating and review count, delivery time and fees, cuisine tags, and an analytics block with price/image/description coverage. Menus and reviews are NOT nested here - see the menuItems and reviews outputs.

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

One item per menu item across all scraped restaurants, each row carrying the parent restaurant's name and UUID. Includes price in minor and major units, availability, sold-out state, image URL, the section it was found in, and any other sections the same dish appears in. Each row carries the `runId` that produced it.

## `reviews` (type: `string`):

One item per public review, each row carrying the parent restaurant's name, UUID, aggregate rating and currency. This is the review sample Uber's public page exposes - typically 1-3 per restaurant, occasionally more. Each row carries the `runId` that produced it.

# 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 = {
    "address": "New York, NY",
    "addressCountry": "us",
    "searchQuery": "",
    "searchQueries": [],
    "startUrls": [],
    "excludeStores": [],
    "storeType": "",
    "maxItems": 20,
    "includeMenu": true,
    "maxMenuItemsPerStore": 250,
    "maxFeedPages": 1,
    "includeReviews": true,
    "maxReviews": 0,
    "reviewsSince": "",
    "locale": "us",
    "diningMode": "DELIVERY",
    "maxConcurrency": 4,
    "minConcurrency": 1,
    "maxRequestRetries": 3,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = {
    "address": "New York, NY",
    "addressCountry": "us",
    "searchQuery": "",
    "searchQueries": [],
    "startUrls": [],
    "excludeStores": [],
    "storeType": "",
    "maxItems": 20,
    "includeMenu": True,
    "maxMenuItemsPerStore": 250,
    "maxFeedPages": 1,
    "includeReviews": True,
    "maxReviews": 0,
    "reviewsSince": "",
    "locale": "us",
    "diningMode": "DELIVERY",
    "maxConcurrency": 4,
    "minConcurrency": 1,
    "maxRequestRetries": 3,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/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 '{
  "address": "New York, NY",
  "addressCountry": "us",
  "searchQuery": "",
  "searchQueries": [],
  "startUrls": [],
  "excludeStores": [],
  "storeType": "",
  "maxItems": 20,
  "includeMenu": true,
  "maxMenuItemsPerStore": 250,
  "maxFeedPages": 1,
  "includeReviews": true,
  "maxReviews": 0,
  "reviewsSince": "",
  "locale": "us",
  "diningMode": "DELIVERY",
  "maxConcurrency": 4,
  "minConcurrency": 1,
  "maxRequestRetries": 3,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call ahmed_jasarevic/ubereats-scraper --silent --output-dataset

```

## MCP server setup

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