# YouTube Channel Email Finder — Creator Business Contacts (`logical_vivacity/creator-contact-finder`) Actor

Find the business email behind a YouTube channel — including creators who hide it, by following their own site. Returns the channel's identity, subscriber count, links and the best contact address, with where it came from and whether the domain can receive mail.

- **URL**: https://apify.com/logical\_vivacity/creator-contact-finder.md
- **Developed by:** [Logical Vivacity](https://apify.com/logical_vivacity) (community)
- **Categories:** Lead generation, Social media, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$60.00 / 1,000 creator enricheds

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/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 Channel Email Finder — Creator & Influencer Business Contacts

**A handle goes in. The person you email goes out.**

Who is this creator, how big are they, and — the part you actually came for — **what address do you write to about a sponsorship?**

One record per creator: the business email, *where that address came from*, whether the domain can receive mail at all, and the whole public profile around it — subscriber count, video and view counts, country, join date, description, website and every social account they link. Plus a 0-100 confidence score, so you can tell a certain answer from a likely one.

***

### Try it in 30 seconds

Paste these into **Creators** and hit Start:

```
@mkbhd
https://www.youtube.com/@LinusTechTips
@veritasium
```

Handles, full channel URLs and raw channel IDs (`UC...`) can all sit in the same list — paste the column straight out of your spreadsheet. (Video links are the one thing that won't work: paste the channel, not the video.)

Those three are a fair sample of real life. Two come back with an address. The third doesn't — and the record says so honestly instead of inventing one.

***

### What you get per creator

```jsonc
{
  "input": "@mkbhd",
  "platform": "youtube",
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "name": "Marques Brownlee",
  "handle": "@mkbhd",
  "channelUrl": "https://www.youtube.com/@mkbhd",
  "description": "Quality Tech Videos | YouTuber | Geek | Consumer Electronics...",
  "country": "US",

  "subscriberCount": 21300000,
  "subscriberCountText": "21.3M subscribers",
  "videoCount": 1800,
  "viewCount": 4700000000,
  "joinedDate": "Mar 21, 2008",
  "avatar": "https://yt3.googleusercontent.com/...",
  "keywords": "tech, reviews, smartphones",

  "links": [                                  // every outbound link, classified
    { "title": "MKBHD",     "url": "https://mkbhd.com",            "kind": "website", "platform": null },
    { "title": "Instagram", "url": "https://instagram.com/mkbhd",  "kind": "social",  "platform": "instagram" },
    { "title": "Shop",      "url": "https://shop.mkbhd.com",       "kind": "store",   "platform": null }
  ],
  "socialProfiles": [
    { "title": "Instagram", "url": "https://instagram.com/mkbhd",  "kind": "social",  "platform": "instagram" }
  ],
  "website": "https://mkbhd.com",             // the creator's OWN site, not a storefront

  "businessEmail": "business@mkbhd.com",
  "emailSource": "channel page",              // or "linked website"
  "allEmails": [
    { "email": "business@mkbhd.com", "source": "channel page" }
  ],
  "pagesRead": null,                          // the pages read on their site, when we had to go there

  "emailCheck": {                             // domain-level only — see the FAQ
    "verdict": "deliverable_domain",
    "reason": "MX_OK",
    "mxProvider": "Google Workspace",
    "isRole": true,
    "isFreeProvider": false,
    "spfPolicy": "soft",
    "dmarcPolicy": "reject"
  },

  "confidence": 88,
  "status": "ok",
  "scrapedAt": "2026-09-17T12:31:08+00:00"
}
```

From the same run: **Linus Tech Tips**, 16,900,000 subscribers, `partnerships@linusmediagroup.com`, confidence 88. And **Veritasium**, 21,300,000 subscribers — with **no address**, because that channel keeps its business email behind a sign-in gate and publishes nothing on its own site either. That row comes back `no_email` at confidence 40, with the rest of the profile intact.

Export as JSON, CSV, Excel, XML or HTML, or pull it from the API.

***

### Who uses this

**Influencer marketing agencies** — turn a shortlist of channels into a contactable outreach list in one run, with the subscriber counts already attached so you can sort by reach before you write a word.

**Brand partnership teams** — you know which ten creators fit the campaign. This gets you the ten inboxes, and tells you which of them are a managed business address versus a personal one.

**Sponsorship outreach** — a per-creator address, its source, and a domain check, so your sequence isn't half bounces on day one.

**Talent scouts and creator networks** — find who represents a creator: `partnerships@` at a media group is a very different conversation from `hello@` at a personal domain, and the record shows you which you have.

**PR and comms** — press contacts for creators in a beat, with their sites and social handles in the same row.

***

### What makes it different

**It finds the address even when the channel hides it.** A large share of channels put their business email behind a sign-in gate, and a channel-page-only scraper simply returns nothing for them. When the channel won't show it, this Actor goes to the creator's *own website* — contact, about, press, partnership and work-with-me pages — and looks there. Storefronts, link-in-bio pages and social profiles are deliberately skipped, so you get the creator's site, not their merch shop.

**It tells you where each address came from.** `emailSource` is `channel page` or `linked website`, and `allEmails` carries every address found with its own source. An address the creator published on their channel for business enquiries is worth more than one scraped off a footer, and you can see which you have instead of guessing.

**It checks the domain can actually receive mail.** `emailCheck` reads the domain's mail setup: does it have mail servers, who runs them, is this a role address, is it a free mailbox, and what are its SPF and DMARC policies. Domains with no mail servers at all are flagged `invalid` before you waste a send on them.

**It refuses to return the wrong channel.** Older YouTube URL forms live in a different namespace from handles, and the same word can belong to two different channels. A real case: `/user/veritasium` is a 2,070-subscriber account called `@veritasium5359` — not the 21-million-subscriber channel you meant. This Actor only accepts a page whose own handle matches what you asked for, and returns `not_found` rather than a confident wrong answer. A missing row you can chase; a wrong row you email by mistake.

**A confidence score on every row.** 0-100, built from what was actually established: did we pin the channel ID, do we have a subscriber count, did we find an address, did it come from the channel page or a website, and what the mail-domain check said. Auto-send above 80, eyeball the rest.

**Nothing to configure.** No API keys, no accounts, no proxies to set up. Connection handling, retries and pacing are managed for you.

***

### Not every creator publishes an address — plainly

This matters more than any feature, so here it is straight.

Many channels **hide their business email behind a sign-in gate**. For those, the Actor falls back to the creator's own linked website and looks for a business address there. That often works. Sometimes it doesn't — the creator has no site, or their site has no address, or they genuinely don't publish one and take enquiries only through a form.

Those creators come back as **`no_email`**, with the full profile — name, subscriber count, socials, website, country — and no address. That is the honest answer, and it is not a failure of the run. If you only want rows that carry an address, turn on **Only return creators that have an address** and the rest come back unbilled.

Anyone promising an email for every channel is either guessing at one or reading a stale cache.

***

### Settings

| Setting | What it does |
|---|---|
| **Creators** | Your list — @handles, channel URLs, or channel IDs, mixed freely |
| **Check the email domain can receive mail** | Adds the `emailCheck` block (mail servers, provider, role/free flags, SPF, DMARC). Domain-level only |
| **Follow the creator's own site when the channel hides its email** | The fallback that finds addresses channel-only scrapers miss. On by default |
| **Maximum pages to read per website** | How far to look on a creator's site before giving up. Stops early as soon as an address is found |
| **Only return creators that have an address** | Creators with no address come back `no_email` and are not charged |

There are no proxy, concurrency or browser knobs. There is nothing to tune.

***

### Bulk lists and automation

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~creator-contact-finder/runs?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
        "creators": [
          "@mkbhd",
          "https://www.youtube.com/@LinusTechTips",
          "@veritasium"
        ],
        "verifyEmail": true,
        "crawlWebsite": true,
        "maxPagesPerSite": 5,
        "onlyWithEmail": false
      }'
```

Works with Make, Zapier, n8n, Google Sheets and the Apify API, and as an MCP tool for AI agents. Schedule it to re-check a creator list on any cadence.

***

### Results you can trust

Every input reports what happened, so nothing fails silently:

| `status` | Meaning | Charged? |
|---|---|---|
| `ok` | The creator was found and a business address was returned | Yes |
| `no_email` | The creator was found, but publishes no business address | Yes when **Only return creators that have an address** is off — you still get the full profile. No when it is on, and then only the handle and a note come back |
| `not_found` | No channel matching that handle answered, or the page that answered was a different channel | No |
| `invalid_input` | That text doesn't name a channel — a video link, or not a handle at all | No |
| `error` | A page was briefly unreachable — retry that creator | No |

***

### FAQ

**Why does a big creator come back with no email?**
Because they don't publish one where it can be read. Most often the channel keeps its business address behind a sign-in gate; the Actor then tries the creator's own website, and if there's no address there either, the row is `no_email`. Some creators take enquiries only through a form or an agency. Veritasium, with 21 million subscribers, is exactly this case.

**Which platforms are supported?**
YouTube, today. Handles, channel URLs and channel IDs all work. Other platforms are not supported yet.

**Does the email check prove the inbox is live?**
**No, and nothing that skips the mailbox can.** `emailCheck` is a domain-level read: syntax, disposable domains, whether the domain has mail servers, which provider runs them, whether the address is a role or free-provider address, and the domain's SPF and DMARC policies. It says the domain is set up to receive mail. It does not say this particular mailbox exists. Google and Microsoft — who host the overwhelming majority of these domains — accept mail for every address at the door and bounce it later, so no check short of sending can tell you more. Treat `deliverable_domain` as "this domain is real and takes mail", not as "this mailbox is confirmed".

**What's the difference between `website` and the other links?**
`website` is the creator's **own** site. Storefronts, link-in-bio services, marketplaces, streaming and social links are all excluded from it, though they still appear in `links` with a `kind` of `social`, `store` or `website` and a platform name where we know it.

**Why did I get `not_found` for a channel I'm sure exists?**
Because the page that answered wasn't provably the channel you asked for. Older URL forms can resolve to a different account with a similar name, and we won't pass one off as the other. Try the exact `@handle` or the channel ID.

**Are duplicates handled?**
Paste a clean list. The same channel listed twice is looked up twice and charged twice.

**How fresh is it?**
Read live from the public page at the moment of your run — no cached email database. `scrapedAt` records exactly when we looked.

***

### Terms of Use

**1. Public data.** This Actor reads information that creators have published publicly on their own channel pages and websites — including business addresses they chose to publish for enquiries. It does not log in, and it does not access anything behind a sign-in gate.

**2. Lawful use is your responsibility.** You are the data controller for the results. You are solely responsible for how you store, use, share and delete them, and for complying with all applicable law in your jurisdiction — including the GDPR and comparable privacy laws, the CAN-SPAM Act and equivalent marketing rules, and any consent, opt-out, unsubscribe and record-keeping obligations that come with them. A published address is not consent to be added to a bulk mailing list.

**3. Respect platform terms.** Your use of the results must comply with the terms of service of the platforms and websites the data came from.

**4. No spam, no harassment.** Do not use the results to send unsolicited bulk mail, to harass, threaten or dox anyone, or for any unlawful purpose.

**5. No affiliation.** This Actor is not affiliated with, endorsed by or sponsored by YouTube, Google LLC, or any creator, channel, agency or brand whose public data appears in its output. Names and marks are used only to identify the accounts you asked about.

**6. No warranty of accuracy.** Data is read from public pages that change without notice and may be incomplete, outdated or wrong. Confidence scores are estimates. The `emailCheck` block is a domain-level signal and is not proof that a mailbox exists or that mail to it will be delivered. Verify before you act on a result.

**7. Liability.** The Actor is provided "as is", without warranties of any kind. To the maximum extent permitted by law, the developer is not liable for any loss or damage arising from your use of the results, and you agree to indemnify the developer against claims arising from your use.

If you do not agree to these terms, do not run this Actor.

***

*A creator it couldn't crack, or need volume pricing?* Open an issue on the Actor's Issues tab.

# Actor input Schema

## `creators` (type: `array`):

One creator per line — an @handle, a full channel URL, or a channel ID (UC...). Mixed formats in the same list are fine. Video links are not accepted: paste the channel, not the video.

## `verifyEmail` (type: `boolean`):

Adds an emailCheck block to each record: syntax, disposable-domain check, whether the domain has mail servers at all, which provider handles its mail, whether the address is a role address or a free mailbox, and the domain's SPF and DMARC policies. This is a domain-level check — it does NOT prove that the individual mailbox exists.

## `crawlWebsite` (type: `boolean`):

Many channels put their business address behind a sign-in gate. When that happens, the Actor visits the creator's own website (never a storefront or a social link) and looks at its contact, about and partnership pages for a business address. Turn this off for a channel-page-only run.

## `maxPagesPerSite` (type: `integer`):

How many pages of a creator's own site to read before giving up. The Actor stops as soon as it finds an address, so most sites cost far fewer than this.

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

When on, a creator with no published business address comes back as `no_email` and is NOT charged. When off (the default), that creator is still returned in full — profile, subscriber count, website and socials — and is charged, because the profile record is useful on its own.

## Actor input object example

```json
{
  "creators": [
    "@mkbhd",
    "https://www.youtube.com/@LinusTechTips",
    "@veritasium"
  ],
  "verifyEmail": true,
  "crawlWebsite": true,
  "maxPagesPerSite": 5,
  "onlyWithEmail": false
}
```

# Actor output Schema

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

Every creator with their channel stats and best contact address.

## `overview` (type: `string`):

The same rows as a spreadsheet-style table, with the most useful columns first.

# 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 = {
    "creators": [
        "@mkbhd",
        "https://www.youtube.com/@LinusTechTips",
        "@veritasium"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logical_vivacity/creator-contact-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 = { "creators": [
        "@mkbhd",
        "https://www.youtube.com/@LinusTechTips",
        "@veritasium",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("logical_vivacity/creator-contact-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 '{
  "creators": [
    "@mkbhd",
    "https://www.youtube.com/@LinusTechTips",
    "@veritasium"
  ]
}' |
apify call logical_vivacity/creator-contact-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,logical_vivacity/creator-contact-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/07lD3dsh7TwJ0Wlui/builds/v6POH2QZrAfPRn6gU/openapi.json