# LinkedIn People Search by Name (`lergassy/linkedin-people-search-by-name`) Actor

Find LinkedIn profiles by person name without login: for each name, up to 50 matching public profiles with full name, location, current company, number of other companies and schools, photo and profile URL. Filter by location or company; optional full profile.

- **URL**: https://apify.com/lergassy/linkedin-people-search-by-name.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Lead generation, Social media, Agents
- **Stats:** 6 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.21 / 1,000 people

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Search by Name** finds LinkedIn profiles from a list of person names — **without a LinkedIn account, login or cookies**. For every name you get up to **50 matching public profiles** with **full name, location, current company, how many other companies and schools they list, profile photo and profile URL**, plus how many people with that name LinkedIn has in total. Narrow the matches by location or company, and add the **full public profile** (headline, experience, education, about) when you need it.

**$0.30 per 1,000 profiles** ($0.0003 each) plus **$0.001 per name** that returns at least one profile — a full 50-profile name costs $0.016. Names with no match, bad input and failed lookups are free. No fee per run.

### Tested head-to-head — 13 October 2026

Same request for six LinkedIn people-search tools on Apify: the name **"Maria Garcia"**, 20 results.

| | This Actor | The other five tools |
|---|---|---|
| Rows returned (20 asked) | **20** | 5–20 |
| Rows that really are "Maria Garcia" | **18 of 20** — LinkedIn's own name directory | 2 of 10 … 16 of 20 on keyword-style search |
| Fields per row | **21** — incl. current company, schools count, photo | 4–77 |
| Price for these 20 rows | **$0.007** | $0.004 (10 rows) – $0.10 |
| Time | **6 s** | 2–11 s |

The cheapest other tool returns 10 people per $0.004 page with loose name matching; the ones with a job headline on every row charge $5–7 per 1,000. Here the headline comes with the full-profile add-on.

### What is LinkedIn People Search by Name?

It is the "who is this person on LinkedIn?" step of a sales, recruiting or research workflow, done in bulk. It reads **LinkedIn's public people directory** (`linkedin.com/pub/dir`) — the page LinkedIn itself shows logged-out visitors and search engines when someone looks a person up by name — and turns it into clean rows. Because nothing is logged in, there is no session cookie to paste and no LinkedIn account that can be restricted.

Paste one name or ten thousand; run it from the Apify console, the API, a spreadsheet, n8n, Make, Zapier or an AI agent.

### What data can it extract?

| Field | Example | Meaning |
|---|---|---|
| `fullName`, `firstName`, `lastName` | Satya Nadella | Name as shown on the card |
| `location` | Redmond, WA | Location as the member wrote it — a city, metro area or country |
| `currentCompany` | Microsoft | The first company LinkedIn lists on the card — in practice the current or latest one |
| `moreCompaniesCount` | 4 | Other companies on the profile ("Microsoft, +4 more") |
| `schoolsCount`, `school` | 3, "Manipal Institute of Technology, Manipal" | Number of schools; the first school when LinkedIn names it instead of a count |
| `photoUrl` | https://media.licdn.com/… | Profile photo (200×200) when the member has a public one |
| `linkedinUrl`, `publicIdentifier` | https://www.linkedin.com/in/satyanadella | Profile URL and slug |
| `rank`, `totalMatches` | 1, 11 | Position among the cards LinkedIn showed for the name, and how many people with that name LinkedIn reports in total |
| `searchName`, `searchFirstName`, `searchLastName` | Satya Nadella | Which of your names this row answers, and how it was searched |
| `headline`, `fullProfile` | Chairman and CEO at Microsoft | **Add-on ($):** the full public profile — headline, title, company, experience with dates, education, about, followers, connections, skills, certifications, languages and more |

Every person row has every field; what the card does not show is `null`. The card does **not** show a headline or job title — turn on the full-profile add-on for those.

### How much does it cost?

Pay per result (pay-per-event), with Apify's usual discounts on paid plans:

| Event | Price (Free plan) | Bronze | Silver | Gold+ |
|---|---|---|---|---|
| Name search — once per name that returns at least one profile | **$0.001** | $0.001 | $0.001 | $0.001 |
| Person — one matching profile row | **$0.0003** | $0.00027 | $0.00024 | $0.00021 |
| Add-on: full profile — only when you turn it on and the profile was read | **$0.003** | $0.0027 | $0.0024 | $0.0021 |

- **What a name costs (Free plan):** 50 profiles $0.016 · 20 profiles $0.007 · 1 profile $0.0013. With the full profile of every match: 10 profiles $0.034.
- **Results per $1:** about **3,100 profiles** at 50 per name (≈ 4,300 on Gold), or **about 300 profiles with full profile**.
- Apify's free plan ($5 of monthly credit) covers roughly **15,000 profiles** a month.
- **Free:** names with no match, names where none of the matches pass your filters, input values that are not names, lookups LinkedIn refused this time, names not searched because "Max cost per run" was reached, full profiles that could not be read. You get a row saying why, and it costs $0.
- Filtered-out cards are never charged — you pay for the rows you get.
- No start fee and no proxy charge — the route to LinkedIn is included in the price.
- Set **Max cost per run** in the run options and the Actor stops itself, green, at that amount.

### How to search LinkedIn people by name

1. Open the Actor and put your names in **Person names**, one per line.
2. Optionally type a **Location contains** or **Company contains** filter.
3. Optionally turn on **Add the full profile of every match ($)**.
4. Click **Start**. A name takes 5–15 seconds; four names run in parallel.
5. Download the results as CSV, Excel or JSON, or fetch them through the API.

#### How names are read

- "First Last" → the first word is the first name, everything after it the last name ("Ludwig van Beethoven" → *Ludwig* + *van Beethoven*). For names of three or more words, if that split finds nobody, the other split is tried once (*Ludwig van* + *Beethoven*) at no cost to you.
- "Smith, John" (CRM / last-name-first exports) is turned around to John Smith.
- Titles, credentials and middle initials are dropped: "Dr. John F. Kennedy, PhD" → John Kennedy.
- One word → searched as a first name ("Satya" → everyone named Satya, 50 cards).
- Duplicate names are searched once.

### ⬇️ Input

```json
{
  "names": ["Satya Nadella", "John Smith"],
  "locationContains": "",
  "companyContains": "",
  "maxResultsPerName": 50,
  "includeFullProfile": false
}
```

| Field | Required | What it does |
|---|---|---|
| `names` | yes | Person names, one per line |
| `locationContains` | no | Keep people whose location contains this text (`London`, `TX`); alternatives with `|` (`London|Manchester`) |
| `companyContains` | no | Keep people whose current company contains this text (`Microsoft`); alternatives with `|` |
| `maxResultsPerName` | no | 1–50, default 50 |
| `includeFullProfile` | no | Paid add-on, default off |

**The filters are applied on our side, after fetching.** LinkedIn's public directory has no location or company filter, so the Actor takes the up-to-50 cards LinkedIn shows for a name and keeps the ones that match. A filter narrows those 50 — it cannot reach people beyond them. Matching is case- and accent-insensitive substring matching on the text the card shows: a card that says "Dallas, TX" matches `TX` and `Dallas`, but not `United States`, because the card does not say it. Filtered-out cards are not charged, and a name whose cards are all filtered out costs nothing.

### ⬆️ Output

```json
{
  "type": "person",
  "searchName": "Satya Nadella",
  "searchFirstName": "Satya",
  "searchLastName": "Nadella",
  "rank": 1,
  "fullName": "Satya Nadella",
  "firstName": "Satya",
  "lastName": "Nadella",
  "location": "Redmond, WA",
  "currentCompany": "Microsoft",
  "moreCompaniesCount": 4,
  "schoolsCount": 3,
  "school": "Manipal Institute of Technology, Manipal",
  "photoUrl": "https://media.licdn.com/dms/image/v2/C5603AQHHUuOSlRVA1w/profile-displayphoto-shrink_200_200/…",
  "linkedinUrl": "https://www.linkedin.com/in/satyanadella",
  "publicIdentifier": "satyanadella",
  "totalMatches": 11,
  "headline": null,
  "fullProfile": null,
  "fullProfileError": null,
  "scrapedAt": "2026-10-05T06:00:40.105Z"
}
```

With **Add the full profile of every match** on, `headline` is filled and `fullProfile` holds the public profile — the same fields as our [LinkedIn Profile Scraper](https://apify.com/lergassy/linkedin-profile-scraper): `headline`, `title`, `company`, `companyLinkedinUrl`, `location`, `city`, `region`, `countryCode`, `about`, `followers`, `connections`, `experience[]` (title, company, dates, description), `education[]`, `certifications[]`, `languages`, `skills`, `imageUrl`, `memberId` and more.

A name with no match gives one free row:

```json
{ "type": "notice", "kind": "no-results", "searchName": "Zxqvbn Qwplkjh", "totalMatches": 0, "notice": "LinkedIn's public directory has no profiles named \"Zxqvbn Qwplkjh\". Not charged." }
```

The dataset has three views: **People** (the table above; free rows explaining a name with no match come after the people, with a Note column), **With full profile** and **Notices and errors**. The run's key-value store holds a `SUMMARY` record (names searched, no-match names, cards removed by filters, rows delivered).

### Use cases

#### Sales and lead enrichment

You have names from a CRM, an event attendee list or a conference badge scan — find their LinkedIn profiles, current company and location, then filter by the company you expected.

#### Recruiting

Find the profile of a referred candidate from just a name and city, or check whether a name on a CV matches a public profile at the stated company.

#### Identity checks and research

How common is a name on LinkedIn (`totalMatches`), who with that name works at a given company, which one lives in a given city.

#### AI agents and RAG

An agent with the Apify MCP server can call this Actor with `names: ["Jane Doe"]` and `companyContains: "Stripe"` and get structured rows back — no login flow, no secrets to provide.

### Integrations

Run it through the [Apify API](https://docs.apify.com/api/v2) or the Python and JavaScript clients, schedule it, or connect it to **n8n, Make, Zapier, Google Sheets, Slack, Airbyte, LangChain** and the **Apify MCP server**. Results export as JSON, CSV, Excel, XML or HTML.

```bash
curl -X POST "https://api.apify.com/v2/acts/lergassy~linkedin-people-search-by-name/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "content-type: application/json" \
  -d '{"names":["Satya Nadella"],"companyContains":"Microsoft"}'
```

### Limitations — read before a big run

- **At most 50 profiles per name.** LinkedIn's public directory shows logged-out visitors no more than 50 people per name; there is no next page. For a common name ("John Smith" — 102,000+ on LinkedIn) you get 50 of them, and which 50 can change between runs. Use the filters, or add a middle name, to narrow common names.
- **Filters are applied after fetching**, to those 50 cards (see Input).
- **No headline or job title on the card** — only the first listed company. Turn on the full-profile add-on for headline, title and experience.
- Only members whose profile is public appear in LinkedIn's public directory.

### Troubleshooting

- **A name came back as an error row "Could not open LinkedIn's public directory…"** — LinkedIn refused that lookup this time. It is free; run the name again.
- **"None of them matched your filters"** — the card text does not contain your filter word. Try a shorter word (`TX` instead of `Texas`), alternatives (`NY|New York`), or no filter.
- **`fullProfileError` is filled** — LinkedIn did not show that profile to a logged-out visitor on this try; the add-on was not charged for it.

### ❓ FAQ

#### Do I need a LinkedIn account or cookies?

No. The Actor reads LinkedIn's public directory and public profile pages only. Nothing is logged in, so no account can be restricted.

#### Is it legal to scrape LinkedIn?

The Actor reads only information people have made public, as any logged-out visitor or search engine sees it. In the US, the Ninth Circuit held in hiQ Labs v. LinkedIn that collecting publicly accessible profiles is unlikely to be "unauthorized access" under the CFAA, but the rows are still personal data: under GDPR, CCPA and similar laws you need a lawful basis (for example legitimate interest) to process them, must honour opt-out and deletion requests, and should respect LinkedIn's terms. Use it for legitimate business purposes and consult a lawyer if unsure.

#### Why only 50 results for "John Smith"?

That is LinkedIn's own ceiling for logged-out visitors. Tools that go deeper log in with an account and pay with ban risk and a higher price.

#### How fresh is the data?

Every run reads LinkedIn live; nothing is cached.

#### Can I search by job title or company only?

Not with this Actor — it needs a name. For "everyone with title X at company Y", see the other LinkedIn Actors below.

#### Does it return emails or phone numbers?

No — public profiles do not show them. For a work email, use [LinkedIn Email Finder](https://apify.com/lergassy/linkedin-email-finder).

### Your feedback

Found a bug or need a field? Open an issue on the Actor's **Issues** tab — we answer within a day. If the Actor saved you time, a short review helps other people find it.

### You might also like

| Actor | What it does |
|---|---|
| [LinkedIn Profile Scraper — No Cookies](https://apify.com/lergassy/linkedin-profile-scraper) | Full public profile from a profile URL: experience, education, skills, posts |
| [LinkedIn Profile Scraper with Email](https://apify.com/lergassy/linkedin-profile-email-scraper) | The profile plus a work email |
| [LinkedIn Email Finder](https://apify.com/lergassy/linkedin-email-finder) | Work email for a LinkedIn profile |
| [LinkedIn Company Scraper](https://apify.com/lergassy/linkedin-company-scraper) | Size, industry, followers and HQ of the companies you find here |
| [LinkedIn Jobs Scraper](https://apify.com/lergassy/linkedin-jobs-scraper) | Who a company is hiring |
| [LinkedIn Posts Scraper](https://apify.com/lergassy/linkedin-posts-scraper) | A person's or company's latest posts |

**Also known as:** LinkedIn people search API, find LinkedIn profile by name, LinkedIn name lookup, LinkedIn people finder, search LinkedIn without login, LinkedIn profile search by name, LinkedIn public directory scraper, reverse name lookup LinkedIn.

# Changelog

This Actor's version history is a separate document: https://apify.com/lergassy/linkedin-people-search-by-name/changelog.md

# Actor input Schema

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

Full names to look up, one per line — <b>Satya Nadella</b>. The first word is the first name, the rest the last name (3+ words: the other split is tried if the first finds nobody). "Smith, John" works too. One word = first name only. Up to 50 matching public profiles per name.

## `locationContains` (type: `string`):

Keep only people whose location contains this text, e.g. <b>London</b> or <b>TX</b>. Case- and accent-insensitive; separate alternatives with | (London|Manchester). Applied on our side to the 50 cards LinkedIn returns per name — it narrows them, it cannot find more. Leave empty for everyone.

## `companyContains` (type: `string`):

Keep only people whose current company (the first one LinkedIn lists on the card) contains this text, e.g. <b>Microsoft</b>. Alternatives with |. Applied on our side to the 50 cards per name. Leave empty for everyone.

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

How many matching profiles to return for each name, after the filters. 50 is the ceiling: LinkedIn's public directory shows at most 50 people per name to logged-out visitors.

## `includeFullProfile` (type: `boolean`):

Paid add-on: also open each match's public profile and add its headline, current title, experience with dates, education, about, followers and more to the row (field fullProfile). Charged per profile actually read; profiles that could not be read are free.

## Actor input object example

```json
{
  "names": [
    "Satya Nadella",
    "John Smith"
  ],
  "maxResultsPerName": 20,
  "includeFullProfile": false
}
```

# Actor output Schema

## `results` (type: `string`):

One row per matching public LinkedIn profile: name, location, current company, other companies and schools count, photo, profile URL, rank and total matches; plus free notice/error rows.

## `runSummary` (type: `string`):

JSON summary of the run: names searched, no-match names, cards removed by filters, profiles and full profiles delivered, failed names (free).

## `notAttempted` (type: `string`):

JSON list of names the run did not reach before its timeout. Not charged — pass them as input to a new run. Present only when the run stopped early.

# 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",
        "John Smith"
    ],
    "maxResultsPerName": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/linkedin-people-search-by-name").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",
        "John Smith",
    ],
    "maxResultsPerName": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("lergassy/linkedin-people-search-by-name").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",
    "John Smith"
  ],
  "maxResultsPerName": 20
}' |
apify call lergassy/linkedin-people-search-by-name --silent --output-dataset

```

## MCP server setup

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

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/LXUfaqcAGtdVAjycB/builds/ODKFtknSrXKhEG6GM/openapi.json