# Uber Eats Email Scraper (`leads-scraper/uber-eats-email-scraper`) Actor

Uber Eats Email Scraper SD - Uber Eats Email Scraper is a lead generation tool that extracts leads with public contact emails, account names and profile URLs from Uber Eats results by keyword, location and email domain - Uber Eats email extractor.

- **URL**: https://apify.com/leads-scraper/uber-eats-email-scraper.md
- **Developed by:** [Leads Scraper](https://apify.com/leads-scraper) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Email Scraper

**Uber Eats Email Scraper** collects publicly visible business contact emails from Uber Eats
pages that Google has already indexed. It turns a keyword and a city into a usable restaurant
owner email list you can import straight into a CRM.

Uber Eats Email Scraper is built for B2B teams selling to restaurants and takeaways: POS
vendors, delivery integrators, food distributors, packaging suppliers, hospitality recruiters
and local agencies that need food delivery leads for restaurant lead generation.

**Read this before you run it.** Uber Eats indexes city and category pages far more heavily
than individual store pages, so most rows carry an email **without** a store handle. That is
the defining characteristic of this Actor, and it is not a bug.

In our own test run, on a sample of about 10 parsed results, only 2 rows had an account
identity and 2 had a profile URL - but 10 unique emails were found. Email volume on Uber Eats
is high; handle coverage is low.

So the honest framing is this: Uber Eats Email Scraper is **excellent if you want addresses,
and poor if you need a merchant handle on every row**. Need a handle per lead? The
[Grubhub Email Scraper](https://apify.com/leads-scraper/grubhub-email-scraper) beat it there.

Uber Eats Email Scraper does not log in, does not use any Uber Eats API, and never opens the
Uber Eats website. There is no browser and no JavaScript rendering - every field comes from
public Google search results fetched through the Apify GOOGLE\_SERP proxy.

#### Why this Actor exists on Uber Eats

Restaurant listings publish a business address so diners can arrange catering, large group
orders and reservations. Those addresses are business contact points, which is what makes the
catering leads Uber Eats Email Scraper returns legitimate B2B targets.

What you get back is a lead row per email: the address, the domain it matched, the keyword and
query that found it, the raw title and a cleaned snippet. Uber Eats Email Scraper adds an
account name and a store handle whenever Google actually printed one.

Uber Eats is also the most international platform in this family. Uber Eats Email Scraper
works against US, UK, French, Australian and many other Uber Eats markets, which makes it the
broadest source of merchant contact data in the batch.

Note that Postmates has been folded into Uber Eats. The
**Postmates Email Scraper** still runs,
but its pages mostly redirect here and it is largely superseded by this Actor.

### Key features of Uber Eats Email Scraper

Every capability below is something the code actually does. Nothing in this table is
aspirational.

| Feature | What it does |
|---|---|
| Google SERP parsing | Reads Google result blocks structurally by locating the `<h3>` and its smallest surrounding block, so it does not depend on Google's CSS class names |
| `site:` operator targeting | Every query is scoped to `ubereats.com`, so results stay on-platform |
| Query expansion | Base, quoted and `intitle:` phrasings, plus one variant per query modifier; base queries run first |
| Domain filtering | Only emails ending in your `customDomains` are kept, with boundary-correct matching |
| Obfuscated email decoding | Understands `name [at] domain [dot] com`, `name (at) domain`, `name @ domain.com`, `domain .com`, zero-width characters and the full-width `＠` |
| Email deduplication | Global dedupe across every query and every page in the run |
| Junk filter | Rejects placeholders such as `email@`, `yourname@`, `test@`, `xxx@` and single-character locals |
| Soft-wrap repair | Drops a hit that is only the tail of another email in the same block |
| Snippet extraction | Cleans bio and caption text of labels and engagement counters |
| Concurrency control | An `asyncio` worker pool with a shared stop signal once `maxEmails` is reached |
| Exponential backoff | Up to 3 attempts per page, with a fresh proxy session per request |
| CAPTCHA detection | CAPTCHA, "unusual traffic" and consent pages are detected and retried, not counted as empty |
| Failed-query requeue | Blocked or failed queries are re-queued once at the end of the run |
| Resumable runs | State is kept in the key-value store keyed by an input hash, and saved on `PERSIST_STATE`, `MIGRATING` and `ABORTING` |
| Fallback parser | If Google's markup changes, the run degrades to "emails without account details" rather than "no emails" |
| Dataset export | Results stream into the Apify dataset immediately, ready for CSV, JSON or Excel export |
| Run summary | Logs pages fetched, blocked pages, retries and emails per page |

Two of these matter more on this platform than elsewhere. Domain filtering decides how much
Uber Eats Email Scraper finds outside the US, and the fallback parser is why a low-handle
platform still yields a usable restaurant email list rather than nothing.

Taken together they make it a practical restaurant email extractor rather than a generic
email scraping tool: every query is scoped to one domain, and every address is checked against
your own domain list before it reaches the dataset.

### How Uber Eats Email Scraper works

Six steps, start to finish. Uber Eats Email Scraper pushes each lead as soon as it is found,
so you can watch the dataset fill during the run.

1. **Reads your input** - keywords, location, email domains and the run limits.
2. **Builds `site:` queries** against `ubereats.com`, combining each keyword with each email
   domain and, when expansion is on, with each query modifier.
3. **Fetches Google result pages** through the Apify GOOGLE\_SERP proxy over async HTTP, with
   proxy rotation on every request.
4. **Parses each result block structurally**, finding the `<h3>` title and then the smallest
   block that surrounds it.
5. **Extracts emails** from that block's text with a domain-filtered regex, after normalising
   obfuscated and full-width forms.
6. **Deduplicates globally** and pushes each lead to the dataset straight away.

Query expansion is the step that decides your yield. With `expandQueries` on, each keyword is
paired with every email domain and every modifier, so one keyword becomes a family of `site:`
queries rather than a single capped one.

Because Uber Eats Email Scraper never renders a page, it is cheap to run and cannot see
anything a logged-out Google user could not see. That is also why handle coverage here is
what it is - Google does not print a store slug on most indexed Uber Eats pages.

### Input for Uber Eats Email Scraper

These are the nine input fields of Uber Eats Email Scraper, with titles and defaults exactly
as they appear in the Actor's input schema.

| Field | Title | Type | Default | Meaning |
|---|---|---|---|---|
| `keywords` | Keywords or Queries | array (required) | `["restaurant","takeaway"]` | Search terms describing the Uber Eats accounts you want |
| `location` | Location | string | `""` | Optional location phrase added to every query |
| `customDomains` | Email domains (e.g. @gmail.com, @yahoo.com) | array | `["@gmail.com","@yahoo.com"]` | Only emails on these domains are kept; the `@` is optional |
| `maxEmails` | Max emails | integer 1-10000 | `20` | Stop once this many unique emails are collected |
| `countryCode` | Google country (optional) | string | `""` | Two-letter country for the search proxy (US, GB, DE...) |
| `expandQueries` | Expand queries | boolean | `true` | Search each keyword x domain pair in several phrasings |
| `queryModifiers` | Query modifiers | array | `["email","contact","catering","reservations","owner"]` | Extra words combined with each keyword when expansion is on |
| `maxPagesPerQuery` | Max Google pages per query | integer 1-50 | `30` | Page cap per query |
| `maxConcurrency` | Max concurrency | integer 1-20 | `5` | How many queries run in parallel |

A realistic Uber Eats Email Scraper input for city-level prospecting in Chicago:

```json
{
  "keywords": ["restaurant", "takeaway", "pizza"],
  "location": "Chicago",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 300,
  "countryCode": "US",
  "expandQueries": true,
  "queryModifiers": ["email", "contact", "catering", "reservations", "owner"],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

Start with `maxEmails` low - 20 or 50 - to see what a market returns before committing spend.
Once the shape of the restaurant contact database looks right, raise the cap and rerun
Uber Eats Email Scraper with the same keywords.

#### Getting `location` right

`location` is a plain string appended to every query, and it is the most useful knob in
Uber Eats Email Scraper - restaurant prospecting is inherently local, and a sales rep wants
a territory, not a national blob.

Run **one city per run** ("Chicago", "Manchester", "Lyon") and keep each dataset separate.
The output then arrives already shaped like a territory list, before anyone touches a
spreadsheet.

In dense metros, drop to the neighbourhood or borough - "Brooklyn", "Shoreditch", "Le Marais".
A borough-level pass usually surfaces independent operators that a city-level pass buries
under chains.

Pair `location` with `countryCode` so the search proxy resolves the right Google locale.
Widen to a state or region only when a city genuinely returns too little to work with.

Remember that `location` is matched as text on the indexed page. A city name that Uber Eats
never prints on its own pages will simply narrow your results to nothing, so prefer the
spelling the platform itself uses.

#### `countryCode` matters more here than anywhere else

Uber Eats is the most international platform this family covers, so treat `countryCode` as a
first-class input rather than an afterthought. Run separate Uber Eats Email Scraper passes for
US, GB, FR, AU and any other market you sell into.

Keep those datasets apart. A single blended export mixes currencies, languages and legal
regimes, which makes both segmentation and compliance harder than they need to be.

Widen `customDomains` outside the US as well. The `@gmail.com` / `@yahoo.com` defaults miss
most European and Asia-Pacific operators - add `@hotmail.fr`, `@orange.fr`, `@btinternet.com`,
`@outlook.com`, `@bigpond.com` and similar consumer-mail domains per market.

That one change is usually the difference between a thin non-US run and a full one, because
domain filtering is applied before anything else. Uber Eats Email Scraper cannot keep an
address whose domain you never asked for.

### Output of Uber Eats Email Scraper

Every dataset item from Uber Eats Email Scraper carries all fourteen fields below, always in
this order.

| Field | Meaning |
|---|---|
| `network` | Platform name |
| `keyword` | The keyword that produced the lead |
| `query` | The exact Google query used |
| `title` | Raw result title |
| `accountName` | Account label Google prints (handle or display name) |
| `fullName` | Display name parsed from a profile-style title; empty for snippet-only results |
| `username` | URL-safe handle when the platform exposes one; otherwise `null` |
| `profileUrl` | Canonical account URL when a handle is known; otherwise empty |
| `url` | Direct platform link when exposed, else the profile URL |
| `description` | Bio or snippet text, cleaned of labels and engagement counters |
| `email` | Lower-cased email address |
| `emailDomain` | The matched domain (e.g. `@gmail.com`) |
| `possiblyTruncated` | `true` when Google's snippet ellipsis touched the email - verify before sending |
| `foundAt` | ISO 8601 UTC timestamp |

Three sample rows. Note the second and third: on this platform those handle-less rows are the
common case, not the exception.

```json
[
  {
    "network": "Uber Eats",
    "keyword": "restaurant",
    "query": "site:ubereats.com restaurant \"@gmail.com\" \"Chicago\"",
    "title": "Mario's Trattoria - Chicago - Uber Eats",
    "accountName": "Mario's Trattoria",
    "fullName": "Mario's Trattoria",
    "username": "marios-trattoria-chicago",
    "profileUrl": "https://www.ubereats.com/store/marios-trattoria-chicago",
    "url": "https://www.ubereats.com/store/marios-trattoria-chicago",
    "description": "Family-run Italian kitchen. Catering and large orders: mario.catering@gmail.com",
    "email": "mario.catering@gmail.com",
    "emailDomain": "@gmail.com",
    "possiblyTruncated": false,
    "foundAt": "2025-11-04T09:12:47Z"
  },
  {
    "network": "Uber Eats",
    "keyword": "takeaway",
    "query": "site:ubereats.com takeaway contact \"@gmail.com\" \"Chicago\"",
    "title": "Takeaway near Lincoln Park, Chicago | Uber Eats",
    "accountName": "Uber Eats Chicago",
    "fullName": "",
    "username": null,
    "profileUrl": "",
    "url": "https://www.ubereats.com/city/chicago-il",
    "description": "Order takeaway near Lincoln Park. Bookings and catering: northside.kitchen@yahoo.com",
    "email": "northside.kitchen@yahoo.com",
    "emailDomain": "@yahoo.com",
    "possiblyTruncated": false,
    "foundAt": "2025-11-04T09:13:02Z"
  },
  {
    "network": "Uber Eats",
    "keyword": "restaurant",
    "query": "site:ubereats.com restaurant catering \"@gmail.com\" \"Manchester\"",
    "title": "Best Restaurants in Manchester | Uber Eats",
    "accountName": "Uber Eats Manchester",
    "fullName": "",
    "username": null,
    "profileUrl": "",
    "url": "https://www.ubereats.com/gb/city/manchester-eng",
    "description": "Catering enquiries - northern.spice.events@gmail.com - group orders welcome...",
    "email": "northern.spice.events@gmail.com",
    "emailDomain": "@gmail.com",
    "possiblyTruncated": true,
    "foundAt": "2025-11-04T09:13:55Z"
  }
]
```

Export the Uber Eats Email Scraper dataset as CSV, JSON or Excel from the Apify console, or
pull it through the API for CRM import. The default dataset view already surfaces the eight
fields that matter for cold email outreach and lead enrichment.

### Use cases for Uber Eats Email Scraper

Because Uber Eats Email Scraper returns addresses far more reliably than handles, it suits
buyers whose first action is an email rather than a profile lookup.

| Buyer | How they use it |
|---|---|
| POS and online-ordering vendors | Build POS sales leads city by city, then sequence a pitch at merchants already selling delivery |
| Delivery and integration platforms | Find operators on one marketplace and pitch multi-channel order routing |
| Food distributors and wholesalers | Segment by cuisine keyword so a catalogue reaches the right kitchens |
| Packaging and disposables suppliers | Target takeaway-heavy keywords where container volume is highest |
| Equipment and repair companies | Build local restaurant leads inside a service radius using neighbourhood-level runs |
| Hospitality recruiters | Reach chefs, GMs and front-of-house hiring managers at independent venues |
| Local marketing and SEO agencies | Prospect independents with a delivery presence but a thin web presence |
| Catering brokers | Filter snippets for catering language and work the resulting catering leads directly |
| Market researchers | Measure merchant density per city and per cuisine across countries |

For ICP targeting, the `keyword` field is the one to build on. It records which search term
produced each lead, so one Uber Eats Email Scraper run splits into several segmented
restaurant marketing leads lists afterwards, without re-scraping.

Every buyer above is doing B2B restaurant outreach to a published business address. That is
the only use these food delivery leads are suited to, and the responsible use notes below
apply to all of them.

Hospitality lead generation teams tend to run the same city monthly. Because deduplication is
per run, comparing two Uber Eats Email Scraper exports on the `email` column shows you which
merchants are newly indexed since last time.

### Example runs for Uber Eats Email Scraper

Four recipes covering most of what people ask Uber Eats Email Scraper to do.

**Single-city territory list.** `keywords: ["restaurant"]`, `location: "Chicago"`,
`countryCode: "US"`, `maxEmails: 300`. One rep, one territory, one dataset - the cleanest
starting point for restaurant lead generation.

**Cuisine segmentation.** `keywords: ["pizza","sushi","taqueria","halal"]`,
`location: "Brooklyn"`. Each keyword lands in the `keyword` field, so one export becomes four
cuisine-shaped local restaurant leads lists.

**International pass.** Run the same keywords four times with `countryCode` set to `US`, `GB`,
`FR` and `AU`, widening `customDomains` for each market. Four Uber Eats Email Scraper runs,
four locales, four datasets, no blending.

**Catering-only sweep.** `queryModifiers: ["catering","events","large orders"]` with
`expandQueries: true`. Narrower and slower, but the snippets that come back are far more
likely to be genuine catering leads.

For a second US source, run the
[DoorDash Email Scraper](https://apify.com/leads-scraper/doordash-email-scraper) or the
[Grubhub Email Scraper](https://apify.com/leads-scraper/grubhub-email-scraper) and merge on email.

Outside the US, the
[Just Eat Email Scraper](https://apify.com/leads-scraper/just-eat-email-scraper) and
[TheFork Email Scraper](https://apify.com/leads-scraper/thefork-email-scraper) cover adjacent catalogues.

### Responsible use

These are business contact addresses, published so diners and partners can arrange catering,
large orders and reservations. Treat them as B2B contact points, not as personal data to
harvest.

Identify yourself and your company in the first line. Say plainly why you are writing to that
business address, and keep the message relevant to running a restaurant.

Honour opt-outs immediately and include a working unsubscribe link in every send, as CAN-SPAM
requires. Do not mail consumers, and do not reuse a list for an unrelated campaign.

Under GDPR, keep a record of your lawful basis - usually legitimate interest - including the
balancing test and the source of each address. Suppress anyone who objects, and keep that
suppression list permanently.

Uber Eats Email Scraper collects only what Google already publishes, but what you do with a
list afterwards is your responsibility. This is not legal advice; obligations depend on where
you and the recipient are based, so check them with your own counsel.

### Limitations of Uber Eats Email Scraper

Read this list before you buy compute. These are the real constraints of
Uber Eats Email Scraper, ordered by how often they surprise people.

1. **Most rows have no store handle.** Uber Eats indexes city and category pages more than
   store pages, so the typical row carries an email but no merchant handle. In our test run
   only 2 of about 10 parsed results had an account identity or a profile URL.
2. **Only publicly indexed emails.** If an address is not visible in Google's index, the
   Actor cannot find it. There is no login and no private data access.
3. **Google caps a single query at roughly 300 results.** That cap is precisely why query
   expansion exists - leave `expandQueries` on unless you have a reason not to.
4. **`possiblyTruncated: true` means verify first.** Google's snippet ellipsis may have cut
   the address short, so check those rows before sending.
5. **Requires the Apify GOOGLE\_SERP proxy.** The Actor cannot run without Apify proxy
   credentials.
6. **Free Apify plans are capped at 100 emails per run.** Paid plans are uncapped.
7. **`username` and `profileUrl` are only populated when Google exposes a handle.** Otherwise
   you get `accountName` and `fullName` with an empty handle. This is a Google limitation,
   not a bug.
8. **No volume is guaranteed.** Results vary with your keywords, domains and location.

### Uber Eats Email Scraper FAQ

#### How many results should I expect?

In our own test run, on a sample of about 10 parsed results, we saw 2 rows with an account
identity, 2 with a profile URL, and 10 unique emails. One run's observation, not a guarantee.

#### Why is `username` `null` on so many rows?

Uber Eats indexes city and category landing pages more heavily than store pages, and Google
prints no store slug on those. Uber Eats Email Scraper reports what Google shows.

#### Is the Actor still worth running, then?

Yes, if you need addresses - email volume was the joint-highest in our batch. For a handle on
every lead, [Grubhub](https://apify.com/leads-scraper/grubhub-email-scraper) suits you better.

#### Should I run the Postmates Actor as well?

Generally no. Postmates is folded into Uber Eats and most of its pages redirect here, so the
**Postmates Email Scraper** is superseded.

#### Does Uber Eats Email Scraper log in or use the Uber Eats API?

No. It never logs in, never calls an Uber Eats API and never opens the Uber Eats website, and
it is not affiliated with or endorsed by Uber Eats.

#### Which countries does it work in?

Any market Uber Eats operates in. Set `countryCode` on each Uber Eats Email Scraper run - US,
GB, FR, AU - and keep the datasets separate rather than blending markets.

#### Why am I getting so few results outside the US?

Usually `customDomains`. The `@gmail.com` / `@yahoo.com` defaults miss most non-US operators,
so add local consumer-mail domains for the market you are targeting.

#### Can I filter to business domains only?

Yes. Put the domains you want in `customDomains` - matching is boundary-correct, so
`@gmail.com` will not match inside `@gmail.company` or `@gmail.com.br`.

#### What happens if my run is interrupted?

State is stored in the key-value store keyed by a hash of your input, and saved on Apify's
`PERSIST_STATE`, `MIGRATING` and `ABORTING` events, so a resumed run continues.

#### Does it handle obfuscated addresses?

Yes - `name [at] domain [dot] com`, `name (at) domain`, `name @ domain.com`, `domain .com`,
zero-width characters and the full-width `＠` are all normalised before matching.

#### What does Uber Eats Email Scraper cost to run?

Apify platform compute plus GOOGLE\_SERP proxy usage. There is no separate fee for
Uber Eats Email Scraper beyond your Apify plan, and a low `maxEmails` keeps a test run cheap.

#### How do I get the data into my CRM?

Export as CSV, JSON or Excel, or pull it through the Apify API. The `email`, `accountName` and
`keyword` fields map cleanly onto most CRM import templates for restaurant prospecting.

### Related Actors

| Actor | What it collects |
|---|---|
| [Uber Eats Email and Phone Number Scraper](https://apify.com/leads-scraper/uber-eats-email-and-phone-number-scraper) | Emails and phone numbers from Uber Eats |
| [Uber Eats Phone Number Scraper](https://apify.com/leads-scraper/uber-eats-phone-number-scraper) | Public phone numbers from Uber Eats |
| [Airbnb Email Scraper](https://apify.com/leads-scraper/airbnb-email-scraper) | Public contact emails from Airbnb |
| [Booking.com Email Scraper](https://apify.com/leads-scraper/booking-com-email-scraper) | Public contact emails from Booking.com |
| [Caviar Email Scraper](https://apify.com/neuro-scraper/caviar-email-scraper) | Public contact emails from Caviar |
| [ChowNow Email Scraper](https://apify.com/neuro-scraper/chownow-email-scraper) | Public contact emails from ChowNow |
| [Contiki Email Scraper](https://apify.com/neuro-scraper/contiki-email-scraper) | Public contact emails from Contiki |
| [Craigslist Email Scraper](https://apify.com/leads-scraper/craigslist-email-scraper) | Public contact emails from Craigslist |
| [Delivery.com Email Scraper](https://apify.com/neuro-scraper/delivery-com-email-scraper) | Public contact emails from Delivery.com |
| [DoorDash Email Scraper](https://apify.com/leads-scraper/doordash-email-scraper) | Public contact emails from DoorDash |
| [EatStreet Email Scraper](https://apify.com/neuro-scraper/eatstreet-email-scraper) | Public contact emails from EatStreet |
| [G Adventures Email Scraper](https://apify.com/neuro-scraper/g-adventures-email-scraper) | Public contact emails from G Adventures |
| [GetYourGuide Email Scraper](https://apify.com/leads-scraper/getyourguide-email-scraper) | Public contact emails from GetYourGuide |
| [Grubhub Email Scraper](https://apify.com/leads-scraper/grubhub-email-scraper) | Public contact emails from Grubhub |
| [Hostelbookers Email Scraper](https://apify.com/leads-scraper/hostelbookers-email-scraper) | Public contact emails from Hostelworld |
| [HotelsCombined Email Scraper](https://apify.com/neuro-scraper/hotelscombined-email-scraper) | Public contact emails from HotelsCombined |
| [Intrepid Travel Email Scraper](https://apify.com/neuro-scraper/intrepid-travel-email-scraper) | Public contact emails from Intrepid Travel |
| [Just Eat Email Scraper](https://apify.com/leads-scraper/just-eat-email-scraper) | Public contact emails from Just Eat |
| [Klook Email Scraper](https://apify.com/neuro-scraper/klook-email-scraper) | Public contact emails from Klook |
| [OpenTable Email Scraper](https://apify.com/neuro-scraper/opentable-email-scraper) | Public contact emails from OpenTable |
| [Resy Email Scraper](https://apify.com/leads-scraper/resy-email-scraper) | Public contact emails from Resy |
| [TheFork Email Scraper](https://apify.com/leads-scraper/thefork-email-scraper) | Public contact emails from TheFork |
| [Toast Restaurant Email Scraper](https://apify.com/leads-scraper/toast-restaurant-email-scraper) | Public contact emails from Toast |
| [TourRadar Email Scraper](https://apify.com/leads-scraper/tourradar-email-scraper) | Public contact emails from TourRadar |
| [Traveloka Email Scraper](https://apify.com/leads-scraper/traveloka-email-scraper) | Public contact emails from Traveloka |
| [Tripadvisor Attractions Email Scraper](https://apify.com/leads-scraper/tripadvisor-attractions-email-scraper) | Public contact emails from Tripadvisor |
| [Tripadvisor Hotels Email Scraper](https://apify.com/leads-scraper/tripadvisor-hotels-email-scraper) | Public contact emails from Tripadvisor |
| [Tripadvisor Restaurants Email Scraper](https://apify.com/leads-scraper/tripadvisor-restaurants-email-scraper) | Public contact emails from Tripadvisor |
| [Viator Email Scraper](https://apify.com/leads-scraper/viator-email-scraper) | Public contact emails from Viator |
| [Wanderlog Email Scraper](https://apify.com/leads-scraper/wanderlog-email-scraper) | Public contact emails from Wanderlog |
| [Wego Email Scraper](https://apify.com/leads-scraper/wego-email-scraper) | Public contact emails from Wego |
| [Zomato Email Scraper](https://apify.com/leads-scraper/zomato-email-scraper) | Public contact emails from Zomato |
| [Airbnb Email and Phone Number Scraper](https://apify.com/leads-scraper/airbnb-email-and-phone-number-scraper) | Emails and phone numbers from Airbnb |
| [Booking.com Email and Phone Number Scraper](https://apify.com/leads-scraper/booking-com-email-and-phone-number-scraper) | Emails and phone numbers from Booking.com |
| [Caviar Email and Phone Number Scraper](https://apify.com/neuro-scraper/caviar-email-and-phone-number-scraper) | Emails and phone numbers from Caviar |
| [ChowNow Email and Phone Number Scraper](https://apify.com/neuro-scraper/chownow-email-and-phone-number-scraper) | Emails and phone numbers from ChowNow |
| [Contiki Email and Phone Number Scraper](https://apify.com/neuro-scraper/contiki-email-and-phone-number-scraper) | Emails and phone numbers from Contiki |
| [Craigslist Email and Phone Number Scraper](https://apify.com/leads-scraper/craigslist-email-and-phone-number-scraper) | Emails and phone numbers from Craigslist |
| [Delivery.com Email and Phone Number Scraper](https://apify.com/neuro-scraper/delivery-com-email-and-phone-number-scraper) | Emails and phone numbers from Delivery.com |
| [DoorDash Email and Phone Number Scraper](https://apify.com/leads-scraper/doordash-email-and-phone-number-scraper) | Emails and phone numbers from DoorDash |
| [EatStreet Email and Phone Number Scraper](https://apify.com/neuro-scraper/eatstreet-email-and-phone-number-scraper) | Emails and phone numbers from EatStreet |
| [G Adventures Email and Phone Number Scraper](https://apify.com/neuro-scraper/g-adventures-email-and-phone-number-scraper) | Emails and phone numbers from G Adventures |

### Leave a review

If the Uber Eats Email Scraper saved you time, please leave a star rating and a short review on
the Actor page.

Reviews are how other buyers judge whether a tool works, and they tell us which features to
build next.

If something did not work, email <neurodata.apify@gmail.com>
instead - bugs get fixed faster than they get complained about.

# Actor input Schema

## `keywords` (type: `array`):

Search terms describing the Uber Eats accounts you want (niche, job title, industry).

## `location` (type: `string`):

Optional location phrase added to every query (e.g. "New York").

## `customDomains` (type: `array`):

Only emails ending with one of these domains are collected. With or without the leading @. Each domain is searched separately, so more domains means more results but a longer run - remove some for a faster, narrower search, or add your own (e.g. @company.com).

## `maxEmails` (type: `integer`):

Stop once this many unique emails have been collected.

## `countryCode` (type: `string`):

Two-letter country code for the search proxy (e.g. US, GB, DE). Empty for any.

## `expandQueries` (type: `boolean`):

Search each keyword x domain pair with several phrasings. Recommended - Google caps a single query at ~300 results.

## `queryModifiers` (type: `array`):

Extra words combined with each keyword when Expand queries is on. Tuned for Uber Eats.

## `maxPagesPerQuery` (type: `integer`):

Google rarely returns more than ~30 pages for one query.

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

How many queries run in parallel.

## Actor input object example

```json
{
  "keywords": [
    "restaurant",
    "takeaway"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "countryCode": "",
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "catering",
    "reservations",
    "owner"
  ],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `results` (type: `string`):

Records produced by Uber Eats Email Scraper, stored in the run's default dataset.

# 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 = {
    "keywords": [
        "restaurant",
        "takeaway"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ],
    "countryCode": "",
    "queryModifiers": [
        "email",
        "contact",
        "catering",
        "reservations",
        "owner"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("leads-scraper/uber-eats-email-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 = {
    "keywords": [
        "restaurant",
        "takeaway",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
    "countryCode": "",
    "queryModifiers": [
        "email",
        "contact",
        "catering",
        "reservations",
        "owner",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("leads-scraper/uber-eats-email-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 '{
  "keywords": [
    "restaurant",
    "takeaway"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "countryCode": "",
  "queryModifiers": [
    "email",
    "contact",
    "catering",
    "reservations",
    "owner"
  ]
}' |
apify call leads-scraper/uber-eats-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,leads-scraper/uber-eats-email-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/pvvonPCM9yVNR3ouz/builds/WDfeGL7euT4Qrfa1X/openapi.json