# YouTube Creator Contacts (`lergassy/youtube-creator-contacts`) Actor

One YouTube channel in, one row out: subscribers, videos, description, every link the creator published, their socials, the website and the business e-mail where one is public. Find channels by topic or look up your own list.

- **URL**: https://apify.com/lergassy/youtube-creator-contacts.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Lead generation, Social media, Agents
- **Stats:** 7 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.10 / 1,000 channels

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 Creator Contacts** turns a YouTube channel into a row you can act on: subscribers, video count, description, every link the creator published, their Instagram, TikTok, X, Facebook, LinkedIn, Patreon and Discord — and the **business e-mail**, when one is public.

Paste the channels you already have, or give it a topic — `fitness coach`, `marketing agency` — and it reads YouTube's own channel search, then looks up everything it found. One channel, one row, one charge.

No login, no API key, no browser. Channels that cannot be read are reported as such and are **never billed**.

### What it actually finds, measured

Run on **80 channels** taken from YouTube's own search across four topics (SaaS reviews, travel, real estate, cooking) on 17 September 2026 — median size 30,900 subscribers, so real working creators rather than a handful of famous names:

| | |
|---|---|
| Channels read | **80 of 80** |
| Subscriber count present | **96%** |
| A website among the links | **70%** |
| Social profiles | **58%** |
| **An e-mail found** | **33%** — 26 of 80 |
| …of those, from the channel itself | 21 |
| …from the website the channel links to | 5 |

A second run on 30 channels from two other topics gave 23%. Re-measured on 24 September 2026 on 30 channels (real estate agents, home cooking) after the link reading was fixed: a website for 57%, an e-mail for 43%, and YouTube's "View email address" button — a business e-mail this Actor does not read, flagged as `hasHiddenBusinessEmail` — on 83%. So: **roughly a quarter to a third of creators can be reached by e-mail**, and the rest still come back with their links, socials and audience size.

That number is in this README because the alternative is letting you find it out after you have paid. Nobody publishes an address for every creator, because most creators do not publish one.

### Why the second hop matters

Half of the creator e-mail Actors we tested read the channel page and stop. A creator who puts no address on YouTube usually puts one on the site they link to — that is a fifth of everything found here.

Those addresses are filtered before they reach you. A website often carries a booking widget, a site builder or a platform's support address, and the first version of this Actor happily returned `callie@calendly.com` as a creator's contact. Now an address is kept only when it sits on the creator's own domain or on an ordinary mail provider; a third-party service address is dropped rather than passed off as a lead.

### How much does it cost?

- **$0.003 per channel** — the row itself: audience, links, socials, website.
- **$0.01 extra only when an e-mail is found.**

At the measured hit rate that averages about **$0.0063 per channel — roughly $6.30 per 1,000 channels** (prices since 25 September 2026). Other creator e-mail Actors on the Store price it very differently — from $0.003 per row, or $0.005 per e-mail found, up to $0.12 per row — and some of them also return the "View email address" business e-mail, which this Actor does not read. You pay for the address when there is one.

Channels below your minimum subscriber count, and channels filtered out by **Only channels where an e-mail was found**, cost nothing at all.

#### Bulk export

This Actor is built for bulk jobs — put hundreds of inputs into one run, or call it from the API on
a schedule. There is **no fee per run, no fee per page and no proxy charge**: you pay for the rows
you keep, and error rows are free, so a 50,000-row job costs exactly 50,000 × the row price with
nothing added on top.

### How to use it

#### You already have the channels

Paste handles or URLs into **📺 Channels**. `mkbhd`, `@veritasium`, a full link — all the same.

#### You want to build the list

Fill **🔎 Or find channels by topic** with the phrases your prospects would rank for, set **💯 Channels per query**, and the Actor reads YouTube's channel search first. Two queries at twenty channels each is forty rows and about two minutes.

```json
{
  "searchQueries": ["fitness coach", "personal trainer"],
  "maxChannelsPerQuery": 25,
  "minSubscribers": 10000,
  "onlyWithEmail": true
}
```

That input is a finished prospect list: fitness creators above ten thousand subscribers, only the ones you can actually write to, and nothing billed for the rest.

### ⬆️ Output

```json
{
  "type": "channel",
  "handle": "marketlikeahero",
  "title": "Market Like A Hero",
  "channelId": "UCxxxxxxxxxxxxxxxxxxxxxx",
  "subscribers": 30900,
  "subscribersText": "30.9K subscribers",
  "videoCount": 412,
  "email": "josh@marketlikeahero.com",
  "emailSource": "channel",
  "hasHiddenBusinessEmail": true,
  "website": "https://marketlikeahero.com",
  "instagram": "https://instagram.com/marketlikeahero",
  "links": ["https://marketlikeahero.com", "https://instagram.com/..."],
  "description": "Marketing that actually converts…",
  "scrapedAt": "2026-09-17T01:12:44.020Z"
}
```

`emailSource` says `channel` or `website`, so you always know whether the creator published the address on YouTube themselves. `links` are the links the creator put on the channel (and in its description), not links from video descriptions; `website` is the first of them that is not a social profile, marketplace or tip jar.

### Use cases

#### Influencer and creator outreach

Build a list by topic, filter by size, keep only the reachable ones, and start writing. The socials come along for the ones without an address.

#### Agencies pitching video production or editing

Channels that publish a lot and have a business address are exactly the ones already paying somebody.

#### Sponsorship and affiliate teams

Audience size, topic keywords and contact in one row — enough to sort a hundred candidates in an afternoon.

#### Market research

Who is publishing in a niche, how big they are, and where else they live online.

#### AI agents

One handle in, one flat row out, callable from the Apify API or the Apify MCP server.

### Integrations

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("lergassy/youtube-creator-contacts").call(run_input={
    "searchQueries": ["fitness coach"],
    "maxChannelsPerQuery": 25,
    "onlyWithEmail": True,
})
for creator in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(creator["handle"], creator["subscribers"], creator["email"])
```

Works the same from n8n, Make, Zapier, Google Sheets or a webhook.

### ❓ FAQ

#### Do you get an e-mail for every channel?

No. About a third of creators publish one in plain text — measured, not estimated. The rest come back with links, socials and audience size, and `hasHiddenBusinessEmail` tells you when the creator filed a business e-mail behind YouTube's "View email address" button.

#### Is this legal?

The Actor reads public channel pages and the sites creators link to, and collects only what they published themselves. Whether you may write to those addresses is a separate question governed by GDPR, CAN-SPAM and their local equivalents — that is on you, not on the data.

#### Why is an address sometimes not the creator's?

Because websites carry other people's addresses. Ones that belong to booking widgets, site builders and platform support are filtered out. If one slips through, open an issue and the filter grows.

#### What about the "business inquiries" button on YouTube?

That button hides the address behind a sign-in and a captcha, and this Actor does not read it — some other Actors do. Every row says whether the button is there (`hasHiddenBusinessEmail`), so you know which creators to contact through it. Everything returned here is published in plain text by the creator.

#### Can I use it with the API or an MCP server?

Yes to both, with no required fields, so an agent can call it correctly on the first try.

### Your feedback

Missing a field, or seeing an address that should have been filtered? The **Issues** tab is read and answered.

### You might also like

| Actor | What it does |
|---|---|
| [Website Contacts API](https://apify.com/lergassy/website-contacts-api) | Contacts in depth: crawls past the home page for e-mails and phones |
| [Email Finder API](https://apify.com/lergassy/email-finder-api) | A name and a domain in, the likely work e-mail out |
| [Email & Phone Verifier](https://apify.com/lergassy/email-phone-verifier) | Checks addresses and numbers before you use them |
| [Tech Stack Detector](https://apify.com/lergassy/tech-stack-detector) | What a website runs on, with the contacts from the same page |

# Actor input Schema

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

Handles or channel URLs — <b>mkbhd</b>, <b>@veritasium</b>, <b>https://youtube.com/@MrBeast</b>. One channel, one row.

## `searchQueries` (type: `array`):

Build the list instead of pasting it: <b>fitness coach</b>, <b>marketing agency</b>. YouTube's own channel search is read and every channel it returns is looked up.

## `maxChannelsPerQuery` (type: `integer`):

How many channels to take from each search query.

## `followSiteForEmail` (type: `boolean`):

When a channel publishes no address, the site it links to is read as well. That is where a fifth of the contacts come from. Third-party addresses — booking widgets, site builders, platform support — are dropped rather than passed off as the creator's.

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

Skip channels below this size. Skipped channels are not charged.

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

Deliver a row only when there is an address on it. Channels without one are then neither delivered nor billed.

## `concurrency` (type: `integer`):

How many channels to look up at the same time.

## `maxItems` (type: `integer`):

A hard ceiling on what one run delivers and bills.

## `proxyConfiguration` (type: `object`):

YouTube answers directly in almost every case; the proxy is used only when a page comes back without its data.

## Actor input object example

```json
{
  "channels": [
    "mkbhd",
    "veritasium"
  ],
  "searchQueries": [],
  "maxChannelsPerQuery": 20,
  "followSiteForEmail": true,
  "minSubscribers": 0,
  "onlyWithEmail": false,
  "concurrency": 5,
  "maxItems": 5000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `creators` (type: `string`):

One row per channel: subscribers, video count, description, the links the creator published, their social profiles, the website and the business e-mail where one is public.

# 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",
        "veritasium"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/youtube-creator-contacts").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",
        "veritasium",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("lergassy/youtube-creator-contacts").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 '{
  "channels": [
    "mkbhd",
    "veritasium"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call lergassy/youtube-creator-contacts --silent --output-dataset

```

## MCP server setup

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

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/1ezjSsJ3qmRIgbSWY/builds/8PuHV8odMuymzV4Pi/openapi.json