TL;DR: Many creators, business accounts, and B2B professionals publish their email address publicly in their social media bios. Extracting these emails programmatically is legal, scales well, and dramatically increases the speed of outreach pipelines. This guide covers what's accessible, working code for each major platform, the legal considerations, and the patterns that actually convert when you reach out.

Most outreach is inefficient because finding contact information is the bottleneck, not writing the message. A salesperson, recruiter, or partnerships manager can spend 60% of their time hunting for an email address and only 40% actually doing the outreach. The math is upside down.

The fastest way to fix this: focus your sourcing on the channels where people deliberately publish their contact info. Many creators, founders, and business professionals put their email directly in their Instagram bio, their YouTube About page, their LinkedIn contact section, their X bio. They want to be reached. They've done the work for you.

This guide is a complete playbook on extracting these emails systematically — what's accessible per platform, working code, the legal context, and the outreach patterns that work after you've found the email.

What's Legal and What's Not

Quick legal context. The lawyer's caveat applies — consult counsel for your specific situation — but the general framework:

Legal: Extracting publicly visible information from public profiles. If someone has put their email in a public bio, that's effectively the same as them putting it on their public website. Reading public information at scale doesn't create new legal issues.

Legal but compliance-relevant: Storing extracted emails. GDPR (Europe), CAN-SPAM (US), CCPA (California) and similar laws cover what you do with the data. You generally need to be able to honor unsubscribe/deletion requests.

Risky: Cold outreach to extracted emails at high volume without complying with anti-spam laws. Even if extraction was legal, sending bad outreach is a different question with real legal exposure under CAN-SPAM, CASL, and GDPR.

Illegal: Bypassing privacy settings to access non-public emails. Phishing or social engineering to obtain emails. Buying lists from sources that didn't legitimately collect the data.

For most legitimate B2B and partnership outreach, the practice is firmly in the legal-and-compliant zone if you follow normal anti-spam rules in your outreach.

Where Emails Live on Each Platform

Different platforms expose contact info differently.

Instagram

Email lives in the bio for many creator and business accounts. Sometimes formatted plainly (hello@brand.com), sometimes obfuscated (hello [at] brand [dot] com), sometimes behind a "Contact" button on business accounts.

For business accounts, Instagram sometimes shows a email field in the profile metadata even outside the bio text. This is more reliable than bio parsing.

Hit rate: Roughly 30-40% of creator/business accounts above 10K followers have a discoverable email. Below 10K, it drops to 15-25%.

TikTok

Email is often in the bio (linktree-style), sometimes in the linked website, occasionally in the contact info field for business accounts.

Hit rate: Around 20-35% for accounts above 50K followers. Higher in business categories (beauty, fashion, food) than entertainment.

YouTube

YouTube About pages have a dedicated business-inquiry email field. Many channels expose this for partnership inquiries.

Hit rate: 40-60% for channels above 50K subscribers — the highest hit rate of any platform.

LinkedIn shows a "Contact info" section that often includes email, sometimes phone. Visibility depends on the user's privacy settings.

Hit rate: Variable — 25-50% depending on the audience composition. Consultants, sales professionals, and recruiters tend to make their email visible.

X (Twitter)

Email is often in the bio, sometimes in linked websites. Less prevalent than other platforms because X bios are short.

Hit rate: 15-25% in business contexts.

Threads

Similar to Instagram (which is the same Meta account). Bio-based emails.

Hit rate: Similar to Instagram, roughly 25-35% for business-leaning accounts.

Pattern: Extracting Emails From Bios

The most common extraction pattern: pull a profile, parse the bio for email patterns. Here's the working code.

import re
import requests
from typing import Optional

API_KEY = "your_sociavault_key"
BASE = "https://api.sociavault.com"

# Email regex covers standard format plus common obfuscations
EMAIL_PATTERNS = [
    # Standard
    r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
    # "name [at] domain [dot] com"
    r'[a-zA-Z0-9._%+-]+\s*\[at\]\s*[a-zA-Z0-9.-]+\s*\[dot\]\s*[a-zA-Z]{2,}',
    # "name (at) domain (dot) com"
    r'[a-zA-Z0-9._%+-]+\s*\(at\)\s*[a-zA-Z0-9.-]+\s*\(dot\)\s*[a-zA-Z]{2,}',
]

def normalize_obfuscated(text: str) -> str:
    """Convert obfuscated email format to standard."""
    text = re.sub(r'\s*\[at\]\s*', '@', text, flags=re.IGNORECASE)
    text = re.sub(r'\s*\(at\)\s*', '@', text, flags=re.IGNORECASE)
    text = re.sub(r'\s*\[dot\]\s*', '.', text, flags=re.IGNORECASE)
    text = re.sub(r'\s*\(dot\)\s*', '.', text, flags=re.IGNORECASE)
    return text

def find_emails_in_text(text: str) -> list:
    """Extract all email addresses from a text block."""
    if not text:
        return []

    normalized = normalize_obfuscated(text)
    emails = re.findall(EMAIL_PATTERNS[0], normalized)

    # Filter out obviously fake patterns
    real_emails = []
    for email in emails:
        # Filter out file extensions caught as TLDs
        if any(email.endswith(ext) for ext in ['.png', '.jpg', '.gif', '.mp4']):
            continue
        # Filter out clearly invalid
        if email.count('@') != 1:
            continue
        real_emails.append(email.lower())

    return list(set(real_emails))

def extract_email_from_instagram(handle: str) -> Optional[str]:
    """Get email from Instagram profile bio."""
    resp = requests.get(
        f"{BASE}/v1/scrape/instagram/profile",
        params={"handle": handle},
        headers={"x-api-key": API_KEY},
        timeout=15,
    )
    resp.raise_for_status()
    profile = resp.json()

    # Check structured business email field first
    if profile.get("public_email"):
        return profile["public_email"].lower()

    # Fall back to bio parsing
    emails = find_emails_in_text(profile.get("biography", ""))
    return emails[0] if emails else None

def extract_email_from_youtube(channel_handle: str) -> Optional[str]:
    """Get email from YouTube About page."""
    resp = requests.get(
        f"{BASE}/v1/scrape/youtube/channel",
        params={"handle": channel_handle},
        headers={"x-api-key": API_KEY},
        timeout=15,
    )
    resp.raise_for_status()
    channel = resp.json()

    # YouTube has a specific business email field
    if channel.get("business_email"):
        return channel["business_email"].lower()

    # Fall back to description parsing
    emails = find_emails_in_text(channel.get("description", ""))
    return emails[0] if emails else None

def extract_email_from_tiktok(handle: str) -> Optional[str]:
    """Get email from TikTok profile."""
    resp = requests.get(
        f"{BASE}/v1/scrape/tiktok/profile",
        params={"handle": handle},
        headers={"x-api-key": API_KEY},
        timeout=15,
    )
    resp.raise_for_status()
    profile = resp.json()

    emails = find_emails_in_text(profile.get("signature", ""))
    return emails[0] if emails else None

This handles the basic extraction. Run it across a list of handles and you have email-paired data ready for outreach.

Extraction Workflow at Scale

For systematic prospecting, the workflow looks like this:

import csv
import time

def harvest_creator_emails(handles: list, platform: str = "instagram") -> list:
    """Run extraction across many creators with retry and rate limiting."""
    extractors = {
        "instagram": extract_email_from_instagram,
        "youtube": extract_email_from_youtube,
        "tiktok": extract_email_from_tiktok,
    }

    extractor = extractors[platform]
    results = []

    for handle in handles:
        try:
            email = extractor(handle)
            results.append({
                "handle": handle,
                "platform": platform,
                "email": email,
                "found": email is not None,
            })
            print(f"{handle}: {email or 'no email'}")
        except Exception as e:
            print(f"{handle}: error - {e}")
            results.append({
                "handle": handle,
                "platform": platform,
                "email": None,
                "found": False,
                "error": str(e),
            })

        time.sleep(0.5)  # Be nice to the API

    return results

def save_to_csv(results: list, filename: str):
    with open(filename, 'w', newline='', encoding='utf-8') as f:
        writer = csv.DictWriter(f, fieldnames=["handle", "platform", "email", "found"])
        writer.writeheader()
        for r in results:
            writer.writerow({k: r.get(k) for k in writer.fieldnames})

# Usage
handles_to_research = ["creator1", "creator2", "creator3"]
results = harvest_creator_emails(handles_to_research, "instagram")
save_to_csv(results, "creator_emails.csv")

For 1,000 handles, this typically completes in 15-30 minutes depending on rate limits. Hit rate of 20-40% means 200-400 emails per 1,000 handles.

Going Further: Pairing With Profile Data

Bare emails aren't very useful for outreach. The fix: pair them with profile data so each email comes with context.

def harvest_with_context(handles: list) -> list:
    """Get email + relevant profile data for each handle."""
    enriched = []

    for handle in handles:
        try:
            resp = requests.get(
                f"{BASE}/v1/scrape/instagram/profile",
                params={"handle": handle},
                headers={"x-api-key": API_KEY},
                timeout=15,
            )
            profile = resp.json()

            email = profile.get("public_email")
            if not email:
                emails = find_emails_in_text(profile.get("biography", ""))
                email = emails[0] if emails else None

            if email:
                enriched.append({
                    "handle": handle,
                    "email": email,
                    "name": profile.get("full_name"),
                    "followers": profile.get("follower_count"),
                    "bio": profile.get("biography"),
                    "category": profile.get("category"),
                    "is_business": profile.get("is_business_account", False),
                    "external_url": profile.get("external_url"),
                })
        except Exception as e:
            print(f"{handle}: {e}")
        time.sleep(0.5)

    return enriched

Now each email comes with name, follower count, bio, category, and website. This is what makes outreach actually convert.

What Converts (And What Doesn't) After You Have the Email

Finding the email is the easy part. Here's what actually works in outreach.

High-converting patterns

Personalization rooted in their content. Not "I see you have 50K followers" but "I watched your video about [specific topic] and the way you handle [specific aspect] is what made me reach out."

Clear, specific ask. "I'd love to send you our product to try" is concrete. "Let's chat about partnerships" is vague.

Brevity. Under 100 words. Mobile-readable.

No false urgency. "Just wanted to reach out" beats "Last chance!" by a wide margin.

Reply-to-pause. End with a question. Don't pitch every detail in the first message.

Patterns that don't work

Mass templates. Generic "Hi [first name]" emails get marked as spam at obscene rates.

Pretending it's personal when it isn't. "I love your content" without specifics reads as fake immediately.

Front-loading the ask. "We'd like to offer you $5K to post about our product" without context is presumptuous.

Promotional tone. Everything that reads like a marketing email goes to trash.

Compliance for outreach

CAN-SPAM (US): Unsubscribe link required. Don't lie about who you are. Don't use false subject lines. Honor unsubscribe within 10 business days.

GDPR (EU): You need lawful basis. Legitimate interest works for B2B sales/partnerships. Make sure your privacy practices are documented.

CASL (Canada): More restrictive than CAN-SPAM. Consider whether you have express or implied consent.

CCPA/CPRA (California): Privacy notice obligations. Right to delete on request.

For most legitimate creator outreach, "single email per recipient asking about a partnership, with clear identification and unsubscribe option" is well within compliance everywhere.

Frequently Asked Questions

Is it ethical to use someone's email from their bio without permission?

Email in a bio is published intentionally. The person put it there expecting outreach. Using it for legitimate professional outreach is the use case they intended. The ethical line is bad-faith outreach: spam, scams, harassment, manipulation.

How often does this approach actually work?

For partnership outreach with personalized messages: 5-15% reply rates are normal. With strong personalization on a relevant offer: 20-30%. With generic mass blasts: under 1%, plus you damage your sender reputation.

Can I find emails for accounts under 10K followers?

Yes, but hit rates drop significantly. Most accounts under 10K followers don't publish emails. For high-engagement smaller creators, the bio sometimes has email; more often you'll need to use the contact form on their personal website (which they often link).

Do these methods work for non-English markets?

Yes. The regex patterns work for any language. Bio content might be in different languages but emails are typically in standard ASCII format.

What's the best platform to start with for B2B outreach?

LinkedIn for traditional B2B. YouTube for creator partnerships in any vertical. Instagram for consumer brand partnerships. The right platform depends on your target persona.

How do I avoid being marked as spam?

Send from a real domain with proper SPF/DKIM/DMARC. Warm up new domains slowly. Use legitimate sender names. Personalize every email. Never use mass-merge templates. Respect unsubscribes immediately.

Try SociaVault free → — 50 free credits to find emails at scale.

How to Find Emails from Social Media Profiles (Legally and at Scale)