Real-Time LinkedIn Data API Fresh Profiles vs Stale Databases

1from linkdapi import LinkdAPI
2
3# Initialize the API
4api = LinkdAPI("your_api_key")
5
6# Get profile overview - this queries LinkedIn RIGHT NOW
7response = api.get_profile_overview("ryanroslansky")
8
9if response.get('success'):
10    data = response['data']
11    
12    # What you actually get:
13    print(f"Name: {data['fullName']}")
14    print(f"Current Title: {data['headline']}")
15    print(f"Current Company: {data['CurrentPositions'][0]['name']}")
16    print(f"Joined LinkedIn: {data['joined']}")  # Unix timestamp
17    
18    # This data was pulled from LinkedIn's servers 30 seconds ago
19    # It's as fresh as it gets

1Name: Ryan Roslansky
2Current Title: CEO at LinkedIn
3Current Company: LinkedIn
4Joined LinkedIn: 1086269234000

1import requests
2
3response = requests.get("https://staledatabase.com/api/profile", 
4                       params={"linkedin_url": "ryanroslansky"})
5
6data = response.json()
7
8# What you get:
9print(f"Name: {data['name']}")
10print(f"Current Title: {data['title']}")
11print(f"Current Company: {data['company']}")
12print(f"Last Updated: {data['last_refreshed']}")  # "2024-10-15"

1Name: Ryan Roslansky
2Current Title: Chief Product Officer  ← WRONG (promoted June 2020)
3Current Company: LinkedIn
4Last Updated: 2024-10-15  ← 3 months old

1You → LinkdAPI Server → LinkedIn's Live Endpoint → Fresh Data → You
2                  ↑ 
3          Happens NOW
4          Total time: < 1 second

1LinkedIn → Scraper (Jan) → Database Storage → Your Query (June)
2     ↑                           ↑
3   5 months ago          Reading old data

1from linkdapi import LinkdAPI
2from datetime import datetime
3
4api = LinkdAPI("your_api_key")
5
6def check_profile_freshness(username):
7    """
8    Check if someone's profile has changed recently
9    Returns their current info in real-time
10    """
11    response = api.get_profile_overview(username)
12    
13    if not response.get('success'):
14        return None
15    
16    data = response['data']
17    
18    # Real fields from the actual API response
19    profile = {
20        'name': data['fullName'],
21        'headline': data['headline'],
22        'current_company': data['CurrentPositions'][0]['name'] if data.get('CurrentPositions') else None,
23        'location': data['location']['fullLocation'] if data.get('location') else None,
24        'follower_count': data['followerCount'],
25        'connections': data['connectionsCount'],
26        'premium': data.get('premium', False),
27        'is_creator': data.get('creator', False)
28    }
29    
30    return profile
31
32# Test it
33profile = check_profile_freshness("ryanroslansky")
34print(profile)

1{
2    'name': 'Ryan Roslansky',
3    'headline': 'CEO at LinkedIn',
4    'current_company': 'LinkedIn',
5    'location': 'San Francisco Bay Area',
6    'follower_count': 887877,
7    'connections': 8624,
8    'premium': True,
9    'is_creator': True
10}

1from linkdapi import LinkdAPI
2
3api = LinkdAPI("your_api_key")
4
5def verify_employment(username, expected_company):
6    """
7    Verify if someone actually still works where your CRM says they do
8    """
9    response = api.get_profile_overview(username)
10    
11    if not response.get('success'):
12        return {"verified": False, "reason": "Profile not found"}
13    
14    data = response['data']
15    
16    # Check current positions (real API field)
17    current_positions = data.get('CurrentPositions', [])
18    
19    if not current_positions:
20        return {
21            "verified": False,
22            "reason": "No current position listed",
23            "actual_headline": data['headline']
24        }
25    
26    # Get the actual current company
27    actual_company = current_positions[0]['name']
28    
29    # Compare
30    if expected_company.lower() in actual_company.lower():
31        return {
32            "verified": True,
33            "status": "Confirmed employed",
34            "company": actual_company,
35            "title_from_headline": data['headline']
36        }
37    else:
38        return {
39            "verified": False,
40            "status": "Company changed",
41            "expected": expected_company,
42            "actual": actual_company,
43            "headline": data['headline']
44        }
45
46# Test it
47result = verify_employment("ryanroslansky", "LinkedIn")
48print(result)

1{
2    'verified': True,
3    'status': 'Confirmed employed',
4    'company': 'LinkedIn',
5    'title_from_headline': 'CEO at LinkedIn'
6}

1result = verify_employment("someone-who-left", "OldCompany")

1{
2    'verified': False,
3    'status': 'Company changed',
4    'expected': 'OldCompany',
5    'actual': 'NewCompany',
6    'headline': 'VP of Engineering at NewCompany'
7}

1import json
2import time
3from linkdapi import LinkdAPI
4from datetime import datetime
5
6api = LinkdAPI("your_api_key")
7
8class ProfileMonitor:
9    def __init__(self):
10        self.tracked_profiles = {}
11    
12    def snapshot_profile(self, username):
13        """Take a real-time snapshot of a profile"""
14        response = api.get_profile_overview(username)
15        
16        if not response.get('success'):
17            return None
18        
19        data = response['data']
20        
21        return {
22            'snapshot_time': datetime.now().isoformat(),
23            'fullName': data['fullName'],
24            'headline': data['headline'],
25            'currentCompany': data['CurrentPositions'][0]['name'] if data.get('CurrentPositions') else None,
26            'location': data['location']['fullLocation'] if data.get('location') else None,
27            'followerCount': data['followerCount'],
28            'premium': data.get('premium', False)
29        }
30    
31    def detect_changes(self, username):
32        """
33        Compare current profile against last snapshot
34        Returns what changed
35        """
36        # Get current snapshot
37        current = self.snapshot_profile(username)
38        
39        if not current:
40            return None
41        
42        # Get previous snapshot
43        previous = self.tracked_profiles.get(username)
44        
45        if not previous:
46            # First time tracking this profile
47            self.tracked_profiles[username] = current
48            return {"status": "first_snapshot", "data": current}
49        
50        # Detect changes
51        changes = {}
52        
53        for key in ['headline', 'currentCompany', 'location', 'followerCount']:
54            if current.get(key) != previous.get(key):
55                changes[key] = {
56                    'old': previous.get(key),
57                    'new': current.get(key)
58                }
59        
60        # Update stored snapshot
61        self.tracked_profiles[username] = current
62        
63        return {
64            "status": "changes_detected" if changes else "no_changes",
65            "changes": changes,
66            "timestamp": current['snapshot_time']
67        }
68
69# Usage
70monitor = ProfileMonitor()
71
72# First check
73result1 = monitor.detect_changes("ryanroslansky")
74print("First snapshot:", result1['status'])
75
76# Wait (in real usage, you'd check daily/weekly)
77time.sleep(2)
78
79# Second check (same person, probably no changes)
80result2 = monitor.detect_changes("ryanroslansky")
81print("Second check:", result2)

1{
2    'status': 'changes_detected',
3    'changes': {
4        'headline': {
5            'old': 'VP of Sales at Google',
6            'new': 'Head of Revenue at Stripe'
7        },
8        'currentCompany': {
9            'old': 'Google',
10            'new': 'Stripe'
11        }
12    },
13    'timestamp': '2025-01-29T10:30:00'
14}

1# Database API call (hypothetical)
2prospects = database_api.search(
3    title="VP of Sales",
4    industry="Technology",
5    location="San Francisco"
6)
7
8# You get 100 results
9# But 20 of them have already moved to new companies
10# 10 more have been promoted to C-level
11# You don't know which ones are stale

1from linkdapi import LinkdAPI
2
3api = LinkdAPI("your_api_key")
4
5def find_fresh_prospects(keyword, location=None, current_company=None):
6    """
7    Search for prospects and verify they're still in that role
8    Uses real-time data so results are always fresh
9    """
10    # Search for people (real LinkdAPI endpoint)
11    response = api.search_people(
12        keyword=keyword,  # "VP of Sales" or "Chief Revenue Officer"
13        geo_urn=location,  # Geographic URN for location
14        current_company=current_company
15    )
16    
17    if not response.get('success'):
18        return []
19    
20    prospects = response['data']
21    fresh_prospects = []
22    
23    for prospect in prospects:
24        # Get detailed profile in real-time
25        username = prospect.get('publicIdentifier')
26        if not username:
27            continue
28        
29        profile = api.get_profile_overview(username)
30        
31        if not profile.get('success'):
32            continue
33        
34        data = profile['data']
35        
36        # Verify they're CURRENTLY in this role
37        current_positions = data.get('CurrentPositions', [])
38        
39        if current_positions:
40            fresh_prospects.append({
41                'name': data['fullName'],
42                'headline': data['headline'],
43                'company': current_positions[0]['name'],
44                'location': data['location']['fullLocation'] if data.get('location') else None,
45                'profile_url': f"https://linkedin.com/in/{username}",
46                'username': username,
47                'premium': data.get('premium', False),
48                'follower_count': data['followerCount'],
49                'verified_current': True  # We just verified this in real-time!
50            })
51    
52    return fresh_prospects
53
54# Use it
55prospects = find_fresh_prospects(
56    keyword="VP of Sales",
57    location="103644278"  # San Francisco Bay Area URN
58)
59
60print(f"Found {len(prospects)} verified current prospects")
61for p in prospects[:5]:  # First 5
62    print(f"\n{p['name']}")
63    print(f"  {p['headline']}")
64    print(f"  Company: {p['company']}")
65    print(f"  Location: {p['location']}")
66    print(f"  Verified: ✓ Current as of today")

1from linkdapi import LinkdAPI
2import csv
3from datetime import datetime
4
5api = LinkdAPI("your_api_key")
6
7def extract_linkedin_username(linkedin_url):
8    """
9    Extract username from LinkedIn URL
10    https://linkedin.com/in/ryanroslansky -> ryanroslansky
11    """
12    if '/in/' in linkedin_url:
13        username = linkedin_url.split('/in/')[1].split('/')[0].split('?')[0]
14        return username
15    return None
16
17def enrich_contact_realtime(linkedin_url):
18    """
19    Take a LinkedIn URL and return fresh profile data
20    """
21    username = extract_linkedin_username(linkedin_url)
22    
23    if not username:
24        return None
25    
26    # Get real-time profile data
27    response = api.get_profile_overview(username)
28    
29    if not response.get('success'):
30        return None
31    
32    data = response['data']
33    
34    # Build enriched record using actual API fields
35    enriched = {
36        'linkedin_url': linkedin_url,
37        'full_name': data['fullName'],
38        'first_name': data['firstName'],
39        'last_name': data['lastName'],
40        'headline': data['headline'],
41        'current_company': data['CurrentPositions'][0]['name'] if data.get('CurrentPositions') else None,
42        'location': data['location']['fullLocation'] if data.get('location') else None,
43        'country': data['location']['countryName'] if data.get('location') else None,
44        'follower_count': data['followerCount'],
45        'connections_count': data['connectionsCount'],
46        'premium': data.get('premium', False),
47        'creator': data.get('creator', False),
48        'profile_picture': data.get('profilePictureURL'),
49        'enriched_at': datetime.now().isoformat(),
50        'data_freshness': '< 24 hours'  # Real-time!
51    }
52    
53    return enriched
54
55# Process a CSV of contacts
56def enrich_crm_export(input_csv, output_csv):
57    """
58    Read a CSV of contacts with LinkedIn URLs
59    Enrich each one with real-time data
60    """
61    enriched_contacts = []
62    
63    with open(input_csv, 'r') as f:
64        reader = csv.DictReader(f)
65        contacts = list(reader)
66    
67    print(f"Enriching {len(contacts)} contacts...")
68    
69    for i, contact in enumerate(contacts, 1):
70        linkedin_url = contact.get('linkedin_url')
71        
72        if not linkedin_url:
73            continue
74        
75        # Enrich with real-time data
76        enriched = enrich_contact_realtime(linkedin_url)
77        
78        if enriched:
79            # Merge with original data
80            enriched.update({
81                'crm_id': contact.get('id'),
82                'email': contact.get('email')
83            })
84            enriched_contacts.append(enriched)
85            print(f"✓ Enriched {i}/{len(contacts)}: {enriched['full_name']}")
86        else:
87            print(f"✗ Failed {i}/{len(contacts)}: {linkedin_url}")
88    
89    # Write enriched data
90    if enriched_contacts:
91        with open(output_csv, 'w', newline='') as f:
92            writer = csv.DictWriter(f, fieldnames=enriched_contacts[0].keys())
93            writer.writeheader()
94            writer.writerows(enriched_contacts)
95        
96        print(f"\n✓ Enriched {len(enriched_contacts)} contacts")
97        print(f"✓ Saved to {output_csv}")
98    
99    return enriched_contacts
100
101# Run it
102contacts = enrich_crm_export('crm_export.csv', 'enriched_contacts.csv')

1linkedin_url,full_name,headline,current_company,location,follower_count,enriched_at,data_freshness
2https://linkedin.com/in/ryanroslansky,Ryan Roslansky,"CEO at LinkedIn",LinkedIn,"San Francisco Bay Area",887877,2025-01-29T10:30:00,< 24 hours
3https://linkedin.com/in/satyanadella,Satya Nadella,"Chairman and CEO at Microsoft",Microsoft,"Redmond, WA",19186432,2025-01-29T10:30:15,< 24 hours

1from linkdapi import LinkdAPI
2import json
3import time
4from datetime import datetime
5
6api = LinkdAPI("your_api_key")
7
8class JobChangeMonitor:
9    def __init__(self, storage_file='profile_snapshots.json'):
10        self.storage_file = storage_file
11        self.snapshots = self.load_snapshots()
12    
13    def load_snapshots(self):
14        """Load previously saved snapshots"""
15        try:
16            with open(self.storage_file, 'r') as f:
17                return json.load(f)
18        except FileNotFoundError:
19            return {}
20    
21    def save_snapshots(self):
22        """Save snapshots to disk"""
23        with open(self.storage_file, 'w') as f:
24            json.dump(self.snapshots, f, indent=2)
25    
26    def get_current_job(self, username):
27        """Get someone's current job in real-time"""
28        response = api.get_profile_overview(username)
29        
30        if not response.get('success'):
31            return None
32        
33        data = response['data']
34        current_positions = data.get('CurrentPositions', [])
35        
36        if not current_positions:
37            # Extract from headline as fallback
38            return {
39                'title': data['headline'],
40                'company': 'Unknown',
41                'from_headline': True
42            }
43        
44        return {
45            'title': data['headline'],
46            'company': current_positions[0]['name'],
47            'company_logo': current_positions[0].get('logoURL'),
48            'from_headline': False
49        }
50    
51    def check_for_job_change(self, username, name=None):
52        """
53        Check if someone changed jobs since last check
54        Returns job change details if changed, None if same
55        """
56        current_job = self.get_current_job(username)
57        
58        if not current_job:
59            return {"error": "Could not fetch profile"}
60        
61        # Check if we have a previous snapshot
62        previous = self.snapshots.get(username)
63        
64        if not previous:
65            # First time checking this person
66            self.snapshots[username] = {
67                'name': name or username,
68                'last_job': current_job,
69                'checked_at': datetime.now().isoformat()
70            }
71            self.save_snapshots()
72            return {"status": "first_check", "current_job": current_job}
73        
74        # Compare jobs
75        previous_job = previous['last_job']
76        
77        # Check if company changed
78        company_changed = previous_job['company'] != current_job['company']
79        
80        # Check if title changed (even at same company)
81        title_changed = previous_job['title'] != current_job['title']
82        
83        if company_changed or title_changed:
84            change = {
85                'status': 'job_change_detected',
86                'person': name or username,
87                'username': username,
88                'previous': previous_job,
89                'current': current_job,
90                'detected_at': datetime.now().isoformat()
91            }
92            
93            # Update snapshot
94            self.snapshots[username] = {
95                'name': name or username,
96                'last_job': current_job,
97                'checked_at': datetime.now().isoformat()
98            }
99            self.save_snapshots()
100            
101            return change
102        
103        # No change
104        return {"status": "no_change", "current_job": current_job}
105
106# Usage
107monitor = JobChangeMonitor()
108
109# Add key contacts to monitor
110key_contacts = [
111    ("ryanroslansky", "Ryan Roslansky"),
112    ("satyanadella", "Satya Nadella"),
113    ("jeffweiner08", "Jeff Weiner")
114]
115
116print("Checking for job changes...\n")
117
118for username, name in key_contacts:
119    result = monitor.check_for_job_change(username, name)
120    
121    if result['status'] == 'job_change_detected':
122        print(f"🚨 JOB CHANGE ALERT: {result['person']}")
123        print(f"   Previous: {result['previous']['title']} at {result['previous']['company']}")
124        print(f"   Current:  {result['current']['title']} at {result['current']['company']}")
125        print(f"   Detected: {result['detected_at']}\n")
126    elif result['status'] == 'first_check':
127        print(f"✓ Now monitoring: {name}")
128        print(f"  Current job: {result['current_job']['title']} at {result['current_job']['company']}\n")
129    else:
130        print(f"✓ No change: {name} still at {result['current_job']['company']}\n")

1import requests
2
3def send_slack_alert(webhook_url, job_change):
4    """Send job change alert to Slack"""
5    message = {
6        "text": f"🚨 Job Change Alert: {job_change['person']}",
7        "blocks": [
8            {
9                "type": "header",
10                "text": {
11                    "type": "plain_text",
12                    "text": f"🚨 {job_change['person']} Changed Jobs"
13                }
14            },
15            {
16                "type": "section",
17                "fields": [
18                    {
19                        "type": "mrkdwn",
20                        "text": f"*Previous:*\n{job_change['previous']['title']} at {job_change['previous']['company']}"
21                    },
22                    {
23                        "type": "mrkdwn",
24                        "text": f"*Current:*\n{job_change['current']['title']} at {job_change['current']['company']}"
25                    }
26                ]
27            },
28            {
29                "type": "section",
30                "text": {
31                    "type": "mrkdwn",
32                    "text": f"<https://linkedin.com/in/{job_change['username']}|View Profile on LinkedIn>"
33                }
34            }
35        ]
36    }
37    
38    requests.post(webhook_url, json=message)
39
40# Use it
41for username, name in key_contacts:
42    result = monitor.check_for_job_change(username, name)
43    
44    if result['status'] == 'job_change_detected':
45        send_slack_alert("YOUR_SLACK_WEBHOOK_URL", result)

1Cost: $30,000/year (mid-tier ZoomInfo)
2Stale rate: 20%
3Wasted contacts: 12,000 × 20% = 2,400
4Time per outreach: 15 minutes
5Wasted time: 2,400 × 15 min = 600 hours
6Cost of wasted time: 600 hours × $50/hour = $30,000
7
8Total cost: $30,000 (database) + $30,000 (wasted time) = $60,000

1Cost: $5,000/year (LinkdAPI + lookups)
2Stale rate: 0%
3Wasted contacts: 0
4Wasted time: 0
5Cost of wasted time: $0
6
7Total cost: $5,000

1import asyncio
2from linkdapi import AsyncLinkdAPI
3
4async def enrich_profiles_bulk(usernames):
5    """
6    Enrich multiple profiles concurrently
7    Process 100 profiles in ~30 seconds instead of 5+ minutes
8    """
9    async with AsyncLinkdAPI("your_api_key") as api:
10        # Create tasks for all profiles
11        tasks = [
12            api.get_profile_overview(username)
13            for username in usernames
14        ]
15        
16        # Execute all concurrently
17        results = await asyncio.gather(*tasks, return_exceptions=True)
18        
19        enriched = []
20        for username, result in zip(usernames, results):
21            if isinstance(result, dict) and result.get('success'):
22                data = result['data']
23                enriched.append({
24                    'username': username,
25                    'name': data['fullName'],
26                    'headline': data['headline'],
27                    'company': data['CurrentPositions'][0]['name'] if data.get('CurrentPositions') else None,
28                    'location': data['location']['fullLocation'] if data.get('location') else None
29                })
30        
31        return enriched
32
33# Process 100 profiles
34usernames = ["user1", "user2", "user3", ...]  # 100 usernames
35
36results = asyncio.run(enrich_profiles_bulk(usernames))
37
38print(f"Enriched {len(results)} profiles in real-time")

1from linkdapi import LinkdAPI
2import json
3from datetime import datetime, timedelta
4
5class CachedProfileFetcher:
6    def __init__(self, cache_duration_hours=24):
7        self.api = LinkdAPI("your_api_key")
8        self.cache = {}
9        self.cache_duration = timedelta(hours=cache_duration_hours)
10    
11    def get_profile(self, username, force_refresh=False):
12        """
13        Get profile with smart caching
14        Default: cache for 24 hours
15        """
16        # Check cache
17        if username in self.cache and not force_refresh:
18            cached_data, cached_at = self.cache[username]
19            
20            # Is cache still fresh?
21            if datetime.now() - cached_at < self.cache_duration:
22                return cached_data
23        
24        # Cache miss or expired - fetch fresh
25        response = self.api.get_profile_overview(username)
26        
27        if response.get('success'):
28            self.cache[username] = (response, datetime.now())
29            return response
30        
31        return None
32
33# Use it
34fetcher = CachedProfileFetcher(cache_duration_hours=24)
35
36# First call: hits API (fresh data)
37profile1 = fetcher.get_profile("ryanroslansky")
38
39# Second call within 24 hours: hits cache (still fresh enough)
40profile2 = fetcher.get_profile("ryanroslansky")
41
42# Force refresh if you need absolute latest:
43profile3 = fetcher.get_profile("ryanroslansky", force_refresh=True)

1# Python
2pip install linkdapi

1from linkdapi import LinkdAPI
2
3api = LinkdAPI("your_api_key")
4
5# Get a profile in real-time
6response = api.get_profile_overview("ryanroslansky")
7
8if response.get('success'):
9    data = response['data']
10    print(f"Name: {data['fullName']}")
11    print(f"Title: {data['headline']}")
12    print(f"Company: {data['CurrentPositions'][0]['name'] if data.get('CurrentPositions') else 'N/A'}")

1from linkdapi import LinkdAPI
2from datetime import datetime
3
4api = LinkdAPI("your_api_key")
5
6class TeamVerifier:
7    def __init__(self):
8        self.api = LinkdAPI("your_api_key")
9    
10    def verify_person(self, linkedin_url, claimed_info):
11        """
12        Verify someone's claimed experience against their LinkedIn profile
13        Returns verification report with discrepancies flagged
14        """
15        username = self.extract_username(linkedin_url)
16        
17        # Get real-time profile overview
18        overview_response = self.api.get_profile_overview(username)
19        
20        if not overview_response.get('success'):
21            return {"error": "Could not fetch profile"}
22        
23        overview_data = overview_response['data']
24        
25        # Get full experience history
26        urn = overview_data['urn']
27        experience_response = self.api.get_full_experience(urn)
28        
29        if not experience_response.get('success'):
30            return {"error": "Could not fetch experience"}
31        
32        experience_data = experience_response['data']
33        
34        # Verify current title
35        current_title_verified = self.verify_current_title(
36            overview_data, 
37            claimed_info.get('current_title')
38        )
39        
40        # Verify past experience
41        past_experience_verified = self.verify_past_company(
42            experience_data['experience'],
43            claimed_info.get('past_company'),
44            claimed_info.get('past_title')
45        )
46        
47        # Calculate total experience years
48        total_years = self.calculate_total_experience(experience_data['experience'])
49        
50        # Build verification report
51        report = {
52            'person': overview_data['fullName'],
53            'linkedin_url': linkedin_url,
54            'verified_at': datetime.now().isoformat(),
55            'current_title': {
56                'claimed': claimed_info.get('current_title'),
57                'actual': overview_data['headline'],
58                'verified': current_title_verified,
59                'company': overview_data['CurrentPositions'][0]['name'] if overview_data.get('CurrentPositions') else None
60            },
61            'past_experience': past_experience_verified,
62            'total_years_experience': total_years,
63            'claimed_years': claimed_info.get('years_experience'),
64            'years_verified': abs(total_years - claimed_info.get('years_experience', 0)) <= 1,
65            'premium_account': overview_data.get('premium', False),
66            'follower_count': overview_data['followerCount'],
67            'connections': overview_data['connectionsCount']
68        }
69        
70        return report
71    
72    def verify_current_title(self, profile_data, claimed_title):
73        """Check if current title matches claim"""
74        if not claimed_title:
75            return None
76        
77        actual_headline = profile_data['headline'].lower()
78        claimed_lower = claimed_title.lower()
79        
80        # Fuzzy match (allows for variations)
81        if claimed_lower in actual_headline or actual_headline in claimed_lower:
82            return True
83        
84        # Check for key title words
85        key_words = ['vp', 'vice president', 'director', 'head', 'chief', 'ceo', 'cto', 'cfo']
86        claimed_keywords = [word for word in key_words if word in claimed_lower]
87        actual_keywords = [word for word in key_words if word in actual_headline]
88        
89        if claimed_keywords and actual_keywords:
90            return set(claimed_keywords).intersection(set(actual_keywords))
91        
92        return False
93    
94    def verify_past_company(self, experience, claimed_company, claimed_title=None):
95        """Verify someone worked at a specific company"""
96        if not claimed_company:
97            return None
98        
99        claimed_lower = claimed_company.lower()
100        
101        for exp in experience:
102            company_name = exp['companyName'].lower()
103            
104            if claimed_lower in company_name or company_name in claimed_lower:
105                # Found the company
106                verification = {
107                    'company': exp['companyName'],
108                    'verified': True,
109                    'duration': exp.get('totalDuration') or exp.get('duration'),
110                    'positions': []
111                }
112                
113                # Check positions at that company
114                if exp.get('positions'):
115                    for pos in exp['positions']:
116                        verification['positions'].append({
117                            'title': pos['title'],
118                            'duration': pos['duration']
119                        })
120                        
121                        # If title was claimed, verify it
122                        if claimed_title and claimed_title.lower() in pos['title'].lower():
123                            verification['title_verified'] = True
124                
125                return verification
126        
127        return {'company': claimed_company, 'verified': False}
128    
129    def calculate_total_experience(self, experience):
130        """Calculate total years of experience from all positions"""
131        total_months = 0
132        
133        for exp in experience:
134            duration_str = exp.get('totalDuration') or exp.get('duration') or ''
135            
136            # Parse duration like "10 yrs 3 mos"
137            years = 0
138            months = 0
139            
140            if 'yr' in duration_str:
141                years_part = duration_str.split('yr')[0].strip().split()[-1]
142                try:
143                    years = int(years_part)
144                except:
145                    pass
146            
147            if 'mo' in duration_str:
148                months_part = duration_str.split('mo')[0].strip().split()[-1]
149                try:
150                    months = int(months_part)
151                except:
152                    pass
153            
154            total_months += (years * 12) + months
155        
156        return round(total_months / 12, 1)
157    
158    def extract_username(self, linkedin_url):
159        """Extract username from LinkedIn URL"""
160        if '/in/' in linkedin_url:
161            return linkedin_url.split('/in/')[1].split('/')[0].split('?')[0]
162        return None
163    
164    def verify_team(self, team_list):
165        """
166        Verify an entire team
167        team_list: [{'name': 'John Doe', 'linkedin': 'url', 'claimed': {...}}, ...]
168        """
169        reports = []
170        
171        for member in team_list:
172            print(f"Verifying {member['name']}...")
173            
174            report = self.verify_person(
175                member['linkedin'],
176                member['claimed']
177            )
178            
179            reports.append(report)
180        
181        return reports
182
183# Usage: Verify a startup's executive team
184verifier = TeamVerifier()
185
186team = [
187    {
188        'name': 'Jane Smith',
189        'linkedin': 'https://linkedin.com/in/janesmith',
190        'claimed': {
191            'current_title': 'CEO & Founder',
192            'past_company': 'Google',
193            'past_title': 'VP of Engineering',
194            'years_experience': 10
195        }
196    },
197    {
198        'name': 'Bob Johnson',
199        'linkedin': 'https://linkedin.com/in/bobjohnson',
200        'claimed': {
201            'current_title': 'CTO',
202            'past_company': 'AWS',
203            'past_title': 'Principal Engineer',
204            'years_experience': 12
205        }
206    }
207]
208
209reports = verifier.verify_team(team)
210
211# Print verification results
212for report in reports:
213    if report.get('error'):
214        print(f"\n❌ {report['error']}")
215        continue
216    
217    print(f"\n{'='*60}")
218    print(f"Person: {report['person']}")
219    print(f"LinkedIn: {report['linkedin_url']}")
220    print(f"\nCurrent Title:")
221    print(f"  Claimed: {report['current_title']['claimed']}")
222    print(f"  Actual: {report['current_title']['actual']}")
223    print(f"  Verified: {'✓' if report['current_title']['verified'] else '✗'}")
224    
225    if report['past_experience']:
226        print(f"\nPast Experience:")
227        print(f"  Company: {report['past_experience']['company']}")
228        print(f"  Verified: {'✓' if report['past_experience']['verified'] else '✗'}")
229        if report['past_experience'].get('positions'):
230            print(f"  Positions held:")
231            for pos in report['past_experience']['positions']:
232                print(f"    - {pos['title']} ({pos['duration']})")
233    
234    print(f"\nTotal Experience:")
235    print(f"  Claimed: {report['claimed_years']} years")
236    print(f"  Actual: {report['total_years_experience']} years")
237    print(f"  Verified: {'✓' if report['years_verified'] else '✗'}")