Uber Eats Scraper

Get restaurant listings, menu items and delivery search results from Uber Eats markets such as the US, Canada and UK as clean rows you can export.

• Discover restaurants by city, cuisine, brand or delivery place.
• Collect store details and optional, separately billed menu items.
• Read ratings, delivery estimates, addresses and prices when available.
• Export rows or use them through the Apify API and MCP server.
• Pay only for the rows you receive: $3.00 per 1,000 rows on the Free plan plus a small start fee.

What does Uber Eats Scraper do?

Uber Eats Scraper collects public restaurant and menu information from ubereats.com. Use it to compare restaurant supply, track menu prices or find stores near a delivery address. It is unofficial and not affiliated with Uber Eats.

• Discovery: city, category, cuisines, location and brand list restaurants, cuisine links or cities.
• Delivery: feed lists nearby stores; search finds restaurants or dishes near a place.
• Details: store returns a store; menu_item returns one dish and available customizations.
• Places and links: resolve_place resolves an address; startUrls accepts several supported Uber Eats links.
• Optional rows: includeMatchedItems, includeCuisines and enrichDetails default to false. Extra menu or category rows share the row limit and are billed at the same rate.

What data can you extract from Uber Eats?

Fields depend on the row type and what Uber Eats publishes. The common fields apply across the following tables.

Common fields

Field	Description	Example
itemType	Entity: store, store_detail, menu_item, city, category, brand_city, place	store
title	Display name	Example Restaurant
url	Uber Eats link	https://www.ubereats.com/city/denver-co
locale	Market code	us
scrapedAt	Collection timestamp	2026-10-24T00:00:00Z
leadSource	Source classification, not the row type	page

Source labels remain in source: seoFeed, location and httpSsr variants identify page data; getStoreV1 and getMenuItemV1 identify detail data; appApi.* and brandSearch identify search or place data. Unmapped sources give leadSource: null; enriched store details use detail.

Restaurant listings: store

Field	Description	Example
uuid	Store identifier	00000000-0000-4000-8000-000000000001
ratingValue	Published rating	4.6
reviewCountText	Rating count as displayed	5000+
etaText	Delivery estimate	20–35 min
priceBucket	Relative price level, not a menu price	$$
matchedItemCount	Matching dishes found in search	2

Store details: store_detail

Field	Description	Example
phoneNumber	Public store phone, when published	+1 555 0100
formattedAddress	Display address	123 Example Street, Example City
latitude	Store latitude	39.7392
longitude	Store longitude	-104.9903
addressCheck	Address validation status and precision	{"status":"unverifiable"}

Menu items: menu_item

Field	Description	Example
menuItemUuid	Dish identifier	00000000-0000-4000-8000-000000000002
storeUuid	Parent store identifier	00000000-0000-4000-8000-000000000001
price	Amount in major currency units	12.5
priceMinorUnits	Original amount in minor units	1250
currencyCode	Currency reported by the source	USD
customizationsList	Available choices for a detail lookup	[]

Cities: city

Field	Description	Example
citySlug	City identifier for another input	denver-co

Cuisine links: category

Field	Description	Example
slug	Cuisine identifier	thai

Brand locations: brand_city

Field	Description	Example
brandSlug	Brand identifier	mcdonalds
locationCount	Published branch count	12

Delivery places: place

Field	Description	Example
pl	Encoded place reusable in delivery inputs	Encoded value from your result

How to scrape Uber Eats

1. Open Uber Eats Scraper in Apify Console. A free account is enough to try it.
2. Fill a target such as citySlug. Clear unrelated sample target values in the form.
3. Set maxResults to 5 for the first run.
4. Click Start and wait for completion.
5. Download the dataset or read it through the API.

Empty input {} starts a sushi search in Denver with at most 3 rows. This example is charged like any other run. With mode: "auto", the Actor chooses from the target fields you fill. A US query without a place uses denver-co; outside the US, supply a place.

City

Set citySlug to list stores. city can add delivery listings from the city centre when the city page has fewer rows than requested.

Category

Set citySlug and cuisineSlug to list restaurants in that cuisine.

Cuisines

Choose mode: "cuisines" with citySlug to get cuisine links, not restaurants.

Location

Choose mode: "location" and a locale to list that market's city links. This mode must be selected explicitly.

Feed

Use address to list nearby stores. Coordinates must come as a pair; set locale explicitly outside the US.

Search

Use query with address, coordinates or citySlug. Enable includeMatchedItems for separate dish rows; otherwise stores retain only matchedItemCount.

Store

Use storeUrl or storeUuid. Add enrichDetails: true for menu rows after the store row, subject to the remaining allowance.

Menu item

Use menuItemUuid with storeUrl or storeUuid. Section identifiers are looked up when omitted.

Brand

Use brandSlug alone for brand-city links. Add citySlug for branches in that city, or a delivery place for nearby stores matching the brand name.

Resolve place

Choose mode: "resolve_place" with address to obtain a reusable pl value and available location fields.

Start URLs

Fill startUrls with store, city, category, brand, brand-city, location, feed or search links. Each link uses its market. Delivery links need a place. These URLs take precedence over other targets.

What to fill in

Field	What to enter	Default
mode	auto or an explicit mode above	auto
startUrls	Supported Uber Eats links	Empty
query	Dish, cuisine or restaurant search	Empty; form sample sushi
citySlug	City identifier	Empty; form sample denver-co
cuisineSlug, categorySlug	Cuisine identifier; the second is an alias	Empty
brandSlug	Brand identifier	Empty
storeUrl, storeUuid	Store link or identifier	Empty
storeSlug	Optional store URL slug	Empty
menuItemUuid	Dish identifier for a detail lookup	Empty
locale	Market code, such as us, ca, gb, au, fr, jp	Inferred, otherwise us
address	Delivery address or postal code	Empty
latitude, longitude	Both coordinates as strings	Empty
pl, place	Encoded delivery place; the second is an alias	Empty
maxResults	Rows per input, from 1 to 500	70; form sample 3
maxPages	Feed/search page cap; 0 follows the row limit	0
enrichDetails	Enrich listing details; in store mode also add menu rows	false
includeCuisines	Add category rows in city mode if room remains	false
includeMatchedItems	Add separate matched-dish rows in search	false
sectionUuid, subsectionUuid	Optional menu section identifiers	Looked up
diningMode	Dining context	DELIVERY

City input

{"citySlug":"denver-co","maxResults":5}

Category input

{"citySlug":"vancouver-bc","cuisineSlug":"thai","locale":"ca","maxResults":5}

Cuisines input

{"mode":"cuisines","citySlug":"denver-co","maxResults":5}

Location input

{"mode":"location","locale":"gb","maxResults":5}

Feed input

{"address":"10001","locale":"us","maxResults":5}

Search input

{"query":"sushi","citySlug":"denver-co","maxResults":5}

Store input

Replace the example link with a real store link.

{"storeUrl":"https://www.ubereats.com/store/example-restaurant/EXAMPLE_STORE_TOKEN","enrichDetails":true,"maxResults":5}

Menu-item input

Replace both placeholder identifiers with values from your store and menu rows.

{"storeUuid":"00000000-0000-4000-8000-000000000001","menuItemUuid":"00000000-0000-4000-8000-000000000002","maxResults":1}

Brand input

{"brandSlug":"mcdonalds","citySlug":"houston-tx","maxResults":5}

Resolve-place input

{"mode":"resolve_place","address":"10001","locale":"us","maxResults":1}

Start-URLs input

{"startUrls":["https://www.ubereats.com/city/denver-co","https://www.ubereats.com/city/houston-tx"],"maxResults":3}

• maxItems and limit are accepted aliases of maxResults.
• Unknown field names do not fail the run by themselves. Close misspellings are corrected; other unknown fields are ignored with a note.
• Missing target requirements can produce INVALID_INPUT: mode — .... Other validation errors name the field or requirement, such as supplying both coordinates. Invalid input is rejected before rows are charged; the start fee still applies.
• INPUT_REPORT in the default key-value store records how input was read, including filled, corrected and ignored fields. RUN_SUMMARY reports delivered rows and warnings; ERROR_SUMMARY records failures.

Output example

Illustrative menu row; identifiers and values are examples, not a captured live result.

{
  "itemType": "menu_item",
  "title": "Example noodle bowl",
  "menuItemUuid": "00000000-0000-4000-8000-000000000002",
  "storeUuid": "00000000-0000-4000-8000-000000000001",
  "locale": "us",
  "price": 12.5,
  "priceMinorUnits": 1250,
  "currencyCode": "USD",
  "scrapedAt": "2026-10-24T00:00:00Z"
}

Export the dataset as JSON, CSV, Excel, XML, RSS or an HTML table.

Why use this Uber Eats scraper?

• Pay per delivered row. Unreturned rows are not billed.
• Partial collection. When collection reaches its time limit after finding rows, those rows can be delivered with a warning. This does not guarantee recovery after every manual stop.
• Explainable empty results. NO_MATCH, LOCATION_UNRESOLVED and OUT_OF_SCOPE distinguish no matches, an unresolved place and no delivery coverage.
• Separate entities. Restaurants and menu items are separate rows, not an unlimited menu inside one restaurant row.
• No proxy setup. You do not need to set up proxies.

How much does it cost to scrape Uber Eats?

Pricing is pay-per-event: $0.005 per start event plus a price per delivered row. One start event is charged per GB of allocated memory, with a minimum of one. At the default 512 MB, the start costs $0.005. Platform usage is included in these prices.

Apify plan	Price per row	Price per 1,000 rows
Free	$0.003	$3.00
Starter	$0.003	$3.00
Scale	$0.0026	$2.60
Business	$0.0022	$2.20

• maxResults applies to each start URL or the single scalar input. It defaults to 70; larger requests are collected in parts of 70, up to 500 per input.
• All row types share that allowance. Optional dish and category rows are not free extras.
• Free Apify plan runs stop at 200 rows. This Actor also allows 10 runs on the free plan.
• The whole run stops at your Maximum cost per run (maxTotalChargeUsd in the API).

Example: three URLs returning 50 rows each deliver 150 rows. On the Free plan at 512 MB, the cost is 150 × $0.003 + $0.005 = $0.455. Fewer delivered rows cost less.

What happens when the run timeout is too short

If results need longer than your chosen timeout, the run can pause with the message "Queued on the collection backend; this run will resume automatically when results are ready (about N s)." It temporarily shows ABORTED, rather than a collection failure.

When results are ready, the same run resumes automatically, reports "Resumed: delivering N rows.", writes to the same dataset and finishes as SUCCEEDED. Rows are not delivered or charged twice. You do not need to restart this paused run.

• This can happen at most 3 times per run. Keep the default timeout of 3600 seconds to reduce pauses.
• Synchronous endpoints (run-sync, run-sync-get-dataset-items) wait at most 300 seconds and may return an empty dataset during a pause. Start larger jobs asynchronously, then read the dataset after SUCCEEDED, or use a succeeded-event webhook.

Use with AI agents and the API

Apify MCP server (Claude, ChatGPT, Cursor, VS Code)

Add this remote MCP server:

https://mcp.apify.com?tools=lentic_clockss/ubereats-scraper

Sign in with Apify through OAuth, or send Authorization: Bearer <YOUR_APIFY_TOKEN>. The tool starts a run and returns run and dataset IDs; read rows with get-dataset-items. Clients without remote MCP support can use npx @apify/actors-mcp-server --tools lentic_clockss/ubereats-scraper with APIFY_TOKEN set.

Example prompt: "Find five Uber Eats sushi restaurants in Denver using citySlug denver-co. Return names and ratings."

Apify API

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("lentic_clockss/ubereats-scraper").call(
    run_input={"query": "sushi", "citySlug": "denver-co", "maxResults": 5}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('lentic_clockss/ubereats-scraper').call({
  query: 'sushi', citySlug: 'denver-co', maxResults: 5
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

For asynchronous HTTP use, send input as JSON to POST https://api.apify.com/v2/acts/lentic_clockss~ubereats-scraper/runs with your Bearer token. After completion, read GET https://api.apify.com/v2/datasets/<datasetId>/items?format=json.

Integrations

Use the Integrations tab for Google Sheets, Make, Zapier, n8n, Slack, Airtable or webhooks. Use Apify Schedules for repeated runs.

FAQ

Is it legal to scrape Uber Eats?

Use public data responsibly. You are responsible for complying with the site's terms and applicable data-protection law. Processing personal data requires a lawful basis.

Why did my run end as ABORTED?

If the status message says it will resume automatically, wait for that same run. A manual abort is different and does not guarantee automatic recovery.

How many results can I get?

Request 1–500 rows per input. Source availability, optional rows, the free-plan cap and your spending limit can reduce delivery.

Why are some fields empty?

Uber Eats does not publish every field for every store or market. Missing prices or currency stay empty rather than being guessed. Missing contact information is not evidence that no contact exists.

Is this an official Uber Eats API?

No. This Actor is independent of Uber Eats and does not place orders or access private accounts.

Can I scrape menus?

Yes. Use store with enrichDetails: true for menu rows, or menu_item for one known dish. The default store lookup returns the store row only.

Why did my search use Denver?

A US query with no place retains the default placement denver-co. Supply your intended city, address or coordinates instead.

Limitations

• A selectable locale is not a guarantee of current delivery coverage. Availability varies by country, city, store and time.
• City and category pages do not provide unlimited pagination. City mode can add nearby delivery results; a category page can end below your requested limit.
• Ratings, delivery estimates, availability and menu prices may change between runs.
• Customizations and product details are bounded; truncation counters identify omitted content.
• Coordinates alone can trigger example-field filling. Prefer an address, or provide an explicit mode and a target such as query alongside coordinates; inspect INPUT_REPORT.

Related scrapers

More food delivery and grocery scrapers from the same publisher:

• Grab Scraper
• iFood Scraper
• PedidosYa Scraper
• Deliveroo Scraper
• Foodora Scraper
• Foodpanda Scraper
• DoorDash Scraper
• Rappi Scraper

Browse all of our scrapers at apify.com/lentic_clockss.

Support

Found a problem or need another field? Open an issue in the Issues tab of this Actor's page and include the run ID and the input you used.