# YouTube Channel → Verified Business Email (`nfinitytech/youtube-creator-verified-email`) Actor

Give it YouTube channels; get back verified business emails. Multi-source contact waterfall (description, link-in-bio, website) with SMTP+catch-all verification. You are only charged per VERIFIED email — found-but-unverified contacts are returned free.

- **URL**: https://apify.com/nfinitytech/youtube-creator-verified-email.md
- **Developed by:** [Nfinity Infotech](https://apify.com/nfinitytech) (community)
- **Categories:** AI, Agents, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 verified emails

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Channel → Verified Business Email

Turn a list of YouTube channels into **verified business emails** you can actually send to. Built for sponsorship outreach, influencer marketing agencies, and creator-economy sales teams.

**You only pay for verified emails.** Found-but-unverified contacts are included in your results for free — you're never charged for a guess.

### What you get

For each channel: the creator's resolved identity, their real website, and every business email found across public surfaces — each one verification-checked and confidence-tiered.

```json
{
  "input": "@ThomasFrank",
  "platform": "youtube",
  "channel_id": "UCG-KntY7aVnIGXYEBQvmBAQ",
  "handle": "@ThomasFrank",
  "title": "Thomas Frank",
  "website": "https://thomasjfrank.com/templates/",
  "emails": [
    {
      "email": "thomasfrank@standard.tv",
      "status": "ok",
      "verified": true,
      "confidence": "high",
      "source": "youtube:description"
    }
  ],
  "verified_count": 1,
  "hit": true
}
````

### How it works — the contact waterfall

Most email finders check one place. This actor walks the whole trail a human researcher would, in order, and stops when it has what it needs:

1. **Channel description & About page** — where most creators publish their business contact.
2. **Link-in-bio resolution** — Linktree, Beacons, and similar pages are fetched and mined for contact info.
3. **Creator website crawl** — the creator's own domain, including contact/about pages. Affiliate links, sponsor links, and URL shorteners are filtered out so the crawl lands on the creator's *real* site.
4. **Email verification** — every candidate is checked for deliverability (SMTP + catch-all detection) before you're charged.
5. **One clean record** — deduped, confidence-tiered, ready for your CRM or outreach tool.

De-obfuscation is built in: `name (at) domain (dot) com` and similar patterns are recovered automatically.

### Pricing

| Event | Price | When |
|---|---|---|
| Verified email | **$0.10** | An email confirmed deliverable. The only thing you pay for. |
| Actor start | $0.00 | Free |
| Channel processed | $0.00 | Free — even when no email is found |

Set a maximum spend on your run and the actor respects it: once the cap is reached, any further verified emails in that run are returned **free**.

Compare: a single verified creator contact from typical influencer databases costs $0.50–$2.00, bundled into a subscription you pay whether you use it or not.

### Input

| Field | Type | Description |
|---|---|---|
| `channels` | array | Channel URLs, `@handles`, or channel IDs (`UC...`) |
| `verify` | boolean | Run deliverability verification (default `true`). Turn off for a free preview of found contacts. |
| `crawlWeb` | boolean | Resolve link-in-bio pages and crawl the creator's website (default `true`). Higher hit-rate, slightly slower. |

### Understanding results

| `status` | Meaning | Billed? |
|---|---|---|
| `ok` | Mailbox confirmed deliverable | Yes — this is the product |
| `catch_all` | The domain accepts all mail, so the specific mailbox can't be confirmed. Common for creators with their own domains. Since the creator published the address themselves, these are usually good — tiered `medium` confidence. | **No** |
| `unknown` | Could not be determined | No |
| `skipped` | Third-party address (sponsor site, linked article) — returned for context only, never verified | **No** |

`confidence` combines verification with context: `high` = verified on a business domain; `medium` = verified free-mail address, or a self-published address on the creator's own (catch-all) domain; `low` = everything else.

`origin` tells you who the address actually belongs to: `self_published` (the creator put it in their channel text — includes their manager/agency), `own_site` (found on the creator's own website, link-in-bio, or a brand-matching domain), `third_party` (found on a sponsor's or linked site — we never verify or bill these, unlike scrapers that happily sell you a sponsor's support inbox).

### FAQ

**Where does the data come from?** Public pages only — channel About pages, public link-in-bio pages, and the creator's own website. No logins, no private data, no scraping behind authentication.

**What if no email is found?** You pay nothing for that channel.

**What counts as "verified"?** The address passed live deliverability checks (mailbox exists, domain isn't a spam trap) at the time of the run — the same standard email-verification services charge for separately. Verification reflects deliverability at run time.

**Can I preview before paying?** Yes — set `verify` to `false`. You'll get every found contact with `verified: false`, and pay $0.

**Other platforms?** TikTok is next on the roadmap; the engine underneath is platform-agnostic. Suggestions welcome via Issues.

# Actor input Schema

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

Channel URLs, @handles, or channel IDs (UC...). One per line.

## `verify` (type: `boolean`):

Run SMTP + catch-all verification. Only verified emails are billed. Turn off to preview found contacts free.

## `crawlWeb` (type: `boolean`):

Resolve Linktree/Beacons and crawl the creator's site for contact pages (higher hit-rate, slower).

## Actor input object example

```json
{
  "channels": [
    "https://www.youtube.com/@mkbhd",
    "@MrBeast",
    "UCBJycsmduvYEL83R_U4JriQ"
  ],
  "verify": true,
  "crawlWeb": true
}
```

# Actor output Schema

## `contacts` (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 = {
    "channels": [
        "@mkbhd",
        "@ThomasFrank"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("nfinitytech/youtube-creator-verified-email").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": [
    "@mkbhd",
    "@ThomasFrank"
  ]
}' |
apify call nfinitytech/youtube-creator-verified-email --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel → Verified Business Email",
        "description": "Give it YouTube channels; get back verified business emails. Multi-source contact waterfall (description, link-in-bio, website) with SMTP+catch-all verification. You are only charged per VERIFIED email — found-but-unverified contacts are returned free.",
        "version": "0.1",
        "x-build-id": "q1mdJz1faPqX9akDk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nfinitytech~youtube-creator-verified-email/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nfinitytech-youtube-creator-verified-email",
                "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/nfinitytech~youtube-creator-verified-email/runs": {
            "post": {
                "operationId": "runs-sync-nfinitytech-youtube-creator-verified-email",
                "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/nfinitytech~youtube-creator-verified-email/run-sync": {
            "post": {
                "operationId": "run-sync-nfinitytech-youtube-creator-verified-email",
                "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 URLs, @handles, or channel IDs (UC...). One per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "verify": {
                        "title": "Verify emails",
                        "type": "boolean",
                        "description": "Run SMTP + catch-all verification. Only verified emails are billed. Turn off to preview found contacts free.",
                        "default": true
                    },
                    "crawlWeb": {
                        "title": "Crawl link-in-bio & website",
                        "type": "boolean",
                        "description": "Resolve Linktree/Beacons and crawl the creator's site for contact pages (higher hit-rate, slower).",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
