# YouTube Email Scraper (`email_scraper/youtube-email-scraper`) Actor

Find publicly indexed YouTube contacts with the YouTube Email Scraper. Search multiple keywords, filter by email domains and location, exclude unwanted results, remove duplicates, and export structured YouTube lead data to an Apify Dataset.

- **URL**: https://apify.com/email\_scraper/youtube-email-scraper.md
- **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.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

### YouTube Email Scraper Overview

**YouTube Email Scraper** is an Apify Actor designed to discover publicly published email addresses associated with YouTube search results. It searches Google for YouTube pages using your keywords, optional location, and selected email-domain suffixes, then extracts matching email addresses from result descriptions.

The **YouTube Email Scraper** is useful for lead generation, creator research, outreach preparation, market research, and contact discovery. Instead of manually reviewing search results, the Actor automates search pagination, email extraction, duplicate removal, and dataset storage.

The **YouTube Email Scraper** is especially useful when you want to search specific topics such as fitness, skincare, cosmetics, gaming, marketing, coaching, education, or other niches using multiple related keywords.

### YouTube Email Scraper Features

The **YouTube Email Scraper** provides several controls for refining how searches are performed.

#### Keyword-Based Search

The **YouTube Email Scraper** accepts a list of search keywords or queries. Each keyword is used as part of a Google query targeting `youtube.com`.

For better coverage, use several specific variations rather than relying on one broad keyword. For example, instead of only using `Fitness`, you can search for `Fitness Coach`, `Fitness Trainer`, `Fitness Influencer`, and `Online Fitness Coach`.

#### Email Domain Filtering

The **YouTube Email Scraper** can search for specific email-domain suffixes. The default domain is `@gmail.com`, and you can provide additional domains such as `@yahoo.com`, `@outlook.com`, or business-specific domains.

Each keyword and domain combination is processed separately, giving you more control over the types of public contact information the search targets.

#### Location Filtering

The **YouTube Email Scraper** supports an optional location string. You can enter a country, state, city, or other geographic phrase to narrow the Google search.

Location is included as a quoted phrase in the search query. It helps narrow results, but it is not a post-scrape verification of a channel's actual physical location.

#### Exclusion Filtering

The **YouTube Email Scraper** supports an `excludeWords` list. When an excluded word or phrase appears in a search-result description, that complete result is skipped.

Single-word exclusions are matched as whole words and without regard to letter case. Multi-word phrases are matched as case-insensitive substrings.

#### Incremental Dataset Output

The **YouTube Email Scraper** pushes extracted records to the Apify dataset as they are discovered. Each accepted email is checked against previously seen emails, helping prevent duplicate email addresses across the run.

### How to Use the YouTube Email Scraper

Using the **YouTube Email Scraper** requires only a keyword list and, when useful, optional filtering settings.

#### 1. Enter Keywords

Add one or more keywords to the `keywords` input. Specific keyword combinations can provide more targeted search coverage.

Example:

```json
{
  "keywords": [
    "fitness coach",
    "fitness trainer",
    "online fitness coach",
    "fitness influencer"
  ]
}
```

#### 2. Add a Location

Set `location` to a country or city when you want the Google search to include a geographic phrase.

For broader discovery, leave the location empty:

```json
{
  "location": ""
}
```

#### 3. Select Email Domains

Use `customDomains` to control which email suffixes the **YouTube Email Scraper** searches for.

Example:

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

#### 4. Set the Email Target

`maxEmails` controls the target for each keyword and domain combination. It accepts values from `1` through `10000`, with a default of `10`.

For example, three keywords and two domains create six keyword/domain combinations. With a target of `20`, the scraper processes each combination independently rather than treating `20` as one shared run-wide target.

#### 5. Exclude Unwanted Results

Use `excludeWords` when specific terms should cause search snippets to be skipped.

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

This filtering is applied to the result description before an email is extracted.

### YouTube Email Scraper Data Extraction

The **YouTube Email Scraper** extracts email addresses from the descriptions of Google organic search results that match the generated YouTube-focused query.

The search query follows this general structure:

```text
site:youtube.com KEYWORD "@gmail.com"
```

When a location is provided, the location is added as another quoted search phrase:

```text
site:youtube.com fitness coach "@gmail.com" "New york"
```

The **YouTube Email Scraper** does not directly crawl private YouTube profiles or require private account access. Its extraction is based on information exposed through the Google search-result pages retrieved by the Actor.

#### Google SERP-Based Extraction

The **YouTube Email Scraper** retrieves Google search-result pages through the Apify `GOOGLE_SERP` proxy group. It parses organic result entries and examines their descriptions for email addresses matching the selected domains.

Only email addresses found by the implemented extraction pattern are returned.

#### Email Deduplication

The **YouTube Email Scraper** maintains a set of previously observed email addresses during the run. When the same email appears in multiple results or keyword/domain combinations, it is not pushed as a new record again.

This makes the resulting dataset more useful for contact discovery and data analysis.

#### Search Pagination

The **YouTube Email Scraper** can paginate through Google results for each keyword/domain combination. The implementation can examine up to 1,000 pages for an individual combination, subject to its stopping conditions and the availability of useful results.

The scraper can stop earlier when searches become unproductive, when repeated pages contain no new emails, or when other efficiency conditions are reached.

### YouTube Email Scraper Use Cases

The **YouTube Email Scraper** can support several legitimate research and business workflows where publicly exposed contact information is useful.

#### Lead Generation

Sales and marketing teams can use the **YouTube Email Scraper** to identify publicly listed email addresses associated with YouTube-related search results.

Combining niche keywords with relevant business or professional terms can help create targeted prospect datasets.

#### Creator and Channel Research

The **YouTube Email Scraper** can help researchers find publicly displayed contact information connected with creators, channels, and other YouTube search-result pages.

This can support creator discovery and outreach research without requiring manual review of every search result.

#### Market Research

Researchers can compare contact availability across topics, locations, and email domains. Multiple keyword variations make it possible to explore different segments of the same market.

#### Competitor and Industry Research

The **YouTube Email Scraper** can help collect search-result information around competitors, industries, professional niches, or content categories when publicly listed emails appear in result descriptions.

#### Outreach Preparation

Marketing teams can use the resulting dataset as an input to their own review and outreach workflows. The Actor provides structured records containing the search keyword, title, description, result URL, and extracted email.

### YouTube Email Scraper Input

The **YouTube Email Scraper** uses the following Actor inputs.

| Input           | Type             | Required | Default                     | Description                                                                                  |
| --------------- | ---------------- | -------- | --------------------------- | -------------------------------------------------------------------------------------------- |
| `keywords`      | Array of strings | Yes      | `["skincare", "cosmetics"]` | Keywords or search queries used to search YouTube through Google.                            |
| `location`      | String           | No       | `""`                        | Optional country, state, city, or other location phrase added to the search query.           |
| `customDomains` | Array of strings | No       | `["@gmail.com"]`            | Email-domain suffixes to search for.                                                         |
| `maxEmails`     | Integer          | No       | `10`                        | Target number of addresses for each keyword + domain combination. Allowed range is 1–10,000. |
| `excludeWords`  | Array of strings | No       | `[]`                        | Words or phrases that cause matching search-result descriptions to be skipped.               |

The `keywords` input is the only required field. All other controls are optional and can be adjusted according to the intended search strategy.

For broad discovery, leaving `location` empty can provide wider search coverage. For more targeted research, provide a relevant geographic phrase.

### YouTube Email Scraper Output Data

The **YouTube Email Scraper** writes structured records to the Apify dataset. The implementation actually pushes the following fields:

| Field         | Type   | Description                                                                      |
| ------------- | ------ | -------------------------------------------------------------------------------- |
| `network`     | String | Identifies the source network as `YouTube.com`.                                  |
| `keyword`     | String | The keyword being processed when the email was discovered.                       |
| `title`       | String | The title extracted from the Google organic search result.                       |
| `description` | String | The search-result description used for email extraction and exclusion filtering. |
| `url`         | String | The URL associated with the Google search result.                                |
| `email`       | String | The publicly surfaced email address matching the configured domain pattern.      |

The dataset view defined in `actor.json` displays `keyword`, `title`, `description`, `url`, and `email` as the main lead fields. The runtime implementation also includes the `network` field in each pushed record.

These fields make the **YouTube Email Scraper** output suitable for reviewing search context alongside the extracted contact information. The original result title, description, and URL provide additional context for evaluating a lead instead of receiving an email address by itself.

### Example Input

The following is a valid example using the Actor's actual input structure:

```json
{
  "keywords": [
    "fitness coach",
    "fitness trainer",
    "online fitness coach"
  ],
  "location": "New york",
  "customDomains": [
    "@gmail.com",
    "@outlook.com"
  ],
  "maxEmails": 10,
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

### Example Output

A realistic record produced by the implementation follows this structure:

```json
{
  "network": "YouTube.com",
  "keyword": "fitness coach",
  "title": "Fitness Coach Channel",
  "description": "Fitness coaching content and contact information ... coach@example.com ...",
  "url": "https://www.youtube.com/...",
  "email": "coach@example.com"
}
```

The exact title, description, URL, and email values depend on the Google results available during the run. The **YouTube Email Scraper** only returns records when its implemented email pattern finds a matching address.

### Data Quality and Reliability

The **YouTube Email Scraper** is designed to process search results incrementally and to avoid unnecessary duplicate output.

#### Public Search Data

The Actor relies on Google search-result content targeting `youtube.com`. Because the source is search-result data, availability depends on what Google exposes for the selected search terms and email domains.

An email is not guaranteed to exist for every result. The Actor can only collect addresses that appear in the searchable result description and match the requested domain pattern.

#### Proxy Handling

The **YouTube Email Scraper** initializes an Apify proxy configuration using the `GOOGLE_SERP` proxy group.

When a request fails, the implementation retries after rotating the proxy URL. After repeated hard failures, the current keyword/domain pair can be stopped rather than continuing indefinitely.

#### Resume State

The Actor persists progress in Apify's key-value store. It saves the currently processed keyword/domain position and the set of previously seen emails.

This allows the implementation to maintain run progress across interruptions rather than relying entirely on in-memory state.

#### Automatic Stopping

The **YouTube Email Scraper** does not blindly crawl every possible page. It includes stopping rules for repeated pages without new emails, consecutive empty result pages after page 25, low recent extraction efficiency after page 25, and repeated request failures.

These controls help prevent unnecessary requests when search coverage is no longer producing useful contacts.

### Search Intent and SEO Use

People commonly search for ways to automate YouTube data extraction, discover creator contacts, identify public business emails, and find prospects related to specific topics.

The **YouTube Email Scraper** addresses these search intents by combining keyword-based Google discovery, YouTube-focused search queries, domain filtering, location narrowing, and structured email extraction.

Instead of manually opening many pages, users can define a search strategy and let the Actor process multiple keyword and domain combinations automatically.

### Frequently Asked Questions

#### What is the YouTube Email Scraper?

The **YouTube Email Scraper** is an Apify Actor that searches Google for YouTube-related results and extracts matching publicly surfaced email addresses from result descriptions.

#### How does the YouTube Email Scraper find emails?

The **YouTube Email Scraper** builds Google queries targeting `site:youtube.com` together with each keyword and selected email-domain suffix, retrieves search-result pages, and extracts matching email addresses from result descriptions.

#### Can I use multiple keywords?

Yes. The **YouTube Email Scraper** accepts an array of keywords, allowing you to process several related search terms in one run.

Using multiple specific terms can improve topical coverage compared with relying on one broad keyword.

#### Can I search a specific country or city?

Yes. The `location` field adds your supplied geographic phrase to the Google query.

The location is a search narrowing mechanism, not a guarantee that every returned channel is physically located there.

#### Which email domains can I search?

You can provide custom email-domain suffixes through `customDomains`. The default is `@gmail.com`.

For example, you can add `@yahoo.com`, `@outlook.com`, or other domain suffixes relevant to your research.

#### What does maxEmails control?

`maxEmails` defines the target for each keyword and domain combination. It is not simply one shared target for the entire keyword list.

The configured range is from 1 to 10,000.

#### Can I exclude certain words?

Yes. `excludeWords` lets you provide terms or phrases that should cause a result description to be skipped before email extraction.

Single words use case-insensitive whole-word matching, while phrases use case-insensitive substring matching.

#### Does the Actor remove duplicate emails?

Yes. The **YouTube Email Scraper** keeps a persistent set of previously seen email addresses and skips emails that have already been registered during the run.

#### Does the Actor scrape private YouTube information?

No. The implementation searches public Google result pages and extracts email addresses exposed in searchable result descriptions. It does not implement private-account access.

#### Why did I receive fewer emails than my target?

A target is not a guarantee. Search results may contain no matching email address, the requested domain may be uncommon, exclusion filters may remove results, or Google may stop returning productive results.

Adding related keywords, additional email domains, or broadening the location can increase potential coverage.

#### Can I leave location empty?

Yes. An empty `location` value removes the geographic phrase from the generated query and allows the search to operate without that location constraint.

### Why Use the YouTube Email Scraper

The **YouTube Email Scraper** combines automated search, filtering, email extraction, deduplication, pagination, proxy handling, and structured Apify dataset output in one workflow.

The main advantage is reducing repetitive manual search work. Rather than searching keyword after keyword and copying individual contact details, users can define their target terms and let the Actor process the configured combinations.

The **YouTube Email Scraper** also keeps useful context with every extracted email. The keyword, search-result title, description, and URL remain associated with the address, making the resulting data easier to review and validate.

For larger research tasks, multiple keywords and email domains can be combined to broaden discovery while exclusion filters help reduce unwanted result categories.

### API and Automation

The **YouTube Email Scraper** runs as an Apify Actor, so its configured inputs and dataset output can be used within normal Apify Actor workflows and automation.

Users can configure the Actor with their desired keywords, location, domains, target, and exclusion terms, then consume the resulting structured dataset through the Apify platform.

The implementation pushes records incrementally using Apify dataset storage, which means extracted results are written as the Actor processes them rather than waiting for a final in-memory export.

### Usage Tips for Better Results

For the **YouTube Email Scraper**, search strategy has a major effect on result quality.

Start with several closely related keywords instead of one generic term. For example, a business-focused search could combine a profession, role, niche, or service with more specific variations.

Adding several relevant email domains can increase discovery because not every publicly listed contact address uses Gmail.

Use `excludeWords` when you know certain result categories are undesirable. Keep exclusions focused, because an excluded term anywhere in a matching description causes that result to be skipped.

When a run produces sparse results, broaden the keyword strategy or remove the location constraint. Conversely, when results are too broad, more specific keyword phrases and locations can provide tighter search targeting.

### Support

For issues, improvements, or bespoke scraping requirements related to the **YouTube Email Scraper**, use the support options available on the Actor's Apify page.

For custom development requests, the Actor configuration also provides the contact address `alphascraper69@gmail.com`.

The **YouTube Email Scraper** is built to provide a practical, structured workflow for discovering publicly surfaced YouTube-related email contacts through keyword-driven search.

# 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": [
    "skincare",
    "cosmetics"
  ],
  "location": "New york",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 10,
  "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": [
        "skincare",
        "cosmetics"
    ],
    "location": "New york",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

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

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

```

## MCP server setup

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