Jobs Data API: Access Real-Time Job Market Intelligence

1{
2  "title": "Senior Solutions Engineer",
3  "company": "Acme Corp",
4  "location": "San Francisco, CA",
5  "workplaceType": "Hybrid",
6  "salary": {
7    "min": 180000,
8    "max": 220000
9  },
10  "experienceLevel": "Mid-Senior",
11  "applicantsCount": 47,
12  "postedAt": "2026-03-15",
13  "description": "...expanding our enterprise sales team to support 3x ARR growth...",
14  "hiringTeam": [
15    {
16      "name": "Sarah Chen",
17      "title": "VP of Sales",
18      "profileUrl": "..."
19    }
20  ]
21}

1from linkdapi import AsyncLinkdAPI
2import asyncio
3
4async def monitor_target_accounts(company_ids):
5    """
6    Monitor job postings at target accounts for buying signals
7    """
8    async with AsyncLinkdAPI("your_api_key") as client:
9        
10        # Get all jobs from target companies
11        jobs_response = await client.get_company_jobs(
12            company_ids=company_ids,
13            start=0
14        )
15        
16        if not jobs_response['success']:
17            return []
18        
19        jobs = jobs_response['data']
20        
21        # Analyze for buying signals
22        signals = []
23        
24        for job in jobs:
25            title = job.get('title', '').lower()
26            description = job.get('description', '').lower()
27            
28            # Check for roles that indicate tool purchasing
29            buying_signals = [
30                'solutions engineer',
31                'sales operations',
32                'revenue operations',
33                'marketing operations',
34                'data engineer',
35                'devops',
36                'security engineer'
37            ]
38            
39            for signal in buying_signals:
40                if signal in title:
41                    signals.append({
42                        'company': job.get('company'),
43                        'job_title': job.get('title'),
44                        'job_id': job.get('jobId'),
45                        'signal_type': signal,
46                        'posted_at': job.get('postedAt')
47                    })
48                    break
49        
50        return signals
51
52# Monitor your target accounts
53target_companies = "1441,2135371,1337"  # Company IDs
54signals = asyncio.run(monitor_target_accounts(target_companies))
55
56for signal in signals:
57    print(f"{signal['company']} is hiring: {signal['job_title']}")

1async def find_hiring_managers(job_ids):
2    """
3    Get hiring manager contacts from job postings
4    """
5    async with AsyncLinkdAPI("your_api_key") as client:
6        
7        decision_makers = []
8        
9        for job_id in job_ids:
10            # Get hiring team
11            team_response = await client.get_job_hiring_team(
12                job_id=job_id,
13                start=0
14            )
15            
16            if team_response['success'] and team_response['data']:
17                for person in team_response['data']:
18                    # Filter for senior roles
19                    title = person.get('title', '').lower()
20                    
21                    if any(level in title for level in ['vp', 'director', 'head', 'manager']):
22                        decision_makers.append({
23                            'name': person.get('name'),
24                            'title': person.get('title'),
25                            'profile_url': person.get('profileUrl'),
26                            'job_id': job_id
27                        })
28        
29        return decision_makers
30
31# Get hiring managers from relevant job postings
32job_ids = ["3847291056", "3851234567", "3842098765"]
33managers = asyncio.run(find_hiring_managers(job_ids))
34
35for manager in managers:
36    print(f"{manager['name']} ({manager['title']})")

1async def analyze_competitor_hiring(competitor_ids):
2    """
3    Build a hiring analysis for competitors
4    """
5    async with AsyncLinkdAPI("your_api_key") as client:
6        
7        analysis = {}
8        
9        for company_id in competitor_ids.split(','):
10            # Get company info
11            company_response = await client.get_company_info(id=company_id)
12            company_name = company_response['data'].get('name', 'Unknown')
13            
14            # Get all jobs
15            jobs_response = await client.get_company_jobs(
16                company_ids=company_id,
17                start=0
18            )
19            
20            if not jobs_response['success']:
21                continue
22            
23            jobs = jobs_response['data']
24            
25            # Categorize by department
26            departments = {
27                'engineering': 0,
28                'sales': 0,
29                'marketing': 0,
30                'product': 0,
31                'operations': 0,
32                'other': 0
33            }
34            
35            locations = {}
36            remote_count = 0
37            
38            for job in jobs:
39                title = job.get('title', '').lower()
40                location = job.get('location', 'Unknown')
41                workplace = job.get('workplaceType', '')
42                
43                # Categorize
44                if any(kw in title for kw in ['engineer', 'developer', 'sre', 'devops']):
45                    departments['engineering'] += 1
46                elif any(kw in title for kw in ['sales', 'account', 'sdr', 'bdr']):
47                    departments['sales'] += 1
48                elif any(kw in title for kw in ['marketing', 'content', 'growth']):
49                    departments['marketing'] += 1
50                elif any(kw in title for kw in ['product', 'design', 'ux']):
51                    departments['product'] += 1
52                elif any(kw in title for kw in ['operations', 'finance', 'hr', 'people']):
53                    departments['operations'] += 1
54                else:
55                    departments['other'] += 1
56                
57                # Track locations
58                locations[location] = locations.get(location, 0) + 1
59                
60                if workplace == 'Remote':
61                    remote_count += 1
62            
63            analysis[company_name] = {
64                'total_jobs': len(jobs),
65                'by_department': departments,
66                'top_locations': sorted(locations.items(), key=lambda x: x[1], reverse=True)[:5],
67                'remote_percentage': (remote_count / len(jobs) * 100) if jobs else 0
68            }
69        
70        return analysis
71
72# Analyze competitor hiring
73competitors = "1441,2135371"  # Competitor company IDs
74analysis = asyncio.run(analyze_competitor_hiring(competitors))
75
76for company, data in analysis.items():
77    print(f"\n{company}: {data['total_jobs']} open roles")
78    print(f"  Engineering: {data['by_department']['engineering']}")
79    print(f"  Sales: {data['by_department']['sales']}")
80    print(f"  Remote: {data['remote_percentage']:.0f}%")

1async def find_sourcing_targets(keyword, location, experience_level):
2    """
3    Find companies with similar roles for candidate sourcing
4    """
5    async with AsyncLinkdAPI("your_api_key") as client:
6        
7        # Get location ID
8        geo_response = await client.geo_name_lookup(location)
9        geo_id = geo_response['data'][0]['id'] if geo_response['success'] and geo_response['data'] else None
10        
11        # Search for jobs
12        search_params = {
13            'keyword': keyword,
14            'experience': experience_level,
15            'sortBy': 'date_posted',
16            'count': 50
17        }
18        
19        if geo_id:
20            search_params['locations'] = geo_id
21        
22        jobs_response = await client.search_jobs_v2(**search_params)
23        
24        if not jobs_response['success']:
25            return []
26        
27        # Extract companies with these roles
28        companies = {}
29        
30        for job in jobs_response['data'].get('jobs', []):
31            company_name = job.get('company')
32            company_id = job.get('companyId')
33            
34            if company_name not in companies:
35                companies[company_name] = {
36                    'company_id': company_id,
37                    'roles': [],
38                    'count': 0
39                }
40            
41            companies[company_name]['roles'].append(job.get('title'))
42            companies[company_name]['count'] += 1
43        
44        # Sort by number of roles (companies hiring most = most candidates to source)
45        sorted_companies = sorted(
46            companies.items(),
47            key=lambda x: x[1]['count'],
48            reverse=True
49        )
50        
51        return sorted_companies[:20]
52
53# Find companies hiring Senior Engineers in SF for sourcing
54targets = asyncio.run(find_sourcing_targets(
55    keyword="Senior Software Engineer",
56    location="San Francisco",
57    experience_level="mid_senior"
58))
59
60for company, data in targets:
61    print(f"{company}: {data['count']} open roles")

1async def benchmark_compensation(job_title, locations):
2    """
3    Analyze salary ranges for a role across locations
4    """
5    async with AsyncLinkdAPI("your_api_key") as client:
6        
7        benchmarks = {}
8        
9        for location in locations:
10            # Get location ID
11            geo_response = await client.geo_name_lookup(location)
12            if not geo_response['success'] or not geo_response['data']:
13                continue
14            
15            geo_id = geo_response['data'][0]['id']
16            
17            # Search jobs with salary data
18            jobs_response = await client.search_jobs_v2(
19                keyword=job_title,
20                locations=geo_id,
21                count=50
22            )
23            
24            if not jobs_response['success']:
25                continue
26            
27            salaries = []
28            
29            for job in jobs_response['data'].get('jobs', []):
30                salary = job.get('salary')
31                if salary and salary.get('max'):
32                    salaries.append(salary['max'])
33            
34            if salaries:
35                benchmarks[location] = {
36                    'sample_size': len(salaries),
37                    'median': sorted(salaries)[len(salaries)//2],
38                    'min': min(salaries),
39                    'max': max(salaries),
40                    'avg': sum(salaries) / len(salaries)
41                }
42        
43        return benchmarks
44
45# Benchmark Software Engineer salaries
46locations = ["San Francisco", "New York", "Austin", "Remote"]
47benchmarks = asyncio.run(benchmark_compensation("Software Engineer", locations))
48
49for location, data in benchmarks.items():
50    print(f"{location}: ${data['median']:,.0f} median ({data['sample_size']} samples)")

1async def track_industry_trends(industry_id, date_ranges):
2    """
3    Compare hiring volume across time periods
4    """
5    async with AsyncLinkdAPI("your_api_key") as client:
6        
7        trends = {}
8        
9        for period in date_ranges:
10            jobs_response = await client.search_jobs_v2(
11                industries=industry_id,
12                datePosted=period,
13                count=50
14            )
15            
16            if jobs_response['success']:
17                trends[period] = {
18                    'total_jobs': jobs_response['data'].get('total', 0),
19                    'sample': jobs_response['data'].get('jobs', [])[:5]
20                }
21        
22        return trends
23
24# Compare hiring: last 24h vs last week vs last month
25trends = asyncio.run(track_industry_trends(
26    industry_id="96",  # Software industry
27    date_ranges=["24h", "1week", "1month"]
28))
29
30for period, data in trends.items():
31    print(f"{period}: {data['total_jobs']} jobs posted")

1async def find_expanding_companies(keyword, min_jobs=10):
2    """
3    Find companies with high hiring volume (expansion signal)
4    """
5    async with AsyncLinkdAPI("your_api_key") as client:
6        
7        # Search recent jobs
8        jobs_response = await client.search_jobs_v2(
9            keyword=keyword,
10            datePosted="1week",
11            sortBy="date_posted",
12            count=50
13        )
14        
15        if not jobs_response['success']:
16            return []
17        
18        # Count jobs per company
19        company_jobs = {}
20        
21        for job in jobs_response['data'].get('jobs', []):
22            company = job.get('company')
23            company_id = job.get('companyId')
24            
25            if company not in company_jobs:
26                company_jobs[company] = {
27                    'company_id': company_id,
28                    'job_count': 0,
29                    'roles': []
30                }
31            
32            company_jobs[company]['job_count'] += 1
33            company_jobs[company]['roles'].append(job.get('title'))
34        
35        # Filter for high volume
36        expanding = [
37            (name, data) for name, data in company_jobs.items()
38            if data['job_count'] >= min_jobs
39        ]
40        
41        return sorted(expanding, key=lambda x: x[1]['job_count'], reverse=True)
42
43# Find tech companies in expansion mode
44expanding = asyncio.run(find_expanding_companies(
45    keyword="software engineer",
46    min_jobs=5
47))
48
49for company, data in expanding[:10]:
50    print(f"{company}: {data['job_count']} new roles this week")