LinkedIn has become the primary platform for B2B prospecting, but converting LinkedIn profiles into actionable email contacts remains one of the biggest challenges for sales professionals. With over 900 million users, LinkedIn contains a goldmine of prospect information, yet most professionals struggle to efficiently extract email addresses for their outreach campaigns.
The gap between finding prospects on LinkedIn and reaching them via email creates a bottleneck that limits sales effectiveness. Traditional methods of manually researching each prospect’s email address are time-consuming and often inaccurate. Meanwhile, direct LinkedIn messaging has low response rates and limited scalability compared to email outreach.
This comprehensive guide provides systematic approaches for converting LinkedIn prospects into verified email contacts. We’ll cover proven methods that respect LinkedIn’s terms of service while maximizing your prospect research efficiency. From manual research techniques to advanced automation tools, you’ll learn strategies that work across different industries and company sizes.
Whether you’re a sales development representative building pipeline, a business owner seeking new customers, or a marketer launching account-based campaigns, mastering LinkedIn to email conversion will dramatically improve your prospecting results. The techniques in this guide have been tested across thousands of prospects and consistently deliver higher accuracy rates than generic email finding approaches.
The key to successful LinkedIn to email conversion lies in understanding email patterns, leveraging multiple data sources, and implementing verification processes that protect your sender reputation. This guide provides the complete framework for building high-quality email lists from LinkedIn prospects that actually convert into customers.
Understanding LinkedIn to Email Fundamentals
Converting LinkedIn profiles to email addresses requires understanding both LinkedIn’s data structure and corporate email patterns that enable accurate prospect contact discovery.
Why LinkedIn to Email Conversion Matters
Higher Response Rates: Email outreach consistently outperforms LinkedIn messaging, with response rates typically 3-5x higher for well-crafted email campaigns compared to LinkedIn InMail or connection requests.
Scalability Advantages: Email campaigns can reach hundreds of prospects simultaneously, while LinkedIn messaging is limited by platform restrictions and daily sending limits.
Professional Context: Email communication feels more professional and less intrusive than LinkedIn messaging, making prospects more likely to engage with your outreach.
Integration Benefits: Email addresses integrate seamlessly with CRM systems, marketing automation platforms, and analytics tools, enabling comprehensive campaign tracking and optimization.
Cost Efficiency: Email outreach costs significantly less than LinkedIn premium features while often delivering better results.
LinkedIn Profile Intelligence Gathering
Professional Information Analysis: LinkedIn profiles contain rich information about prospects’ roles, responsibilities, company details, and professional background that inform both email discovery and message personalization.
Company Email Pattern Recognition: By analyzing multiple employees from the same company, you can identify email formatting patterns that help predict email addresses for other prospects at that organization.
Contact Information Signals: Some LinkedIn users include email addresses in their contact information, profiles, or posts, providing direct access to verified contact details.
Mutual Connection Leverage: Mutual connections can provide introductions or verify email addresses, significantly improving outreach effectiveness compared to cold contact attempts.
Engagement History Analysis: Prospects who actively engage with content, post updates, or participate in LinkedIn discussions often respond better to outreach than passive LinkedIn users.
Email Pattern Recognition Strategies
Standard Corporate Formats: Most companies use predictable email formats like [email protected], [email protected], or [email protected] that can be determined through pattern analysis.
Seniority-Based Variations: Senior executives sometimes use different email formats than general employees, such as first initial + last name or full names without periods.
Department-Specific Patterns: Some organizations use department prefixes or different domains for different business units, requiring analysis of multiple employees to identify the correct pattern.
International Considerations: Global companies may use different email formats for different regions, and non-English names may follow different formatting conventions.
Verification Through Public Sources: Company websites, press releases, and published content often reveal email addresses that confirm formatting patterns for that organization.
For foundational understanding of how LinkedIn prospecting fits into comprehensive cold email strategies, read our guide: Cold Email Success: Finding Valid Email Addresses That Actually Convert.
Manual LinkedIn to Email Research Methods
Manual research methods provide high accuracy and deep prospect insights, making them essential for high-value prospects and building email pattern recognition skills.
LinkedIn Profile Deep Dive Techniques
Contact Information Section Review: Start by checking the prospect’s contact information section, where some users voluntarily list email addresses or websites that lead to contact information.
About Section Analysis: Many professionals include contact information or website links in their About section, particularly consultants, freelancers, and business owners seeking direct contact opportunities.
Experience Section Intelligence: Company descriptions and role details sometimes include email addresses, especially for executives who list multiple contact methods for business purposes.
Education and Volunteer Information: Alumni directories and volunteer organization listings occasionally provide alternative contact information that can lead to email discovery.
Activity and Post History: Review recent posts and comments for contact information sharing, website links, or engagement patterns that indicate responsiveness to outreach.
Skills and Recommendations: Recommendations sometimes include contact information or reference shared projects that can provide alternative research angles.
Company Website Email Discovery
Team Page Research: Most company websites have team or about pages that list employee email addresses, particularly for leadership and customer-facing roles.
Contact Page Analysis: Company contact pages often list department-specific email addresses that reveal the organization’s email format and can be adapted for specific prospects.
Press Release Mining: Press releases frequently mention key executives with contact information or quote employees whose email addresses might be available through additional research.
Blog Author Information: Company blogs often include author bios with email addresses or social media links that can lead to email discovery.
Job Posting Contact Information: Job postings sometimes include hiring manager email addresses or HR contacts that reveal company email patterns.
Email Pattern Testing and Verification
Multiple Employee Analysis: Research 3-5 employees from the same company using different methods to identify the consistent email format used by that organization.
Seniority Level Comparison: Compare email formats across different seniority levels to understand if executives use different patterns than general employees.
Department Variation Testing: Check if different departments use variations of the company’s standard email format, particularly for sales, marketing, and technical teams.
Historical Pattern Verification: Use archived web pages, old press releases, or industry directories to verify email patterns that may have changed over time.
Format Probability Ranking: Create a ranked list of most likely email formats based on your research, starting with the most commonly observed pattern for that company.
Social Media Cross-Reference
Twitter Bio Research: Many professionals include email addresses in their Twitter bios or link to websites with contact information.
Professional Blog Discovery: Personal or professional blogs often include contact information and may be linked from LinkedIn profiles.
Industry Forum Participation: Technical forums, industry communities, and professional groups sometimes display email addresses for active participants.
Conference Speaker Information: Industry conference websites often list speaker contact information for prospects who present at events.
Professional Association Directories: Industry associations and professional organizations often maintain member directories with contact information.
Mutual Connection Strategies
Introduction Requests: Reach out to mutual connections for warm introductions, which often include email addresses and significantly improve response rates.
Information Verification: Ask mutual connections to verify email addresses you’ve researched, adding confidence to your outreach approach.
Context Gathering: Mutual connections can provide valuable context about prospects’ current priorities, challenges, and communication preferences.
Referral Opportunities: Some mutual connections may offer to make direct introductions or forward your message, eliminating the need for cold email.
Relationship Mapping: Understand the strength and nature of mutual connections to determine the best approach for requesting assistance.
Automated LinkedIn to Email Tools
Automation tools can significantly improve efficiency for LinkedIn to email conversion while maintaining accuracy and compliance with platform terms of service.
Browser Extension Solutions
Hunter.io Chrome Extension: Hunter.io’s browser extension integrates directly with LinkedIn to find email addresses while browsing profiles.
Key Features:
- Real-time email discovery while viewing LinkedIn profiles
- Confidence scores for found email addresses
- Company domain analysis and email pattern recognition
- Integration with Hunter’s verification system
- Bulk export capabilities for prospect lists
Usage Strategy:
// Example workflow with Hunter extension
1. Navigate to LinkedIn prospect profile
2. Click Hunter extension icon
3. Review found email addresses and confidence scores
4. Verify high-confidence emails using Hunter's verification
5. Export verified emails to CRM or cold email platform
Limitations:
- Requires Hunter.io subscription for full functionality
- Limited to emails available in Hunter’s database
- May not find emails for newer employees or smaller companies
Clearbit Connect Integration: Clearbit Connect provides real-time email discovery and prospect enrichment directly within LinkedIn and Gmail.
Key Features:
- Real-time prospect enrichment while browsing LinkedIn
- Company and personal information enhancement
- Email address discovery with verification confidence
- Integration with Gmail for seamless outreach
- CRM synchronization capabilities
Implementation Example:
# Clearbit API integration for LinkedIn prospect enrichment
import clearbit
def enrich_linkedin_prospect(linkedin_url):
# Extract company domain from LinkedIn profile
company_domain = extract_domain_from_linkedin(linkedin_url)
# Use Clearbit to find company information
company_data = clearbit.Company.find(domain=company_domain)
# Enrich person data if available
person_data = clearbit.Person.find(
email=f"{first_name}.{last_name}@{company_domain}",
given_name=first_name,
family_name=last_name,
company=company_domain
)
return {
'company': company_data,
'person': person_data,
'email_confidence': person_data.get('confidence', 0) if person_data else 0
}
Lusha LinkedIn Integration: Lusha specializes in LinkedIn contact discovery with strong GDPR compliance features.
Key Features:
- Direct LinkedIn profile email discovery
- Phone number finding capabilities
- GDPR-compliant data collection
- Mobile app for on-the-go prospecting
- Integration with popular CRM systems
Best Practices:
- Use for prospects in regions with strict privacy regulations
- Combine with manual verification for high-value prospects
- Leverage phone number discovery for multi-channel outreach
- Export data regularly to maintain organized prospect databases
API-Based Automation Solutions
Apollo.io LinkedIn Integration: Apollo.io provides comprehensive LinkedIn to email conversion through both browser extensions and API access.
Technical Implementation:
import apollo_api
def linkedin_to_email_conversion(linkedin_profiles):
converted_prospects = []
for profile in linkedin_profiles:
# Extract prospect information from LinkedIn profile
prospect_data = {
'first_name': profile['first_name'],
'last_name': profile['last_name'],
'company_name': profile['company'],
'title': profile['title'],
'linkedin_url': profile['url']
}
# Use Apollo API to find email address
search_result = apollo_api.search_people({
'first_name': prospect_data['first_name'],
'last_name': prospect_data['last_name'],
'organization_name': prospect_data['company_name']
})
if search_result and search_result['people']:
person = search_result['people'][0]
if person['email'] and person['email_confidence'] > 85:
prospect_data['email'] = person['email']
prospect_data['confidence'] = person['email_confidence']
converted_prospects.append(prospect_data)
return converted_prospects
ZoomInfo LinkedIn Enhancement: ZoomInfo provides enterprise-grade LinkedIn to email conversion with advanced filtering and verification capabilities.
Advanced Features:
- Intent data integration for prioritizing active prospects
- Organizational chart mapping for account-based prospecting
- Real-time email verification and deliverability scoring
- Advanced search filters for precise prospect targeting
- Bulk processing capabilities for large prospect lists
Enterprise Implementation:
def enterprise_linkedin_conversion(prospect_list):
# Batch processing for large prospect lists
batch_size = 100
processed_prospects = []
for i in range(0, len(prospect_list), batch_size):
batch = prospect_list[i:i + batch_size]
# Process batch through ZoomInfo API
batch_results = zoominfo_api.batch_enrich(batch)
# Filter for high-quality results
quality_prospects = [
prospect for prospect in batch_results
if prospect.get('email_confidence', 0) > 90
and prospect.get('phone_confidence', 0) > 80
]
processed_prospects.extend(quality_prospects)
# Rate limiting to respect API limits
time.sleep(1)
return processed_prospects
LinkedIn Sales Navigator Integration
Advanced Search Capabilities: LinkedIn Sales Navigator provides advanced search features that improve prospect identification before email discovery.
Search Optimization Strategies:
- Use boolean search operators for precise prospect targeting
- Combine multiple filters to create highly specific prospect lists
- Save searches for ongoing prospect identification
- Use lead recommendations to discover similar prospects
- Track prospect activity and engagement for optimal outreach timing
Export and Processing Workflow:
def sales_navigator_to_email_workflow():
# Export Sales Navigator search results
navigator_prospects = export_sales_navigator_search()
# Enrich with email discovery tools
enriched_prospects = []
for prospect in navigator_prospects:
# Try multiple email discovery methods
email_results = []
# Method 1: Apollo.io
apollo_result = apollo_api.find_email(prospect)
if apollo_result and apollo_result['confidence'] > 85:
email_results.append(apollo_result)
# Method 2: Hunter.io
hunter_result = hunter_api.find_email(prospect)
if hunter_result and hunter_result['confidence'] > 85:
email_results.append(hunter_result)
# Method 3: Company domain pattern
if prospect['company_domain']:
predicted_email = predict_email_pattern(
prospect['first_name'],
prospect['last_name'],
prospect['company_domain']
)
pattern_result = verify_email_address(predicted_email)
if pattern_result['deliverable']:
email_results.append({
'email': predicted_email,
'confidence': pattern_result['confidence']
})
# Select highest confidence result
if email_results:
best_result = max(email_results, key=lambda x: x['confidence'])
prospect['email'] = best_result['email']
prospect['email_confidence'] = best_result['confidence']
enriched_prospects.append(prospect)
return enriched_prospects
For detailed comparison of email discovery tools and their LinkedIn integration capabilities, see our comprehensive guide: Email Finder Tools Tested: Which Actually Deliver Accurate Results?.
Email Pattern Recognition and Prediction
Understanding and predicting email patterns is crucial for converting LinkedIn profiles to accurate email addresses, especially for prospects not found in standard databases.
Common Corporate Email Formats
Standard Format Categories:
First.Last Format ([email protected]):
- Most common in professional services, consulting, and finance
- Used by approximately 45% of companies globally
- Easy to predict and verify through pattern recognition
- Examples: [email protected], [email protected]
FirstLast Format ([email protected]):
- Common in technology companies and startups
- Used by approximately 25% of companies
- More compact format preferred by newer organizations
- Examples: [email protected], [email protected]
First_Last Format ([email protected]):
- Popular in government organizations and large corporations
- Used by approximately 15% of companies
- Often combined with department prefixes
- Examples: [email protected], [email protected]
Initial.Last Format ([email protected]):
- Common in European companies and academic institutions
- Used by approximately 10% of companies
- Helps avoid email address length issues
- Examples: [email protected], [email protected]
Department-Specific Formats:
- Some organizations use department prefixes or separate domains
- Sales teams might use [email protected]
- International offices might use different domain extensions
- Examples: [email protected], [email protected]
Pattern Detection Methodology
Multi-Employee Analysis:
def detect_email_pattern(company_domain, known_emails):
"""
Analyze known email addresses to determine company pattern
"""
patterns = {
'first.last': 0,
'firstlast': 0,
'first_last': 0,
'flast': 0,
'firstl': 0
}
for email in known_emails:
local_part = email.split('@')[0]
name_parts = extract_name_parts(email)
if '.' in local_part and len(name_parts) == 2:
if local_part == f"{name_parts[0]}.{name_parts[1]}":
patterns['first.last'] += 1
elif '_' in local_part and len(name_parts) == 2:
if local_part == f"{name_parts[0]}_{name_parts[1]}":
patterns['first_last'] += 1
elif local_part == f"{name_parts[0]}{name_parts[1]}":
patterns['firstlast'] += 1
elif local_part == f"{name_parts[0][0]}{name_parts[1]}":
patterns['flast'] += 1
elif local_part == f"{name_parts[0]}{name_parts[1][0]}":
patterns['firstl'] += 1
# Return most common pattern
return max(patterns, key=patterns.get)
Confidence Scoring System:
def calculate_pattern_confidence(company_domain, pattern, sample_size):
"""
Calculate confidence level for detected email pattern
"""
base_confidence = 0.6 # Base confidence for any pattern
# Increase confidence based on sample size
sample_multiplier = min(sample_size * 0.1, 0.3)
# Increase confidence for common patterns
pattern_weights = {
'first.last': 0.2,
'firstlast': 0.15,
'first_last': 0.1,
'flast': 0.05,
'firstl': 0.05
}
pattern_bonus = pattern_weights.get(pattern, 0)
# Company size and type adjustments
company_type_bonus = analyze_company_type_pattern(company_domain)
total_confidence = min(
base_confidence + sample_multiplier + pattern_bonus + company_type_bonus,
0.95 # Maximum confidence cap
)
return total_confidence
Advanced Pattern Prediction
Industry-Specific Patterns: Different industries tend to favor specific email formats based on organizational culture and IT policies.
Technology Companies:
- Often use [email protected] or [email protected]
- Frequently implement custom domains for different products
- May use nickname-based email addresses for informal cultures
- Example analysis: [email protected] for smaller startups
Financial Services:
- Typically use [email protected] for professional image
- Often implement strict naming conventions
- May include middle initials for executives
- Example: [email protected]
Healthcare Organizations:
- Mix of patterns depending on organization type
- Hospitals often use [email protected]
- Private practices may use more informal patterns
- Academic medical centers often use [email protected]
Manufacturing Companies:
- Often use traditional [email protected] patterns
- May include employee numbers or department codes
- International manufacturers might use country-specific patterns
- Example: [email protected]
Name Processing and Normalization
International Name Handling:
def normalize_name_for_email(first_name, last_name, company_culture='us'):
"""
Normalize names for email prediction considering cultural factors
"""
# Remove special characters and accents
first_clean = remove_accents(first_name.lower())
last_clean = remove_accents(last_name.lower())
# Handle hyphenated names
if '-' in last_clean:
if company_culture == 'us':
last_clean = last_clean.replace('-', '')
else:
last_clean = last_clean.replace('-', '.')
# Handle apostrophes and special characters
first_clean = first_clean.replace("'", "").replace(" ", "")
last_clean = last_clean.replace("'", "").replace(" ", "")
# Handle common name variations
nickname_mapping = {
'robert': 'bob',
'william': 'bill',
'richard': 'rick',
'michael': 'mike',
'elizabeth': 'liz',
'katherine': 'kate'
}
# Check if formal name has common nickname
if first_clean in nickname_mapping:
return [
(first_clean, last_clean), # Formal version
(nickname_mapping[first_clean], last_clean) # Nickname version
]
return [(first_clean, last_clean)]
Email Variation Generation:
def generate_email_variations(first_name, last_name, domain):
"""
Generate multiple email possibilities for testing
"""
normalized_names = normalize_name_for_email(first_name, last_name)
variations = []
for first, last in normalized_names:
# Standard patterns
variations.extend([
f"{first}.{last}@{domain}",
f"{first}{last}@{domain}",
f"{first}_{last}@{domain}",
f"{first[0]}.{last}@{domain}",
f"{first}.{last[0]}@{domain}",
f"{first[0]}{last}@{domain}",
f"{first}{last[0]}@{domain}"
])
# Department-specific variations
departments = ['sales', 'marketing', 'info', 'contact']
for dept in departments:
variations.extend([
f"{dept}.{first}.{last}@{domain}",
f"{first}.{last}.{dept}@{domain}"
])
# Remove duplicates while preserving order
return list(dict.fromkeys(variations))
Verification and Validation Strategies
Converting LinkedIn profiles to email addresses requires robust verification to ensure accuracy and protect sender reputation.
Technical Email Verification
SMTP Verification Process:
import smtplib
import socket
from email.utils import parseaddr
def smtp_verify_email(email_address):
"""
Verify email address using SMTP connection
"""
try:
# Parse email address
name, addr = parseaddr(email_address)
domain = addr.split('@')[1]
# Get MX record for domain
mx_records = get_mx_records(domain)
if not mx_records:
return {'valid': False, 'reason': 'No MX record found'}
# Connect to mail server
mx_host = mx_records[0][1]
server = smtplib.SMTP(timeout=10)
server.connect(mx_host)
server.helo()
# Test email address
code, message = server.rcpt(addr)
server.quit()
# Interpret response
if code == 250:
return {'valid': True, 'confidence': 0.9}
elif code in [451, 452]:
return {'valid': True, 'confidence': 0.6, 'reason': 'Temporary issue'}
else:
return {'valid': False, 'reason': f'SMTP error {code}'}
except Exception as e:
return {'valid': False, 'reason': f'Connection error: {str(e)}'}
def get_mx_records(domain):
"""
Get MX records for domain
"""
import dns.resolver
try:
mx_records = dns.resolver.resolve(domain, 'MX')
return [(record.preference, str(record.exchange)) for record in mx_records]
except:
return []
Multi-Layer Verification Strategy:
def comprehensive_email_verification(email_address):
"""
Multi-layer email verification combining multiple methods
"""
verification_results = {
'email': email_address,
'overall_confidence': 0,
'checks': {}
}
# Syntax validation
syntax_check = validate_email_syntax(email_address)
verification_results['checks']['syntax'] = syntax_check
# Domain validation
domain_check = validate_domain(email_address.split('@')[1])
verification_results['checks']['domain'] = domain_check
# SMTP verification
smtp_check = smtp_verify_email(email_address)
verification_results['checks']['smtp'] = smtp_check
# Disposable email detection
disposable_check = check_disposable_email(email_address)
verification_results['checks']['disposable'] = disposable_check
# Role-based email detection
role_check = check_role_based_email(email_address)
verification_results['checks']['role_based'] = role_check
# Calculate overall confidence
verification_results['overall_confidence'] = calculate_verification_confidence(
verification_results['checks']
)
return verification_results
def calculate_verification_confidence(checks):
"""
Calculate overall confidence based on verification checks
"""
confidence = 0
# Syntax check (required)
if not checks['syntax']['valid']:
return 0
# Domain check (high weight)
if checks['domain']['valid']:
confidence += 0.3
# SMTP check (highest weight)
if checks['smtp']['valid']:
confidence += 0.5 * checks['smtp']['confidence']
# Disposable email penalty
if checks['disposable']['is_disposable']:
confidence -= 0.2
# Role-based email penalty
if checks['role_based']['is_role_based']:
confidence -= 0.1
return max(0, min(1, confidence))
LinkedIn Profile Cross-Verification
Profile Consistency Checking:
def verify_email_profile_match(email_address, linkedin_profile):
"""
Verify email address matches LinkedIn profile information
"""
verification_score = 0
checks = {}
# Extract name from email
email_local = email_address.split('@')[0]
profile_first = linkedin_profile['first_name'].lower()
profile_last = linkedin_profile['last_name'].lower()
# Name matching checks
if profile_first in email_local:
verification_score += 0.3
checks['first_name_match'] = True
if profile_last in email_local:
verification_score += 0.3
checks['last_name_match'] = True
# Company domain verification
profile_company = linkedin_profile.get('company', '').lower()
email_domain = email_address.split('@')[1].lower()
if profile_company and profile_company.replace(' ', '') in email_domain:
verification_score += 0.4
checks['company_match'] = True
# Title/role consistency
profile_title = linkedin_profile.get('title', '').lower()
role_indicators = ['ceo', 'cto', 'vp', 'director', 'manager']
if any(role in profile_title for role in role_indicators):
if any(role in email_local for role in role_indicators):
verification_score += 0.2
checks['role_consistency'] = True
return {
'verification_score': min(1.0, verification_score),
'checks': checks,
'confidence_level': 'high' if verification_score > 0.8 else 'medium' if verification_score > 0.5 else 'low'
}
Activity-Based Verification:
def verify_through_linkedin_activity(email_address, linkedin_profile):
"""
Use LinkedIn activity patterns to verify email accuracy
"""
activity_signals = {
'recent_activity': False,
'professional_engagement': False,
'company_updates': False,
'industry_participation': False
}
# Check recent activity (posts, comments, reactions)
recent_activity = analyze_recent_linkedin_activity(linkedin_profile['url'])
if recent_activity['last_activity_days'] < 30:
activity_signals['recent_activity'] = True
# Check professional engagement patterns
engagement_quality = analyze_engagement_patterns(linkedin_profile['url'])
if engagement_quality['professional_score'] > 0.7:
activity_signals['professional_engagement'] = True
# Check company-related updates
company_updates = check_company_updates(linkedin_profile)
if company_updates['mentions_current_company']:
activity_signals['company_updates'] = True
# Industry participation indicators
industry_participation = analyze_industry_participation(linkedin_profile)
if industry_participation['active_participant']:
activity_signals['industry_participation'] = True
# Calculate confidence modifier
active_signals = sum(activity_signals.values())
confidence_modifier = active_signals * 0.1 # Each signal adds 10% confidence
return {
'activity_signals': activity_signals,
'confidence_modifier': confidence_modifier,
'recommendation': 'high_priority' if active_signals >= 3 else 'standard'
}
For comprehensive guidance on email verification strategies, see our detailed guide: Email Authentication Essentials: SPF, DKIM, and DMARC for API Users.
Advanced LinkedIn Research Techniques
Sophisticated LinkedIn research techniques can uncover email addresses and contact information that basic searches miss.
Content Mining Strategies
Post and Comment Analysis: LinkedIn users sometimes share contact information in posts, comments, or when promoting events and content.
def mine_linkedin_content_for_contacts(profile_url):
"""
Analyze LinkedIn posts and activity for contact information
"""
contact_signals = []
# Analyze recent posts
recent_posts = get_linkedin_posts(profile_url, limit=20)
for post in recent_posts:
# Check for email patterns in post content
email_matches = extract_emails_from_text(post['content'])
if email_matches:
contact_signals.extend([{
'type': 'email',
'value': email,
'source': 'post_content',
'confidence': 0.9,
'date': post['date']
} for email in email_matches])
# Check for website URLs that might lead to contact info
url_matches = extract_urls_from_text(post['content'])
for url in url_matches:
if is_personal_or_company_website(url):
contact_signals.append({
'type': 'website',
'value': url,
'source': 'post_link',
'confidence': 0.7,
'date': post['date']
})
# Analyze comments for additional contact sharing
comments = get_post_comments(post['id'])
for comment in comments:
comment_emails = extract_emails_from_text(comment['content'])
if comment_emails and comment['author'] == profile_url:
contact_signals.extend([{
'type': 'email',
'value': email,
'source': 'comment',
'confidence': 0.8,
'date': comment['date']
} for email in comment_emails])
return contact_signals
Event and Webinar Intelligence:
def analyze_linkedin_events_for_contacts(profile_url):
"""
Check LinkedIn events for contact information sharing
"""
contact_opportunities = []
# Find events where prospect is
