# Just Eat Email Scraper (`leads-scraper/just-eat-email-scraper`) Actor

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

- **URL**: https://apify.com/leads-scraper/just-eat-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

### Just Eat Email Scraper

**Read this before you run anything.** In our own live test run against real Google, the
Just Eat Email Scraper returned **zero results** - 0 account identities, 0 profile URLs and
0 unique emails. Google reported no matching documents for the queries we tested.

The reason is simple: Just Eat blocks most of its listing pages from search engines, so this
Actor often returns nothing at all. That is the honest expectation to start from, not a
worst case.

If you need a usable restaurant owner email list today, run the
[Grubhub Email Scraper](https://apify.com/leads-scraper/grubhub-email-scraper) or the
[Uber Eats Email Scraper](https://apify.com/leads-scraper/uber-eats-email-scraper) instead.

Both of those returned real rows in the same test run. This one did not.

The Just Eat Email Scraper is still real, runnable code, and search indexes change. This
README documents exactly what it *would* return if Just Eat's pages were indexed - treat it
as a specification, not as a promise of a lead list.

Everything below describes the Just Eat Email Scraper as it ships: a keyword-driven
**restaurant email extractor** built on Google SERP parsing. It never logs in, never touches
Just Eat's API and never opens the Just Eat website in a browser.

#### Who the Just Eat Email Scraper is built for

The audience is B2B: restaurant-tech vendors, food distributors, packaging suppliers,
hospitality recruiters and local marketing agencies doing **restaurant lead generation**
against publicly published takeaway business addresses.

Takeaway and restaurant listings publish a business contact address precisely so diners can
arrange catering, large orders and reservations. That is the only kind of address this
Actor collects - business contact points, never personal data harvesting.

### What the Just Eat Email Scraper collects on this platform

Just Eat is UK and Ireland centric. Its public footprint spans `just-eat.co.uk`,
`just-eat.ie` and `justeat.com`, so every query the Just Eat Email Scraper builds is scoped
to those three domains with the `site:` operator.

Where a takeaway has published a contact address on an indexed page, the Just Eat Email
Scraper pulls the email out of the Google snippet along with the account label, any display
name and the result URL. That is the whole data surface.

The problem is upstream of the Just Eat Email Scraper. Just Eat's own robots rules and page
templates keep most restaurant pages out of Google, so there is usually nothing in the index
for the `site:` queries to match.

That is why the honest framing for the Just Eat Email Scraper is "here is the shape of a row
it would produce", not "here is your **restaurant contact database**".

An adjacent platform with far better indexing is the
[ChowNow Email Scraper](https://apify.com/neuro-scraper/chownow-email-scraper), which reaches
independent restaurants.

### Key features of Just Eat Email Scraper

Every feature below is in the shipped Just Eat Email Scraper code. It is a competent
**email scraping tool**; none of these features can create results where Google has indexed
no Just Eat pages.

| Feature | What it does |
|---|---|
| Google SERP parsing | Reads publicly indexed titles, snippets and site labels - no login, no browser, no JavaScript rendering |
| `site:` operator targeting | Scopes every query to `just-eat.co.uk`, `just-eat.ie` and `justeat.com` |
| Query expansion | Base, quoted and `intitle:` variants plus one per query modifier; base queries run first |
| Domain filtering | Only emails ending in your `customDomains` values are kept |
| Global email deduplication | One row per unique address across every query and every page |
| Obfuscated email decoding | Understands `name [at] domain [dot] com`, `name (at) domain`, `name @ domain.com`, `domain .com`, zero-width characters and the `＠` full-width at sign |
| Junk filter | Rejects placeholders such as `email@`, `yourname@`, `test@`, `xxx@` and single-character locals |
| Boundary-correct matching | `@gmail.com` does not match inside `@gmail.company` or `@gmail.com.br` |
| Soft-wrap repair | Drops a hit that is only the tail of another email in the same block |
| Concurrency control | An `asyncio` worker pool with a shared stop signal on `maxEmails` |
| Retries with exponential backoff | Up to 3 attempts per page, with a fresh proxy session per request |
| CAPTCHA detection | Consent pages and "unusual traffic" screens 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 a hash of the input, and saved on `PERSIST_STATE`, `MIGRATING` and `ABORTING` |
| Whole-page fallback parser | If Google's markup changes, the run degrades to "emails without account details" rather than "no emails" |
| Dataset export | Every lead is pushed immediately; export as CSV, JSON or Excel for CRM import |
| Run summary logging | Pages fetched, blocked pages, retries and emails per page |

Taken together, those features make the Just Eat Email Scraper a careful parser. They cannot
manufacture pages that Google's index does not hold.

### How Just Eat Email Scraper works

Six steps, start to finish. The Just Eat Email Scraper does exactly this and nothing more.

1. **Reads input** - keywords, location, email domains, limits and concurrency.
2. **Builds `site:` Google queries** against the Just Eat domains, for example
   `site:just-eat.co.uk takeaway catering "@gmail.com" "Manchester"`.
3. **Fetches SERP pages through the Apify GOOGLE\_SERP proxy** using async `aiohttp` requests
   with proxy rotation.
4. **Parses each result block structurally** - it locates the `<h3>` title, then the smallest
   surrounding block, rather than relying on Google's CSS class names.
5. **Extracts emails with a domain-filtered regex** over the block text, applying the
   normalisation, junk filter and snippet extraction rules above.
6. **Deduplicates globally and pushes each lead to the dataset immediately**, so a partial
   run still leaves you with usable rows.

When Google returns no matching documents - which is what happened in our Just Eat Email
Scraper test run - steps 4 to 6 simply have nothing to work on and the dataset stays empty.

### Input for Just Eat Email Scraper

Nine fields, exactly as they appear in the Just Eat Email Scraper input schema.

| Field | Type | Default | Meaning |
|---|---|---|---|
| `keywords` | array (required) | `["takeaway","restaurant"]` | Search terms (niche, job title, industry) |
| `location` | string | `""` | Optional location phrase added to every query |
| `customDomains` | array | `["@gmail.com","@yahoo.com"]` | Only emails on these domains are kept; `@` optional |
| `maxEmails` | integer 1-10000 | `20` | Stop after this many unique emails |
| `countryCode` | string | `""` | Two-letter country for the search proxy (US, GB, DE...) |
| `expandQueries` | boolean | `true` | Search each keyword x domain in several phrasings |
| `queryModifiers` | array | `["email","contact","catering","reservations","owner"]` | Extra words combined with each keyword when expansion is on |
| `maxPagesPerQuery` | integer 1-50 | `30` | Page cap per query |
| `maxConcurrency` | integer 1-20 | `5` | Parallel queries |

A realistic input for the Just Eat Email Scraper, tuned for the UK:

```json
{
  "keywords": ["takeaway", "restaurant", "curry house"],
  "location": "Manchester",
  "customDomains": ["@gmail.com", "@yahoo.co.uk", "@hotmail.co.uk", "@outlook.com", "@btinternet.com"],
  "maxEmails": 200,
  "countryCode": "GB",
  "expandQueries": true,
  "queryModifiers": ["email", "contact", "catering", "reservations", "owner"],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

Note the widened `customDomains`. The `@gmail.com` / `@yahoo.com` defaults are US-flavoured,
and UK takeaway owners commonly use `@yahoo.co.uk`, `@hotmail.co.uk`, `@outlook.com` or
`@btinternet.com`.

Widening domains is the right call for any UK run - but be clear about what it can do. It
will not rescue a zero-result run, because domain filtering happens *after* Google returns
pages, and here Google returned none.

#### Getting `location` right in the Just Eat Email Scraper

`location` is a plain string the Just Eat Email Scraper appends to every query, and it
matters more here than on most platforms because **restaurant prospecting** is inherently
territory-shaped.

Run one city per run - `"Manchester"`, `"Birmingham"`, `"Dublin"` - and keep the datasets
separate. A sales rep then gets territory-shaped **local restaurant leads** from city-level
prospecting instead of a national blob.

For dense metros, drop to the borough or neighbourhood: `"Shoreditch"`, `"Chorlton"`,
`"Leith"`. Narrower text often matches the way a listing actually prints its address.

Pair `location` with `countryCode` so the search proxy resolves the right Google locale.
For Just Eat that means `"GB"` for the UK and `"IE"` for Ireland - a US locale is the wrong
index for these domains.

Widen to a county or region only when a city returns too little. And remember `location` is
matched as text on the indexed page, so a place name Just Eat never prints will narrow your
Just Eat Email Scraper results to nothing on its own.

### Output of Just Eat Email Scraper

Every dataset item carries all fourteen fields below, whether or not each one is populated.

| 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, display name, or e.g. a subreddit) |
| `fullName` | Display name parsed from a profile-style title; empty for post captions |
| `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/caption snippet, 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 |

**The example below is the shape a row would take *if* the Just Eat Email Scraper finds one.
It is not sample output from a successful run: the query we tested returned nothing.**

```json
[
  {
    "network": "Just Eat",
    "keyword": "takeaway",
    "query": "site:just-eat.co.uk takeaway catering \"@gmail.com\" \"Manchester\"",
    "title": "Spice Garden Takeaway, Manchester - Order Online",
    "accountName": "Spice Garden Takeaway",
    "fullName": "Spice Garden Takeaway",
    "username": "spice-garden-manchester",
    "profileUrl": "https://www.just-eat.co.uk/restaurants-spice-garden-manchester",
    "url": "https://www.just-eat.co.uk/restaurants-spice-garden-manchester",
    "description": "Family-run curry house in Manchester. Catering and large orders: spicegarden.catering@gmail.com",
    "email": "spicegarden.catering@gmail.com",
    "emailDomain": "@gmail.com",
    "possiblyTruncated": false,
    "foundAt": "2026-08-31T09:14:22Z"
  },
  {
    "network": "Just Eat",
    "keyword": "restaurant",
    "query": "site:just-eat.ie restaurant contact \"@yahoo.co.uk\" \"Dublin\"",
    "title": "Harbour Grill - Dublin - Just Eat",
    "accountName": "Harbour Grill",
    "fullName": "Harbour Grill",
    "username": null,
    "profileUrl": "",
    "url": "https://www.just-eat.ie/",
    "description": "Seafood and grill house. Bookings and functions: harbourgrill.orders@yahoo.co.uk",
    "email": "harbourgrill.orders@yahoo.co.uk",
    "emailDomain": "@yahoo.co.uk",
    "possiblyTruncated": true,
    "foundAt": "2026-08-31T09:16:41Z"
  }
]
```

The second row shows the low-handle case the Just Eat Email Scraper hits most often: Google
printed a display name but no URL-safe handle, so `username` is `null` and `profileUrl` is
empty.

That row also shows `possiblyTruncated: true`, which means Google's snippet ellipsis touched
the address. Verify it before you send anything.

### Use cases for Just Eat Email Scraper

These are the buyer types the Just Eat Email Scraper is aimed at. Read the table as "what
you would do with rows", given the zero-result caveat above.

| Buyer | How they use it |
|---|---|
| Restaurant-tech vendors (POS, online ordering, delivery integrations) | Build an ICP-targeted list of independent takeaways by city - **POS sales leads** for cold email outreach |
| Food distributors and wholesale suppliers | Segment by cuisine keyword and pitch by category for **catering leads** |
| Packaging and disposables suppliers | Target high-volume takeaway categories where container spend is highest |
| Equipment suppliers and service engineers | Cuisine segmentation identifies kitchens likely to run specific equipment |
| Hospitality recruiters (chefs, GMs, front-of-house) | **Hospitality lead generation** across a defined travel-to-work area |
| Local marketing and SEO agencies | Territory-sized **local restaurant leads** and **restaurant marketing leads** for independent-restaurant retainers |
| Delivery aggregators and payment providers | **Food delivery leads** and **merchant contact data** for merchant acquisition in a named region |
| CRM and sales ops teams | Dataset export to CSV, turning a raw **restaurant email list** into CRM import and lead enrichment |

### Example Just Eat Email Scraper runs

Three recipes worth trying. Run them expecting a possible empty dataset: the Just Eat Email
Scraper cannot conjure pages Google has not indexed.

**A single UK city.** `keywords: ["takeaway"]`, `location: "Leeds"`, `countryCode: "GB"`,
UK-widened `customDomains`, `maxEmails: 100`. This is the tightest, most realistic shape
for **B2B restaurant outreach** and **restaurant prospecting**.

**Cuisine segmentation.** `keywords: ["curry house", "pizza takeaway", "kebab shop"]`,
`location: "Glasgow"`, `countryCode: "GB"`. Separate runs per cuisine keep the segments
clean for a **restaurant email extractor** workflow.

**An Ireland sweep.** `keywords: ["restaurant", "takeaway"]`, `location: "Dublin"`,
`countryCode: "IE"`. Targets `just-eat.ie`, which has an even smaller indexed footprint
than the UK domain.

**A control run.** Send the same keywords through the
[Tripadvisor Restaurants Email Scraper](https://apify.com/leads-scraper/tripadvisor-restaurants-email-scraper)
to confirm the gap is Just Eat's indexing, not your input.

### Responsible use

Anything the Just Eat Email Scraper returns is a business contact address, published so
diners and partners can arrange catering, large orders and reservations. Contact them as
businesses, about business, and nothing else.

Under GDPR - which applies squarely to UK and Irish takeaways - identify yourself and your
company, say plainly why you are contacting that business address, and keep a written
lawful-basis or legitimate-interest record for the outreach.

Under CAN-SPAM and equivalent rules, do not use deceptive subject lines or headers, include a
real postal address, honour opt-outs promptly and give every message a working unsubscribe.

Never send to consumers, and never repurpose a business address as personal data. This is
not legal advice - check your own obligations, and your own counsel, before you send.

### Limitations of Just Eat Email Scraper

Read all eight limitations of the Just Eat Email Scraper. The first one matters most.

1. **Just Eat blocks most of its listing pages from search engines, so the Just Eat Email
   Scraper often returns nothing.** In our test run it returned zero rows. If you need comparable
   coverage, use the \[Grubhub Email Scraper]\(https://apify.com/leads-scraper/grubhub-email-
   scraper) or the \[Uber Eats Email Scraper]\(https://apify.com/leads-scraper/uber-eats-email-
   scraper).
2. It only finds emails that are **publicly visible in Google's index**. An address Google
   has not indexed does not exist as far as the Just Eat Email Scraper is concerned.
3. Google caps a single query at roughly **300 results**, which is exactly why query
   expansion exists.
4. `possiblyTruncated: true` means Google's snippet ellipsis may have cut the email. Verify
   it before you send.
5. The Just Eat Email Scraper requires the Apify **GOOGLE\_SERP proxy** and 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 the platform exposes a handle in the
   Google result. Otherwise you get `accountName` and `fullName` with an empty handle - a
   Google limitation, not a bug.
8. Results vary with keywords, domains and location, and **no volume is guaranteed**.

### Just Eat Email Scraper FAQ

#### How many results should I expect?

Honestly: possibly none. In our own test run - a sample of about 10 parsed results - the
Just Eat Email Scraper produced 0 account identities, 0 profile URLs and 0 unique emails,
because Google reported no matching documents. Plan for an empty dataset.

#### So what should I run instead?

The [Grubhub Email Scraper](https://apify.com/leads-scraper/grubhub-email-scraper) was the strongest performer in the same batch.
The [Uber Eats Email Scraper](https://apify.com/leads-scraper/uber-eats-email-scraper) returned plenty of emails with fewer handles.

Both are far better starting points than this one for a **restaurant owner email list** or
any serious **restaurant lead generation** programme.

#### Why publish a Just Eat Email Scraper that may return nothing?

Because it is real, working code against a real platform, and search indexes change. If Just
Eat's pages become indexable, this Actor will pick them up with no changes on your side.

#### Will widening `customDomains` fix the zero result?

No. UK provider domains like `@yahoo.co.uk` or `@btinternet.com` are the right choice for a
UK run, but domain filtering runs after Google returns pages. No pages means no emails to
filter.

#### Does the Just Eat Email Scraper log into Just Eat or use its API?

No. There is no login, no API, no cookies, no browser and no JavaScript rendering. It reads
publicly indexed Google search results through the Apify GOOGLE\_SERP proxy.

#### Which country code should I use?

`"GB"` for `just-eat.co.uk` and `"IE"` for `just-eat.ie`. Pairing `countryCode` with a real
UK or Irish `location` gives a Just Eat Email Scraper run the right Google locale.

#### Why is `username` sometimes `null`?

Google printed a display name but no URL-safe handle for that result. You still get
`accountName`, `fullName` and the email; `profileUrl` is an empty string.

#### Can I export Just Eat Email Scraper results to my CRM?

Yes. The Apify dataset exports to CSV, JSON or Excel, which covers CRM import and most lead
enrichment pipelines - assuming the run produced rows.

#### Is this affiliated with Just Eat?

No. The Just Eat Email Scraper is an independent Apify Actor. It is not endorsed by,
affiliated with or officially supported by Just Eat.

#### Is the data legal to use for outreach?

The addresses are publicly published business contact points, but your obligations depend on
your jurisdiction and your purpose. Read the responsible use section and check with your own
counsel.

#### Can I resume an interrupted Just Eat Email Scraper run?

Yes. Run state is stored in the key-value store keyed by a hash of your input, so resumable
runs survive migrations and aborts.

#### What happens if Google blocks a page request?

CAPTCHA and consent screens are detected, retried with exponential backoff, and any query
that still fails is re-queued once at the end of the run.

### Related Actors

| Actor | What it collects |
|---|---|
| [Just Eat Email and Phone Number Scraper](https://apify.com/leads-scraper/just-eat-email-and-phone-number-scraper) | Emails and phone numbers from Just Eat |
| [Just Eat Phone Number Scraper](https://apify.com/leads-scraper/just-eat-phone-number-scraper) | Public phone numbers from Just Eat |
| [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 |
| [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 |
| [Uber Eats Email Scraper](https://apify.com/leads-scraper/uber-eats-email-scraper) | Public contact emails from Uber Eats |
| [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 Just Eat 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 Just Eat 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 Just Eat.

## `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": [
    "takeaway",
    "restaurant"
  ],
  "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 Just Eat 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": [
        "takeaway",
        "restaurant"
    ],
    "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/just-eat-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": [
        "takeaway",
        "restaurant",
    ],
    "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/just-eat-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": [
    "takeaway",
    "restaurant"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "countryCode": "",
  "queryModifiers": [
    "email",
    "contact",
    "catering",
    "reservations",
    "owner"
  ]
}' |
apify call leads-scraper/just-eat-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,leads-scraper/just-eat-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/xAm9j3hFeDlXWw5Ie/builds/Rszc51x0ObcF5cvIw/openapi.json