# YouTube Email Finder: Find YouTube Influencers & Channel Emails (`pnda/youtube-email-finder`) Actor

YouTube email finder: find YouTube influencers by niche, or paste channels, and get each channel's verified business email. YouTube channel email finder and email scraper, no login. $25 per 1,000 verified emails, pay only for emails found.

- **URL**: https://apify.com/pnda/youtube-email-finder.md
- **Developed by:** [PNDA](https://apify.com/pnda) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 8 total users, 7 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $22.50 / 1,000 verified email founds

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/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

## YouTube Email Finder: Find YouTube Influencers & Channel Emails

Find YouTube influencers by niche, or paste your own list of channels, and get each channel's **verified business email**, with subscribers, country, description and links. No login, no cookies, no YouTube account.

You only pay for what you get: **a verified email is billed, a failed lookup is free.**

- 💸 **Cheaper per email found**: $0.025 per verified email, and channels without an email cost nothing. Many YouTube email tools bill every channel processed, or charge $0.10+ per email.
- ✅ **You only pay for verified emails**: every address is checked by SMTP before it is billed.
- 🔎 **Search by niche included**: no need to bring a list of channels, type a niche ("dropshipping", "fitness coach", "personal finance") and get the channels with their emails.

### What it does

- **Find channels** (search mode): type niche keywords ("dropshipping", "personal finance", "home workout", "AI tools"), pick a language and a country, and the actor finds matching YouTube channels through Google, then looks for each one's business email.
- **Find emails for my list** (list mode): paste channel URLs, `@handles`, channel ids (`UC…`) or video URLs, and get each channel with its business email.

### Where the email comes from

YouTube hides many business emails behind "Sign in to see email address". This actor never signs in and never reads that hidden email: it finds the creator's email where the creator published it, then checks it by SMTP.

1. **Channel description**: an email written in the About text (including `name [at] domain [dot] com`).
2. **Website**: the link-in-bio page (Linktree, Beacons…), then the creator's own website: homepage, contact page, legal notice, about page.
3. **Business-address dictionary** on the website domain: `contact@`, `info@`, `hello@`, `bonjour@`, `hi@`, `support@`, `partenariat(s)@`, `collab@`, `business@`, `pro@`, `marketing@`, then `firstname@` and `firstname.lastname@`.
4. **Guessed domain**: many creators own `<handle>.com` without linking it. The actor tries the handle and the channel name with `.com`, `.fr`, `.io` and `.co` (with and without dots or dashes), keeps only a domain that has a mail server, checks that its homepage belongs to the creator (it links to the channel or names it), reads the emails on that homepage, then tries the same dictionary.
5. **Our database**: emails found in earlier runs are served from our database. An email older than 30 days is re-verified by SMTP before being served.
6. **Deep search (optional, off by default)**: when none of the steps above finds a public email, the actor can query additional third-party data sources on the Apify Store (cheapest first, the next one only for what is still missing). They are billed at their own rate **directly to your Apify account** and appears in your runs; we add **no fee** on those emails. It is capped to a share of your channels (max 25 %, at most 50 channels per run) and to a maximum charge per run (0.15 $ per channel, Apify minimum 1 $), so you never pay more than announced; you only pay the emails it actually returns.

Every address is verified by SMTP (mail server handshake, catch-all probe) before it is billed.

#### Role addresses (contact@, info@…)

Email verifiers rate role addresses as "risky" by design, even when the mailbox exists. For YouTube business contacts, these addresses **are** the answer creators want brands to use. So a role address counts as **verified and billable** when the mail server confirms the mailbox is deliverable and the domain is **not** catch-all, and "role" is the only risk (not disabled, not a full inbox, not disposable). The `email_is_role` field tells you which emails are role addresses.

### Output

One row per channel:

| Field | Description |
|---|---|
| `channelName`, `handle`, `channelId`, `channelUrl` | The channel |
| `email` | Business email (verified when `email_status` is `found`) |
| `email_status` | `found` (verified, billed), `catch-all`, `unverified`, `not-found`, `no-website`, `no-mx`, `error` (all free) |
| `email_confidence` | `verified`, `catch-all`, `unverified`, `none` |
| `email_source` | `description`, `bio-link-page`, `website`, `website-contact-page`, `website-pattern`, `guessed-domain`, `guessed-domain-pattern`, `instagram-bio`, `tiktok-bio` |
| `email_source_url` | Page where the email was read |
| `email_pattern` | `contact`, `hello`, `first.last`… for the dictionary steps |
| `email_is_role` | True for a role address (contact@, info@…) |
| `website` | The creator's own website domain |
| `other_emails` | Other public emails seen (not verified, free) |
| `subscribers`, `views`, `videos`, `country`, `joinedDate` | Channel stats |
| `description`, `links`, `avatarUrl` | Channel About page |
| `hasHiddenBusinessEmail` | YouTube shows "Sign in to see email address" for this channel |
| `searchKeyword`, `searchRank`, `searchTitle`… | Search mode only |

Example:

```json
{
  "channelName": "Scale Me - Pierre",
  "handle": "@ScaleMePierre",
  "email": "hello@scale-me.fr",
  "email_status": "found",
  "email_confidence": "verified",
  "email_source": "website-contact-page",
  "email_source_url": "https://www.scale-me.fr/contact",
  "email_is_role": true,
  "website": "scale-me.fr",
  "subscribers": 14100,
  "country": "France",
  "hasHiddenBusinessEmail": true
}
```

### Pricing

**Store discounts:** on Apify Silver, Gold, Platinum and Diamond plans, some events cost up to 20 % less. The Pricing tab of the Store page shows the exact price for each plan.

Pay per event, no start fee:

| Event | Price |
|---|---|
| `email-found`: a verified business email | $0.025 ($25 per 1,000) |
| `search-result`: a channel found by the niche search | $0.0065 ($6.50 per 1,000) |

Deep search (optional): emails found by the additional source are billed by that source at its own rate, directly to your Apify account; we charge nothing on them.

Coming soon: an email the creator **published** (description, links, website, linked Instagram / TikTok) on a catch-all mail server will be billed at half the price of a verified email ($0.0125), while a catch-all **guess** (`contact@…` pattern) stays free; until this is enabled, both are free.

Free: channels without a verified email, catch-all guesses, unverified public emails, channels filtered out by your subscriber range, channels that cannot be read. Set a **maximum cost per run** in Run options: the actor stops before going over it.

**Works with a free Apify account too.** Free-plan accounts can use every feature at the same per-result prices, paid from their monthly Apify credit. Limit: free accounts share a daily capacity; once it is used up, the remaining inputs are skipped with one `free-plan-limit` row (not charged). Retry the next day, or switch to a paid Apify plan to run without this limit.

### Tips

- In search mode, set `language` and `country` to the audience's (e.g. `fr` / `fr` for French creators).
- Use `minSubscribers` / `maxSubscribers` to target micro or mid-size creators.
- `requireEmail` keeps only channels with a usable email.
- Results are cached for 30 days: a channel looked up recently is served instantly, at the same price.

### FAQ

**Do you read the email hidden behind "Sign in to see email address"?** No. That would need a YouTube account and a CAPTCHA. The actor finds the email where the creator published it elsewhere (description, website, social bios), which also makes it a contact the creator chose to make public.

**Why are some emails not billed?** Only SMTP-verified emails are billed. Catch-all servers accept any address, so a guess on them cannot be confirmed: it is delivered for free with `email_status: "catch-all"`.

**Is it legal?** The actor only collects business contact data that creators made public. You are responsible for using it in line with the laws that apply to you (privacy and anti-spam rules).

### Related actors

- [YouTube Scraper](https://apify.com/pnda/youtube-scraper): Need video data rather than emails? Views, likes, transcripts and channel stats by URL.
- [Find Influencers (Instagram & TikTok)](https://apify.com/pnda/creator-contact-finder): Looking for Instagram and TikTok creators? Find influencers by niche and city, with engagement rate and verified email.

# Actor input Schema

## `mode` (type: `string`):

"Find channels": no URL needed, the actor finds YouTube channels by niche keyword (Google search of YouTube). "Find emails for my list": paste channel URLs, @handles or video URLs and get each channel's verified business email.

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

One niche per line, as a creator would describe their channel: "dropshipping", "personal finance", "home workout", "AI tools". Each keyword is searched separately.

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

Narrows the search to channels that mention this place, e.g. "Paris", "London", "Canada".

## `language` (type: `string`):

Language of the channels (Google interface language, 2 letters): en, fr, es, de, pt, it…

## `country` (type: `string`):

Country of the Google search (2 letters): us, fr, gb, es, de, br… Set it to the audience's country.

## `maxResultsPerKeyword` (type: `integer`):

How many channels to find for each keyword.

## `onlyNew` (type: `boolean`):

Search mode: skip the channels you already received from this Actor in previous runs (same Apify account, last 12 months) and keep searching for new ones. Example: 20 marketing YouTubers yesterday, run again with onlyNew for 20 more, no duplicate. Channels skipped are never charged.

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

One per line: https://www.youtube.com/@mkbhd, @mkbhd, https://www.youtube.com/channel/UC…, or a video URL (its channel is used). Duplicates are removed.

## `findEmail` (type: `boolean`):

Looks for each channel's business email and verifies it by SMTP. Only a verified email is billed ("email-found"). Always on in list mode.

## `minSubscribers` (type: `integer`):

Skip channels with fewer subscribers (free, not delivered).

## `maxSubscribers` (type: `integer`):

Skip channels with more subscribers (free, not delivered).

## `requireEmail` (type: `boolean`):

Deliver only channels with a verified email or a public email that could not be confirmed (never a catch-all guess).

## `deepSearch` (type: `boolean`):

When none of our methods finds a public email, also query an additional third-party data source on the Apify Store. That source is billed at its own rate directly to your Apify account (it appears in your runs) — we add no fee on those emails. Capped by the share below.

## `deepSearchMaxShare` (type: `integer`):

At most this share of the run's channels (rounded up, max 50 per run) may use the deep search. Max 25 %.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "personal finance"
  ],
  "language": "en",
  "country": "us",
  "maxResultsPerKeyword": 10,
  "onlyNew": false,
  "channels": [
    "https://www.youtube.com/@mkbhd"
  ],
  "findEmail": true,
  "requireEmail": false,
  "deepSearch": false,
  "deepSearchMaxShare": 25
}
```

# Actor output Schema

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

All channels (JSON, CSV, Excel).

# 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 = {
    "mode": "search",
    "keywords": [
        "personal finance"
    ],
    "maxResultsPerKeyword": 10,
    "channels": [
        "https://www.youtube.com/@mkbhd"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pnda/youtube-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 = {
    "mode": "search",
    "keywords": ["personal finance"],
    "maxResultsPerKeyword": 10,
    "channels": ["https://www.youtube.com/@mkbhd"],
}

# Run the Actor and wait for it to finish
run = client.actor("pnda/youtube-email-finder").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 '{
  "mode": "search",
  "keywords": [
    "personal finance"
  ],
  "maxResultsPerKeyword": 10,
  "channels": [
    "https://www.youtube.com/@mkbhd"
  ]
}' |
apify call pnda/youtube-email-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pnda/youtube-email-finder"
        }
    }
}
```

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/AyT6ALYa9oRs9lhbJ/builds/dUU7Yp4DfanrGm5wH/openapi.json