Scraping Uber Eats Menus and Prices: A Rendered-Page Workflow
Collecting public Uber Eats menu and price data runs into two hard walls: the platform's terms restrict automated collection, and the storefront only shows menus after JavaScript runs and a delivery location is set. This guide walks through a rendered-request workflow in Python that stays inside the public storefront, handles the location gate, and copes with lazy-loaded menus. It is not a way around the terms — it is a way to keep any legitimate, low-volume collection disciplined.
What the platform's terms allow
Uber's Terms of Use, depending on the country, expressly prohibit scripts used to scrape, index, survey, or otherwise data-mine any portion of the Uber Services, or to unduly burden them. That makes automated collection a contractual issue regardless of the technical method. US courts have held that scraping publicly accessible data does not necessarily violate federal anti-hacking law, but that does not remove contract, copyright, privacy, or other risks. This is not legal advice. If you are asking whether it is legal to scrape Uber Eats, start with Uber's own rules, keep any research limited and non-intrusive, and consult a qualified lawyer before commercial use. The technical scope here is limited to public restaurant storefronts that require neither login nor personal data.
Is there an Uber Eats API?
Not for general menu browsing. No official feed lets you walk every restaurant and dish. Uber does run partner-facing interfaces — the Marketplace API for store, menu, and order management, and Uber Direct for merchant delivery logistics — but both sit behind an approval process and OAuth credentials, so neither serves as an open consumer data source. For anyone outside that partner program, the rendered public storefront is the realistic route, which is why the rest of this guide works on store pages. Keep that work confined to public, non-personal fields, use genuine delivery addresses, hold request volume down, and treat Uber's anti-automation terms as a live constraint rather than a footnote.
Why the storefront is hard to scrape
Three properties make the storefront awkward. First, it is a JavaScript application: a plain request usually returns an app shell or incomplete HTML without rendered menu data, so you need to render JavaScript. Second, results are geo-gated and depend on the selected delivery address. A restaurant may serve one neighborhood but not another, and its prices, fees, operating status, menu availability, and estimated delivery times vary by location. Third, Cloudflare protection and request-level controls evaluate headers, request frequency, browser behavior, and IP reputation. The practical response is JavaScript rendering, consistent location state through proxies, and rate-limited requests.
What you need before starting
You need a web scraping API API key and Python 3.10+. Create a working folder, set up a virtual environment, and install the client libraries. The exact shell commands are supplied as protected modules and should be used verbatim.
Step 1 — Set a delivery location
Uber Eats shows no restaurants until a delivery address is defined. Open the site, set the location and delivery schedule, and pick a restaurant. The URL in your browser's address bar is the store URL you will target. Note that the proposed item catalog and prices change by delivery zone and by the user's context, so the same store URL can yield different menus for different addresses.
Step 2 — Render the store page
Fetch the store URL through the client with JavaScript rendering and a proxy. The premium_proxy parameter routes the request through a proxy pool to get past Cloudflare, and render_js makes the page execute JavaScript as a real browser would. A 200 status and a bulky HTML body are encouraging signals, yet neither confirms that menu content actually rendered. Before you hand the response to a parser, assert that expected menu selectors or item text are present; if the body is a block page or a bare app shell, raise an explicit error instead of parsing an empty document.
Step 3 — Extract menu items and prices
Parse the rendered HTML with BeautifulSoup. Each product card is anchored to an element whose data-testid starts with store-item-, and the name and price live in rich-text spans inside an item-thumbnail-label. A tag-agnostic selector works whether items render as <li> or <div>. From this step onward the example switches to stealth_proxy, which is stronger than premium_proxy and must be paired with country_code so the proxy country matches the storefront. In the captured run, this produced 13 items — low for a restaurant, but explained by the next step.
Step 4 — Handle lazy-loaded menus
Uber Eats manages long menus lazily, which is why the first pass returned only 13 items. Scroll the DOM vertically with the scroll_y parameter and give the page time with wait. In the captured run, scrolling raised the count from 13 to 139 items. The higher the scroll_y value, the more products you intercept; for data far down the page, chain several scroll_y and wait instructions. Finding the right configuration takes some testing.
Step 5 — Get clean fields with AI extraction
Selector-based parsing is brittle: when the DOM or class names change, scrapers break. The ai_query parameter lets you describe the fields you want in plain English and returns structured JSON. Ask for a bounded number of items (the example asks for up to 10 visible menu items) so the response stays small enough to be complete, valid JSON. Asking for a full menu in one request can produce a response that is truncated before the JSON array closes; response.json() then fails. For complete menus, split the extraction into smaller batches or sections and save the successfully parsed results to a local menu.json file. Any per-request credit surcharge for ai_query is a commercial term that must be confirmed for the publisher operating this guide before it is quoted to readers.
Step 6 — Iterate locations and stay polite
To scale beyond one store, remember that the storefront only shows data after a delivery location is defined, so insert real locations to obtain restaurant URLs. The example defines a DELIVERY_ZONES array mapping locations to store URLs, loops over them, and writes results to ubereats_results.csv. Between requests it sleeps a random 3–6 seconds, and every fifth request it pauses 20–30 seconds. The CSV columns are delivery_location, store_url, category, item_name, description, price, currency, and error — the error column captures HTTP failures, invalid JSON, non-list AI responses, and non-object menu items so a bad row never silently disappears.
Rendered page vs. internal JSON API
There are two ways to get the data: render a public store page and parse the HTML, or replay the internal API requests the site itself uses. Both expose similar information but differ in maintainability, implementation risk, and alignment with the platform's rules. Rendering is not immune to front-end changes — selectors break when attributes are renamed or components restructured — but at low volume, with deliberate rate limiting and real delivery locations, it is generally the more maintainable and defensible option. Internal endpoints return compact JSON and skip HTML parsing, but request formats, headers, CSRF tokens, and session requirements can change without notice, so an integration that works in development can fail later. In practice the apparently cleaner JSON approach can create substantially more maintenance work. Internal-endpoint extraction is what productized scraping tools do; for other cases, rendering public pages at low volume is the right approach.
Staying unblocked and polite at scale
A single well-formed request to a public store page completes without a hard CAPTCHA, but blocking risk rises with volume. Anti-bot systems weigh headers, request frequency, behavioral patterns, and IP reputation, so wait a few seconds between requests, avoid unnecessary concurrency, and cache results rather than refetching unchanged pages. Two proxy parameters matter: premium_proxy is the first go-to for hard sites, and stealth_proxy is the stronger option when premium_proxy is still blocked — it supports geolocation, so you must set country_code. Whether failed requests such as a 500 status are billed is a commercial policy that must be confirmed for the publisher operating this guide before it is promised to readers.
A worked example: 13 items vs. 139 items
The captured run against a Porto's Bakery & Cafe storefront in Glendale shows why the scroll step matters. Without scrolling, the parser found 13 products, including a Spicy Chicken Milanesa Sandwich at $12.45 and a Chocolate Croissant at $3.55. With a js_scenario that scrolls 600 pixels and waits 1,500 ms, the same store returned 139 items, adding entries such as a Cubano (Cuban Sandwich) at $11.25 and a Black Bean Soup at $7.35. The lesson is not that 139 is the full menu — it is that item count is a function of how far the page has been scrolled and how long the scraper waited. Treat any count as a lower bound until you have verified the menu end.
A pre-run checklist
Before you run a collection job, confirm each of the following. (1) You have read the current Uber terms and your use case is public, non-personal, and low-volume. (2) Each target URL was captured after setting a real delivery location for the zone you care about. (3) JavaScript rendering and a proxy parameter are enabled. (4) Your parser checks for expected menu selectors before trusting a 200 response. (5) A scroll-and-wait scenario is configured, and you have tested how item count changes with scroll depth. (6) If you use ai_query, you request a bounded number of items and handle truncated JSON. (7) Your loop sleeps between requests and backs off periodically. (8) Your output schema includes an error column so failed rows are visible.
Frequently asked questions
Is it legal to scrape Uber Eats?
It is legally risky and may violate Uber's Terms of Use, which restrict automated scraping, crawling, and bulk data collection, including pricing. Some US court decisions have held that accessing publicly available data does not violate specific computer-access laws, but those rulings do not eliminate contractual, copyright, privacy, or other legal risks. None of this is legal advice. Confine collection to public data, keep request volumes modest, and have a qualified lawyer review your particular use case.
Does Uber Eats have an API?
No. Uber Eats does not offer a public API for browsing all restaurants and menus. Uber's Marketplace APIs help approved partners manage stores, menus, and orders, and Uber Direct supports merchant delivery logistics. Both require approval and credentials and are not general consumer menu data feeds.
Why does my Uber Eats scraper return nothing?
Two things usually explain an empty result. The storefront is a JavaScript app, so a bare Python requests or BeautifulSoup call often gets back only the initial HTML shell with no rendered menu inside it. On top of that, the site is location-dependent: until a delivery location is chosen, restaurant availability simply is not there to read. Turn on JavaScript rendering and set a genuine delivery address before you parse.
How do I get Uber Eats restaurants for a specific city or address?
Set a real delivery location for the area you want to examine. Uber Eats scopes restaurant availability, menus, and prices to delivery zones, with location context maintained through page parameters, browser state, and cookies. To compare markets or cover a city, use real delivery locations rather than guessing coordinates.
What data can I get from Uber Eats?
You can collect public storefront data such as restaurant listings available for an address, menu categories, item names, descriptions, prices, ratings, and delivery estimates. Focus on catalog information visible without authentication. Avoid collecting personal information from reviews or contact details, and never access customer, account, or order data behind a login.
Do I need to log in to scrape Uber Eats menus?
No, and you should not. Public restaurant menus and prices can be viewed without an account after a delivery location is selected. Login-only areas such as cart, checkout, account, and order data are outside this guide's scope and should not be scraped.
[
{
"category": "Featured items",
"item_name": "Spicy Chicken Milanesa Sandwich",
"description": "Example post details.",
"price": "12.45",
"currency": "$"
},
{
"category": "Featured items",
"item_name": "Fresh Fruit Tart",
"description": null,
"price": "40.89",
"currency": "$"
},
{
"category": "Featured items",
"item_name": "Milk N' Berry",
"description": "Example post details.",
"price": "47.69",
"currency": "$"
},
<...OMITTED FOR BREVITY...>
{
"category": "Featured items",
"item_name": "Tres Leches Cake Loaf",
"description": "Example post details.",
"price": "16.99",
"currency": "$"
},
{
"category": "Featured items",
"item_name": "Chocolate Croissant",
"description": "Example post details.",
"price": "3.55",
"currency": "$"
}
]