# LinkedIn People Search (`deepmine/linkedin-people-search`) Actor

LinkedIn people search scraper with no login: find profiles by job title, company, location and keywords, then open each public profile for place, photo, followers, about, current company, schools and more. Pay the full price only for profiles that open.

- **URL**: https://apify.com/deepmine/linkedin-people-search.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** Lead generation, Social media, Jobs
- **Stats:** 1 total users, 1 monthly users, 93.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.45 / 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

LinkedIn people search scraper with no login: type a job title, company, location or keywords and get the LinkedIn profiles that match, with each person's public profile opened for place, photo, followers, about, current company, schools and more.

| 👤 Name | 📝 Headline | 🏢 Company | 📍 Location | ✨ Enriched | 👥 Followers | 🤝 Connections |
|---|---|---|---|---|---|---|
| Pedro M. | Product Manager | T-Mobile | Seattle, Washington, United States | ✅ | 796 | 500+ |
| Stephen C. | E-commerce Founder and Product Manager | Capy | Seattle, Washington, United States | ✅ | 1,735 | 500+ |
| Kelly A. | Sr Product Manager, Amazon | Amazon | Seattle | – | – | 273 |

<sub>Collected 2026-10-06 from the prefilled search (Product Manager, Seattle). Last names shortened here; the dataset has full names.</sub>

**Price:** $0.75 per 1,000 people on Starter, plus $2.00 per 1,000 profiles that open ($0.90 + $2.00 on Free, $0.60 + $2.00 on Scale, $0.45 + $2.00 on Business). No start fee. The prefilled run (50 people, 50 profiles opened on our run of 2026-10-06) costs about $0.14 on Starter.

### What you get

- **Every person the search lists**, in search order (`rank`; the first row is whichever of the first few profiles answers first, so it shows up sooner), up to your max: name, headline, job title, current company, school, place, connections, profile URL and the search snippet.
- **Opened profiles** (`isEnriched: true`): photo, exact place and country, followers, connections, about text, current company and school with their LinkedIn pages and logos, education with dates, languages, certifications, courses, awards, volunteering, organizations, projects, publications, websites, recommendations count and similar profiles.
- **Profiles that don't open** (`isEnriched: false`, rare) still come with what the search result shows, at the partial price.
- `seniorityLevel` and `jobFunction` on every row, read from the title and headline, with filters on both.

**How many profiles open?** Nearly all. On our own runs of 2026-10-06 (version 0.1.15, three searches at a time): data scientists in San Francisco 300 of 300, registered nurses in Chicago 300 of 300, product managers in Seattle 299 of 300, and 1,000 of 1,000 on a 1,000-person run of the same search; on 2026-10-07 (version 0.1.18) 300 of 300 on each of product managers in Seattle, registered nurses in Chicago and Stripe. You pay the opened-profile price only for the ones that open. A profile LinkedIn refuses is asked once more through residential proxy while the run's small allowance for that lasts (a share of what the run charges); past it, the person comes with the search result's fields at the partial price, and the run's status message says how many.

No LinkedIn account, cookie or login is used anywhere.

### How to use it

1. Type a **💼 Job title** and a **📍 Location** (or a **🏢 Company**, or **🔤 Keywords**, in any mix).
2. Set **💯 Max people per search** and keep **✨ Open each profile** on for the full fields.
3. Start. Rows arrive while the run goes; export them as CSV, Excel or JSON, or call the run through the API.

**Depth.** One search-engine result list stops after 200 to 500 people, so a search also runs sliced copies of itself: your title with the role phrases people write ("Senior Product Manager"), plus the employers and schools of the people already found, and keeps only people whose search result names your title (and company). On our runs of 2026-10-06, Product Manager in Seattle listed 1,500 people from one search (platform run, profile opening off, 3 minutes; the same search listed 245 to 257 before), and Stripe, Registered Nurse in Chicago and Software Engineer in Austin each listed 1,000 on local runs. Set **💯 Max people per search** as high as you want; a search ends when the results run out, and the run summary lists every sliced query and what it added. Several searches in one run: put more lines in **📝 More searches** (Advanced), e.g. `"data scientist" "Berlin"`. A person found by two searches is delivered and charged once.

#### Filters (free)

- **📍 Only people in this location** (on by default): leaves out people whose LinkedIn place names somewhere else. A search for *Austin* also finds people *named* Austin; they're left out too when their place isn't shown and only their name holds the word. People shown with just a country are kept.
- **🎚️ Seniority** and **🧭 Job function**: keep only the levels and functions you pick.

People a filter leaves out are never charged.

### Input example

```json
{
  "title": "Product Manager",
  "location": "Seattle",
  "maxResults": 50,
  "enrichProfiles": true
}
```

### Output fields

One row per person; every row has every key (`null` when unknown), in this order:

- `photo`: profile photo URL (opened profiles)
- `fullName`, `firstName`, `lastName`
- `headline`: the profile headline (from the search result; LinkedIn hides it on most logged-out pages)
- `jobTitle`: current job title (current position when shown, else the start of the headline)
- `currentCompany`, `location`
- `profileUrl`: `https://www.linkedin.com/in/<id>`
- `isEnriched`: `true` when the public profile opened
- `followers`, `connections` (500 for "500+"), `connectionsText`
- `aboutSnippet`, `about`: the about text LinkedIn shows logged out (it cuts long ones at about 300 characters)
- `currentCompanyUrl`, `currentCompanyLogo`, `country`, `countryCode`, `school`, `schoolUrl`, `schoolLogo`
- `experience`: positions LinkedIn shows logged out (`title`, `company`, `companyUrl`, `companyLogo`, `location`, `isCurrent`, `startDate`, `endDate`, `duration`, `description`). Current positions come with their company, company page, logo and place; past positions (`isCurrent: false`) with their place and company logo, since LinkedIn names no company on them for logged-out visitors. LinkedIn hides titles and dates on nearly every position (13 of 983 positions carried them on our runs of 2026-10-06). Hidden or masked values are left out, never passed on.
- `education`: `school`, `schoolUrl`, `schoolLogo`, `degree`, `startDate`, `endDate`
- `schools`, `languages`, `certifications`, `courses`, `awards`, `volunteering`, `organizations`, `projects`, `publications`, `websites`, `badges`: lists
- `recommendations`: recommendations received
- `coverImage`, `similarProfileUrls`
- `seniorityLevel`: Intern, Entry, Senior, Manager, Director, VP, CXO, Partner or Owner
- `jobFunction`: Sales, Marketing, Engineering, Data, Product, Design, Finance, Human Resources, Operations, Legal, IT, Customer Success, Consulting, Education or Healthcare
- `publicIdentifier`: the part of the URL after `/in/`
- `memberId`: LinkedIn's numeric member id (opened profiles)
- `enrichmentStatus`: `enriched`, `notPublic` (LinkedIn refused the page), `notRequested` (Open each profile off, or the run stopped opening profiles because LinkedIn opened fewer than 1 in 5 of the first 40 or more: the status message says so) or `failed`
- `searchSnippet`: the text the search result showed
- `rank`: position in its search's results
- `searchQuery`: the search that found the person
- `scrapedAt`: when the row was collected (UTC)

Photo and cover links are LinkedIn's signed image links; they keep working for a long time but aren't permanent.

Dataset views: 📊 Overview, 📈 Stats and 🪪 Profile details. The run summary (`OUTPUT` in the key-value store) lists every search: people found, delivered, opened, left out by each filter, result pages read and why it ended.

### Good to know

- **Where the people come from:** a web search of LinkedIn's public profiles (the `site:linkedin.com/in` search that recruiters use), read page by page and walked again on fresh connections to list more. LinkedIn's own people search needs a login, so it isn't used.
- **Depth:** see above. Free-form lines in 📝 More searches are listed as typed, without sliced copies.
- **Not shown to logged-out visitors, so not returned:** skills and endorsements, interests, featured items, Premium, verified, Open-to-Work and hiring flags, the date a member joined, employment and workplace type, titles and dates of most positions, emails and phone numbers. (Checked 2026-10-06/07 on public profile pages under a browser and under 10 link-preview and search crawlers, and on each LinkedIn data endpoint that carries these fields: each one answers a logged-out visitor with 401, 410 or 999.)
- **Memory:** runs default to 2,048 MB. LinkedIn's pages and the search engine's results need CPU, and at 512 MB a 1,000-person run was CPU-bound.
- A search with no matches ends successfully and says so; if the search engine refuses every page after retries, the run fails with a clear message instead of returning nothing.

### Related Actors

- [LinkedIn Jobs Search](https://apify.com/deepmine/linkedin-jobs-search): job listings with company details
- [LinkedIn Ad Library API](https://apify.com/deepmine/linkedin-ad-library): the ads a company runs on LinkedIn

### Feedback

Found a bug or need a field? Open an issue on the Issues tab; we answer within 48 hours. If the Actor saved you time, a review on the Store helps other buyers find it.

# Actor input Schema

## `title` (type: `string`):

The role people have, as they write it on LinkedIn, e.g. <code>Product Manager</code>, <code>registered nurse</code>, <code>Head of Growth</code>. Matched as an exact phrase.

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

A city, region or country, e.g. <code>Seattle</code>, <code>London</code>, <code>Germany</code>. Matched as an exact phrase.

## `company` (type: `string`):

A company name, e.g. <code>Stripe</code>: people who mention it on their profile (mostly its staff, sometimes former staff). Matched as an exact phrase.

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

Any other words a profile should contain, e.g. <code>python fintech</code>. Put a phrase in quotes to match it exactly.

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

How many people to collect and pay for per search, in the order the search lists them. On our test searches (a title + a city, or a company) one search listed 1,000 people or more; a narrow one lists fewer.

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

Open each person's public LinkedIn profile for place, photo, followers, connections, about, current company and school links, schools, languages, certifications and more. Nearly all open without login (299 or 300 of 300 on each of our 300-person test runs, see the README); one that doesn't comes with the search result's fields (name, headline, company, school, place). An opened profile costs extra; a profile that doesn't open costs the partial price only.

## `strictLocation` (type: `boolean`):

Leave out people whose LinkedIn place names somewhere else (a search for Austin also finds people named Austin). People whose place isn't shown, or shown only as a country, are kept. People left out are free.

## `seniorityLevels` (type: `array`):

Keep only these seniority levels, read from each person's title and headline (seniorityLevel in the output). Empty = everyone. People whose headline names no role are left out while this filter is on.

## `jobFunctions` (type: `array`):

Keep only these functions, read from each person's title and headline (jobFunction in the output). Empty = everyone.

## `searchQueries` (type: `array`):

Extra searches, one per line, each with its own max: words and "exact phrases", e.g. <code>"data scientist" "Berlin"</code> or <code>"recruiter" "Toronto" fintech</code>. People found by an earlier search aren't charged twice.

## `maxResultsTotal` (type: `integer`):

Stop after this many people across all searches. Empty = no limit (your max cost per run still applies).

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

Leave as is: the search and the profiles run on Apify datacenter proxy (a profile it refuses is asked once more through Apify residential), at no extra cost to you. Your own proxy URLs, if you set them, are used for both.

## Actor input object example

```json
{
  "title": "Product Manager",
  "location": "Seattle",
  "maxResults": 50,
  "enrichProfiles": true,
  "strictLocation": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "title": "Product Manager",
    "location": "Seattle",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/linkedin-people-search").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 = {
    "title": "Product Manager",
    "location": "Seattle",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/linkedin-people-search").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 '{
  "title": "Product Manager",
  "location": "Seattle",
  "maxResults": 50
}' |
apify call deepmine/linkedin-people-search --silent --output-dataset

```

## MCP server setup

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

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/JTeKBhfN3dd73nXpC/builds/eoEJVLy9MMSwvFT1x/openapi.json