You can scrape Uber Eats data restaurant listings, menus, item prices, ratings, delivery fees, and delivery times in one of three ways: automate a browser to read public store pages, call the same internal JSON requests the Uber Eats website uses, or use a managed data feed that does both for you. Uber Eats has no public API for this kind of market data; every page is rendered with JavaScript, and what you see depends on the delivery address you set. Those three facts decide which method fits your project.

This guide covers all three, with working Python code for the do-it-yourself route and a clear view of where that route stops scaling.

Key takeaways

• There’s no public Uber Eats API for market data. Uber’s developer APIs are for approved restaurant partners and delivery integrations, not for pulling competitor menus or prices.
• A plain HTTP request returns almost nothing. Menus load with JavaScript, so you need a real browser (Playwright or Selenium) or the site’s own JSON requests.
• Location decides what you see. Store lists, delivery fees, and delivery times change with the delivery address, so record which address each data point came from.
• Read Uber’s Terms of Use before you start. They restrict automated scraping. Collect only public data, never personal data, and keep request volumes low.
• DIY works for dozens of stores, not thousands. At scale, markup changes, blocking, and multi-city coverage make a managed feed the cheaper option.

What Uber Eats data can you extract?

Fees charged at checkout, customer details, and order history aren’t public, so they’re out of scope for scraping, and they should be.

Does Uber Eats have a public API?

Not for market data. Uber offers developer APIs, but they’re built for businesses that work with Uber, not for analysing it:

• Uber Eats Marketplace APIs let approved restaurant partners and point-of-sale providers manage their own menus, stores and orders.
• Uber Direct lets businesses book Uber couriers to deliver their own orders.

Both need Uber’s approval, and neither returns competitors’ menus, prices, or ratings. That’s why teams that need Uber Eats market data either scrape the public pages or buy a structured feed, such as FoodSpark’s Uber Eats API. If you’re a restaurant looking to integrate your own store, see our guide on how to use the Uber Eats API.

Is it legal to scrape Uber Eats?

It depends on what you collect, how you collect it, and where you are, so treat this section as orientation, not legal advice. Three things to know:

1. Uber’s Terms of Use restrict automated scraping and data mining of its services. Breaking a site’s terms is usually a contract question rather than a criminal one, but it’s a real risk for commercial projects.
2. Courts have generally treated scraping publicly accessible pages differently from breaking into systems. US decisions have leaned toward public data not being “hacking,” but contract, copyright, and privacy law still apply.
3. Personal data is where the serious risk sits. Stay with public business data: menus, prices, ratings, store details. Don’t collect customer names, courier details, or anything behind a login.

For a commercial project, have your counsel review the use case. In practice, responsible scraping means: public pages only, no logins, low request rates, and honouring takedown requests.

Why Uber Eats is harder to scrape than most sites

• JavaScript rendering. The HTML your server downloads is mostly an empty shell; menus and prices appear only after scripts run. That’s why requests + Beautiful Soup on its own usually returns nothing useful.
• The delivery-address gate. Uber Eats shows the stores that deliver to the address you’ve set. Delivery fees and times follow that address too, so the same restaurant can look different in two neighbourhoods.
• Bot protection. Heavy or fast traffic gets throttled or challenged. A handful of pages is fine; thousands from one machine is not.
• Frequent front-end changes. Class names and page structure change without notice, so selectors that work today can break next month.

Three ways to get Uber Eats data

The tutorial below uses the first approach, because it’s the easiest to learn and relies only on public pages. The “Scaling up” section explains when to switch.

Step-by-step: scrape an Uber Eats menu with Python and Playwright

Step 1 — Install Playwright.

Playwright drives a real Chromium browser, so JavaScript-rendered menus load just as they do for a visitor.

pip install playwright
playwright install chromium

Step 2 — Pick your store pages.

Open Uber Eats in your browser, enter a delivery address, open the restaurants you want and copy their URLs. A store page shows its full menu without an address, but delivery fees and times depend on where the order is going. If you need those, save the address you used next to the data.

Step 3 — Run the script.

Paste your store URLs into STORE_URLS and run it. It saves every menu item to ubereats_menu.csv.

import csv
import random
import re
import time

from playwright.sync_api import sync_playwright

# Paste the public store pages you want, copied from your browser's address bar.
STORE_URLS = [
    "https://www.ubereats.com/store/your-store-name/STORE_ID",
]

ITEM_SELECTOR = '[data-testid^="store-item-"]'  # one card per menu item
PRICE_RE = re.compile(r"(?:[$£€₹¥]|[A-Z]{3}\s?)\s?\d[\d,]*(?:\.\d{1,2})?")


def parse_item(text):
    """Turn the visible text of one menu card into name, price and description."""
    lines = [line.strip() for line in text.split("\n") if line.strip()]
    if not lines:
        return None
    name = lines[0]
    price_line = next((line for line in lines[1:] if PRICE_RE.search(line)), "")
    price = PRICE_RE.search(price_line).group(0) if price_line else ""
    others = [line for line in lines[1:] if line != price_line]
    description = max(others, key=len) if others else ""
    return {"item": name, "price": price, "description": description}


def scroll_until_stable(page, max_rounds=15):
    """Keep scrolling until no new menu cards appear (Uber Eats lazy-loads sections)."""
    last_count = -1
    for _ in range(max_rounds):
        count = page.locator(ITEM_SELECTOR).count()
        if count == last_count:
            break
        last_count = count
        page.mouse.wheel(0, 4000)
        page.wait_for_timeout(1500)


def scrape_store(page, url):
    page.goto(url, wait_until="domcontentloaded", timeout=60_000)
    page.wait_for_selector(ITEM_SELECTOR, timeout=30_000)
    scroll_until_stable(page)

    try:
        store = page.locator("h1").first.inner_text(timeout=5_000).strip()
    except Exception:
        store = ""

    rows = []
    for text in page.locator(ITEM_SELECTOR).all_inner_texts():
        item = parse_item(text)
        if item:
            rows.append({"store": store, "store_url": url, **item})
    return rows


def main():
    all_rows = []
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page(locale="en-US")
        for url in STORE_URLS:
            try:
                rows = scrape_store(page, url)
                print(f"{len(rows)} items from {url}")
                all_rows.extend(rows)
            except Exception as exc:
                print(f"Skipped {url}: {exc}")
            time.sleep(random.uniform(4, 8))  # pause between stores
        browser.close()

    with open("ubereats_menu.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=["store", "store_url", "item", "price", "description"])
        writer.writeheader()
        writer.writerows(all_rows)
    print(f"Saved {len(all_rows)} rows to ubereats_menu.csv")


if __name__ == "__main__":
    main()

Step 4 — What the script is doing:

• It waits for the menu cards to render. Each card carries a data-testid attribute starting with store-item-.
• It scrolls until the number of cards stops growing, because Uber Eats loads lower menu sections only as you scroll.
• It reads each card’s visible text and splits it into item name, price, and description. The price pattern handles $, £, €, ₹, ¥, and three-letter codes such as AED.
• It pauses 4–8 seconds between stores so it doesn’t flood the site, then writes everything to one CSV.

Step 5 — When it stops working:

• Zero items found: Uber Eats has changed its markup. Open DevTools (F12), inspect a menu item and update ITEM_SELECTOR to match.
• Timeouts or a challenge page: you’ve sent too many requests. Slow down, and scrape fewer stores per run.
• Unexpected prices or currency: check which region and address your browser session is using.

What the output looks like

Illustrative rows showing the CSV structure; your stores and values will differ.

Get Started

Skip the scraper maintenance

Get clean Uber Eats restaurant, menu and price data by city, delivered by API or scheduled feed. Start with a free sample.

Get a Free Uber Eats Data Sample

Scaling up: what breaks after the first few dozen stores

The script above is a good way to learn and a practical way to check a handful of competitors. Past that point, six problems appear one after another:

1. Coverage. Monitoring a market means thousands of stores across many cities and delivery addresses, not a few URLs you picked by hand.
2. Layout changes. Each time Uber Eats updates its front end, selectors break, and someone has to notice and fix them, often after data has already gone missing.
3. Blocking. Higher volumes need rotating infrastructure, retries, and pacing to keep collection steady and polite.
4. Location logic. Delivery fees, delivery times and store availability differ by address, so each city needs its own set of reference addresses.
5. Clean, comparable data. Currencies, sizes, bundles and item names need normalising before you can compare prices across stores, cities or platforms.
6. Tracking change. Pricing work depends on history: what changed, when, and where, which means scheduled runs, storage and deduplication.

That’s the work FoodSpark takes off your plate. Our Uber Eats data scraping service and Uber Eats API deliver structured restaurant, menu, price, fee, and rating data by city, on the schedule you choose, as CSV, JSON, or API. Want to check the quality first? Ask for a free sample.

What you can do with Uber Eats data

• Competitive pricing. Compare your menu prices against nearby restaurants in the same cuisine, and see who discounts, when, and by how much.
• Menu engineering. Find which items, bundles, and price points competitors lead with, and where a category is crowded or has a gap.
• Market and location research. Map which cuisines are well covered in a neighbourhood and which are missing before you open a location or a delivery-only kitchen.
• Promotion tracking. Watch how often competitors run offers and how deep they go, so your own promotions are based on evidence, not guesswork.
• Cross-platform comparison. Put Uber Eats alongside DoorDash and Grubhub to see how the same restaurant prices and positions itself on each. See our DoorDash vs Uber Eats vs Grubhub data comparison.
• Analytics and AI products. Feed clean, current menu and price data into dashboards, forecasting models, or AI assistants. For worked examples, see Uber Eats data analytics.

For the wider US market picture, read food delivery companies in the USA.

Frequently asked questions

Can you scrape Uber Eats data?

Yes. Public store pages show restaurant details, menus, prices, ratings, and delivery estimates, and you can collect them with browser automation such as Playwright or Selenium, or through a managed data provider. Uber’s Terms of Use restrict automated scraping, so keep to public data and low request rates, and get legal advice for commercial use.

Is it legal to scrape Uber Eats?

It depends on your jurisdiction, what you collect, and how. Uber’s terms restrict scraping, and privacy law applies to any personal data. Collecting public business data menus, prices, ratings at a modest rate carries much less risk than collecting personal or logged-in data. This isn’t legal advice; for commercial projects, talk to counsel.

Does Uber Eats have a public API?

Not for market data. Uber’s Marketplace APIs and Uber Direct are for approved partners managing their own stores or deliveries. To get competitor menus and prices in a structured form, you need to scrape public pages or use a data provider such as FoodSpark’s Uber Eats API.

What data can I get from Uber Eats?

Restaurant names, addresses, cuisines, ratings and review counts, opening hours, full menus with descriptions and options, item prices and discounts, delivery fees, delivery-time estimates, promotions and sold-out status.

Why does my Uber Eats scraper return nothing?

Usually one of three reasons: the page needs JavaScript to render (so requests + Beautiful Soup sees an empty shell), your selector no longer matches because the layout changed, or you’ve been rate-limited. Use a real browser, check your selectors in DevTools, and slow down.

How do I get Uber Eats restaurants for a specific city or address?

Set the delivery address first. Uber Eats lists only the stores that deliver there, and fees and times depend on it. For city-wide coverage, you need a set of reference addresses spread across each city.

Are there tools that combine proxies with scraping for Uber Eats data?

Yes. Scraping APIs bundle rotating proxies with headless browsers, and managed data providers go a step further: they run the collection and deliver the finished dataset. If you need ongoing multi-city data rather than a one-off pull, a managed feed is usually cheaper than building and maintaining the infrastructure yourself.

Do I need to log in to scrape Uber Eats menus?

No. Menus and prices are visible on public store pages without an account. Stay away from anything that requires a login or shows personal information.

Get Started

Need more than a few dozen stores?

FoodSpark delivers Uber Eats data across every city you track, refreshed on your schedule.

Request a Free Sample →

Conclusion

Scraping Uber Eats comes down to three facts: there’s no public API for market data, the pages need a real browser, and the delivery address changes what you see. For a few dozen stores, the Playwright script above will get you clean menus and prices in minutes. For ongoing coverage across cities, with history, change tracking, and data you can compare, the maintenance soon costs more than the data is worth to build yourself.

That’s where FoodSpark comes in. Tell us which cities, stores, or cuisines you need, and we’ll deliver structured Uber Eats data by API or scheduled feed, starting with a free sample so you can check the quality first.

Also scraping other platforms? See our DoorDash restaurant data scraping service and all our food data scraping services.