# YouTube Channel Email Finder: Niche Creators, Telegram & Web (`meskaoui.azeddine/niche-creator-contact-finder`) Actor

Find YouTube creators, Telegram channels and blogs of any niche, score how on-topic each one is, and get their public business email with its source. Look up channels you already know, or read a channel's commenters. $5 per 1,000 prospects, $15 per 1,000 emails found. No login, no cookies.

- **URL**: https://apify.com/meskaoui.azeddine/niche-creator-contact-finder.md
- **Developed by:** [Azeddine MESKAOUI](https://apify.com/meskaoui.azeddine) (community)
- **Categories:** Lead generation, Social media, Videos
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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: Niche Creators, Telegram & Web

Finds the creators of **one topic** on YouTube, Telegram and the web, decides which ones are really in that topic, and
looks for their **public business email** — with the exact place each address was read.

- **Find** creators by keyword: YouTube channels and videos, public Telegram channels, blogs and course sellers.
- **Qualify** each one with a 0–100 relevance score and readable reasons. Off-topic channels are left out, not billed.
- **Contact**: public email from the channel description, channel links, recent video descriptions, link-in-bio page
  and own website, classified as *business* or *personal mailbox*.
- **Look up** channels you already know, or read the **commenters** of a channel as its engaged audience.
- No login, no cookies, no browser. **$5 per 1,000 prospects, plus $15 per 1,000 emails found.**

### Who uses it

- **Affiliate and partnership managers** building a list of creators who actually talk about their product category.
- **Agencies and freelancers** delivering a qualified influencer list to a client, with a reason next to every name.
- **SaaS, course and tool vendors** looking for reviewers, educators and communities in a narrow niche.
- **Sponsorship buyers** who want the business address of a set of channels without opening forty About tabs.

Built for partnership and affiliate outreach, where the expensive mistake is not a missing address but a list full of
channels that have nothing to do with your product. This Actor scores every candidate and leaves the off-topic ones out,
counting them in the run summary so you can see what it refused and why.

### What it does

1. **Finds.** Every keyword is searched on the sources you turn on:
   - **YouTube** — the Channels tab *and* the Videos tab of the search, because the best creators of a niche rarely put
     the niche word in their channel name. Each video leads back to its channel.
   - **Telegram** — public channels of the topic, found by web search and from the list you can pass in the input, then
     read through the public `t.me/s/<channel>` preview (description, subscriber count, recent messages).
   - **Web** — blogs, course sellers, training sites and software vendors, found by web search and grouped per domain.
2. **Qualifies.** Each prospect gets a relevance score from 0 to 100 and a short list of readable reasons:
   - how many niche words appear in its name, its description and its recent video or message titles (a name like
     `OrderFlowSolutions` counts, glued together or not);
   - audience size, and how recently it published;
   - minus the off-topic signals (vlog, gaming, music, entertainment) and the promotion-shop signals
     (*paid promotion only*, *we promote your channel*, *buy views*).
     Prospects below `minRelevanceScore` are counted in `RUN_SUMMARY`, not saved, and not billed. The scoring dictionary
     is built for you: your keywords and their meaningful words for any niche (and a ready-made, deeper dictionary when
     the keywords are about order-flow trading). Pass `nicheTerms` to supply your own vocabulary; `RUN_SUMMARY.dictionary`
     says which one was used.
3. **Finds the contact.** An address is looked for in the order a human would read: the channel or Telegram description,
   then the channel's own links, then the descriptions of the latest videos, then the creator's own website
   (homepage plus its contact and about pages). Every address comes with `emailSource`, the exact place it was read, and
   `emailType`:
   - `business` — an address on a domain the creator pays for, a role mailbox (`contact@`, `info@`, `collab@`), or a free
     mailbox the creator itself presents as its business contact ("Business inquiries: …");
   - `generic free mailbox` — a personal Gmail-style address with nothing marking it as a business contact.
     Addresses that belong to channel-promotion agencies are dropped rather than scored.

### Three ways to use it

- **A niche, by keywords.** Fill `keywords`. Turn on `requireEmail` to keep only the prospects for which a public
  address was found; the on-topic ones without an address are still counted in the run summary.
- **Channels you already know.** Fill `youtubeChannels` with addresses, `@handles` or channel ids. Each channel is read
  directly and the owner's public email is looked for in its description, its links, its recent video descriptions, its
  link-in-bio page (Linktree, Beacons…) and its own website. These channels are scored for information and never
  rejected on their score. An affiliate link (`/aff/`, `?ref=`) is never treated as the creator's own website, so a
  vendor's support address is not handed over as the owner's.
- **The audience of a channel.** Fill `audienceOfChannels`. YouTube publishes no list of a channel's subscribers, to
  anyone but the owner. What is public is who comments under its videos: the commenters of the latest videos are listed,
  each one's public channel profile is opened, and the email it wrote in its own channel description is collected.
  Rows come out with `prospectType: "audience"`, `audienceOf`, `commentsSeen` and `commentSample`. Expect a public email
  on about 2% of commenters (3 out of 185 in our test runs), nearly all of them personal mailboxes.

### What you pay for

Pay per result, nothing per run and nothing per page read.

| Event | Price | When |
| --- | --- | --- |
| **Prospect saved** | $0.005 | once per row saved: a creator, channel or website that passed your threshold, a channel you asked to look up, or an audience member |
| **Public email found** | $0.015 | once per saved row that has an email, on top of the prospect |

Rejected candidates, duplicates and pages that fail are free. Examples:

- 1,000 qualified prospects, 400 of them with an email: 1,000 × $0.005 + 400 × $0.015 = **$11**.
- `requireEmail` on, 300 prospects saved, all with an email: 300 × $0.02 = **$6**.
- Audience of a channel, 5,000 commenters read, 100 with a public email (default: only those are saved): **$2**.

The spending limit you set on a run is respected: the Actor stops saving when it is reached.

### Input

| Field | Meaning |
| --- | --- |
| `keywords` | Search phrases of the niche, one per line. Prefilled with order-flow trading phrases. Optional when channels are given below. |
| `sources` | Any of `youtube`, `telegram`, `web`. All three by default. |
| `maxResultsPerKeyword` | Candidates taken from each search before qualification (default 20). |
| `requireEmail` | Save only prospects with a public email. Off by default. |
| `youtubeChannels` | YouTube channels to look up directly for the owner's public email. |
| `audienceOfChannels` | YouTube channels whose commenters are read as their engaged audience. |
| `maxAudienceVideos`, `maxAudienceProfiles` | Recent videos read per channel (default 5) and distinct commenters opened per channel (default 200). |
| `audienceRequireEmail` | Save only the audience members with a public email (default on). |
| `telegramChannels` | Public channel usernames or `t.me` links to read whatever the search returns. |
| `language`, `country` | Two-letter codes used for the searches (`en`, `US`). |
| `minRelevanceScore` | Threshold to be saved. Default 50. |
| `minSubscribers`, `maxSubscribers`, `activeWithinDays` | Audience and activity window. 0 disables each one. |
| `nicheTerms`, `negativeTerms` | Your own niche vocabulary and off-topic words. Optional: the dictionary is derived from the keywords when left empty. |
| `maxVideoDescriptionsPerChannel` | Recent video descriptions to read when the channel description has no address (default 3). |
| `visitWebsites`, `maxPagesPerSite` | Whether to open the creator's own site for a contact page, and how deep. |
| `youtubeApiKey` | Optional. Only needed if YouTube stops answering the public web search from your IP; the official Data API v3 is used instead and the quota is charged to that key. |
| `maxConcurrency` | Prospects qualified in parallel (default 5). |
| `proxyConfiguration` | Apify Proxy. Keep it on. |

### Output

One dataset row per prospect, deduplicated and sorted by score. The same channel found through several keywords is one
row; a creator found on both YouTube and Telegram is one row too, when one of the two profiles links to the other
(`alsoOn` then says where else it was seen).

```json
{
  "platform": "youtube",
  "name": "Orderflow Stream",
  "url": "https://www.youtube.com/@orderflowstream",
  "handle": "@orderflowstream",
  "subscribers": 14500,
  "lastPublishedAt": "2026-10-03T00:00:00.000Z",
  "language": null,
  "country": null,
  "relevanceScore": 78,
  "relevanceReasons": ["niche words in the name: order flow", "4 niche words in the description", "14,500 subscribers", "published in the last 7 days"],
  "matchedKeywords": ["order flow", "footprint", "volume profile", "DOM"],
  "topicsFound": ["order flow", "footprint", "volume profile", "DOM"],
  "email": "contact@example-trader.com",
  "emailSource": "website https://example-trader.com/contact/",
  "emailType": "business",
  "otherEmails": [],
  "website": "https://example-trader.com",
  "telegram": "https://t.me/examplechannel",
  "telegramContacts": [],
  "socialLinks": { "telegram": ["https://t.me/examplechannel"], "instagram": ["https://instagram.com/example"] },
  "sampleTitles": ["Reading absorption on the footprint", "DOM basics", "Tape reading a reversal"],
  "foundVia": ["youtube channel search: order flow trading", "youtube video search: footprint chart"],
  "alsoOn": [],
  "description": "…",
  "scrapedAt": "2026-10-10T08:00:00.000Z"
}
```

`RUN_SUMMARY` in the key-value store holds the counts per keyword and per source (candidates found, rejected below the
threshold, with an email, errors), a sample of the rejected prospects with the reason, and any source that stopped
answering during the run.

### Tips for a better list

- Give **three to seven keywords**, phrased the way the audience searches. One keyword gives a thin dictionary and a
  strict score.
- Start with `minRelevanceScore: 50`. Look at `rejectedSample` in `RUN_SUMMARY`: if good channels are in it, lower the
  threshold or add their vocabulary to `nicheTerms`.
- Use `maxSubscribers` to stay under the size where channels only answer through an agency, and `activeWithinDays: 90`
  to drop abandoned channels.
- Check `emailSource` before writing. When the domain of an address does not look like the channel's name, it may be
  the address of a vendor the channel links to rather than the creator's own.

### FAQ

**Does it use the YouTube API or need a key?** No. It reads what YouTube shows to an anonymous visitor. An optional
`youtubeApiKey` exists only as a fallback if YouTube stops answering the web search from your IP.

**How many creators have a public email?** In our runs on a trading niche, about half of the qualified YouTube channels
and half of the websites. Channels that keep their address only behind YouTube's "View email address" button come out
with their website and social links instead.

**Can I get the subscribers of a channel?** Nobody can: YouTube shows that list to the channel owner only. The audience
mode reads the commenters of the latest videos, and about 2% of them publish an email on their own profile.

**Can I use it for a niche other than trading?** Yes. The examples in the input are about trading; replace them and
the scoring follows your keywords.

**Export formats?** JSON, CSV, Excel, HTML or XML from the dataset, or through the Apify API and integrations
(n8n, Make, Zapier).

### Honest limits

- **No network that requires a login.** Facebook, Instagram, TikTok, X and LinkedIn are not supported, by design. No
  login, no captcha solving, no cookie borrowed from a browser session.
- **The YouTube "View email address" button is not used.** That button asks for a login and a captcha. Only text YouTube
  already shows to anonymous visitors is read: the channel description, the channel's links, the descriptions of recent
  videos, and the linked website. A creator who keeps its address only behind that button comes out with `email: null`
  and its website and social links instead.
- **Subscriber lists do not exist publicly.** Neither YouTube nor Telegram shows who subscribes to a channel. The
  audience mode reads commenters, which is a smaller and more engaged group than subscribers, and only those who
  comment under the latest videos.
- **Audience members are mostly private individuals.** Their addresses are personal data even though they published
  them. Many of them never asked to be contacted about anything: read the compliance note before writing to them.
- **Public addresses only.** Nothing is guessed, permutated or verified against a mail server. `firstname.lastname@` is
  never invented: if no address was published, the row says so.
- **Audience numbers are what the platform displays** — rounded ("27K"), and `lastPublishedAt` is derived from relative
  dates ("3 weeks ago"), so it is accurate to the day at best.
- **Telegram** can only be read when the channel has a public preview. Private channels, groups and invite links are
  reported and skipped.
- **Web search** has no API key, so result counts are modest and vary between runs. A search engine that rate-limits is
  reported in `RUN_SUMMARY`; the other sources keep running.
- **Merged rows mix their sources.** When a website and a YouTube channel turn out to be the same business, the row keeps
  one `platform` and fills its empty fields from the other, so `subscribers` may describe the profile named in `alsoOn`.
- **Scoring is a filter, not a judgement.** Read `relevanceReasons` before writing to anybody.

### Compliance

This Actor collects only contact details that the creator **published itself for professional contact** — a business
email in a channel description, a contact page on its own website. It does not break logins, does not solve captchas and
does not scrape private profiles.

If you contact people in the EU or the UK, the GDPR applies to you as the sender: write only about a genuine business
proposal relevant to their activity, identify yourself, say where you found their address, honour an opt-out
immediately, and keep the data no longer than the outreach needs. Addresses collected here are for your own outreach:
**do not resell them and do not build a public list out of them.** Some of these addresses are personal data even when
they are publicly visible.

The audience mode deserves more care than the creator modes. A creator who writes "business inquiries:" invites
professional contact; a viewer who left an address on a personal profile did not. In the EU, the UK and several other
jurisdictions, unsolicited marketing email to individuals needs their prior consent, and "the address was public" is not
a legal basis. Use that mode to understand who the audience is, and get advice before running a campaign on it.

This Actor sends nothing and contacts nobody. It only tells you who is worth writing to, and where to write.

# Actor input Schema

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

One search phrase per line, the way someone looking for this topic would type it. Replace the examples with your own niche. Each phrase is searched on every source you turn on; three to seven phrases give the best score. Leave empty if you only look up channels or read an audience below.

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

On: a prospect is saved only when a public email was found for it. The on-topic prospects without an address are still counted in the run summary.

## `sources` (type: `array`):

YouTube channels and videos, public Telegram channels, and websites found by web search. Networks that require a login (Facebook, Instagram, TikTok, X, LinkedIn) are not supported.

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

How many candidates to take from each search before qualifying them. Duplicates across keywords are merged later.

## `telegramChannels` (type: `array`):

Public channel usernames or t.me links to read whatever the search returns. Invite links and private channels cannot be read.

## `youtubeChannels` (type: `array`):

Channel addresses, @handles or channel ids. Each one is read directly and the owner's public email is looked for: channel description, channel links, recent video descriptions, link-in-bio page, own website. These channels are never rejected on their relevance score.

## `audienceOfChannels` (type: `array`):

YouTube does not publish who subscribes to a channel. What is public is who comments under its videos: for each channel given here, the commenters of its recent videos are listed and the email each one wrote in its own channel description is collected.

## `maxAudienceVideos` (type: `integer`):

How many of the latest videos have their comments read.

## `maxAudienceProfiles` (type: `integer`):

Upper limit of distinct commenters whose profile is opened, per channel. Expect a public email on a few percent of them.

## `audienceRequireEmail` (type: `boolean`):

On by default: a commenter without a public email is counted, not saved. Turn off to get every commenter with its profile.

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

Two-letter language code used for the searches and the page language, for example en, fr, es.

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

Two-letter country code the searches are made from, for example US, FR, MA.

## `minRelevanceScore` (type: `integer`):

Prospects below this score are counted in the run summary and left out of the results. 50 keeps clearly on-topic creators; lower it to see borderline ones.

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

Skip creators with fewer subscribers or members than this. 0 keeps everybody.

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

Skip creators above this size, useful to avoid channels that only answer through an agency. 0 means no limit.

## `activeWithinDays` (type: `integer`):

Skip creators whose last video or message is older than this. 0 keeps everybody, including channels whose date is unknown.

## `nicheTerms` (type: `array`):

Words and phrases that prove a creator is in your niche. Leave empty and the dictionary is built for you: the order-flow trading dictionary when your keywords are about trading order flow, otherwise your keywords and their meaningful words. Fill it for a sharper score in any niche.

## `negativeTerms` (type: `array`):

Words that mark a channel as something else (vlog, gaming, music). Leave empty to use the built-in list.

## `maxVideoDescriptionsPerChannel` (type: `integer`):

When the channel description holds no address, this many recent video descriptions are read, where creators usually write their business email.

## `visitWebsites` (type: `boolean`):

Last resort for an address: open the creator's own site and its contact or about page.

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

How many contact or about pages to open besides the homepage.

## `youtubeApiKey` (type: `string`):

Only needed if YouTube stops answering the public web search from your IP. With a key, the official YouTube Data API v3 is used instead and the quota is charged to that key.

## `maxConcurrency` (type: `integer`):

Keep it moderate: YouTube and Telegram slow down fast callers. 5 is a safe value.

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

Apify Proxy spreads the requests over several IP addresses. Turn it off only for local runs.

## Actor input object example

```json
{
  "keywords": [
    "order flow trading",
    "depth of market DOM trading",
    "tape reading futures",
    "footprint chart",
    "heatmap bookmap",
    "trade copier NinjaTrader",
    "NinjaTrader 8 indicators"
  ],
  "requireEmail": false,
  "sources": [
    "youtube",
    "telegram",
    "web"
  ],
  "maxResultsPerKeyword": 20,
  "maxAudienceVideos": 5,
  "maxAudienceProfiles": 200,
  "audienceRequireEmail": true,
  "language": "en",
  "country": "US",
  "minRelevanceScore": 50,
  "minSubscribers": 0,
  "maxSubscribers": 0,
  "activeWithinDays": 0,
  "maxVideoDescriptionsPerChannel": 3,
  "visitWebsites": true,
  "maxPagesPerSite": 2,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `prospects` (type: `string`):

One row per creator: platform, audience, relevance score and reasons, matched keywords, public email with where it was found, website and social links.

## `runSummary` (type: `string`):

Counts per keyword and per source: candidates found, rejected below the threshold, with an email, errors, and any source that stopped answering.

# 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 = {
    "keywords": [
        "order flow trading",
        "depth of market DOM trading",
        "tape reading futures",
        "footprint chart",
        "heatmap bookmap",
        "trade copier NinjaTrader",
        "NinjaTrader 8 indicators"
    ],
    "sources": [
        "youtube",
        "telegram",
        "web"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("meskaoui.azeddine/niche-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 = {
    "keywords": [
        "order flow trading",
        "depth of market DOM trading",
        "tape reading futures",
        "footprint chart",
        "heatmap bookmap",
        "trade copier NinjaTrader",
        "NinjaTrader 8 indicators",
    ],
    "sources": [
        "youtube",
        "telegram",
        "web",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("meskaoui.azeddine/niche-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 '{
  "keywords": [
    "order flow trading",
    "depth of market DOM trading",
    "tape reading futures",
    "footprint chart",
    "heatmap bookmap",
    "trade copier NinjaTrader",
    "NinjaTrader 8 indicators"
  ],
  "sources": [
    "youtube",
    "telegram",
    "web"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call meskaoui.azeddine/niche-creator-contact-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,meskaoui.azeddine/niche-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/lbVDbuI8ckoAhdGmu/builds/gi52uS7lSgeygC2Zy/openapi.json