# LinkedIn People Search by Name with Company & School Filters (`vexaloom-labs/linkedin-people-search-by-name-with-company`) Actor

Search LinkedIn for a list of names and get matching profiles with headline, location, current role and company, connection degree, and profile picture.

- **URL**: https://apify.com/vexaloom-labs/linkedin-people-search-by-name-with-company.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Social media, Lead generation, Automation
- **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 Name & Company (No Login)

Turn a list of names into LinkedIn profiles — with the current employer, location, headline, photo and followers — without a LinkedIn account, cookie or proxy. Give the actor names plus an optional company or location, and it returns the people who match.

### What this actor does

- Looks up each name in LinkedIn's public people directory and returns the matching profiles, up to 50 candidates per name.
- Narrows the list with strict **current company** and **location** filters: every candidate's public profile page is checked before a row is kept, so a person whose company only appears in a directory summary is verified or dropped.
- Opens each matched profile to fill the public details: current employer, location, followers, "500+" connection indicator, about text, education and profile photo.
- Understands full names, single names, middle names, and one-sided searches (`first:Madonna`, `last:Smith`).
- Removes duplicates, so the same profile is never returned twice in one run.
- Works with zero credentials and zero proxy setup. No LinkedIn login is used at any point.

### Output per profile

| Field | Description |
|---|---|
| `name` | The person's name as shown on their profile. |
| `profileUrl` | Canonical `https://www.linkedin.com/in/...` profile URL. |
| `headline` | Real headline when publicly visible or recoverable from an indexed public result (`headlineSource: "page"` or `"search_engine"`); omitted when LinkedIn hides it everywhere. |
| `currentTitle` | Job title parsed from a real headline, when available. |
| `location` | The location shown on the profile. |
| `currentCompany` | Current employer as `{name, slug, url}`. |
| `companyText` | The employer summary shown in the directory card, kept for traceability. |
| `companyRedacted` | `true` when LinkedIn hides the employer and would otherwise show the job title in its place. |
| `about` | The public About text (`aboutSource`: `page`, `dom` or `og`). |
| `aboutTruncated` | `true` when LinkedIn only exposes a truncated About excerpt to logged-out visitors. |
| `followersCount` | Follower count. |
| `connectionsText` | Public connection indicator, usually `"500+"`. |
| `currentSchool` | School shown in the profile's top card. |
| `education` / `educationCount` | Public education entries (profile data, with an `og:description` fallback) and their count. |
| `profilePicture` / `profileImageUrl` | Profile photo URL when the member has a real photo. |
| `searchName` | The input name that produced this row. |
| `discoveredVia` | `directory`, `directory_profile` (the directory page was the profile itself) or `search_engine`. |
| `searchEngine` | `yahoo` or `duckduckgo` when the row came from the search-engine fallback. |
| `scrapedAt` | ISO 8601 UTC timestamp. |

Empty fields are omitted, never emitted as `null`. The legacy keys `connectionDegree`, `verifiedStatus`, `openToWork`, `mutualConnections` and `commonInterests` remain part of the record shape but are not available without a logged-in session, so they do not appear.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `names` | List of strings | – | Names to look up. Full names, single names, or `first:` / `last:` for a one-sided search. Required. |
| `maxResultsPerName` | Integer (1–50) | `10` | Profiles to return per name. |
| `currentCompany` | String | – | Keep only people whose current employer contains this text. |
| `location` | String | – | Keep only people whose location contains this text. |
| `enrichProfiles` | Boolean | `true` | Open each matched profile for photo, about, followers, education and a verified employer. Off = directory cards only. |
| `includeHeadlinesFromSearchEngines` | Boolean | `true` | Best-effort extra matches and indexed headlines from public search engines, including a company-specific headline fallback derived from each profile. Also drives the company-augmented rescue query. |

#### Example: name plus company

```json
{
  "names": ["Satya Nadella", "Sundar Pichai"],
  "currentCompany": "Microsoft",
  "maxResultsPerName": 5
}
```

#### Example: location filter

```json
{
  "names": ["John Smith"],
  "location": "London",
  "enrichProfiles": true
}
```

#### Example: fastest mode

```json
{
  "names": ["Ada Lovelace", "Grace Hopper"],
  "enrichProfiles": false,
  "maxResultsPerName": 10
}
```

### Use cases

- **Lead research** — turn a list of names into current employer, role and profile links.
- **Recruiting** — confirm a candidate's current company and location before outreach.
- **CRM cleanup** — refresh LinkedIn URLs and employers for existing contacts.
- **Name disambiguation** — use company or location to pick the right person among namesakes.

### FAQ

**Do I need a LinkedIn cookie or account?** No. The actor reads only LinkedIn's public directory and logged-out profile pages. It never asks for a login and does not use your account.

**Why is a person missing from the results?** LinkedIn's public directory shows at most 50 candidates per name. Very common names ("John Smith") can push the person you want outside that window. Add a company or location filter: the actor then also runs a company-augmented public search-engine query, which recovers many common-name cases, and verifies every candidate against its profile.

**Are the company and location filters exact?** They are case-insensitive text matches, verified against the profile the actor opens. They keep people whose current employer or location contains your text. They are not LinkedIn's own server-side filters.

**Why is the headline missing for some people?** LinkedIn hides most logged-out headlines and replaces them with asterisks or the current company. The actor returns a real headline when it is visible on the page or recoverable from an indexed public result (name, vanity and name+company query forms); otherwise the field is left out rather than guessed.

**Why do some rows have `companyRedacted: true`?** On some profiles LinkedIn hides the employer and puts the job title where the company should be. The actor detects that pattern, never reports the job title as a company, and marks the record instead.

**Why does the connection count say "500+"?** LinkedIn caps the public connection indicator at "500+". An exact number is not exposed to logged-out visitors.

**Can I get email addresses, skills or full work history?** No. Those fields require a logged-in LinkedIn session and are outside this actor's public-data scope.

**What happens when a name has no matches?** No row is emitted for that name; the run continues with the remaining names.

**Is this actor affiliated with LinkedIn?** No. It is an independent tool and is not affiliated with, endorsed by or sponsored by LinkedIn Corporation.

### Data source & limitations

The actor reads LinkedIn's public people directory (`/pub/dir/`) and the public, logged-out profile pages it links to. It selects its own access path automatically; no proxy configuration is needed.

Honest limits: the directory window is about 50 candidates per name; exact connections, skills, full experience history, education degrees and contact details are not public; and headline visibility depends on what LinkedIn and public search indexes expose to logged-out visitors. The search-engine fallback is best-effort and may pause itself when the engines rate-limit. About texts are often truncated for anonymous visitors (flagged with `aboutTruncated`).

# Actor input Schema

## `names` (type: `array`):

Person names to look up. Use a full name ("Satya Nadella"), a single name, or "First Middle Last". Prefix a single term with "first:" or "last:" for a one-sided search.

## `maxResultsPerName` (type: `integer`):

Maximum profiles to return for each name. LinkedIn's public directory lists up to 50 candidates per name.

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

Keep only people whose current employer contains this text, e.g. "Microsoft" or "Conrad Labs". Checked against the profile the actor opens for each candidate.

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

Keep only people whose location contains this text, e.g. "London" or "Pakistan".

## `enrichProfiles` (type: `boolean`):

Open each matched profile's public page to fill photo, about, followers, education and a verified current employer. Turn off for a faster, directory-only result.

## `includeHeadlinesFromSearchEngines` (type: `boolean`):

When the directory has fewer matches than requested, also check public search-engine results for the name. Also recovers indexed headlines. Free and best-effort.

## Actor input object example

```json
{
  "names": [
    "Satya Nadella"
  ],
  "maxResultsPerName": 1,
  "enrichProfiles": true,
  "includeHeadlinesFromSearchEngines": true
}
```

# Actor output Schema

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

Dataset containing one row per matched profile.

# 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 = {
    "names": [
        "Satya Nadella"
    ],
    "maxResultsPerName": 1,
    "enrichProfiles": true,
    "includeHeadlinesFromSearchEngines": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/linkedin-people-search-by-name-with-company").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 = {
    "names": ["Satya Nadella"],
    "maxResultsPerName": 1,
    "enrichProfiles": True,
    "includeHeadlinesFromSearchEngines": False,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/linkedin-people-search-by-name-with-company").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 '{
  "names": [
    "Satya Nadella"
  ],
  "maxResultsPerName": 1,
  "enrichProfiles": true,
  "includeHeadlinesFromSearchEngines": false
}' |
apify call vexaloom-labs/linkedin-people-search-by-name-with-company --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/linkedin-people-search-by-name-with-company"
        }
    }
}
```

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/qbDkwl2DwUF7XO3zX/builds/7KkQyVManVFJioeS8/openapi.json