Migrate from Proxycurl to LinkdAPI

1# Remove Proxycurl (if you used their SDK)
2pip uninstall proxycurl
3
4# Install LinkdAPI
5pip install linkdapi

1from proxycurl import Proxycurl
2
3proxycurl = Proxycurl(api_key='YOUR_PROXYCURL_KEY')
4person = proxycurl.linkedin.person.get(url='https://www.linkedin.com/in/ryanroslansky')

1from linkdapi import AsyncLinkdAPI
2import asyncio
3
4async def get_profile():
5    client = AsyncLinkdAPI("YOUR_LINKDAPI_KEY")
6    profile = await client.get_full_profile("ryanroslansky")
7    return profile
8
9# Run it
10profile = asyncio.run(get_profile())

1# Test with a known profile
2profile = asyncio.run(get_profile())
3
4print(f"Name: {profile['firstName']} {profile['lastName']}")
5print(f"Headline: {profile['headline']}")
6print(f"Company: {profile['position'][0]['companyName']}")
7
8# If this works, you're good to go

1from proxycurl import Proxycurl
2
3proxycurl = Proxycurl(api_key='YOUR_KEY')
4
5# Get basic profile
6person = proxycurl.linkedin.person.get(
7    url='https://www.linkedin.com/in/ryanroslansky'
8)
9
10print(person['first_name'])
11print(person['headline'])

1from linkdapi import LinkdAPI
2
3client = LinkdAPI("YOUR_KEY")
4
5# Get FULL profile in one call
6profile = client.get_full_profile("ryanroslansky")
7
8print(profile['firstName'])
9print(profile['headline'])

1from linkdapi import AsyncLinkdAPI
2import asyncio
3
4async def get_profile():
5    client = AsyncLinkdAPI("YOUR_KEY")
6    
7    # Get FULL profile in one call
8    profile = await client.get_full_profile("ryanroslansky")
9    
10    return profile
11
12# Run it
13profile = asyncio.run(get_profile())
14
15print(profile['firstName'])
16print(profile['headline'])

1from proxycurl import Proxycurl
2import time
3
4proxycurl = Proxycurl(api_key='YOUR_KEY')
5
6usernames = ["ryanroslansky", "williamhgates", "jeffweiner08"]  # 100 usernames
7profiles = []
8
9for username in usernames:
10    url = f"https://www.linkedin.com/in/{username}"
11    profile = proxycurl.linkedin.person.get(url=url)
12    profiles.append(profile)
13    time.sleep(1)  # Rate limiting
14    
15# Takes: 100 seconds for 100 profiles

1from linkdapi import AsyncLinkdAPI
2import asyncio
3
4async def enrich_bulk(usernames):
5    client = AsyncLinkdAPI("YOUR_KEY")
6    
7    # Process ALL concurrently
8    tasks = [client.get_full_profile(username) for username in usernames]
9    profiles = await asyncio.gather(*tasks)
10    
11    return profiles
12
13# Run it
14usernames = ["ryanroslansky", "williamhgates", "jeffweiner08"]  # 100 usernames
15profiles = asyncio.run(enrich_bulk(usernames))
16
17# Takes: 0.5 seconds for 100 profiles (200x faster!)

1from proxycurl import Proxycurl
2
3proxycurl = Proxycurl(api_key='YOUR_KEY')
4
5# Call 1: Get profile
6person = proxycurl.linkedin.person.get(
7    url='https://www.linkedin.com/in/ryanroslansky'
8)
9
10# Call 2: Get contact info (separate endpoint!)
11contact = proxycurl.linkedin.person.contact.get(
12    url='https://www.linkedin.com/in/ryanroslansky'
13)
14
15# Combine manually
16result = {**person, **contact}

1from linkdapi import AsyncLinkdAPI
2import asyncio
3
4async def get_profile_with_contact():
5    client = AsyncLinkdAPI("YOUR_KEY")
6    
7    # ONE call gets everything
8    profile = await client.get_full_profile("ryanroslansky")
9    
10    # All data already included:
11    # - Basic info
12    # - Experience
13    # - Education
14    # - Skills
15    # - Contact info (if available)
16    
17    return profile
18
19profile = asyncio.run(get_profile_with_contact())

1from proxycurl import Proxycurl
2
3proxycurl = Proxycurl(api_key='YOUR_KEY')
4
5company = proxycurl.linkedin.company.get(
6    url='https://www.linkedin.com/company/linkedin'
7)
8
9print(company['name'])
10print(company['follower_count'])

1from linkdapi import AsyncLinkdAPI
2import asyncio
3
4async def get_company():
5    client = AsyncLinkdAPI("YOUR_KEY")
6    
7    # Use company_name (vanity name) not full URL
8    company = await client.get_company_info(name="linkedin")
9    
10    return company
11
12company = asyncio.run(get_company())
13
14print(company['name'])
15print(company['followerCount'])

1from proxycurl import Proxycurl
2
3proxycurl = Proxycurl(api_key='YOUR_KEY')
4
5posts = proxycurl.linkedin.profile.posts(
6    url='https://www.linkedin.com/in/ryanroslansky'
7)
8
9for post in posts['results']:
10    print(post['text'])

1from linkdapi import AsyncLinkdAPI
2import asyncio
3
4async def get_posts():
5    client = AsyncLinkdAPI("YOUR_KEY")
6    
7    # First get the profile URN
8    profile = await client.get_profile_overview("ryanroslansky")
9    urn = profile['urn']
10    
11    # Then get all posts using the URN
12    posts = await client.get_all_posts(urn)
13    
14    return posts
15
16posts = asyncio.run(get_posts())
17
18for post in posts:
19    print(post.get('text', ''))

1{
2  "first_name": "Ryan",
3  "last_name": "Roslansky",
4  "headline": "CEO at LinkedIn",
5  "experiences": [...]
6}

1{
2  "success": true,
3  "statusCode": 200,
4  "message": "Data retrieved successfully",
5  "errors": null,
6  "data": {
7    "firstName": "Ryan",
8    "lastName": "Roslansky",
9    "headline": "CEO at LinkedIn",
10    "position": [...]
11  }
12}

1# SDK automatically extracts data
2profile = await client.get_full_profile("ryanroslansky")
3# profile is already the data object, not wrapped

1def convert_proxycurl_to_linkdapi_format(proxycurl_profile):
2    """
3    Convert Proxycurl response format to LinkdAPI format
4    Useful during migration for backward compatibility
5    """
6    return {
7        'firstName': proxycurl_profile.get('first_name'),
8        'lastName': proxycurl_profile.get('last_name'),
9        'headline': proxycurl_profile.get('headline'),
10        'summary': proxycurl_profile.get('summary'),
11        'profilePicture': proxycurl_profile.get('profile_pic_url'),
12        'position': proxycurl_profile.get('experiences', []),
13        'educations': proxycurl_profile.get('education', []),
14        'skills': proxycurl_profile.get('skills', []),
15        # Add more fields as needed
16    }

1class LinkdAPIProxycurlAdapter:
2    """
3    Adapter to make LinkdAPI responses look like Proxycurl
4    Use this for gradual migration
5    """
6    def __init__(self, linkdapi_key):
7        self.client = AsyncLinkdAPI(linkdapi_key)
8    
9    async def get_person(self, url):
10        # Extract username from URL
11        username = url.split('/')[-1] if '/' in url else url
12        
13        # Get profile from LinkdAPI
14        profile = await self.client.get_full_profile(username)
15        
16        # Convert to Proxycurl format
17        return {
18            'first_name': profile.get('firstName'),
19            'last_name': profile.get('lastName'),
20            'headline': profile.get('headline'),
21            'summary': profile.get('summary'),
22            'profile_pic_url': profile.get('profilePicture'),
23            'experiences': profile.get('position', []),
24            'education': profile.get('educations', []),
25            'skills': profile.get('skills', []),
26            # Add more fields as needed
27        }
28
29# Usage
30adapter = LinkdAPIProxycurlAdapter("YOUR_KEY")
31person = await adapter.get_person("https://www.linkedin.com/in/ryanroslansky")
32# Returns Proxycurl-like format

1# Step 1: Create adapter
2class ProxycurlCompatAdapter:
3    """Drop-in replacement for Proxycurl that uses LinkdAPI"""
4    
5    def __init__(self, api_key):
6        self.client = AsyncLinkdAPI(api_key)
7    
8    async def get_person(self, url):
9        username = url.split('/')[-1]
10        profile = await self.client.get_full_profile(username)
11        
12        # Convert to Proxycurl format
13        return self._convert_to_proxycurl_format(profile)
14    
15    def _convert_to_proxycurl_format(self, linkdapi_profile):
16        return {
17            'first_name': linkdapi_profile.get('firstName'),
18            'last_name': linkdapi_profile.get('lastName'),
19            # ... rest of conversion
20        }
21
22# Step 2: Replace Proxycurl client
23# OLD: client = Proxycurl(api_key='...')
24# NEW: client = ProxycurlCompatAdapter(api_key='...')
25
26# Step 3: Your code works without changes!
27person = await client.get_person('https://www.linkedin.com/in/ryanroslansky')