# YouTube Email Scraper – Creator Business Email Finder (`logiover/youtube-creator-email-finder`) Actor

Extract YouTube creator business emails in bulk from channel IDs, @handles or URLs. Login-free, instant results. Pulls emails from channel About + linked website for influencer outreach, sponsorships & B2B lead generation.

- **URL**: https://apify.com/logiover/youtube-creator-email-finder.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation, Social media, Marketing
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 – Creator Business Email Finder

**Extract YouTube creator business emails in bulk — from channel IDs, @handles, or URLs.**
Login-free, instant results, no CAPTCHA, no Google accounts, no waiting in a queue.

This Actor is a fast **YouTube email scraper**, **YouTube channel email extractor**, and **YouTube creator email finder** built for **influencer outreach**, **sponsorship prospecting**, and **B2B lead generation**. Feed it a list of channels and it returns each creator's **business email**, linked **website**, and **social contact links** as clean JSON, CSV, or Excel — ready for your outreach tool, CRM, or data pipeline.

> Looking for a **YouTube influencer email finder**, a **bulk YouTube email extraction tool**, a **creator contact scraper**, or a **YouTube outreach tool** for sponsorship and collaboration campaigns? This Actor turns a channel list into an outreach-ready contact list at scale.

---

### ✅ What this Actor does

Given YouTube **channel IDs, handles, or URLs**, the Actor:

- Resolves each input to a channel and reads its **About / description**
- Extracts the **business email** published in the channel description
- When no email is in the description, follows the creator's **linked website** and scans its **Contact / About / Impressum** pages for emails
- Captures the **linked website** and **social links** (Instagram, TikTok, X/Twitter, Discord, Telegram, and more)
- Reports the **subscriber count**, **country**, and **handle** for quick lead qualification
- Tells you exactly **where each email came from** (`description` · `website` · `none`) — no fabricated data, ever

---

### ⚡ Why this YouTube email finder is different

Most YouTube email tools either scrape only public metadata (and miss the email entirely) or rely on a queue of logged-in Google accounts that you wait on for 45 minutes. This Actor takes the practical path:

- **Login-free & instant** — no managed Google accounts, no CAPTCHA-solving queue, no 45-minute polling. Results stream into your dataset as the run goes.
- **Two-layer extraction** — description **plus** linked-website crawling, for a much higher hit rate than description-only scrapers.
- **Honest output** — if there's no public email, you get `none`, not a guess. Clean lists, no junk.
- **No ban risk** — 100% public-data extraction, no account farms, nothing against your name.
- **Bulk-ready** — drop in hundreds of channels per run; export to CSV, Excel, JSON, or push to your CRM via the Apify API.
- **Smart noise filtering** — platform/boilerplate addresses (Patreon, Wix, Sentry, no-reply, etc.) are filtered out so you only get real contact emails.

---

### 🎯 Best for

- **Influencer outreach** — find creator emails to pitch collaborations and product seeding
- **Sponsorship prospecting** — build targeted YouTube influencer email lists for brand deals
- **Creator partnerships** — source business-inquiry emails for collabs at scale
- **Agency lead generation** — extract YouTube emails in bulk for client prospect lists
- **Media buying & PR outreach** — get channel contact emails for placements and press
- **Affiliate & UGC recruiting** — find creators to onboard into your program
- **Sales prospecting** — turn a niche channel list into a ready-to-send outreach list

---

### 🛠 How to use

1. Add YouTube **channels** — IDs (`UC...`), `@handles`, or full URLs. **Channel IDs are the most reliable** (they avoid handle/URL redirect issues).
2. Keep **Crawl linked website** on (recommended) to boost the hit rate beyond description-only scraping.
3. Optionally enable **Always crawl linked website** to also collect secondary emails, or **Only output channels with an email** for a clean hit-list.
4. Run the Actor and export results as **CSV / Excel / JSON**, or pull them via the **Apify API**.

#### 🔎 Where do I get channel lists?
Build a niche channel list with a **YouTube influencer / channel / lookalike discovery** scraper, then feed those channels straight into this Actor to get their business emails. You can also paste a list you already track in a spreadsheet or CRM.

#### 💡 How to maximize your hit rate
Submit channels that are likely to publish a contact email — creators who already do **sponsorships, brand deals, or run a business/website**. Monetizing mid-to-large channels almost always list a business or management email in the description or on their site.

---

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `channels` *(required)* | array | Channel IDs, `@handles`, or URLs |
| `crawlLinkedSite` | boolean | Crawl the creator's linked site when no email is in the description (default: `true`) |
| `alwaysCrawlSite` | boolean | Crawl the site even if an email was already found (default: `false`) |
| `maxSitePages` | integer | Pages of the linked site to scan — homepage + contact/about variants (default: `3`) |
| `onlyWithEmail` | boolean | Skip channels with no email found (default: `false`) |
| `maxResults` | integer | Stop after N channels, `0` = no limit |

#### Example input
```json
{
  "channels": ["@mkbhd", "@MrBeast", "UCBJycsmduvYEL83R_U4JriQ"],
  "crawlLinkedSite": true,
  "onlyWithEmail": true
}
````

***

### 📤 Output

One row per channel:

```json
{
  "channelTitle": "Marques Brownlee",
  "handle": "@mkbhd",
  "channelUrl": "https://www.youtube.com/@mkbhd",
  "subscriberCount": 19800000,
  "email": "business@mkbhd.com",
  "emails": ["business@mkbhd.com"],
  "emailSource": "description",
  "linkedWebsite": "http://shop.MKBHD.com/",
  "socialLinks": ["https://www.instagram.com/mkbhd", "https://x.com/MKBHD"],
  "country": "US"
}
```

Export to **CSV, Excel, JSON, or HTML**, or fetch programmatically through the **Apify API** and drop the results straight into your outreach sequence.

***

### 🆚 How this compares to other YouTube email tools

**vs. metadata-only scrapers** — Tools that scrape only the channel page often return no email at all, because the contact email frequently lives on the creator's linked website. This Actor crawls that site too, so it captures emails the metadata misses.

**vs. logged-in / CAPTCHA-gated tools** — Tools that click YouTube's "View email address" button need a fleet of logged-in Google accounts and a CAPTCHA solver, then make you wait in a polling queue. This Actor skips all of that: no accounts, no CAPTCHA, no waiting — results are instant and there's zero ban risk. It targets the emails creators publish openly in their description and on their site, which is where a large share of monetizing creators put their business contact.

**vs. manual lookup** — Checking channels one by one and copying emails is slow and error-prone. This Actor processes hundreds of channels per run and outputs a clean, de-duplicated, source-labeled list.

***

### ❓ FAQ

**Does it get the email behind YouTube's "View email address" button?**
No — that email is gated behind a logged-in Google account and a CAPTCHA. This Actor instead harvests the emails creators publish openly in their **description** and on their **linked website**, with zero accounts and zero ban risk. For a large share of monetizing creators, that's exactly where the business email lives.

**What's the hit rate?**
It depends entirely on your input list — channels that actively monetize almost always publish a contact email. The Actor reports `emailSource` so you can see whether each email came from the description or the website, and `none` when a creator simply hasn't published one.

**Do I get charged when no email is found?**
You still get a row with `emailSource: "none"` so you can see coverage. Enable `onlyWithEmail` to keep just the hits.

**What input formats are supported?**
Channel IDs (`UC...`), `@handles`, and full channel URLs (`/channel/...`, `/@...`, `/c/...`).

**Can I test with a small list first?**
Yes — run 5–10 channels to see how the **YouTube email finder** performs before scaling to bulk extraction.

**Is this legal and safe?**
It only reads publicly available data — channel descriptions and public websites — and never logs into any account or bypasses any login wall.

**Can I run it on a schedule?**
Yes. Use an Apify Schedule to re-check your channel lists periodically and catch newly added emails.

***

### 🔁 Pairs well with

- **YouTube influencer / channel / lookalike discovery scrapers** → build the channel list
- **Website Contact Scraper** → enrich any remaining domains with emails, phones & socials
- **Bulk Email Verifier** → validate the extracted emails before you hit send

***

#### Keywords

youtube email scraper, youtube channel email extractor, youtube creator email finder, youtube influencer email scraper, youtube business email finder, find youtube channel email, bulk youtube email extraction, youtube outreach tool, influencer contact scraper, youtube lead generation, sponsorship prospecting, creator email list builder, youtube channel contact scraper, extract emails from youtube, youtube influencer outreach, brand deal prospecting, youtube email finder bulk.

***

### Changelog

- **2026-06-01** — Maintenance & reliability pass: pulled the latest source and rebuilt the Actor on the current base image; build verified.

*Last reviewed: 2026-06-01.*

# Actor input Schema

## `channels` (type: `array`):

Channel IDs (UC...), @handles, or full channel URLs. Channel IDs are the most reliable.

## `crawlLinkedSite` (type: `boolean`):

When no email is found in the channel description, follow the creator's linked website and scan its Contact/About pages. Boosts hit rate significantly.

## `alwaysCrawlSite` (type: `boolean`):

Crawl the linked website even when an email was already found in the description (collects additional/secondary emails).

## `maxSitePages` (type: `integer`):

How many pages of the linked site to scan (homepage + contact/about variants).

## `onlyWithEmail` (type: `boolean`):

Skip channels where no email was found. Keep off to see full coverage and email source.

## `maxResults` (type: `integer`):

Stop after this many channels (0 = no limit).

## Actor input object example

```json
{
  "channels": [
    "@veritasium",
    "UCBJycsmduvYEL83R_U4JriQ"
  ],
  "crawlLinkedSite": true,
  "alwaysCrawlSite": false,
  "maxSitePages": 3,
  "onlyWithEmail": false,
  "maxResults": 0
}
```

# Actor output Schema

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

Dataset of YouTube channels with extracted business emails, linked websites and social links.

# 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 = {
    "channels": [
        "@MrBeast",
        "@mkbhd",
        "UCBJycsmduvYEL83R_U4JriQ"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/youtube-creator-email-finder").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 = { "channels": [
        "@MrBeast",
        "@mkbhd",
        "UCBJycsmduvYEL83R_U4JriQ",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/youtube-creator-email-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "channels": [
    "@MrBeast",
    "@mkbhd",
    "UCBJycsmduvYEL83R_U4JriQ"
  ]
}' |
apify call logiover/youtube-creator-email-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/youtube-creator-email-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Email Scraper – Creator Business Email Finder",
        "description": "Extract YouTube creator business emails in bulk from channel IDs, @handles or URLs. Login-free, instant results. Pulls emails from channel About + linked website for influencer outreach, sponsorships & B2B lead generation.",
        "version": "1.0",
        "x-build-id": "SWc70D4t1Hk1vMGah"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~youtube-creator-email-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-youtube-creator-email-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~youtube-creator-email-finder/runs": {
            "post": {
                "operationId": "runs-sync-logiover-youtube-creator-email-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~youtube-creator-email-finder/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-youtube-creator-email-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "channels"
                ],
                "properties": {
                    "channels": {
                        "title": "YouTube channels",
                        "type": "array",
                        "description": "Channel IDs (UC...), @handles, or full channel URLs. Channel IDs are the most reliable.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "crawlLinkedSite": {
                        "title": "Crawl linked website for emails",
                        "type": "boolean",
                        "description": "When no email is found in the channel description, follow the creator's linked website and scan its Contact/About pages. Boosts hit rate significantly.",
                        "default": true
                    },
                    "alwaysCrawlSite": {
                        "title": "Always crawl linked website",
                        "type": "boolean",
                        "description": "Crawl the linked website even when an email was already found in the description (collects additional/secondary emails).",
                        "default": false
                    },
                    "maxSitePages": {
                        "title": "Max website pages per channel",
                        "minimum": 1,
                        "maximum": 6,
                        "type": "integer",
                        "description": "How many pages of the linked site to scan (homepage + contact/about variants).",
                        "default": 3
                    },
                    "onlyWithEmail": {
                        "title": "Only output channels with an email",
                        "type": "boolean",
                        "description": "Skip channels where no email was found. Keep off to see full coverage and email source.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many channels (0 = no limit).",
                        "default": 0
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```