YouTube Channel Email Finder - Creator Contacts & Socials

Give YouTube channels (or a search) and get one row per channel: the business e-mail addresses the channel shows in public, its social profiles and links, and its channel numbers. No login, no cookies, no CAPTCHA solving. Optional: an AI fit review (beta, paid plans).

What you pay for (details under Pricing): each row with a full public e-mail ($0.032 on BRONZE) on top of its channel looked up ($0.008 on BRONZE, also one YouTube says does not exist) · each search made ($0.008) · a run-start fee once per run ($0.004) · each AI fit verdict if you ask for one ($0.024) · each lookup or search YouTube refused (HTTP 403/429, $0.008, instead of the lookup or search event). A paid run of 100 entered channels where 40 show a public e-mail is about $2.08 on BRONZE (an estimate: the e-mail share is different for every list).

E-mails YouTube shows only after sign-in are not opened on any plan. The Actor tells you which channels have one (hiddenBusinessEmail), and that is all.

	Free plan (preview)	Paid Apify plan (Starter and up)
Channels per run	5 (with searches: the first search only)	up to maxChannels (default 100, 1,000 per run), up to 100 per search
Each channel row	the channel only: channelId, handle, channelUrl, title, exists, what you entered	the full row: numbers, country, join date, About text, e-mails, links, social profiles
Public e-mail addresses	not per channel: the run's total (how many channels show one, how many addresses) in a free-plan-preview row	full addresses, the page each was found on, own domain or free mail, whether the domain takes mail
"E-mail shown only after sign-in"	the run's total	per channel (the address itself is not opened on any plan)
Social profiles and links	the run's total	every address
AI fit review (beta)	locked — a free run asks no model	optional, for up to aiMaxItems channels (1,000 a run)
What a paid run of the same input costs	an estimate in the free-plan-preview row (BRONZE prices, from this run's sample)	—
Price	run-started, search-query, channel-checked and source-access-checked	all six events, with plan discounts

A free run ends as SUCCEEDED with a status message that says what it found, what was withheld and what a paid run of the same input would cost. To get the full rows, switch to a paid Apify plan and run the same input again. Nothing in a free run's dataset, log or key-value store holds an address, a link or the About text.

What it is for

• Sponsorship and influencer outreach: turn a list of channels, or a search like indie game review, into contacts you can sort.
• Creator lead lists: public business e-mail, website, Instagram, X, TikTok, LinkedIn, Discord and link-page addresses in one row.
• Shortlisting (optional AI fit review, beta, paid plans): describe your campaign once in brief; channels the review is made for come back as strong, possible, weak or unclear, with the sentences of the channel's own About text the verdict rests on.

Where the addresses come from

Only from what the channel itself publishes to visitors who are not logged in:

1. the channel's About text, including addresses written as name [at] domain [dot] com;
2. when the About text shows none: one page behind each of up to three links the channel lists (its website or link page — not social profiles or shops). Nothing beyond that page is opened.

YouTube also has a "View email address" button that works only for signed-in users. This Actor does not open it, on the free plan or on any paid plan. On a paid plan it tells you that the button is there (hiddenBusinessEmail: true), so you know which channels have a business address that is not shown in public; a free run gives only the number of such channels.

Addresses that are not a contact are left out: file names (logo@2x.png), placeholders (you@example.com), no-reply addresses, and the addresses of site builders, trackers and the platforms themselves.

How to use it

1. Enter channels (@handle, channel address or channel ID) and/or searches.
2. Optional (beta, paid plans): turn on AI fit review and describe your campaign in Campaign brief.
3. Run. Each channel is one row, and each search made is one row (recordType: "search"). A channel YouTube says does not exist is a row too (exists: false), charged as a lookup. A channel or a search YouTube refused (HTTP 403 or 429) is a row too (accessRefused: true), charged once as source-access-checked. A channel or a search we could not read on our side (a time-out, an answer that could not be read) is a notice row and is not charged.

Input

Field	Type	Description
channels	array	@handle, youtube.com/@name, /channel/UC…, /c/name, /user/name or a channel ID. The same channel entered twice is read and charged once. A handle or ID YouTube does not know is still looked up and charged: its row says so. A lookup YouTube refuses (HTTP 403/429) is a row charged as source-access-checked instead of channel-checked
searchQueries	array	Search words, 2–100 characters each. Each search made is charged as search-query, also one that returns no channels; the channels YouTube returns are checked and charged like entered ones. A search YouTube refuses (HTTP 403/429) is a search row charged as source-access-checked instead of search-query
maxChannelsPerSearch	integer	Channels taken from each search, 1–100 (default 20)
maxChannels	integer	The most channels a run looks at, 1–1,000 (default 100; free plan: 5)
followLinks	boolean	Read one page behind up to 3 of the channel's links when the About text shows no address (default true)
aiFit	boolean	Optional AI fit review (beta, paid plans, default false). Needs brief
brief	string	Your campaign in your own words, 20–2,000 characters
aiMaxItems	integer	The most channels sent to the model in a run, 1–1,000 (default 100)
proxyConfiguration	object	Off by default. Turn it on if a run reports refused requests: every request to YouTube then leaves through it (the limits row counts them in requests.viaProxy). Pages a channel links to are always read directly

{
  "channels": ["@mkbhd", "https://www.youtube.com/@veritasium"],
  "searchQueries": ["mechanical keyboard review"],
  "maxChannels": 50,
  "aiFit": true,
  "brief": "Mechanical keyboard brand looking for English-speaking tech reviewers who cover desk setups; not gaming-only channels."
}

Output

One row per channel (recordType: "channel"):

Field	What it holds
exists	true for a channel that was read; false when YouTube answered that there is no such channel (see below)
input, searchQuery	What you entered, or the search that found the channel
channelId, handle, channelUrl, title, description	The channel
subscribers, views, videos (+ subscribersText, viewsText, videosText)	Numbers, and the text YouTube shows them as
joined, country	Join date (YYYY-MM-DD) and country, when the channel shows them
emails[]	address, source (description or link), sourceUrl, domainType (own or free), domainHasMx (true, false, or null when it could not be found out)
emailFound, emailCount	Whether and how many public addresses were found
hiddenBusinessEmail	true when YouTube shows a business e-mail only after sign-in
website, links[], linkCount	The channel's first own site, and all links it lists (title, url)
socials, socialPlatforms	{ "instagram": "https://…", "x": "https://…" } and the platform names
fit	Optional AI fit review (beta): status (reviewed or not-reviewed with a reason), fit, reasons[] (quote, why), audience, audienceEvidence, flags[], model, modelRequests (how many requests the review took, on rows the model was asked about)
plan, locked[]	free or paid, and which parts of the row are withheld or masked
billedEvents[]	The events this row is charged for
checkedAt, disclaimer	When it was read, and the notice below
rowId	A fixed id of the row within the run (every row has one, notices and the limits row too). A run that is restarted reads these ids from its dataset and writes no row a second time

{
  "recordType": "channel",
  "input": "@examplechannel",
  "channelId": "UCxxxxxxxxxxxxxxxxxxxxxx",
  "handle": "@examplechannel",
  "channelUrl": "https://www.youtube.com/@examplechannel",
  "title": "Example Channel",
  "subscribers": 123000,
  "subscribersText": "123K subscribers",
  "country": "United States",
  "emails": [
    { "address": "business@example-channel.tv", "source": "description", "sourceUrl": "https://www.youtube.com/@examplechannel/about", "domainType": "own", "domainHasMx": true }
  ],
  "emailFound": true,
  "hiddenBusinessEmail": true,
  "website": "https://example-channel.tv/",
  "socials": { "instagram": "https://www.instagram.com/examplechannel", "x": "https://x.com/examplechannel" },
  "socialPlatforms": ["instagram", "x"],
  "fit": {
    "status": "reviewed",
    "fit": "strong",
    "reasons": [{ "quote": "Weekly reviews of mechanical keyboards and desk setups", "why": "The channel covers the product category of the brief." }],
    "audience": "not stated",
    "flags": ["business-contact-stated"],
    "model": "claude-haiku-5-5"
  },
  "plan": "paid",
  "billedEvents": ["channel-checked", "email-found", "fit-reviewed"]
}

A channel that does not exist. When YouTube itself answers that there is no channel for what you entered (a misspelled, renamed or removed handle, or a mistyped ID), you get a row with exists: false, input, lookedUp (the address or channel ID that was looked up), notFoundReason (one sentence: what YouTube answered and the likely causes), checkedAt, and empty e-mail, link and social fields. The lookup was made, so the row is charged as channel-checked. No e-mail is looked for and no AI review is made for it.

{
  "recordType": "channel",
  "exists": false,
  "input": "@examplechanel",
  "lookedUp": "https://www.youtube.com/@examplechanel",
  "notFoundReason": "YouTube answered that there is no channel at this address. The handle may be misspelled, or the channel was renamed or removed.",
  "emails": [],
  "emailFound": false,
  "billedEvents": ["channel-checked"]
}

A lookup that YouTube refused (HTTP 403 or 429 — the site's answer, not a fault in this Actor) is a row of its own: exists: null, accessRefused: true, refusedStatus, lookedUp, refusalReason and billedEvents: ["source-access-checked"], with nothing about the channel in it; it is charged once and the channel is not asked again in the same run. A lookup that failed on our side (it timed out, or its answer could not be read) is never reported as "does not exist": it is a channel-unreadable notice row and is not charged.

A search is one row (recordType: "search"): searchQuery, channelsFound, channelsTaken (checked in this run, each its own channel row), channelsLeftOut (past maxChannels), lastPageFailed, a message and billedEvents: ["search-query"] — also when YouTube returns no channels for it. A search YouTube refused (HTTP 403/429) is a search row with accessRefused: true and billedEvents: ["source-access-checked"]. A search whose answer could not be read on our side is a search-unreadable notice and is not charged.

On the free plan a channel row holds only recordType, exists, input, searchQuery, channelId, handle, channelUrl, title, plan, locked, billedEvents, rowId, checkedAt and disclaimer (a channel that does not exist also lookedUp and notFoundReason). Whether a channel shows an e-mail is not on its row: the free-plan-preview row gives the run's totals — channels with a public e-mail, addresses, channels with an e-mail shown only after sign-in, links and social profiles — and an estimate of a paid run of the same input.

Other rows, never charged: notice rows (noticeCode: channel-unreadable, search-unreadable, duplicate-input, invalid-input, input-limit, charge-limit-reached, free-plan-preview, ai-off, pricing-unverified and others, each with a message) and one limits row that adds the run up: what was read, what was left out and why, each search, and what was charged.

AI fit review (optional, beta, paid plans)

The review is an extra you can ask for; the contacts are the product. It is made only when all of these hold — otherwise the rows go out without a verdict, nothing is charged for reviews, and an ai-off notice (or the row's fit.reason) says why:

• the run is on a paid Apify plan, aiFit is on and brief has 20–2,000 characters;

• the run's price list has the fit-reviewed event;

• the review is available in this run (the model service answers and the Actor's model key is set);

• the channel has an About text, and fewer than aiMaxItems channels were reviewed so far;

• your run's maximum charge still pays for the whole row (channel, e-mail and review);

• the run's own spending cap for model calls is not used up.

• What is sent: the channel's public About text (first 6,000 characters), its name, subscriber text, country and the names of the platforms it links to, together with your brief. E-mail addresses and web addresses are removed before sending. When aiFit is on, this text goes to Anthropic's API (United States); the model is claude-haiku-5-5.

• What comes back: strong, possible, weak or unclear, up to three reasons each quoting the channel's own words, the audience the channel states (or not stated), and flags from a fixed list.

• What we check before it is delivered and charged: every quote must be in the channel's text letter for letter, every number the answer writes must be in the channel's text or your brief, and the answer may hold no address. An answer that fails is thrown away — you get the row without a verdict and are not charged for the review.

• The verdict is a reading of what the channel says about itself. It is an aid for sorting a list, not a statement about the channel's audience or performance.

• A channel with no About text is not sent to the model (fit.reason: "no-material", not charged), nor is a channel that does not exist (fit.reason: "channel-not-found").

Pricing

Pay per event, six events. The main one is email-found; a channel with a full public e-mail is email-found + channel-checked (FREE $0.05, BRONZE $0.04, GOLD $0.026):

Event	FREE	BRONZE	SILVER	GOLD and up	When
email-found	$0.04	$0.032	$0.026	$0.0208	The row carries at least one full public e-mail address (once per channel, however many addresses), on top of the row's channel-checked
channel-checked	$0.01	$0.008	$0.0065	$0.0052	A channel was looked up and delivered as a row — also when no e-mail was found, and also when YouTube answered that the channel does not exist (exists: false)
search-query	$0.01	$0.008	$0.0065	$0.0052	A search was made (once per search, however many result pages; also when it returns no channels)
run-started	$0.005	$0.004	$0.00325	$0.0026	Once per run, right before the run starts looking anything up
fit-reviewed	$0.03	$0.024	$0.0195	$0.0156	Optional (beta): an AI verdict that passed our checks is on the row
source-access-checked	$0.01	$0.008	$0.0065	$0.0052	YouTube refused a channel lookup or a search (HTTP 403 or 429): the request was made and the row says so (accessRefused: true). Charged once, instead of channel-checked or search-query: an entry or a search gets one of them in a run, also when the run is restarted

A lookup is charged because it was made: a channel that turns out to be misspelled or removed costs the same lookup as one that exists, and its row tells you so. The same holds for a search that finds nothing, and for a lookup or search YouTube refuses (403/429): that refusal is the site's answer, not a fault in this Actor.

What is not charged: entries that are not a YouTube channel (nothing is looked up for them, and a run whose input has no valid channel or search pays no run-start fee either), lookups and searches that failed on our side (time-outs, answers that could not be read, our errors), the same channel or search entered twice, masked addresses, e-mails shown only after sign-in (they are not opened), reviews that failed or were thrown away, notice rows and the limits row.

Your maximum charge is respected. The run-start fee is counted against your run's limit before the first lookup: when the limit does not cover it, the run looks nothing up, charges nothing and ends as SUCCEEDED with a charge-limit-reached notice. A search is counted the same way before it is made. Before a row is written the Actor counts whether your run's limit still pays for it. When the limit pays for the channel but not for its e-mail event, the row is delivered with the addresses masked and without that charge; when it does not pay for the channel, the run ends as SUCCEEDED with a charge-limit-reached notice. A run that is restarted (a migration, or a resurrected run) first charges the rows it had delivered and not yet charged — only as far as your limit pays for them; what does not fit is named in a restart-unsettled notice and nothing further is delivered until the limit is raised.

Good to know

• The same channel in two runs is charged in both. The Actor keeps nothing between runs.
• A restarted run (migration or resurrect) continues where it stopped: channels and searches already in the dataset are not charged again, the run-start fee is not charged a second time, and a row that was delivered right before the restart is charged then. A run stopped between its run-start fee and its first lookup has paid only that fee; resurrect it and it goes on.
• A typo is a lookup. Check handles before a large run: @examplechanel instead of @examplechannel is looked up, comes back with exists: false and is charged as channel-checked.
• An address found on a linked page (source: "link") is the address that page shows; it may be a general contact of the site rather than the channel owner's own. sourceUrl tells you where it was read.
• Requests: up to 4 channels at a time, with a pause between requests. If YouTube refuses five requests in a row the run stops asking and says so; the refused lookups are rows charged as source-access-checked, and nothing is charged for channels that were not asked (the run-start fee was charged when the run began looking up).
• Counts (subscribers, views, videos) are read from YouTube's English wording and rounded as YouTube rounds them (21.4M → 21,400,000).

Responsible use

This is an unofficial, independent tool. It is not affiliated with, endorsed by, or sponsored by YouTube or Google. It reads only what YouTube and the pages a channel links to show to visitors who are not logged in. It does not use accounts or login cookies, and it sends no messages.

The output contains contact details that channels publish. You are responsible for how you run this Actor and how you use its output: having a lawful basis for processing personal data (for example under GDPR, CCPA or PIPA), complying with anti-spam law (for example CAN-SPAM) and any consent a message requires, and respecting YouTube's terms. You are the data controller for the output of your runs. Do not use it to send unsolicited bulk messages or to harass anyone.