# LinkedIn People Search - By Title & Company, No Login (`garnet_puppet/linkedin-people-search`) Actor

Find people on LinkedIn by job title, company and location without logging in: name, headline, current company, location and profile URL. Only people who match your search are delivered and charged.

- **URL**: https://apify.com/garnet_puppet/linkedin-people-search.md
- **Developed by:** [Mehmet](https://apify.com/garnet_puppet) (community)
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 person founds

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 Title & Company, No Login

Find people on LinkedIn by **job title**, **company** and **location**: name, headline, current company, location,
country and LinkedIn profile URL for every match. No LinkedIn account, no cookies, no browser extension.

- **Only real matches are delivered and charged.** A search for "Head of Marketing" at Stripe returns people whose
  headline or LinkedIn summary says they hold that role at that company. Results that merely mention the company ("Ex-Stripe",
  "Stripe Partner", "Shopify Plus Architect") or a past role ("Previously: head of marketing at ...") are skipped
  and never charged.
- **Many searches in one run.** Every job title is searched at every company (and in every location): paste
  "CTO" and "VP Engineering" with 50 target companies and get the decision makers of all 50.
- **Live profile check (optional).** Open each person's public LinkedIn profile to add the live current company,
  company LinkedIn URL, school, full location, followers and photo. If the live profile shows the person has moved
  to another company, they are dropped and not charged (with `strictMatching` on, the default).

### How to use

```json
{
  "jobTitles": ["Head of Marketing", "VP Marketing"],
  "companies": ["Stripe", "Shopify"],
  "locations": ["London"],
  "maxResultsPerSearch": 25,
  "openProfiles": true
}
```

This runs 4 searches (2 job titles × 2 companies × 1 location). Each job title is searched as an exact phrase.
Abbreviations are not expanded, so add both "CTO" and "Chief Technology Officer" if you want both.

### What you get

A real record from a run with the example input "Head of Marketing" at Stripe and profile opening on. That run
delivered 5 people, all five heads of marketing teams at Stripe, and skipped 41 non-matching search results (the
person's name and profile address are shortened here):

```json
{
  "fullName": "Maria P.",
  "headline": "Head of EMEA Marketing at Stripe",
  "headlineIsTruncated": false,
  "currentCompany": "Stripe",
  "companySource": "profile-page",
  "companyLinkedinUrl": "https://www.linkedin.com/company/stripe",
  "searchCompany": null,
  "companyMismatch": false,
  "location": "Amsterdam, North Holland, Netherlands",
  "locationSource": "profile-page",
  "school": "NIMA, Nederlands Instituut voor Marketing",
  "schoolLinkedinUrl": "https://www.linkedin.com/school/nima-nederlands-instituut-voor-marketing",
  "connections": "500+",
  "followers": 3000,
  "followersIsApproximate": true,
  "photoUrl": null,
  "about": "B2B marketing leader with 20+ years of experience helping high-growth technology",
  "aboutIsTruncated": true,
  "countryCode": "NL",
  "countryIsApproximate": true,
  "linkedinUrl": "https://www.linkedin.com/in/<profile>",
  "publicIdentifier": "<profile>",
  "profileStatus": "ok",
  "matched": { "jobTitle": true, "company": true, "location": null },
  "searchQuery": "Head of Marketing at Stripe",
  "searchRank": 12,
  "scrapedAt": "2026-10-13T13:06:11.311Z"
}
```

Every record also carries `search` (the job title, company, location and keywords of the search that found it) and
`searchSnippet` (the search result text the fields were read from).

| Field | Where it comes from |
|---|---|
| `fullName`, `headline` | Search result title. `headlineIsTruncated: true` when the search engine cut the headline and the full text was not available. |
| `currentCompany`, `companySource` | `profile-page` (live profile), `profile-summary` (LinkedIn's own summary in the search result), `headline` ("... at Stripe") or `search-facts`. |
| `searchCompany`, `companyMismatch` | Set when the live profile shows a different company than the search result. |
| `location`, `locationSource` | Live profile, or LinkedIn's summary in the search result (present for about 1 in 5 results). |
| `school`, `connections` | Live profile, or LinkedIn's summary in the search result when it shows them. |
| `followers`, `photoUrl`, `about`, `companyLinkedinUrl`, `schoolLinkedinUrl` | Live profile only (`openProfiles`). `followers` such as "6K" are approximate; `aboutIsTruncated` is true when LinkedIn cut the About text for logged-out visitors. |
| `countryCode` | The country part of the profile address (`uk.linkedin.com` → GB). Approximate: people move. |
| `profileStatus` | `ok`, `closed` (the person hides their profile from logged-out visitors), `not-found`, `blocked`, or `not-requested`. |
| `matched` | Whether the job title, company and location were found. Location never filters: it is often unknown. |

Job history, skills and the full "About" text are only shown to logged-in LinkedIn members, so this Actor does not
return them.

### Pricing

Pay per result:

- **$2 per 1,000 people** delivered (`person-found`), cheaper on higher Apify plans.
- **+$2 per 1,000 profiles opened** (`profile-opened`), only when `openProfiles` is on and the profile is public.

Not charged: search results that do not match, duplicates, people who moved to another company according to their
live profile, and closed profiles (for the profile charge). `maxResults` caps the cost of every run.

### FAQ

**Can I search LinkedIn people without logging in?**
Yes. This Actor never logs in to LinkedIn and needs no account or cookies. People are found through public search
engine results of LinkedIn profiles, and profile details come from the public profile page LinkedIn shows to
logged-out visitors.

**Is there a LinkedIn people search API?**
Every Apify Actor is an API. Start a run with your job titles and companies through the Apify API or one of the
Apify clients and read the results as JSON when it finishes.

**How do I export LinkedIn search results to Excel?**
Open the run's dataset and export it as Excel or CSV, or download it through the API.

**Is there a LinkedIn people search limit?**
Up to 200 searches per run, up to 100 people per search and up to 5,000 people per run. How many people one search
finds depends on how many such people are publicly listed: in our tests, senior titles at a single company (VP
Marketing, CTO, Head of Sales) returned 0 to 10 people per search, common roles such as Recruiter up to 22. To reach
more people, add more companies, title variants ("VP Sales", "Head of Sales", "Sales Director") or locations.

**Why do some people have `profileStatus: closed`?**
They hide their profile from logged-out visitors. Their name, headline and company still come from the search result;
the profile charge is not applied.

**How fresh is the data?**
Search results can be weeks or months old. Turn on `openProfiles` to read the live profile: the current company and
location then come from LinkedIn itself, and people who have moved to another company are dropped.

**Can I search by person name?**
Not in this Actor: it searches by job title, company, location and keywords.

**Do you also have company data?**
Yes: [LinkedIn Company Scraper](https://apify.com/garnet_puppet/linkedin-company-scraper) returns industry, size,
headquarters and followers for a company, plus the emails and phone numbers on the company's own website.

# Actor input Schema

## `jobTitles` (type: `array`):

One job title per line, e.g. Head of Marketing, CTO. Each title is searched as an exact phrase. Abbreviations are not expanded: add both CTO and Chief Technology Officer if you want both.

## `companies` (type: `array`):

One company per line, e.g. Stripe. Every job title is searched at every company.

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

Optional. One city, region or country per line, e.g. London. Every combination of job title, company and location becomes one search (at most 200 per run).

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

Optional words added to every search, e.g. fintech or SaaS.

## `maxResultsPerSearch` (type: `integer`):

How many matching people to collect for each search. Search results thin out after the first pages, so very broad searches may return fewer.

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

Upper limit on people delivered in this run. You are billed per delivered person, so this is also your cost ceiling.

## `openProfiles` (type: `boolean`):

Opens each matching person's public LinkedIn profile to add the live current company, company LinkedIn URL, school, full location, followers and photo. Search results can be months old; the profile page is current. Charged separately, and only when the profile is public.

## `strictMatching` (type: `boolean`):

On: a person is delivered only if their headline contains every word of the job title and the company name. Off: looser search results are delivered too, with match flags, and are charged.

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

Apify Proxy is used by default.

## Actor input object example

```json
{
  "jobTitles": [
    "Head of Marketing"
  ],
  "companies": [
    "Stripe"
  ],
  "maxResultsPerSearch": 10,
  "maxResults": 500,
  "openProfiles": true,
  "strictMatching": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One record per matching person: name, headline, current company, location, country and LinkedIn profile URL, each with its source. With profile opening on: live company, company LinkedIn URL, school, followers and photo.

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

Counts for the whole run: searches, people delivered, results that did not match, duplicates and profiles opened.

# 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 = {
    "jobTitles": [
        "Head of Marketing"
    ],
    "companies": [
        "Stripe"
    ],
    "maxResultsPerSearch": 10,
    "openProfiles": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("garnet_puppet/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 = {
    "jobTitles": ["Head of Marketing"],
    "companies": ["Stripe"],
    "maxResultsPerSearch": 10,
    "openProfiles": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("garnet_puppet/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 '{
  "jobTitles": [
    "Head of Marketing"
  ],
  "companies": [
    "Stripe"
  ],
  "maxResultsPerSearch": 10,
  "openProfiles": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call garnet_puppet/linkedin-people-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,garnet_puppet/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/UwpizG4OLOV0GwdxS/builds/FoSXoZ5jlbO1n2fC1/openapi.json