# LinkedIn Hiring Signals & B2B Leads (`trakk/linkedin-hiring-intelligence`) Actor

Find companies hiring right now and turn public LinkedIn jobs into actionable B2B leads. Get decision-makers, business emails, phone numbers, reviews, hiring signals, and change alerts—all in one export.

- **URL**: https://apify.com/trakk/linkedin-hiring-intelligence.md
- **Developed by:** [Blynx](https://apify.com/trakk) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 job results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## LinkedIn Hiring Signals & B2B Leads

> 🚀 Turn public hiring activity into **job data, company buying signals, decision-maker contacts, business emails, phone numbers, reviews, and trackable changes** — in one structured dataset.

Finding an open role is useful. Knowing **which company is hiring, what team is growing, who may own the decision, and how to reach the business** is much more useful.

This Actor connects those pieces for sales teams, recruiters, agencies, founders, and market researchers. Start with job keywords, LinkedIn job URLs, or company URLs, then export clean records to JSON, CSV, Excel, or your own workflow.

### ✨ Why run this Actor?

- **Find companies with active demand** instead of working from a static company list.
- **Prioritize accounts by hiring momentum** using open-role counts, locations, departments, and a hiring-signal score.
- **Turn job posts into lead context** with company details, relevant decision makers, and evidence-backed contact data.
- **Collect emails and phones honestly**: public, generated, deliverable, catch-all, unavailable, and other statuses stay clearly separated.
- **Add company reputation context** from publicly visible rating and review sources when available.
- **Monitor a market continuously** and receive new, changed, and no-longer-observed job events.
- **Audit every result** with source URLs, confidence, completeness, unavailable fields, and timestamps.

No LinkedIn login or Sales Navigator account is required for public results.

### 🎯 Popular use cases

| Goal | How this Actor helps |
|---|---|
| B2B lead generation | Discover companies that are hiring for technologies or teams related to your offer. |
| Recruiting intelligence | Track employers, job titles, locations, seniority, and hiring departments. |
| Agency prospecting | Exclude staffing intermediaries and focus on direct employers with active demand. |
| Account scoring | Compare companies using open jobs, remote roles, salary visibility, locations, and hiring-signal scores. |
| Contact research | Find relevant public decision makers, company mailboxes, business emails, and phone evidence. |
| Market monitoring | Save a baseline and detect jobs that appeared, changed, or disappeared. |
| Employer research | Combine hiring activity with public company details and review signals. |

### 🧭 Choose a workflow

| Mode | Best for | Primary output |
|---|---|---|
| `jobs` | Clean job search and export | One normalized record per public job |
| `signals` | Account research and company scoring | Aggregated company hiring signals and enrichment |
| `contacts` | Lead generation and outreach research | Jobs, companies, relevant people, emails, phones, and reviews |
| `monitor` | Recurring market or competitor tracking | New, changed, and no-longer-observed job events |
| `selfTest` | Scheduled Actor health checks | Machine-readable checks and diagnostics |

### 📦 What data do you get?

#### 💼 Job records

- search query and search location;
- job ID, title, company, location, and canonical URL;
- published date and source date text;
- description, seniority, employment type, function, industry, and department;
- applicant count and benefits when publicly shown;
- application mode: external application, LinkedIn Apply, or sign-in required;
- first-seen and last-seen timestamps;
- availability, completeness, and unavailable-field markers.

#### 📈 Company and hiring-signal records

- company name and public LinkedIn company URL;
- website, domain, legal name, description, and address when available;
- open-job, remote-job, and salary-visible-job counts;
- hiring locations, departments, and sample titles;
- hiring-signal score, label, and human-readable reasons;
- public company email and phone evidence;
- source, confidence, completeness, and timestamp fields.

#### 🎯 Contact records

- decision-maker name, title, department, persona, and public profile URL;
- company-level public mailboxes and phone numbers;
- generated business email patterns kept explicitly labeled as `guessed`;
- syntax, mail-routing, and mailbox-acceptance signals when a check is possible;
- normalized E.164 phones when the country context is sufficient;
- evidence URL, confidence, verification time, and unavailable fields.

#### ⭐ Review records

- source and review type;
- rating, rating scale, and review count;
- public title, excerpt, author, and date when exposed by the source;
- review URL, evidence type, source warnings, confidence, and timestamp.

Reviews are naturally optional. If a supported public source has no matching company or exposes no rating, the Actor reports the gap instead of inventing a value.

### ⚡ Ready-to-run examples

#### 1. Export jobs with full descriptions

```json
{
  "scrapeType": "jobs",
  "queries": ["backend engineer", "data engineer"],
  "locations": ["Berlin", "Remote"],
  "includeDetails": true,
  "includeCompanyEnrichment": false,
  "includeContacts": false,
  "includeEmails": false,
  "includePhones": false,
  "includeReviews": false,
  "maxResults": 100,
  "maxPages": 5
}
````

#### 2. Build a full hiring-intent lead list

```json
{
  "scrapeType": "contacts",
  "queries": ["machine learning engineer", "head of data"],
  "locations": ["United States"],
  "targetPersonas": [
    "recruiter",
    "hiring_manager",
    "vp_engineering",
    "head_of_data"
  ],
  "includeDetails": true,
  "includeCompanyEnrichment": true,
  "includeContacts": true,
  "includeEmails": true,
  "verifyGeneratedEmails": true,
  "includePhones": true,
  "includeReviews": true,
  "excludeStaffingAgencies": true,
  "maxResults": 250,
  "maxContactsPerCompany": 5,
  "maxReviewsPerCompany": 5
}
```

#### 3. Enrich a list of known companies

No job query is required when you already have company URLs.

```json
{
  "scrapeType": "contacts",
  "queries": [],
  "companyUrls": [
    "https://www.linkedin.com/company/example-company/",
    "https://example.org"
  ],
  "targetPersonas": ["founder", "sales_leader", "marketing_leader"],
  "includeCompanyEnrichment": true,
  "includeContacts": true,
  "includeEmails": true,
  "verifyGeneratedEmails": true,
  "includePhones": true,
  "includeReviews": true,
  "maxContactsPerCompany": 5
}
```

#### 4. Use exact job or search URLs

```json
{
  "scrapeType": "jobs",
  "queries": [],
  "startUrls": [
    {
      "url": "https://www.linkedin.com/jobs/view/1234567890/"
    },
    {
      "url": "https://www.linkedin.com/jobs/search/?keywords=product%20manager"
    }
  ],
  "includeDetails": true,
  "maxResults": 50
}
```

#### 5. Monitor a niche every day

Reuse the same input and `watchlistName` on every scheduled run.

```json
{
  "scrapeType": "monitor",
  "watchlistName": "germany-ai-hiring",
  "queries": ["AI engineer", "machine learning engineer"],
  "locations": ["Germany"],
  "excludeStaffingAgencies": true,
  "maxResults": 500,
  "maxPages": 10
}
```

The first run creates a baseline. Later runs emit change records for newly observed, updated, and no-longer-observed jobs.

### 🛠️ Input guide

You can combine discovery sources. The Actor merges and deduplicates them before producing results.

#### 🔎 Discovery

| Field | What to enter |
|---|---|
| `queries` | Job titles, skills, technologies, or keywords. Examples: `React developer`, `VP Sales`, `SAP consultant`. |
| `locations` | Cities, regions, or countries applied to every query. Leave empty for unrestricted public results. |
| `startUrls` | Public LinkedIn job pages or job-search URLs. |
| `companyUrls` | Public LinkedIn company pages or official company websites for direct enrichment. |
| `targetPersonas` | Roles to prioritize: recruiter, hiring manager, founder, engineering, data, sales, or marketing leadership. |

#### ✨ Enrichment switches

| Field | What it controls |
|---|---|
| `includeDetails` | Full available job description and structured job attributes. |
| `includeCompanyEnrichment` | Company identity, website, domain, and hiring signals. |
| `includeContacts` | Relevant public people and company contact records. |
| `includeEmails` | Public emails and clearly labeled generated business patterns. |
| `verifyGeneratedEmails` | Deliverability signals for emails when the receiving server permits a check. |
| `includePhones` | Public phone numbers with source evidence. |
| `includeReviews` | Public company rating or review evidence when available. |

#### 🧰 Strict filters

Allowlist filters run first. Denylist filters always win. Text matching is case-insensitive.

| Field | Behavior |
|---|---|
| `includeTitles` / `excludeTitles` | Keep or remove jobs by title text. |
| `includeCompanies` / `excludeCompanies` | Keep or remove normalized company names. |
| `includeCountries` / `excludeCountries` | Keep or remove countries by name or two-letter ISO code. |
| `excludeStaffingAgencies` | Remove likely staffing, recruiting, and outsourcing intermediaries. |

#### 📏 Limits

| Field | Behavior |
|---|---|
| `maxResults` | Primary job, company, or contact limit. Enrichment can add related dataset rows. |
| `maxPages` | Maximum result pages processed for each query/location pair. |
| `maxConcurrency` | Number of independent public pages processed at once. The default is a balanced choice. |
| `maxContactsPerCompany` | Contact-record limit for each company. |
| `maxReviewsPerCompany` | Review-record limit for each company; use `0` to disable review rows. |
| `watchlistName` | Stable snapshot name used by `monitor` mode. |

#### Fast 50-job recipe

Use this jobs-only configuration when you want to search many roles while keeping the returned dataset and runtime compact:

```json
{
  "scrapeType": "jobs",
  "queries": ["Software Engineer", "Data Engineer", "Product Manager"],
  "locations": ["United States"],
  "includeDetails": true,
  "maxResults": 50,
  "maxPages": 1,
  "maxConcurrency": 50
}
```

`maxResults` controls the number of returned jobs. The Actor keeps extra candidates internally so strict filters can still produce a full result set, but it does not fetch detail pages for an unbounded number of jobs. For a full export of hundreds or thousands of detailed jobs, increase `maxResults` and expect a proportionally longer run.

### 🧠 Evidence-first data model

The Actor separates **where a value came from** from **whether it appears deliverable today**.

| Email status | Meaning |
|---|---|
| `public` | Published on a public source. This confirms provenance, not current delivery. |
| `smtp_valid` | A mailbox-level check was accepted at verification time. |
| `catch_all` | The domain accepts arbitrary recipients, so this mailbox cannot be confirmed individually. |
| `mx_only` | The domain can receive email, but the specific mailbox was not confirmed. |
| `guessed` | Generated from a likely company pattern; never presented as a verified source. |
| `invalid` | Available checks indicate the address should not be used. |
| `error` | Verification could not be completed. Do not treat the address as verified. |

Use `emailStatus`, `emailDeliveryStatus`, `emailConfidence`, `emailEvidenceUrl`, and `emailVerifiedAt` together. Delivery is always a point-in-time signal and can change later.

Phone records include the public value, `phoneE164` when normalization is possible, an inferred type when available, and `phoneEvidenceUrl`.

### 📤 Output and exports

Every dataset item is a flat record with a `recordType`. The default dataset keeps the complete, backwards-compatible export, while the Output tab exposes six clean type-specific datasets plus the overview:

1. **Overview** — the most useful identity, status, evidence, and timestamp columns.
2. **Jobs** — normalized public job records.
3. **Companies** — company identity, enrichment, and aggregate hiring signals.
4. **Contacts** — people, mailboxes, emails, phones, evidence, and confidence.
5. **Reviews** — public company rating and review evidence.
6. **Changes** — monitoring additions, updates, and removals.
7. **Diagnostics** — empty, skipped, failed, or partially enriched work with a reason.

Export any view as **JSON, CSV, Excel, XML, or RSS**, or read the default dataset through the Apify API and integrations.

#### Example job record

```json
{
  "recordType": "job",
  "query": "machine learning engineer",
  "searchLocation": "United States",
  "jobId": "1234567890",
  "title": "Senior Machine Learning Engineer",
  "company": "Example Company",
  "location": "New York, NY",
  "jobUrl": "https://www.linkedin.com/jobs/view/1234567890/",
  "postedAt": "2026-07-15",
  "seniority": "Mid-Senior level",
  "employmentType": "Full-time",
  "applicationMode": "external",
  "applyUrl": "https://jobs.example.com/roles/123",
  "availabilityStatus": "available",
  "dataCompleteness": 0.91,
  "unavailableFields": ["benefits"],
  "scrapedAt": "2026-07-17T12:00:00Z"
}
```

#### Example contact record

```json
{
  "recordType": "contact",
  "contactType": "decision_maker",
  "fullName": "Example Person",
  "jobTitle": "VP Engineering",
  "targetPersona": "vp_engineering",
  "linkedinUrl": "https://www.linkedin.com/in/example-person/",
  "company": "Example Company",
  "email": "person@example.com",
  "emailStatus": "guessed",
  "emailDeliveryStatus": "mx_only",
  "emailConfidence": 0.72,
  "emailEvidenceUrl": "https://example.com/team",
  "phone": "+1 202 555 0100",
  "phoneE164": "+12025550100",
  "phoneEvidenceUrl": "https://example.com/contact",
  "evidenceUrl": "https://example.com/team",
  "confidence": 0.84,
  "availabilityStatus": "partial",
  "scrapedAt": "2026-07-17T12:00:00Z"
}
```

> The records above are illustrative. Real rows keep the complete view-specific column contract.

### ✅ Complete fields without fake data

Every row includes all fields declared by its record-specific view:

- `not_available` means the field is relevant, but the public source did not provide it;
- `not_applicable` means the field does not apply to that record subtype;
- `availabilityStatus` summarizes whether the record is complete, partial, or unavailable;
- `dataCompleteness` provides a comparable coverage score;
- `unavailableFields` lists source gaps explicitly.

This makes CSV and Excel exports stable while preventing a missing value from being mistaken for an extraction error.

### 💡 Recommended settings

| Scenario | Suggested mode and settings |
|---|---|
| Fast job export | `jobs`, details on, all other enrichment off |
| Company prioritization | `signals`, company enrichment on, contacts optional |
| Full lead research | `contacts`, emails + phones + reviews on, 3–5 contacts per company |
| Exact account list | `contacts` or `signals` with `companyUrls` |
| Recurring alert | `monitor` with a stable `watchlistName` and unchanged search scope |
| First trial | 1 query, 1 location, `maxPages: 1`, `maxResults: 10` |

### 💰 Cost and run size

Usage depends mainly on the number of query/location combinations, pages, jobs, companies, and optional enrichment steps.

For a predictable first run:

1. Start with one query and one location.
2. Set `maxPages` to `1` and `maxResults` to `10`.
3. Inspect the Output and Diagnostics views.
4. Enable only the enrichment you need, then scale the limits.

For large lead-generation runs, company/contact/review enrichment naturally does more work than a jobs-only export. Limits always give you a clear way to control the run size.

### 🔄 Monitoring tips

- Keep the same `watchlistName`, queries, locations, URLs, and filters across runs.
- Use a new watchlist name when the scope changes materially.
- Schedule the Actor at the interval that matches your market: daily for active niches, weekly for slower ones.
- Treat “no longer observed” as a source observation, not guaranteed proof that an employer closed the role.

### 🧪 Scheduled health check

`selfTest` performs a deliberately small end-to-end run and writes a machine-readable `SELF_TEST` report plus diagnostics. It is suitable for recurring platform tests.

```json
{
  "scrapeType": "selfTest",
  "queries": ["software engineer"],
  "locations": ["United States"],
  "includeEmails": true,
  "includePhones": true,
  "includeReviews": true,
  "maxResults": 3,
  "maxPages": 1,
  "maxConcurrency": 2
}
```

### ⚖️ Data coverage and responsible use

Results depend on what is publicly visible at run time. Some jobs, profiles, contacts, ratings, or review excerpts may be absent, localized, delayed, or changed by their publishers. Evidence URLs and timestamps help you assess freshness and confidence.

Use the Actor only for lawful purposes. You are responsible for applicable privacy, employment, marketing, data-protection, and website rules, including required notices and opt-out mechanisms. Do not use contact data for spam, harassment, sensitive profiling, or automated decisions about people.

This Actor is not affiliated with, endorsed by, or sponsored by LinkedIn.

### ❓ FAQ

#### Does every contact include an email and phone?

No. A real source gap is better than invented data. Emails can be public or clearly labeled generated patterns. Phone numbers require public evidence.

#### Is a public email the same as a verified email?

No. `public` describes provenance. Deliverability is reported separately, and even a positive mailbox signal is a point-in-time result rather than a guarantee.

#### Can I run it with company URLs and no job query?

Yes. Add `companyUrls` and use `signals` or `contacts`. The Actor will enrich those companies directly; contact and review coverage still depends on public evidence.

#### Can I combine queries, job URLs, and company URLs?

Yes. All supplied discovery sources are processed together and deduplicated.

#### Why did I receive fewer records than expected?

The source may expose fewer public results, strict filters may remove items, duplicates are consolidated, and optional enrichment can be unavailable. Open the **Diagnostics** view for run-specific counts and reasons.

#### Why is `applyUrl` unavailable for some jobs?

`applyUrl` is reserved for a real external application destination. LinkedIn Apply and sign-in-required flows are identified in `applicationMode` without inventing an external URL.

#### How do I avoid duplicate monitoring events?

Reuse the same `watchlistName` and unchanged search definition. Use a new name when you change the monitored market significantly.

#### What should I do with guessed or catch-all emails?

Use them as research leads, not as verified delivery guarantees. Apply your own outreach policy, suppression list, and consent or legitimate-interest assessment before contact.

# Actor input Schema

## `scrapeType` (type: `string`):

Choose the primary outcome. Jobs is the fastest export; Signals groups hiring activity by company; Contacts adds lead research; Monitor compares runs; Self-test checks Actor health.

## `queries` (type: `array`):

Add one search per line, for example “backend engineer”, “VP Sales”, or “SAP consultant”. Each query is combined with every location below.

## `locations` (type: `array`):

Cities, regions, or countries, for example “New York”, “Germany”, or “Remote”. Leave empty to avoid adding a location restriction.

## `startUrls` (type: `array`):

Optional public LinkedIn job pages and job-search URLs. Use these for exact targets or combine them with keyword discovery.

## `companyUrls` (type: `array`):

Optional LinkedIn company pages or official company websites, one per line. In Signals or Contacts mode you can use this list without any job query.

## `targetPersonas` (type: `array`):

Select the roles to prioritize in Contacts mode. Choose personas that match the problem your product or service solves.

## `includeDetails` (type: `boolean`):

Collect the full available description, seniority, employment type, job function, industries, benefits, applicant count, and application mode.

## `includeCompanyEnrichment` (type: `boolean`):

Add company website, domain, legal identity, address, hiring locations, departments, open-role counts, and a hiring-signal score when available.

## `includeContacts` (type: `boolean`):

Find public people who match the selected personas and keep their title, company, profile, evidence, and confidence together.

## `includePhones` (type: `boolean`):

Return a phone only when public evidence exists. The Actor also provides an E.164 version when normalization is possible.

## `includeEmails` (type: `boolean`):

Return public business emails and likely company email patterns. Generated addresses remain explicitly labeled as guessed and are never presented as public evidence.

## `verifyGeneratedEmails` (type: `boolean`):

Check syntax and mail routing, then attempt a mailbox acceptance check when the receiving server permits it. Provenance and deliverability remain separate statuses.

## `includeReviews` (type: `boolean`):

Add publicly visible company rating or review evidence from supported sources when a matching profile exists.

## `includeTitles` (type: `array`):

Optional strict allowlist. A job stays only when its title contains at least one value, matched case-insensitively.

## `excludeTitles` (type: `array`):

Optional strict denylist. A match is removed even when it passed an allowlist.

## `includeCompanies` (type: `array`):

Optional strict company allowlist matched against normalized names, case-insensitively.

## `excludeCompanies` (type: `array`):

Optional strict company denylist. A match is removed even when it passed an allowlist.

## `includeCountries` (type: `array`):

Optional strict country allowlist. Use names or ISO codes such as US, DE, or GB.

## `excludeCountries` (type: `array`):

Optional strict country denylist. A match is removed even when it passed an allowlist.

## `excludeStaffingAgencies` (type: `boolean`):

Remove likely staffing, recruiting, and outsourcing intermediaries from company results.

## `maxResults` (type: `integer`):

Maximum primary job, company, or contact records. Related company, contact, review, and diagnostic rows can increase the final dataset item count.

## `maxPages` (type: `integer`):

Stop each query/location combination after this many result pages, even if the primary result limit has not been reached.

## `maxConcurrency` (type: `integer`):

How many independent public pages may be processed at once. The default balances speed and stability; 40-60 is usually fastest for large jobs-only runs, while higher values are available for experimentation.

## `maxReviewsPerCompany` (type: `integer`):

Maximum public review records for each company. Set to 0 when review rows are not needed.

## `maxContactsPerCompany` (type: `integer`):

Maximum public mailboxes, phone records, and decision makers returned for each company.

## `watchlistName` (type: `string`):

Monitor mode compares the current run with the previous snapshot stored under this name. Keep both the name and search scope stable across scheduled runs.

## `proxyConfiguration` (type: `object`):

The default is recommended for most runs. Advanced users can customize the connection configuration here.

## `maxRetries` (type: `integer`):

Maximum attempts for a temporarily unavailable request before the item is recorded in Diagnostics. The default is recommended.

## Actor input object example

```json
{
  "scrapeType": "jobs",
  "queries": [
    "software engineer"
  ],
  "locations": [],
  "startUrls": [],
  "companyUrls": [],
  "targetPersonas": [
    "recruiter",
    "hiring_manager"
  ],
  "includeDetails": true,
  "includeCompanyEnrichment": true,
  "includeContacts": true,
  "includePhones": true,
  "includeEmails": true,
  "verifyGeneratedEmails": true,
  "includeReviews": true,
  "includeTitles": [],
  "excludeTitles": [],
  "includeCompanies": [],
  "excludeCompanies": [],
  "includeCountries": [],
  "excludeCountries": [],
  "excludeStaffingAgencies": true,
  "maxResults": 100,
  "maxPages": 5,
  "maxConcurrency": 10,
  "maxReviewsPerCompany": 5,
  "maxContactsPerCompany": 5,
  "watchlistName": "default",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxRetries": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `jobs` (type: `string`):

No description

## `companies` (type: `string`):

No description

## `contacts` (type: `string`):

No description

## `reviews` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `diagnostics` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("trakk/linkedin-hiring-intelligence").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("trakk/linkedin-hiring-intelligence").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call trakk/linkedin-hiring-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trakk/linkedin-hiring-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Hiring Signals & B2B Leads",
        "description": "Find companies hiring right now and turn public LinkedIn jobs into actionable B2B leads. Get decision-makers, business emails, phone numbers, reviews, hiring signals, and change alerts—all in one export.",
        "version": "0.1",
        "x-build-id": "bDSYZdaRST5vkILpl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trakk~linkedin-hiring-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trakk-linkedin-hiring-intelligence",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/trakk~linkedin-hiring-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-trakk-linkedin-hiring-intelligence",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/trakk~linkedin-hiring-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-trakk-linkedin-hiring-intelligence",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "scrapeType"
                ],
                "properties": {
                    "scrapeType": {
                        "title": "What do you want to build?",
                        "enum": [
                            "jobs",
                            "signals",
                            "contacts",
                            "monitor",
                            "selfTest"
                        ],
                        "type": "string",
                        "description": "Choose the primary outcome. Jobs is the fastest export; Signals groups hiring activity by company; Contacts adds lead research; Monitor compares runs; Self-test checks Actor health.",
                        "default": "jobs"
                    },
                    "queries": {
                        "title": "Job titles, skills, or keywords",
                        "type": "array",
                        "description": "Add one search per line, for example “backend engineer”, “VP Sales”, or “SAP consultant”. Each query is combined with every location below.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": [
                            "software engineer"
                        ]
                    },
                    "locations": {
                        "title": "Target locations",
                        "type": "array",
                        "description": "Cities, regions, or countries, for example “New York”, “Germany”, or “Remote”. Leave empty to avoid adding a location restriction.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "startUrls": {
                        "title": "Exact LinkedIn job or search URLs",
                        "type": "array",
                        "description": "Optional public LinkedIn job pages and job-search URLs. Use these for exact targets or combine them with keyword discovery.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "LinkedIn URL",
                                    "description": "A public LinkedIn job page or job-search URL.",
                                    "type": "string"
                                }
                            }
                        },
                        "default": []
                    },
                    "companyUrls": {
                        "title": "Companies to enrich directly",
                        "type": "array",
                        "description": "Optional LinkedIn company pages or official company websites, one per line. In Signals or Contacts mode you can use this list without any job query.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "targetPersonas": {
                        "title": "Which decision makers matter?",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select the roles to prioritize in Contacts mode. Choose personas that match the problem your product or service solves.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "recruiter",
                                "hiring_manager",
                                "founder",
                                "vp_engineering",
                                "head_of_data",
                                "sales_leader",
                                "marketing_leader"
                            ],
                            "enumTitles": [
                                "🧑‍💼 Recruiter / Talent Acquisition",
                                "👥 Hiring Manager",
                                "🚀 Founder / Owner",
                                "💻 VP / Head of Engineering",
                                "📊 Head of Data / AI",
                                "💰 Sales Leadership",
                                "📣 Marketing Leadership"
                            ]
                        },
                        "default": [
                            "recruiter",
                            "hiring_manager"
                        ]
                    },
                    "includeDetails": {
                        "title": "Full job details",
                        "type": "boolean",
                        "description": "Collect the full available description, seniority, employment type, job function, industries, benefits, applicant count, and application mode.",
                        "default": true
                    },
                    "includeCompanyEnrichment": {
                        "title": "Company identity and hiring signals",
                        "type": "boolean",
                        "description": "Add company website, domain, legal identity, address, hiring locations, departments, open-role counts, and a hiring-signal score when available.",
                        "default": true
                    },
                    "includeContacts": {
                        "title": "Relevant public decision makers",
                        "type": "boolean",
                        "description": "Find public people who match the selected personas and keep their title, company, profile, evidence, and confidence together.",
                        "default": true
                    },
                    "includePhones": {
                        "title": "Public phone numbers",
                        "type": "boolean",
                        "description": "Return a phone only when public evidence exists. The Actor also provides an E.164 version when normalization is possible.",
                        "default": true
                    },
                    "includeEmails": {
                        "title": "Public and generated business emails",
                        "type": "boolean",
                        "description": "Return public business emails and likely company email patterns. Generated addresses remain explicitly labeled as guessed and are never presented as public evidence.",
                        "default": true
                    },
                    "verifyGeneratedEmails": {
                        "title": "Email deliverability signals",
                        "type": "boolean",
                        "description": "Check syntax and mail routing, then attempt a mailbox acceptance check when the receiving server permits it. Provenance and deliverability remain separate statuses.",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Public company ratings and reviews",
                        "type": "boolean",
                        "description": "Add publicly visible company rating or review evidence from supported sources when a matching profile exists.",
                        "default": true
                    },
                    "includeTitles": {
                        "title": "Keep only job titles containing",
                        "type": "array",
                        "description": "Optional strict allowlist. A job stays only when its title contains at least one value, matched case-insensitively.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "excludeTitles": {
                        "title": "Remove job titles containing",
                        "type": "array",
                        "description": "Optional strict denylist. A match is removed even when it passed an allowlist.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "includeCompanies": {
                        "title": "Keep only company names containing",
                        "type": "array",
                        "description": "Optional strict company allowlist matched against normalized names, case-insensitively.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "excludeCompanies": {
                        "title": "Remove company names containing",
                        "type": "array",
                        "description": "Optional strict company denylist. A match is removed even when it passed an allowlist.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "includeCountries": {
                        "title": "Keep only countries",
                        "type": "array",
                        "description": "Optional strict country allowlist. Use names or ISO codes such as US, DE, or GB.",
                        "items": {
                            "type": "string",
                            "minLength": 2
                        },
                        "default": []
                    },
                    "excludeCountries": {
                        "title": "Remove countries",
                        "type": "array",
                        "description": "Optional strict country denylist. A match is removed even when it passed an allowlist.",
                        "items": {
                            "type": "string",
                            "minLength": 2
                        },
                        "default": []
                    },
                    "excludeStaffingAgencies": {
                        "title": "Focus on direct employers",
                        "type": "boolean",
                        "description": "Remove likely staffing, recruiting, and outsourcing intermediaries from company results.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum primary results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum primary job, company, or contact records. Related company, contact, review, and diagnostic rows can increase the final dataset item count.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Pages per query and location",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop each query/location combination after this many result pages, even if the primary result limit has not been reached.",
                        "default": 5
                    },
                    "maxConcurrency": {
                        "title": "Processing concurrency",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many independent public pages may be processed at once. The default balances speed and stability; 40-60 is usually fastest for large jobs-only runs, while higher values are available for experimentation.",
                        "default": 10
                    },
                    "maxReviewsPerCompany": {
                        "title": "Reviews per company",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum public review records for each company. Set to 0 when review rows are not needed.",
                        "default": 5
                    },
                    "maxContactsPerCompany": {
                        "title": "Contacts per company",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum public mailboxes, phone records, and decision makers returned for each company.",
                        "default": 5
                    },
                    "watchlistName": {
                        "title": "Watchlist name",
                        "minLength": 1,
                        "maxLength": 100,
                        "type": "string",
                        "description": "Monitor mode compares the current run with the previous snapshot stored under this name. Keep both the name and search scope stable across scheduled runs.",
                        "default": "default"
                    },
                    "proxyConfiguration": {
                        "title": "Connection configuration",
                        "type": "object",
                        "description": "The default is recommended for most runs. Advanced users can customize the connection configuration here.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxRetries": {
                        "title": "Recovery attempts",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Maximum attempts for a temporarily unavailable request before the item is recorded in Diagnostics. The default is recommended.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
