# LinkedIn People Finder by Role, Seniority & Network (`nimbryxo-studio/linkedin-people-finder-by-role-seniority`) Actor

Search LinkedIn people with structured filters for company, school, seniority, job function, years of experience, industry, and connection degree, using your own LinkedIn session.

- **URL**: https://apify.com/nimbryxo-studio/linkedin-people-finder-by-role-seniority.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## LinkedIn People Finder by Role, Seniority & Network

Search LinkedIn people search with your own session — well beyond a plain keyword box. Combine free-text search with structured filters for company, school, seniority, job function, years of experience, company size, industry, and more, and get back one row per matching profile.

### What this actor does

- Runs a LinkedIn people search using your own session cookie, combining a free-text query with any number of structured filters
- Passes structured filters to LinkedIn: company, school and location IDs, industry, job function, seniority level, years of experience, employer headcount, connection degree, profile language and "open to" status
- Adds free-text values (a location name, company or school names, a topic, first/last name and job title) to the search keywords, so they narrow results the way typing them into LinkedIn's search box would
- Can narrow to people who follow a given company or are connections of a specific member, using their numeric IDs or URNs
- Flags when a result card shows an "Open to Work" or Premium marker or a verified indicator
- Fields LinkedIn doesn't expose for a given profile (for example a profile picture or mutual-connections count) are left off that record

### Output per profile

- `name` — the person's full name
- `profileUrl` — their canonical LinkedIn profile URL
- `headline` — their LinkedIn headline, as written
- `location` — the location shown on their profile
- `connectionDegree` — their connection degree to your account (`1st`, `2nd`, `3rd+`), when LinkedIn shows one
- `currentCompany` — their current employer as `{name}`, plus `slug` and `url` when LinkedIn supplies a structured company link; usually derived from a headline such as "Engineer at Acme"
- `currentTitle` — their current job title, usually the part of the headline before "at …"
- `industryName` — the industry LinkedIn associates with the profile, when available
- `educationCount` — how many education entries appear on their profile, when greater than zero
- `openToWork` — true when the result shows an "Open to Work" marker (omitted otherwise)
- `premium`, `premiumStatus` — true when the result shows a Premium marker (omitted otherwise)
- `verifiedStatus` — true when the result card carries a verified indicator (omitted otherwise)
- `profilePicture`, `profileImageUrl` — the profile photo URL, when visible to your account
- `mutualConnections` — the mutual-connections text LinkedIn shows for that profile, when available
- `scrapedAt` — when the actor fetched the record

`industryName` and `educationCount` only come through on some result layouts, so many rows won't have them.

#### Cookie notice row

If the `cookie` input is empty, or LinkedIn reports the session as expired or invalid, the run doesn't fail. Instead the dataset gets a single notice row with `_status: "no_data"`, `_reason` (`cookie-missing` or `cookie-invalid`), `_message`, `_help` (how to export a fresh cookie) and `scrapedAt`, and no profiles. A cookie value that can't be parsed at all fails the run.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQuery` | string | – | Free-text search keywords. Required. |
| `keywords` | string | – | Extra keywords combined with `searchQuery` with a space; handy for adding modifiers without editing your main query. |
| `cookie` | string | – | Your LinkedIn session cookie — either the `li_at` value or a full cookie JSON export. Required. |
| `location` | string | – | Free-text location, e.g. `San Francisco Bay Area`; added to the search keywords. Use `geoUrn` for a strict location filter. |
| `geoUrn` | string | – | A LinkedIn geo URN or numeric geo ID (e.g. `103644278` for the United States) for a strict location filter. |
| `currentCompany` | string | – | Current employer, by name or LinkedIn company URN/ID. A URN applies a strict structured filter; a plain name is added to the search keywords. |
| `pastCompany` | string | – | Past employer, by name or LinkedIn company URN/ID. Works like `currentCompany`: an ID applies the filter, a name is added to the keywords. |
| `school` | string | – | School or university attended. A school URN/ID applies the school filter; a name is added to the keywords. |
| `firstNameKeyword` | string | – | First name; sent as a first-name filter and added to the keywords. |
| `lastNameKeyword` | string | – | Last name; sent as a last-name filter and added to the keywords. |
| `titleKeyword` | string | – | Job title text, e.g. `Director of Engineering`; sent as a title filter and added to the keywords. |
| `serviceCategory` | string | – | LinkedIn Services Marketplace category, e.g. `Web Development`; sent as a filter and added to the keywords. |
| `companyHeadcount` | array | – | Employer size bucket(s), from self-employed up to 10,001+ employees. |
| `followerOf` | string | – | Restrict to people who follow a given company. Needs a company URN or numeric ID; a plain name is ignored. |
| `connectionDegree` | string | `""` (any) | `F` (1st degree), `S` (2nd degree), or `O` (3rd+ degree). |
| `industry` | string | `""` (any) | One of 13 industries, e.g. `Software Development`, `Healthcare`. |
| `seniorityLevel` | string | `""` (any) | `Entry level`, `Associate`, `Mid-Senior level`, `Director`, or `Executive`. |
| `yearsOfExperience` | string | `""` (any) | Total professional experience bucket, from less than 1 year up to 16+ years. |
| `jobFunction` | string | `""` (any) | Department/function, e.g. `ENGINEERING`, `SALES`, `MARKETING`. |
| `openTo` | array | – | What the person has flagged as open to: `HIRING`, `GETTING_HIRED`, `PROVIDING_SERVICES`, `JOINING_A_NONPROFIT`. |
| `profileLanguages` | array | – | ISO 639-1 language code(s) the profile is written in, e.g. `["en", "es"]`. |
| `contactOf` | string | – | Restrict to connections of a specific LinkedIn member (member URN or numeric profile ID). |
| `talksAbout` | string | – | A keyword/topic to look for on the person's profile; appended to the search keywords. |
| `maxResults` | integer | `25` | Maximum profiles to return (1–100). |
| `proxyConfiguration` | object | – | Optional Apify proxy configuration. |

### Example: role + company + connection degree

```json
{
  "searchQuery": "product manager",
  "cookie": "YOUR_LI_AT_COOKIE",
  "currentCompany": "Airbnb",
  "connectionDegree": "F",
  "maxResults": 25
}
```

### Example: senior engineers by function, seniority, and company size

```json
{
  "searchQuery": "engineering",
  "cookie": "YOUR_LI_AT_COOKIE",
  "jobFunction": "ENGINEERING",
  "seniorityLevel": "Director",
  "companyHeadcount": ["G", "H", "I"],
  "maxResults": 50
}
```

### Example: people open to freelance work in a given industry

```json
{
  "searchQuery": "brand designer",
  "cookie": "YOUR_LI_AT_COOKIE",
  "industry": "Marketing and Advertising",
  "openTo": ["PROVIDING_SERVICES"],
  "maxResults": 30
}
```

### Use cases

- **Recruiting and sourcing** — build a candidate shortlist filtered by seniority, function, and years of experience
- **Sales prospecting** — find decision-makers at companies of a specific size and industry
- **Talent mapping** — see how many people with a given title work at a target company or came from a specific school
- **Freelance/agency hiring** — search for people who've flagged themselves as `PROVIDING_SERVICES` in a niche
- **Alumni and network outreach** — find people from a specific school or who follow your company page

### FAQ

**Why does this actor need a LinkedIn cookie?**
People search is only available to logged-in LinkedIn users, so a valid session cookie (`li_at` or a full cookie export) is required. Without one, or with an expired one, the run returns only the cookie notice row described above.

**Will my results match what I'd see searching manually?**
Closely, but not identically — LinkedIn personalizes search results based on your account's own network, location, and plan, so the same query can return different people from different accounts.

**What's the difference between `currentCompany` as a name versus a URN?**
A company URN or numeric ID applies LinkedIn's strict structured company filter. A plain company name is instead folded into the free-text search keywords, which is usually accurate for well-known company names but less exact than a URN.

**Why is `connectionDegree` sometimes missing from a result?**
LinkedIn only shows a connection-degree badge for profiles it places in your visible network graph; some results simply don't carry one.

**Why don't all profiles have a `profilePicture`?**
Some LinkedIn users restrict their photo to connections only; the actor returns the picture URL only when the search response actually includes one.

**Can I combine many filters at once?**
Yes — every filter is sent with the same search, and the more you combine, the narrower (and often smaller) the result set. LinkedIn decides how strictly each filter is honoured for your account, so spot-check results when you stack many of them.

**How many profiles can I get per run?**
Up to `maxResults`, capped at 100 per run.

**Is this affiliated with LinkedIn?**
No. This is an independent, third-party actor that uses your own LinkedIn session to run a people search; it is not affiliated with or endorsed by LinkedIn.

# Actor input Schema

## `searchQuery` (type: `string`):

Search keywords for finding people on LinkedIn. Examples: 'software engineer', 'John Smith', 'product manager Google'

## `keywords` (type: `string`):

Optional companion to Search Query. When both are set, they are combined with a space. Use this to keep a primary role in Search Query and add modifiers (industry buzzwords, tools) here.

## `cookie` (type: `string`):

Your LinkedIn session cookie. Accepts either: (1) the li_at value from browser DevTools → Application → Cookies, or (2) full cookies JSON array exported from an extension like EditThisCookie.

## `location` (type: `string`):

Filter results by location (city, state, or country). Example: 'San Francisco Bay Area', 'New York', 'United Kingdom'

## `currentCompany` (type: `string`):

Filter by current company. Accepts a company name (e.g. 'Google') or a LinkedIn fsd_company URN/numeric ID. URN format produces the strict structured currentCompany filter; plain names are added to keywords.

## `pastCompany` (type: `string`):

Filter by past company. Accepts a company name or a LinkedIn fsd_company URN/numeric ID.

## `school` (type: `string`):

Filter by school or university attended. Accepts a school name or a LinkedIn fsd_school URN/numeric ID. Example: 'Stanford University', 'MIT', or '12345'.

## `firstNameKeyword` (type: `string`):

Filter by first name token. Adds a strict firstName filter to the search.

## `lastNameKeyword` (type: `string`):

Filter by last name token. Adds a strict lastName filter to the search.

## `titleKeyword` (type: `string`):

Filter by current job title keyword (e.g. 'Director of Engineering', 'CTO'). Different from Industry / Job Function — this is the free-text title.

## `serviceCategory` (type: `string`):

Filter by LinkedIn Services Marketplace category (e.g. 'Web Development', 'Marketing Strategy').

## `companyHeadcount` (type: `array`):

Filter by employer company size. A=Self-employed, B=1-10, C=11-50, D=51-200, E=201-500, F=501-1,000, G=1,001-5,000, H=5,001-10,000, I=10,001+.

## `followerOf` (type: `string`):

Filter to people who follow a specific company. Accepts an fsd_company URN or numeric company ID.

## `geoUrn` (type: `string`):

Precise location filter using a LinkedIn geo URN or numeric geo ID (e.g. '103644278' for the United States). Use this for strict geographic filtering instead of the free-text Location field.

## `connectionDegree` (type: `string`):

Filter by connection degree to your account.

## `industry` (type: `string`):

Filter results by industry. Applied to both Voyager filters and the HTML search URL.

## `seniorityLevel` (type: `string`):

Filter results by seniority level.

## `yearsOfExperience` (type: `string`):

Filter results by years of total professional experience. 1=Less than 1 year, 2=1-2 years, 3=3-5 years, 4=6-10 years, 5=11-15 years, 6=16+ years.

## `jobFunction` (type: `string`):

Filter results by job function / department.

## `openTo` (type: `array`):

Filter people by what they are open to. Select one or more options. HIRING = open to hiring, GETTING_HIRED = open to new jobs, PROVIDING_SERVICES = open to providing freelance/consulting services, JOINING_A_NONPROFIT = open to joining a nonprofit.

## `profileLanguages` (type: `array`):

Filter by the language(s) the person's LinkedIn profile is written in. Use ISO 639-1 codes, e.g. \["en", "es", "fr", "de", "zh", "ar", "pt"].

## `contactOf` (type: `string`):

Filter to show people who are connections of the specified LinkedIn member. Provide the member's URN (e.g. 'urn:li:member:123456') or numeric profile ID.

## `talksAbout` (type: `string`):

Filter to people who talk about the specified keyword or topic in their profile. This is appended to the search keywords.

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

Maximum number of profiles to return.

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

Optional Apify proxy configuration.

## Actor input object example

```json
{
  "searchQuery": "software engineer",
  "connectionDegree": "",
  "industry": "",
  "seniorityLevel": "",
  "yearsOfExperience": "",
  "jobFunction": "",
  "maxResults": 25
}
```

# Actor output Schema

## `profiles` (type: `string`):

Dataset containing all scraped LinkedIn profiles from the search.

# 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 = {
    "searchQuery": "software engineer",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/linkedin-people-finder-by-role-seniority").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 = {
    "searchQuery": "software engineer",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/linkedin-people-finder-by-role-seniority").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchQuery": "software engineer",
  "maxResults": 25
}' |
apify call nimbryxo-studio/linkedin-people-finder-by-role-seniority --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/linkedin-people-finder-by-role-seniority"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/M7DHH5XpX0Xay3eLy/builds/CrEkFHlcagPwfg7e7/openapi.json