# Yelp Email Scraper (`email_scraper/yelp-email-scraper`) Actor

Yelp Email Scraper extracts publicly available email addresses from Yelp-related search results using targeted keywords, locations, and custom email domains. Build structured business lead lists with filtering, duplicate protection, and flexible per-search email limits.

- **URL**: https://apify.com/email\_scraper/yelp-email-scraper.md
- **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### 🔎 Yelp Email Scraper – Overview

**Yelp Email Scraper** is an Apify Actor designed to discover publicly available email addresses associated with Yelp-related search results. It lets you enter specific keywords, optionally narrow the search by location, choose the email domains you want to collect, and filter out unwanted profile descriptions.

The **Yelp Email Scraper** is useful for lead generation, local business research, outreach preparation, market research, prospect discovery, and building structured contact datasets from publicly indexed Yelp information.

Instead of manually searching Yelp results and opening profiles one by one, the actor processes your keyword and email-domain combinations automatically and stores discovered contact records in an Apify dataset.

> **💡 Yelp Email Scraper at a glance**
>
> - Search Yelp-related results using targeted keywords
> - Extract publicly visible email addresses matching selected domains
> - Optionally filter searches by city, state, country, or region
> - Use multiple keywords and multiple email domains in one run
> - Exclude unwanted descriptions using words or phrases
> - Save results incrementally to an Apify dataset
> - Automatically avoids duplicate email addresses
> - Free users are limited to 100 collected emails
> - Paid users do not have the actor's 100-email free-tier ceiling

The easiest way to start is to provide several practical keywords such as `Restaurant`, `Seller`, or `Supplier`, select an email suffix such as `@gmail.com`, and run the actor.

For better coverage, use several closely related search terms instead of relying on one broad keyword. For example, `Restaurant Owner`, `Restaurant Manager`, `Catering Business`, and `Food Supplier` can target different parts of the same market.

***

### 🚀 Yelp Email Scraper – Key Features

The **Yelp Email Scraper** focuses on targeted email discovery rather than collecting unrelated Yelp profile information. Its controls are designed to help you define the audience you want before the extraction begins.

> **✨ Key Features**
>
> - Keyword-based Yelp email discovery
> - Multiple search keywords per run
> - Multiple email-domain filters
> - Optional geographic targeting
> - Exclude-word and exclude-phrase filtering
> - Duplicate email protection
> - Per keyword + domain collection target
> - Incremental dataset storage
> - Resume-friendly run progress
> - Structured lead output

#### 🎯 Targeted Keyword Search

The actor accepts a list of search keywords, allowing you to create focused searches for specific industries, services, business types, or professional audiences.

Specific keywords generally create more targeted search intent than broad terms. Instead of entering only `Fitness`, you could use terms such as `Fitness Trainer`, `Fitness Coach`, `Personal Trainer`, or `Online Fitness Coach`.

#### 🌍 Location-Based Search

The optional location field can narrow searches to a country, state, city, or other region.

For example, you can use:

- `New York`
- `Chicago`
- `California`
- `United States`

Leaving the location empty allows the search to run without a geographic filter.

#### 📧 Custom Email Domains

The `customDomains` input lets you specify which email suffixes should be considered.

Examples include:

- `@gmail.com`
- `@yahoo.com`
- `@outlook.com`
- `@hotmail.com`

You can also use business-domain suffixes when your research requires them.

#### 🚫 Exclude Unwanted Results

Use `excludeWords` to skip descriptions containing terms or phrases you do not want.

For example:

- `crypto`
- `onlyfans`
- `adult`
- `casino`

Single-word matching is case-insensitive and uses whole-word matching, while phrases are matched as phrases within the description text.

***

### 📊 Yelp Email Scraper – What Data You Can Extract

The **Yelp Email Scraper** stores each discovered lead as a structured dataset record. The actor's configured dataset view is designed around five primary fields that are useful for understanding where each email came from.

> **📦 Output / Data Fields**
>
> | Field         | Description                                                               |
> | ------------- | ------------------------------------------------------------------------- |
> | `keyword`     | Search keyword that produced the result                                   |
> | `title`       | Title associated with the search result                                   |
> | `description` | Description or search-result snippet containing the extracted information |
> | `url`         | Result URL                                                                |
> | `email`       | Email address discovered in the result                                    |

The `keyword` field helps you understand which search term generated a particular lead. This is especially useful when you run multiple business categories or market segments in one job.

The `title`, `description`, and `url` provide context around the discovered email. Together, they make the output easier to review, qualify, and organize before using the leads in another workflow.

The `email` field contains the extracted address that matches your selected domain suffix.

The actor also tracks already discovered email addresses during processing so the same email is not repeatedly added as a new lead.

***

### ⚙️ Yelp Email Scraper – How to Use It

Using the **Yelp Email Scraper** requires only a few practical inputs.

#### 1. 🔑 Enter Your Keywords

The `keywords` field is required and accepts a list of search terms.

Example:

```json
{
  "keywords": [
    "Restaurant",
    "Restaurant Owner",
    "Restaurant Manager",
    "Catering Business"
  ]
}
```

More specific keywords can help you build a more targeted lead dataset.

#### 2. 🌎 Add a Location

The `location` field is optional.

Example:

```json
{
  "location": "New York"
}
```

Use this when your campaign or research focuses on a particular geographical market.

#### 3. 📩 Select Email Domains

The default domain is:

```json
{
  "customDomains": [
    "@gmail.com"
  ]
}
```

You can provide several domains:

```json
{
  "customDomains": [
    "@gmail.com",
    "@yahoo.com",
    "@outlook.com"
  ]
}
```

The actor processes keyword and domain combinations individually, giving you more control over the search coverage.

#### 4. 🔢 Set the Email Target

Use `maxEmails` to control how many addresses the actor aims to collect for each keyword + email-domain combination.

The accepted range is **1 to 10,000**, with a default value of **10**.

For example, three keywords and two domains with `maxEmails: 20` create six keyword-domain combinations. The actor can therefore target up to 20 results independently for each combination, subject to what is publicly available.

This is not a guarantee that every combination will produce the requested number of emails.

#### 5. 🚫 Add Exclude Words

You can optionally provide terms that should cause a result description to be skipped.

Example:

```json
{
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

#### 6. ▶️ Run the Actor

After configuring your inputs, start the actor. Discovered records are pushed incrementally into the dataset while processing continues.

***

### 🔍 How to Extract Yelp Business Emails Using Specific Keywords

A practical way to use the **Yelp Email Scraper** is to think about your target audience first and then build a group of related queries.

For example, a restaurant-focused campaign could use:

```text
Restaurant Owner
Restaurant Manager
Catering Company
Cafe Owner
Bakery Owner
Food Supplier
```

A broader business research campaign might use:

```text
Seller
Supplier
Distributor
Retail Store
Local Business
Business Owner
```

Specific combinations help separate different search intents. They can also make your final dataset easier to segment because the original keyword is retained in every output record.

> **💡 Search strategy tip**
>
> - Start with several highly relevant keywords.
> - Add location information when geography matters.
> - Use multiple email domains when you need broader coverage.
> - Review early results and refine your keywords.
> - Use `excludeWords` when search snippets contain unwanted categories.

***

### 🧩 Can You Target a Specific City or Region?

Yes. The actor supports an optional `location` value that can narrow the search geographically.

For example:

```json
{
  "keywords": [
    "Dental Clinic",
    "Dentist",
    "Dental Office"
  ],
  "location": "Los Angeles"
}
```

This can be helpful for local business prospecting, regional market research, and city-specific lead generation.

For broader discovery, simply leave `location` empty.

***

### 🔄 How the Keyword and Domain Combinations Work

The **Yelp Email Scraper** processes the provided keyword list together with the selected email-domain list.

Suppose you use:

```json
{
  "keywords": [
    "Restaurant",
    "Catering"
  ],
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 25
}
```

The actor works through these four combinations:

- Restaurant + `@gmail.com`
- Restaurant + `@yahoo.com`
- Catering + `@gmail.com`
- Catering + `@yahoo.com`

Each combination has its own target. This means the limit is not simply one shared number across the entire matrix.

Actual results depend on the amount of publicly indexed information that matches the query and selected domain.

***

### 💼 Yelp Email Scraper – Use Cases

The actor can support several data collection and research workflows.

> **🎯 Use Cases**
>
> - Local business lead generation
> - Sales prospect discovery
> - Email-based outreach research
> - Business directory research
> - Market and competitor research
> - Regional business prospecting
> - Industry-specific contact discovery
> - Agency prospect research
> - Service-provider research
> - Building segmented contact datasets

#### 📈 Lead Generation

Sales teams and marketers can search for business categories and collect publicly available email addresses associated with relevant search results.

#### 🏪 Local Business Research

Location filtering is useful when researching businesses in a particular city, state, country, or market.

#### 🎯 Audience Segmentation

Because the keyword is preserved in the dataset, you can later group records by search intent, business category, product type, or target segment.

#### 🔎 Market Research

Researchers can combine different keywords to study the types of businesses appearing for related searches and identify publicly available contact opportunities.

***

### 📝 Input

The actor supports the following user-facing inputs:

| Input           | Type    | Required | Default                      | Limits / Notes                  |
| --------------- | ------- | -------: | ---------------------------- | ------------------------------- |
| `keywords`      | Array   |      Yes | Restaurant, Seller, Supplier | Search terms or queries         |
| `location`      | String  |       No | Empty                        | Country, state, city, or region |
| `customDomains` | Array   |       No | `@gmail.com`                 | Email suffixes to include       |
| `maxEmails`     | Integer |       No | `10`                         | 1–10,000                        |
| `excludeWords`  | Array   |       No | Empty                        | Words or phrases to skip        |

A simple complete input example is:

```json
{
  "keywords": [
    "Restaurant Owner",
    "Restaurant Manager",
    "Catering Business"
  ],
  "location": "New York",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "excludeWords": [
    "crypto"
  ]
}
```

The only required field is `keywords`.

***

### 📤 Output

The actor produces structured records in the Apify dataset.

#### 📄 Sample Output

```json
{
  "keyword": "Restaurant Owner",
  "title": "Example Restaurant",
  "description": "Restaurant information and contact details...",
  "url": "https://www.yelp.com/...",
  "email": "example@gmail.com"
}
```

The output is designed for easy review in the Apify dataset and can be used as structured lead data for downstream workflows.

The configured dataset view presents the main fields in a table, including the result URL as a clickable link.

***

### 💰 Pricing and Result Limits

The provided Actor configuration does **not specify a monetary price**, so this README does not invent one.

The code does define different result limits based on the user's plan.

> **💳 Pricing / Usage Behavior**
>
> - Free users are limited to a maximum of **100 emails**.
> - If a free user requests more than 100, the actor applies the 100-email ceiling.
> - Paid users are not restricted by this 100-email free-tier ceiling.
> - `maxEmails` still controls the requested collection target.
> - Results are charged through the actor's result events according to the configured Apify billing setup.
> - No specific per-result price is stated in the provided configuration.

The requested `maxEmails` value remains subject to the actor's actual search results and stopping conditions.

***

### 🛠️ Tips and Best Practices

> **⚡ Important Notes**
>
> - Use several specific keywords instead of one extremely broad keyword.
> - Combine related business terms for broader market coverage.
> - Add a location when you need region-specific leads.
> - Use several email domains when appropriate.
> - Start with a smaller `maxEmails` value to test search quality.
> - Use `excludeWords` to remove unwanted categories.
> - Results may be lower than your requested target when relevant public information is unavailable.
> - Large searches can require more runtime because the actor processes multiple keyword and domain combinations.
> - The actor can stop a search combination when additional pages are no longer producing useful new email results.

The most important optimization is relevance. More keywords do not automatically mean better leads. A smaller set of highly targeted queries can produce a more useful dataset than many unrelated terms.

For example, `Restaurant Owner` is generally more specific for a restaurant-owner campaign than simply `Business`.

***

### ⏱️ What Happens When Results Become Sparse?

The **Yelp Email Scraper** does not continue indefinitely when searches stop producing useful new contacts.

Processing can end for a keyword-domain combination when there are consecutive pages without new emails, when result pages become empty, when later pages become inefficient, or when retrieval repeatedly fails.

This behavior helps avoid spending excessive processing time on searches that are no longer producing meaningful new data.

It also means that `maxEmails` is a target rather than a guarantee.

For the same reason, increasing `maxEmails` does not necessarily produce more results if the underlying search has already reached its available public matches.

***

### 🔁 Can the Yelp Email Scraper Resume Progress?

The actor persists its progress while processing and stores discovered email addresses to help prevent duplicates.

This allows the run state to be maintained as processing moves through the keyword and domain combinations.

The dataset is updated incrementally rather than waiting until every search has completed, which is useful for longer-running jobs.

***

### 📚 Frequently Asked Questions

#### ❓ What is a Yelp Email Scraper?

A Yelp Email Scraper is a data extraction tool that searches Yelp-related indexed results for publicly available email addresses and saves matching contacts as structured dataset records.

#### ❓ How does the Yelp Email Scraper find email addresses?

The actor processes search results related to Yelp and looks for email addresses that match the email-domain suffixes you specify.

#### ❓ Can I scrape Yelp emails by city?

Yes. Enter a city, state, country, or other region in the `location` field to narrow the search geographically.

#### ❓ Can I use multiple Yelp keywords?

Yes. The `keywords` input accepts a list, so you can search multiple business categories or related queries in the same run.

#### ❓ Can I search for Gmail and Yahoo emails together?

Yes. Add multiple values to `customDomains`, such as `@gmail.com` and `@yahoo.com`.

#### ❓ What is the maximum `maxEmails` value?

The configured input accepts values from **1 to 10,000**.

#### ❓ Is `maxEmails` a global run limit?

No. The actor processes the target independently for each keyword + email-domain combination.

#### ❓ Is the requested number of emails guaranteed?

No. The actor can only return emails that are publicly available and discoverable for the selected searches and domains.

#### ❓ Can I exclude unwanted keywords?

Yes. Use `excludeWords` to skip search-result descriptions containing specified words or phrases.

#### ❓ Is the free-user limit 100 emails?

Yes. The actor applies a maximum of **100 emails** for free users.

#### ❓ Do paid users have the same 100-email ceiling?

No. The actor's code removes that free-tier ceiling for paid users, while your selected `maxEmails` target still controls collection behavior.

#### ❓ What fields are included in the output?

The configured dataset view contains `keyword`, `title`, `description`, `url`, and `email`.

#### ❓ Can I collect business emails for a specific industry?

Yes. Use industry-specific and role-specific keywords, such as `Restaurant Owner`, `Hotel Manager`, `Dental Clinic`, or another relevant business term.

#### ❓ Why did my run return fewer emails than requested?

The selected searches may not contain enough publicly available matching email addresses. Narrow searches, limited email domains, geographic filters, and sparse search results can all reduce the final total.

#### ❓ How can I improve Yelp email scraping results?

Use several relevant keywords, consider additional email domains, broaden the location, and remove unnecessary exclusion terms.

***

### 📞 Support

For questions, custom requirements, improvements, or bespoke actor development:

- contact me by email : <alphascraper69@gmail.com>

# Actor input Schema

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

A list of keywords or queries to search for.

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

Optional country, state or city used to narrow the search. Leave it empty to search without a geographic filter.

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

List of custom email domains

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

How many addresses each search keyword + domain suffix combination may collect before the finder moves on to the next one. This is a per-combination target, not a run-wide total: with 3 keyword and 2 Domains and a limit of 20, the run works through all 6 combinations and aims for up to 20 addresses in each, so up to 120 overall. Lower values finish sooner and cost less; higher values dig deeper but never guarantee a fuller result, since the run can only find what is publicly listed.

## `excludeWords` (type: `array`):

Words or phrases you do not want to see.

## Actor input object example

```json
{
  "keywords": [
    "Restaurant Owner",
    "Restaurant Manager"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 5,
  "excludeWords": []
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 Owner",
        "Restaurant Manager"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("email_scraper/yelp-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 Owner",
        "Restaurant Manager",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
    "excludeWords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("email_scraper/yelp-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 Owner",
    "Restaurant Manager"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "excludeWords": []
}' |
apify call email_scraper/yelp-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,email_scraper/yelp-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/UttNCO1KjyOaKSZsk/builds/DOLn3Gq03W15bqDDY/openapi.json