Pricing

$2.00 / 1,000 stores

Go to Store

Uber Eats Scraper

Try for free

Developed by

James

An actor designed to scrape Uber Eats APIs to help you quickly retrieve restaurant data including store names, ratings, and detailed menu items (with price and description). Use this tool to gain insights into local eateries, conduct competitive research, or power your own food discovery application

0.0 (0)

Pricing

$2.00 / 1,000 stores

Monthly users

Runs succeeded

97%

Last modified

2 months ago

Automation

Developer tools

Other

You can access the Uber Eats Scraper programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in Integrations settings in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

1{
2  "openapi": "3.0.1",
3  "info": {
4    "version": "0.0",
5    "x-build-id": "JauWHSas9MhaUVRWv"
6  },
7  "servers": [
8    {
9      "url": "https://api.apify.com/v2"
10    }
11  ],
12  "paths": {
13    "/acts/james.logantech~uber-eats-scraper/run-sync-get-dataset-items": {
14      "post": {
15        "operationId": "run-sync-get-dataset-items-james.logantech-uber-eats-scraper",
16        "x-openai-isConsequential": false,
17        "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
18        "tags": [
19          "Run Actor"
20        ],
21        "requestBody": {
22          "required": true,
23          "content": {
24            "application/json": {
25              "schema": {
26                "$ref": "#/components/schemas/inputSchema"
27              }
28            }
29          }
30        },
31        "parameters": [
32          {
33            "name": "token",
34            "in": "query",
35            "required": true,
36            "schema": {
37              "type": "string"
38            },
39            "description": "Enter your Apify token here"
40          }
41        ],
42        "responses": {
43          "200": {
44            "description": "OK"
45          }
46        }
47      }
48    },
49    "/acts/james.logantech~uber-eats-scraper/runs": {
50      "post": {
51        "operationId": "runs-sync-james.logantech-uber-eats-scraper",
52        "x-openai-isConsequential": false,
53        "summary": "Executes an Actor and returns information about the initiated run in response.",
54        "tags": [
55          "Run Actor"
56        ],
57        "requestBody": {
58          "required": true,
59          "content": {
60            "application/json": {
61              "schema": {
62                "$ref": "#/components/schemas/inputSchema"
63              }
64            }
65          }
66        },
67        "parameters": [
68          {
69            "name": "token",
70            "in": "query",
71            "required": true,
72            "schema": {
73              "type": "string"
74            },
75            "description": "Enter your Apify token here"
76          }
77        ],
78        "responses": {
79          "200": {
80            "description": "OK",
81            "content": {
82              "application/json": {
83                "schema": {
84                  "$ref": "#/components/schemas/runsResponseSchema"
85                }
86              }
87            }
88          }
89        }
90      }
91    },
92    "/acts/james.logantech~uber-eats-scraper/run-sync": {
93      "post": {
94        "operationId": "run-sync-james.logantech-uber-eats-scraper",
95        "x-openai-isConsequential": false,
96        "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
97        "tags": [
98          "Run Actor"
99        ],
100        "requestBody": {
101          "required": true,
102          "content": {
103            "application/json": {
104              "schema": {
105                "$ref": "#/components/schemas/inputSchema"
106              }
107            }
108          }
109        },
110        "parameters": [
111          {
112            "name": "token",
113            "in": "query",
114            "required": true,
115            "schema": {
116              "type": "string"
117            },
118            "description": "Enter your Apify token here"
119          }
120        ],
121        "responses": {
122          "200": {
123            "description": "OK"
124          }
125        }
126      }
127    }
128  },
129  "components": {
130    "schemas": {
131      "inputSchema": {
132        "type": "object",
133        "required": [
134          "address",
135          "query"
136        ],
137        "properties": {
138          "address": {
139            "title": "Address",
140            "type": "string",
141            "description": "Enter the address to geocode (e.g., 45 Victor Street, Chatswood, NSW 2067)."
142          },
143          "query": {
144            "title": "Search Query",
145            "type": "string",
146            "description": "Search query for the Uber Eats API (e.g., German)."
147          },
148          "maxStores": {
149            "title": "Max Number of Stores Retrieved",
150            "type": "integer",
151            "description": "This is the maximum number of stores information will be retrieved for"
152          }
153        }
154      },
155      "runsResponseSchema": {
156        "type": "object",
157        "properties": {
158          "data": {
159            "type": "object",
160            "properties": {
161              "id": {
162                "type": "string"
163              },
164              "actId": {
165                "type": "string"
166              },
167              "userId": {
168                "type": "string"
169              },
170              "startedAt": {
171                "type": "string",
172                "format": "date-time",
173                "example": "2025-01-08T00:00:00.000Z"
174              },
175              "finishedAt": {
176                "type": "string",
177                "format": "date-time",
178                "example": "2025-01-08T00:00:00.000Z"
179              },
180              "status": {
181                "type": "string",
182                "example": "READY"
183              },
184              "meta": {
185                "type": "object",
186                "properties": {
187                  "origin": {
188                    "type": "string",
189                    "example": "API"
190                  },
191                  "userAgent": {
192                    "type": "string"
193                  }
194                }
195              },
196              "stats": {
197                "type": "object",
198                "properties": {
199                  "inputBodyLen": {
200                    "type": "integer",
201                    "example": 2000
202                  },
203                  "rebootCount": {
204                    "type": "integer",
205                    "example": 0
206                  },
207                  "restartCount": {
208                    "type": "integer",
209                    "example": 0
210                  },
211                  "resurrectCount": {
212                    "type": "integer",
213                    "example": 0
214                  },
215                  "computeUnits": {
216                    "type": "integer",
217                    "example": 0
218                  }
219                }
220              },
221              "options": {
222                "type": "object",
223                "properties": {
224                  "build": {
225                    "type": "string",
226                    "example": "latest"
227                  },
228                  "timeoutSecs": {
229                    "type": "integer",
230                    "example": 300
231                  },
232                  "memoryMbytes": {
233                    "type": "integer",
234                    "example": 1024
235                  },
236                  "diskMbytes": {
237                    "type": "integer",
238                    "example": 2048
239                  }
240                }
241              },
242              "buildId": {
243                "type": "string"
244              },
245              "defaultKeyValueStoreId": {
246                "type": "string"
247              },
248              "defaultDatasetId": {
249                "type": "string"
250              },
251              "defaultRequestQueueId": {
252                "type": "string"
253              },
254              "buildNumber": {
255                "type": "string",
256                "example": "1.0.0"
257              },
258              "containerUrl": {
259                "type": "string"
260              },
261              "usage": {
262                "type": "object",
263                "properties": {
264                  "ACTOR_COMPUTE_UNITS": {
265                    "type": "integer",
266                    "example": 0
267                  },
268                  "DATASET_READS": {
269                    "type": "integer",
270                    "example": 0
271                  },
272                  "DATASET_WRITES": {
273                    "type": "integer",
274                    "example": 0
275                  },
276                  "KEY_VALUE_STORE_READS": {
277                    "type": "integer",
278                    "example": 0
279                  },
280                  "KEY_VALUE_STORE_WRITES": {
281                    "type": "integer",
282                    "example": 1
283                  },
284                  "KEY_VALUE_STORE_LISTS": {
285                    "type": "integer",
286                    "example": 0
287                  },
288                  "REQUEST_QUEUE_READS": {
289                    "type": "integer",
290                    "example": 0
291                  },
292                  "REQUEST_QUEUE_WRITES": {
293                    "type": "integer",
294                    "example": 0
295                  },
296                  "DATA_TRANSFER_INTERNAL_GBYTES": {
297                    "type": "integer",
298                    "example": 0
299                  },
300                  "DATA_TRANSFER_EXTERNAL_GBYTES": {
301                    "type": "integer",
302                    "example": 0
303                  },
304                  "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
305                    "type": "integer",
306                    "example": 0
307                  },
308                  "PROXY_SERPS": {
309                    "type": "integer",
310                    "example": 0
311                  }
312                }
313              },
314              "usageTotalUsd": {
315                "type": "number",
316                "example": 0.00005
317              },
318              "usageUsd": {
319                "type": "object",
320                "properties": {
321                  "ACTOR_COMPUTE_UNITS": {
322                    "type": "integer",
323                    "example": 0
324                  },
325                  "DATASET_READS": {
326                    "type": "integer",
327                    "example": 0
328                  },
329                  "DATASET_WRITES": {
330                    "type": "integer",
331                    "example": 0
332                  },
333                  "KEY_VALUE_STORE_READS": {
334                    "type": "integer",
335                    "example": 0
336                  },
337                  "KEY_VALUE_STORE_WRITES": {
338                    "type": "number",
339                    "example": 0.00005
340                  },
341                  "KEY_VALUE_STORE_LISTS": {
342                    "type": "integer",
343                    "example": 0
344                  },
345                  "REQUEST_QUEUE_READS": {
346                    "type": "integer",
347                    "example": 0
348                  },
349                  "REQUEST_QUEUE_WRITES": {
350                    "type": "integer",
351                    "example": 0
352                  },
353                  "DATA_TRANSFER_INTERNAL_GBYTES": {
354                    "type": "integer",
355                    "example": 0
356                  },
357                  "DATA_TRANSFER_EXTERNAL_GBYTES": {
358                    "type": "integer",
359                    "example": 0
360                  },
361                  "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
362                    "type": "integer",
363                    "example": 0
364                  },
365                  "PROXY_SERPS": {
366                    "type": "integer",
367                    "example": 0
368                  }
369                }
370              }
371            }
372          }
373        }
374      }
375    }
376  }
377}

Uber Eats Scraper OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for Uber Eats Scraper from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

Uber Eats Scraper API in Python

Uber Eats Scraper API in JavaScript

Uber Eats Scraper API through CLI

Uber Eats Scraper API

Pricing

Pricing model

Pay per result

This Actor is paid per result. You are not charged for the Apify platform usage, but only a fixed price for each dataset of 1,000 items in the Actor outputs.

Price per 1,000 items

$2.00

Uber Eats Scraper

natanielsantos/uber-eats-scraper

This no-code tool allows you to scrape data from Uber Eats restaurants, like name, categories, location, menu items, and more.

Nataniel Santos

Uber Eats Store Search Scraper 🍽️

easyapi/uber-eats-store-search-scraper

Extract detailed restaurant data from Uber Eats search results. Get comprehensive information about stores including ratings, status, location, and images. Perfect for market research, competitor analysis, and food delivery insights. 🍽️🔍

EasyApi

🍴Uber Eats Scraper [PPR]

borderline/uber-eats-scraper-ppr

Pay per result - Fast and cost-effective Uber Eats Scraper requiring just a search query and location. Instantly retrieve comprehensive restaurant data, including names, phone, ratings, locations, and menus. Seamlessly integrates, offering a highly efficient data solution.

borderline

🍴Uber Eats Scraper [RENTAL]

borderline/ubereats-scraper

Rental - Fast and cost-effective Uber Eats Scraper requiring just a search query and location. Instantly retrieve comprehensive restaurant data, including names, ratings, locations, reviews and menus. Seamlessly integrates with tools like Google Sheets, and more, offering a highly efficient solution

borderline

Grubhub Restaurant Scraper 🍽️

easyapi/grubhub-restaurant-scraper

Scrape restaurant data from Grubhub including menus, prices, ratings, and delivery information. Extract detailed business information and menu items for market research, price monitoring, or competitor analysis.

EasyApi

Wolt Restaurants Scraper 🥡

lucen_data/wolt-restaurants-scraper

Extract data from restaurants on the Wolt food delivery platform using this simple to use Wolt API. Simply choose a city to obtain information such as restaurant names, addresses, zip codes, phone numbers, ratings and more. Download scraped data in various formats including JSON, CSV and Excel.

Lucen

Google Places Menu Scraper

rajahaikal2234/google-places-menu-scraper

Scrape Google's Businesses Menu

Raja Haikal

Glovo Scraper

antonionduarte/glovo-scraper

A Glovo scraper that extracts comprehensive restaurant data and category listings. Designed for seamless automation with retry mechanisms, rate limiting, and structured JSON outputs. Ideal for market analysis, competitive research, and operational optimization.