LinkdAPI Python - The best API for professional Data

🔑 Get Your API Key (100 free credits) • 📖 Full Documentation • 💬 Support

⚡ Now with Async Support! • 🚀 Up to 40x Faster • 🎯 Production Ready

📑 Table of Contents

Why LinkdAPI?

Why LinkdAPI Beats Alternatives

📦 Installation

pip install linkdapi

✨ Key Features

🚀 Quick Start

Synchronous Usage

from linkdapi import LinkdAPI
# Initialize the client
client = LinkdAPI("your_api_key")
# Get profile overview
profile = client.get_profile_overview("ryanroslansky")
print(f"Profile: {profile['data']['fullName']}")
# Get company information
company = client.get_company_info(name="google")
print(f"Company: {company['data']['name']}")

Async Usage

import asyncio
from linkdapi import AsyncLinkdAPI
async def main():
 # Use async context manager (recommended)
 async with AsyncLinkdAPI("your_api_key") as api:
 # Single request
 profile = await api.get_profile_overview("ryanroslansky")
 print(f"Profile: {profile['data']['fullName']}")
 # Fetch multiple profiles concurrently
 profiles = await asyncio.gather(
 api.get_profile_overview("ryanroslansky"),
 api.get_profile_overview("satyanadella"),
 api.get_profile_overview("jeffweiner08")
 )
 for profile in profiles:
 print(f"Name: {profile['data']['fullName']}")
# Run the async function
asyncio.run(main())

Advanced Async Pattern

import asyncio
from linkdapi import AsyncLinkdAPI
async def fetch_profile_data(username: str):
 """Fetch complete profile data including posts and connections."""
 async with AsyncLinkdAPI("your_api_key") as api:
 # Get profile overview first
 overview = await api.get_profile_overview(username)
 urn = overview['data']['urn']
 # Fetch multiple endpoints concurrently
 results = await asyncio.gather(
 api.get_profile_details(urn),
 api.get_full_experience(urn),
 api.get_education(urn),
 api.get_skills(urn),
 return_exceptions=True # Handle errors gracefully
 )
 return {
 "overview": overview,
 "details": results[0],
 "experience": results[1],
 "education": results[2],
 "skills": results[3]
 }
# Usage
data = asyncio.run(fetch_profile_data("ryanroslansky"))

⚡ Performance Benefits

📚 API Reference

💡 Real-World Examples

Example 1: Bulk Profile Enrichment

import asyncio
from linkdapi import AsyncLinkdAPI
async def enrich_leads(usernames: list):
 """Enrich a list of usernames with profile data."""
 async with AsyncLinkdAPI("your_api_key") as api:
 # Fetch all profiles concurrently
 tasks = [api.get_profile_overview(username) for username in usernames]
 profiles = await asyncio.gather(*tasks, return_exceptions=True)
 enriched_data = []
 for username, profile in zip(usernames, profiles):
 if isinstance(profile, dict) and profile.get('success'):
 data = profile['data']
 enriched_data.append({
 'username': username,
 'name': data.get('fullName'),
 'headline': data.get('headline'),
 'location': data.get('location'),
 'company': data.get('company')
 })
 return enriched_data
# Process 100 leads in seconds instead of minutes
leads = ['ryanroslansky', 'satyanadella', 'jeffweiner08', ...]
data = asyncio.run(enrich_leads(leads))

Example 2: Company Intelligence Dashboard

import asyncio
from linkdapi import AsyncLinkdAPI
async def get_company_intelligence(company_name: str):
 """Get comprehensive company data for analysis."""
 async with AsyncLinkdAPI("your_api_key") as api:
 # Get company info
 company_info = await api.get_company_info(name=company_name)
 company_id = company_info['data']['id']
 # Fetch multiple data points concurrently
 results = await asyncio.gather(
 api.get_company_employees_data(company_id),
 api.get_similar_companies(company_id),
 api.get_company_jobs(company_id),
 api.get_company_affiliated_pages(company_id),
 return_exceptions=True
 )
 return {
 'info': company_info,
 'employees': results[0],
 'similar': results[1],
 'jobs': results[2],
 'affiliates': results[3]
 }
intelligence = asyncio.run(get_company_intelligence("google"))

Example 3: Job Market Analysis

from linkdapi import AsyncLinkdAPI
import asyncio
async def analyze_job_market(role: str, locations: list):
 """Analyze job market across multiple locations."""
 async with AsyncLinkdAPI("your_api_key") as api:
 # Search jobs in multiple locations concurrently
 tasks = [
 api.search_jobs(keyword=role, location=location, time_posted='1week')
 for location in locations
 ]
 results = await asyncio.gather(*tasks)
 analysis = {}
 for location, result in zip(locations, results):
 if result.get('success'):
 jobs = result['data']['jobs']
 analysis[location] = {
 'total_jobs': len(jobs),
 'companies': list(set([j['company'] for j in jobs])),
 'salary_range': [j.get('salary') for j in jobs if j.get('salary')]
 }
 return analysis
# Analyze "Software Engineer" jobs across 5 cities in parallel
analysis = asyncio.run(analyze_job_market(
 "Software Engineer",
 ["San Francisco, CA", "New York, NY", "Austin, TX", "Seattle, WA", "Boston, MA"]
))

📈 Use Cases

🔧 Error Handling

import httpx
from linkdapi import AsyncLinkdAPI
async def fetch_with_error_handling():
 async with AsyncLinkdAPI("your_api_key") as api:
 try:
 profile = await api.get_profile_overview("username")
 if profile.get('success'):
 print(f"Success: {profile['data']}")
 else:
 print(f"API Error: {profile.get('message')}")
 except httpx.HTTPStatusError as e:
 # Handle HTTP errors (4xx, 5xx)
 print(f"HTTP Error {e.response.status_code}: {e.response.text}")
 except httpx.RequestError as e:
 # Handle network errors
 print(f"Network Error: {str(e)}")
 except Exception as e:
 # Handle unexpected errors
 print(f"Unexpected Error: {str(e)}")

Built-in Retry Mechanism

# Configure retry behavior
async with AsyncLinkdAPI(
 api_key="your_api_key",
 max_retries=5, # Default: 3
 retry_delay=2.0, # Default: 1.0 seconds
 timeout=60.0 # Default: 30.0 seconds
) as api:
 # Requests will be retried automatically on failure
 profile = await api.get_profile_overview("username")

🏁 Why Choose LinkdAPI Python SDK?

⚡ Performance First

🛡️ Production Ready

🚀 Developer Experience

🔗 Resources

📜 License

🌟 Support the Project

Built with ❤️ for developers who need reliable access to professional data

Website • Documentation • Twitter • Support