# YouTube Channel Contact Email Finder (`nimbryxo-studio/youtube-channel-contact-email-finder`) Actor

Find publicly listed contact emails for YouTube channels by scanning each About page and the Instagram, TikTok, and Linktree profiles it links to. No login or API key needed.

- **URL**: https://apify.com/nimbryxo-studio/youtube-channel-contact-email-finder.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Lead generation, Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Channel Contact Email Finder

Extract publicly listed contact emails from YouTube channels — including the ones creators only put in their linked Instagram, TikTok, or Linktree bios.

### What this actor does

- **Creator emails:** found in the channel's About description and links, and on linked profiles
- **External sources:** Instagram, TikTok, and Linktree links from the channel
- **Bulk channels:** multiple channels per run
- **Optional network fallback:** automatic route switching when a page looks blocked
- **Empty fields are omitted** — records only contain values that are actually populated.

### Output

One record per channel. Fields with no value are omitted.

```json
{
  "channelUrl": "https://www.youtube.com/@Apify/about",
  "channelId": "UCx...",
  "channelHandle": "@Apify",
  "channelName": "Apify",
  "channelDescription": "We help businesses extract data from the web...",
  "subscriberCount": 12500,
  "emails": ["hello@apify.com", "press@apify.com"],
  "sources": [
    {"email": "hello@apify.com", "sourceUrl": "https://www.youtube.com/@Apify/about", "sourceType": "channel_description"},
    {"email": "press@apify.com", "sourceUrl": "https://www.instagram.com/apify/", "sourceType": "instagram_bio"}
  ],
  "externalLinks": [
    "https://apify.com",
    "https://www.instagram.com/apify/",
    "https://twitter.com/apify"
  ],
  "scrapedAt": "2026-04-24T12:00:00+00:00"
}
```

**Field descriptions**

- **`channelUrl`** — canonical URL of the scraped About page
- **`channelId`** — YouTube's stable channel identifier (`UC...`)
- **`channelHandle`** — the `@handle` form of the channel
- **`channelName`** — human-readable channel title
- **`channelDescription`** — full About description text
- **`subscriberCount`** — subscriber count expanded from YouTube's displayed label (so `1.2M` becomes `1200000`; approximate for large channels)
- **`emails`** — deduplicated, lower-cased, alphabetically sorted list of every email discovered for the channel
- **`sources`** — one entry per email with the exact URL and source type
- **`externalLinks`** — advertised links from the About page (not all are crawled)
- **`scrapedAt`** — ISO-8601 timestamp of when the channel was processed

**Source types**

| `sourceType` | Where the email came from |
| --- | --- |
| `channel_description` | The channel's About description. |
| `channel_external_link` | An email embedded directly in an advertised link. |
| `instagram_bio` | Creator's Instagram profile (bio text or metadata). |
| `tiktok_bio` | Creator's TikTok profile. |
| `linktree` | A Linktree hub linked from the channel. |

**Error record** — emitted instead of a channel record when something goes wrong, so the run never fails entirely:

```json
{
  "type": "youtube_email_scraper_error",
  "reason": "fetch_failed",
  "message": "Could not fetch About page (blocked / offline / not found).",
  "channelUrl": "https://www.youtube.com/@SomeClosedChannel/about",
  "scrapedAt": "2026-04-24T12:00:00+00:00"
}
```

`reason` is one of: `invalid_url` (the entry isn't a recognizable YouTube channel link), `fetch_failed` (the About page couldn't be fetched), `parse_failed` (the page loaded but its data couldn't be located), `scrape_error` (an unexpected error while scraping that channel), or `invalid_input` (no `channelUrls` were provided at all — this one has no `channelUrl` field since there's no URL to report).

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `channelUrls` | array of strings | — | **Required.** YouTube channel URLs in any supported shape. |
| `followExternalProfiles` | boolean | `true` | Follow Instagram / TikTok / Linktree links discovered on the channel. |
| `maxExternalPerChannel` | integer | `5` | Cap on external profiles fetched per channel. The scraper enforces an internal cap of 20 regardless of a higher value. |
| `autoProxyFallback` | boolean | `true` | Automatically retry through Apify residential proxy when a page looks blocked. |

#### Example: multiple channels with external profiles

```json
{
  "channelUrls": [
    "https://www.youtube.com/@Apify",
    "https://www.youtube.com/@MrBeast",
    "@MKBHD"
  ],
  "followExternalProfiles": true,
  "maxExternalPerChannel": 5,
  "autoProxyFallback": true
}
```

#### Example: single channel, About page only

```json
{
  "channelUrls": ["@MrBeast"],
  "followExternalProfiles": false
}
```

### Use cases

- **Influencer outreach** — build a ranked contact list for a shortlist of creators in a niche
- **Brand partnership research** — harvest business emails from your competitor's sponsored-creator roster
- **Agency sourcing** — quickly see which creators publish a reachable inbox vs. hide behind management
- **PR and press** — find the right email for an interview, quote, or product-review request
- **CRM enrichment** — keep your creator-contacts database synced with the emails currently advertised publicly

### FAQ

**Does this scraper bypass CAPTCHAs?**
No. The actor uses only the public About page and the public profile pages of Instagram, TikTok, and Linktree. When a page is fully blocked, the scraper emits an error record for that channel and moves on.

**Do I need cookies, a login, or a YouTube API key?**
No. The scraper is unauthenticated and reads only publicly available data.

**Will it find every email on a channel?**
It finds every email advertised in plain text, as a `mailto:` link, with common obfuscation (`[at]` / `[dot]`), and on linked Instagram / TikTok / Linktree bios. It cannot extract emails hidden behind YouTube's "View email address" click-to-reveal button — that gate requires a logged-in account and is not supported.

**Does it follow every external link on a channel?**
No — only Instagram, TikTok, and Linktree, because those are where creators most often advertise a contact address. All external links are still listed in `externalLinks` so you can follow them downstream if you wish.

**What if a channel has no public emails?**
The channel record is still emitted, just without the `emails` and `sources` fields. You can filter on the presence of `emails` in post-processing.

**How does the proxy fallback work?**
If a page looks blocked, the scraper retries it once more through an Apify residential proxy (US). Set `autoProxyFallback: false` to never use the proxy; blocked pages then simply yield no emails (or a `fetch_failed` record for the About page).

**How many linked profiles are opened per channel?**
Up to `maxExternalPerChannel` successfully loaded Instagram, TikTok or Linktree pages, never more than 20 even if you set a higher number. Other links (websites, X, Facebook) are listed in `externalLinks` but not opened.

**Is this affiliated with YouTube?**
No. This is an independent, third-party actor that reads publicly available channel pages; it isn't affiliated with or endorsed by YouTube or Google.

### Known limitations

- **Click-to-reveal emails on YouTube are not supported.** YouTube's "View email address" button requires a logged-in session; this actor is login-free by design.
- **Instagram login walls** occasionally show for certain regions or IP ranges. When this happens the scraper skips that bio and keeps the emails it already found elsewhere.
- **TikTok region restrictions** can replace a profile with an interstitial page; the scraper still extracts whatever metadata the interstitial exposes.
- **Channels without a public About page** (some custom-branding and music-artist channels) return a `parse_failed` error record.
- **Subscriber counts** reflect YouTube's publicly displayed rounded value (e.g. `12K` → `12000`). Exact counts below YouTube's display threshold are not available.

# Actor input Schema

## `channelUrls` (type: `array`):

List of YouTube channel URLs to scan for contact emails. Supports @handle, /channel/UC..., /c/name, /user/name formats, and plain @handle shortcuts.

## `followExternalProfiles` (type: `boolean`):

When true, the scraper also opens external profile links advertised on the channel (Instagram, TikTok, Linktree) to discover emails hidden in their bios.

## `maxExternalPerChannel` (type: `integer`):

Upper bound on how many external profile URLs are fetched per channel (keeps runs cheap and predictable).

## `autoProxyFallback` (type: `boolean`):

Transparently retry a fetch via Apify residential proxy when the direct request looks like a block page (empty body or unusually small response). Saves credits by only using the proxy when needed.

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@apify"
  ],
  "followExternalProfiles": true,
  "maxExternalPerChannel": 5,
  "autoProxyFallback": true
}
```

# Actor output Schema

## `channels` (type: `string`):

Dataset containing all scraped channel contact records with emails, sources, and 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 = {
    "channelUrls": [
        "https://www.youtube.com/@apify"
    ],
    "followExternalProfiles": true,
    "autoProxyFallback": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/youtube-channel-contact-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 = {
    "channelUrls": ["https://www.youtube.com/@apify"],
    "followExternalProfiles": True,
    "autoProxyFallback": True,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/youtube-channel-contact-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 '{
  "channelUrls": [
    "https://www.youtube.com/@apify"
  ],
  "followExternalProfiles": true,
  "autoProxyFallback": true
}' |
apify call nimbryxo-studio/youtube-channel-contact-email-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/youtube-channel-contact-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/iUDQnZLC66Ye2jePm/builds/OBSQqvkfKtnJFwuih/openapi.json