How to Scrape Emails From YouTube

I tried to scrape emails from YouTube the way most people expect to: call the official API, read the email field, done. There is no email field. The YouTube Data API channels resource hands back the channel description, country, subscriber count, and topic categories, and nowhere in that response is a contact address. That single fact splits this whole task into two very different jobs, and knowing which one you are doing decides what you build and what it costs.

The first job is reading the email a creator typed openly into their description or About links, which is free and needs no browser but returns very little. The second is pulling the business email YouTube hides behind a “View email address” button, which needs a logged-in session and a CAPTCHA solver and is the expensive one. Below is the runnable code for the free method, an honest account of the gated method, and the managed endpoint I use when I want the public emails as JSON without writing either.

Can you scrape emails from YouTube at all?

You can scrape two kinds of email from YouTube, and only one of them is easy: the addresses a creator published in plain text, and the gated business email behind a reveal button. There is no third bulk source, because YouTube was built specifically to stop mass email harvesting.

Here is the full map of where a YouTube email can live and how reachable each spot is:

The two easy sources are text: the description and the linked sites are plain strings, so a regex finds any address a creator typed there, no login required. The hard source is the gated business email, which Google’s own documentation describes as an opt-in business-inquiries field a creator configures in YouTube Studio, shown only after a viewer clicks a button and clears a check that confirms they are human. The honest answer, then: you can read the public text cheaply, automate the gated reveal expensively, and the API helps with neither. The next section starts with the cheap path, the one most projects should try first.

How do you scrape a YouTube channel email with Python and regex?

You scrape a YouTube channel email by fetching the channel’s public description, then running an email regex over that text to pull any address the creator typed in plain text. This is the no-browser, no-login method, and it works because the description is a public string that both the channel page and the Data API expose.

The cleanest source for the description is the Data API itself, since it sidesteps the consent interstitial that a raw page request hits from a server. The channels.list call returns snippet.description for one unit of quota, well inside the 10,000-unit daily allocation. Here is the extraction end to end:

import re
import requests

API_KEY = "YOUR_YOUTUBE_DATA_API_KEY"

# Matches plain addresses and lightly obfuscated ones like "hello [at] domain [dot] com"
EMAIL_RE = re.compile(
    r"[a-z0-9._%+-]+\s*(?:@|\[at\]|\(at\))\s*"
    r"[a-z0-9.-]+\s*(?:\.|\[dot\]|\(dot\))\s*[a-z]{2,}",
    re.IGNORECASE,
)

def get_channel_description(handle):
    r = requests.get(
        "https://www.googleapis.com/youtube/v3/channels",
        params={"part": "snippet", "forHandle": handle, "key": API_KEY},
        timeout=20,
    )
    items = r.json().get("items", [])
    if not items:
        return ""
    return items[0]["snippet"]["description"]

def find_emails(text):
    raw = EMAIL_RE.findall(text)
    cleaned = []
    for m in raw:
        # normalize the obfuscated separators back to a real address
        e = (m.replace("[at]", "@").replace("(at)", "@")
               .replace("[dot]", ".").replace("(dot)", ".")
               .replace(" ", "").lower())
        if not e.startswith("//") and e not in cleaned:
            cleaned.append(e)
    return cleaned

if __name__ == "__main__":
    desc = get_channel_description("MrBeast")
    print(find_emails(desc) or "no public email in description")

Two things about that regex matter in practice. It handles the obfuscated forms creators use to dodge naive scrapers, like hello [at] example [dot] com, which a plain \S+@\S+ pattern would miss entirely. And it filters the // false positive, the same single guard the widely copied open-source email-scraper script on GitHub uses to avoid catching protocol-relative URLs as addresses. That community script reads the same About text, just by scraping the page DOM instead of calling the API.

The honest limitation is yield, not code. Most creators never type an email into their description, so this method returns an empty list far more often than it returns an address. Smaller channels are the worst case: creators under roughly 100,000 subscribers rarely publish a contact email at all, while larger channels almost always do. You can widen the net by following the About-tab links to a creator’s website or Linktree and running the same regex on those pages, which catches addresses that live one hop away. But the addresses sitting behind YouTube’s reveal button stay invisible to this method no matter how good your regex is, which is the wall the next section walks into.

How do you get the gated business email behind the View email address button?

You get the gated business email by automating the exact reveal a human performs: load the channel About tab in a logged-in browser, click “View email address,” and solve the reCAPTCHA that appears before the address renders. There is no shortcut around the button, because the email is not in the page source until the CAPTCHA clears.

That single sentence hides a lot of moving parts, which is why the gated reveal is the hard, paid tier:

• A logged-in Google session. The button only serves the address to an authenticated account, and only on desktop. A logged-out request or the mobile app never sees it.
• A stealth headless browser. You are driving a real browser session, not a plain HTTP request, so you need headless automation that survives YouTube’s bot checks. Scrapfly’s YouTube scraping guide shows the same shape for channel About data: a headless browser clicks to trigger the metadata call, then you parse the XHR response.
• A CAPTCHA solver. The reveal opens a reCAPTCHA, so an automated run pipes that challenge to a solving service. 2captcha prices reCAPTCHA solving from about 0.99 EUR per 1,000 challenges, and that is on top of running the browser fleet.
• A daily reveal cap. A single logged-in account can reveal only a handful of addresses a day before YouTube stops serving them, so scaling means rotating many accounts and identities, not hammering one.

Add those together and the per-email economics make sense. The dedicated reveal actor from DataOverCoffee on Apify states plainly that it clicks the View email address button with logged-in Google accounts to get the real business email, runs automated CAPTCHA solving server-side, and prices the result at $0.12 per email (with a force-fresh option at $0.40 and no charge when a channel has no email). That is roughly 100 times the cost per record of the free regex method, and it buys you exactly the addresses the regex method cannot reach. The trade is yield against effort: the reveal route returns more real business emails, but every one is a logged-in click and a solved CAPTCHA, so you pay per address rather than per page. If you would rather not stand up that infrastructure, the managed endpoint in the next section returns the public emails directly and tells you when a paid reveal is the only way to go deeper.

How do you scrape YouTube emails with a managed API?

A managed YouTube email API returns a channel’s publicly listed emails as parsed JSON from a single request, so you skip both the description parsing and the browser-plus-CAPTCHA reveal stack. You send a channel handle and get back the emails the creator published, with no API key from Google and no headless browser on your side. I use our YouTube email endpoint for this, and the call is one GET keyed with your API key as a query parameter:

curl "https://api.youtubescraperapi.com/api/v1/youtube/email?channel=@SomeChannel&api_key=$API_KEY"

The response returns the data object directly, with the emails plus enough channel context to know what you are looking at:

{
  "channel": "@SomeChannel",
  "channel_id": "UCxxxxxxxxxxxxxxxxxxxxxx",
  "channel_name": "Some Channel",
  "emails": ["hello@example.com"],
  "email_count": 1,
  "links": [
    { "title": "My Course", "display": "example.com", "url": "https://www.example.com/", "from": "links_section" },
    { "title": null, "display": "discord.gg/abc123", "url": "https://discord.gg/abc123", "from": "description" },
    { "title": "X / Twitter", "display": "@SomeChannel", "url": "https://twitter.com/SomeChannel", "from": "description" }
  ],
  "links_count": 3,
  "source": "public_description",
  "reveal_available": false
}

The same call works from Python with requests, which slots straight into a loop over a list of channels:

import os
import requests

def channel_emails(handle):
    r = requests.get(
        "https://api.youtubescraperapi.com/api/v1/youtube/email",
        params={"channel": handle, "api_key": os.environ["API_KEY"]},
        timeout=60,
    )
    return r.json()

if __name__ == "__main__":
    data = channel_emails("@SomeChannel")
    if data["email_count"]:
        print("found:", ", ".join(data["emails"]), "via", data["source"])
    elif data["reveal_available"]:
        print("no public email; a paid reveal is available for this channel")
    else:
        print("no public email and no reveal available")

    # Links come from both the About Links widget and the description,
    # each tagged with where it was found
    for link in data["links"]:
        print(f"  [{link['from']}] {link['display']} -> {link['url']}")

A few fields in that response are the honest part of the design. The source tells you the email came from public_description, the same public text the regex method reads, so you know it is an openly published address and not something pried out from behind the gate. And reveal_available is explicit about the ceiling: when a creator gated their email, the emails array comes back empty and this flag tells you whether the harder paid reveal is even possible for that channel. Right now it is always false, since the reCAPTCHA-gated reveal is a separate tier that is not built into this endpoint, so an empty emails array is a real signal that the creator published nothing openly, not a failure to parse.

The links array is where the description-plus-links route I described earlier gets folded into one call. Each entry carries a from tag that is either links_section, meaning it came from the structured About “Links” widget, or description, meaning it was parsed out of the description blurb itself. That description parsing catches full URLs, bare domains with a path, and X:, Twitter:, Instagram:, and TikTok: handle mentions, which it resolves to the profile URL. So a creator’s LinkedIn, Discord, course site, or social handles get picked up wherever they put them, and every url is normalized to an absolute https address you can follow or run the regex against for an off-channel email.

For where this fits, the split is the same one this whole guide turns on. For openly listed emails across a list of channels, this endpoint is the fastest path, because it returns the parsed address and the channel context in one call with no Google quota to manage and no DOM to scrape. A free youtubescraperapi.com key from the sign-up page covers enough requests to test the public-email endpoint against your own target channels first.

For the gated business emails behind the reveal, you are back to the paid, slower tier whatever tool you use, since that address is a logged-in CAPTCHA click by definition. If you want to see how the full managed tools compare on hit rate and price for that gated reveal, I ranked them in best YouTube email scrapers in 2026.

What should you do with the emails once you have them?

Once you have the emails, the legal line shifts from collecting to contacting, and the contacting side is the regulated one. Pulling an address a creator published voluntarily is generally treated as collecting public data, which US courts have read narrowly under the CFAA in hiQ v. LinkedIn. Sending to those addresses is where the rules bite: the US CAN-SPAM Act sets requirements on identification and opt-out with civil penalties per violating message, and the EU GDPR ties unsolicited contact to a documented lawful basis.

The privacy rules, the platform terms, and where the public-data line actually sits are worth settling before you mail anyone, which I cover in is scraping YouTube legal.

Most teams also pair the email with channel numbers first, because a raw address is half a lead without the subscriber count, niche, and country to qualify it. Pulling deeper channel data turns a bare email into a scored prospect.

Discovering channels by keyword through a search-results scrape gives you the list to enrich in the first place. That is the front of the same pipeline: find the channels, qualify them, then extract the address.

If you are deciding between the regex route, the Data API, and a full scraper in general, how to scrape YouTube channels with Python lays out the build before you collect anything at scale.