# LinkedIn Company Employees Scraper (`deepmine/linkedin-company-employees`) Actor

LinkedIn company employees scraper with no login or cookies: type company names or LinkedIn company URLs, get the people who work there with job title, role start date, place, profile URL and how each match was confirmed. Build employee lists for sales, recruiting and account research.

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

## Pricing

from $0.79 / 1,000 employees

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 Company Employees Scraper

LinkedIn company employees scraper with no login or cookies: type company names or LinkedIn company URLs and get the people who work there, with job title, the month their role started, place, profile URL and how each match was confirmed.

| 👤 Name | 💼 Title | 🏢 Company | 📅 Role start | 📍 Location | ✅ Company match |
|---|---|---|---|---|---|
| Jordan W. | Account Executive | Stripe | Mar 2025 | Chicago, Illinois, United States | profileCurrentJob |
| Anuj P. | Fraud Strategist | Stripe | Jun 2025 | San Antonio, Texas, United States | profileCurrentJob |
| Katherine T. | VP, Global Events and Experiential Marketing | HubSpot | Sep 2021 | New York City Metropolitan Area | profileCurrentJob |

<sub>Rows with every column filled, from the prefilled run of 2026-11-02 (Apify run QjRnKfpYKSCws3f4Y, build 0.1.28): 50 people, all 50 opened. Not every row is this full: 16 of 25 rows at each company had a role start. Last names shortened here; the dataset has full names.</sub>

**Price:** $1.49 per 1,000 employees on Starter ($1.78 Free, $1.19 Scale, $0.79 Business). No start fee, and opening each profile is included. The prefilled run (25 people at each of 2 companies, 50 people) costs about $0.07 on Starter.

### What you get

- **People at the company now.** Every result is read for what it says: a dated current job, or the company named as the job. A past job ("Ex-Stripe") or the company word in someone's name is left out, free.
- **`currentRoleStart`, the month the role began.** Useful for spotting new hires and tenure. On 10 test companies, 75.9% of the top rows had it (126 of 166, 2026-11-01); at 25-100 people per company it was 56-76% when Google answered, and on runs that went deep 23-59%, because rows found later show fewer dates (2026-11-02). Rows that come from Yahoo have none, so the total depends on how much Google answers, and that changes from run to run because Google limits the IPs all runs share. Three runs of Figma, Datadog and HubSpot at 100 each, under 3 minutes apart on 2026-11-02, gave 153, 142 and 62 role starts of 300: the first two after a night's rest, and on the third HubSpot had 0 and Figma 6. Rows Google gave had a role start 58-70% of the time on all three. Every run still delivers its people, and the status message names any company that came from Yahoo; for those, run them again later: 24 minutes after the third run, the prefilled run had 16 of 25 role starts at both Stripe and HubSpot.
- **`jobTitle`.** A logged-out LinkedIn profile hides job titles, so this mostly comes from what the search result shows: 36-90% of rows per company on our runs of 2026-11-02, lowest when Google didn't answer.
- **`companyMatch`, how the company was confirmed**, on every row, strongest first:

| `companyMatch` | Meaning |
|---|---|
| `companyPageLink` | The current job on the opened profile links to the company URL you gave |
| `profileCurrentJob` | The opened profile names the company as a current job |
| `datedSearchResult` | The search result shows the company with a start date and "Present" |
| `namedSearchResult` | The search result names the company as the job |

`companyMatchEvidence` holds the text behind it.

- **The opened profile, included in the price:** photo, exact place, country, followers, about text, company and school links with logos, education, past employers, languages, certifications and more.
- `seniorityLevel` and `jobFunction` on every row, with filters on both. `searchEngine` says which engine listed the person.

No LinkedIn account, cookie or login is used anywhere.

### How accurate is it?

**Is the person really there?** On 10 companies from Microsoft to Attio, 162 of 165 accepted rows with a readable page were at the company on the member's own LinkedIn page: 98.2% (2026-11-01). That is LinkedIn's own record, not HR's: someone who left without updating LinkedIn still counts.

**By name, the run keeps the company's main LinkedIn page.** It learns that page from its own first rows, and nobody is charged until it is clear. A row linked only to another employer page is left out, free. Searching the word Notion, 18 lookalikes such as Notion Press were left out, and of the 93 rows with a link, 92 pointed to Notion itself (2026-11-02). The other linked to a school; a row like that is now left out free too. The run's status names the page it chose.

**This also drops subsidiaries with their own page.** "Amazon" leaves out Amazon Web Services and "Microsoft" leaves out Microsoft AI (15 of 600 rows on one run). A row with no company link can't be checked this way and stays: 7 of 100 for Notion. For an exact company, or a subsidiary on its own, paste its URL: only a link to that page counts. That needs the profile open, so a company URL always opens its profiles, included in the price, even with **Open each profile** off. That toggle applies to companies given by name.

**How much of the company do you get?** PostHog publishes its whole team (236 people), which makes it a fair test. Two runs through both search engines found at least 130 and 133 of them, 55-56%, counting exact name matches only (2026-11-02). Larger companies give more rows but a smaller share: 600 of 600 asked for at Microsoft, 300 of 300 at Stripe. Small companies give what the public index holds: asking for 100 each, Browserbase gave 52-54, Mintlify 46-60 and Resend 11-12 on two runs (2026-11-02). Resend is a common word: use its URL.

**This is a good partial list, never a full roster.** Public search shows part of a company's staff. If you need every employee, a signed-in tool goes deeper. If you need current people with titles and dates at a low price and without handing over a cookie, start here.

**Name clashes.** A company called Clay also finds people called Clay. Those are left out free, so a one-word common name gives fewer rows (6 of 20 kept on our test). Paste the company URL instead: the opened profile's company link then settles who works there, and the run's status tells you when a name clashed. By URL, Clay gave the 25 people asked for, all 25 linked to Clay's page, out of 916 people found (2026-11-02). Those left out are free. A word that common takes longer and most of those rows come from Yahoo, so fewer show a role start date (4 of 25 here).

### How to use it

1. Type one company per line in **🏢 Companies**: a name (`Stripe`) or a LinkedIn company URL.
2. Set **💯 Max employees per company**.
3. Start. Rows arrive while the run goes; export them as CSV, Excel or JSON, or call the run through the API.

Optional: **💼 Job title** and **📍 Location** narrow every company, e.g. `Account Executive` in `Dublin`.

#### Example input

```json
{
  "companies": ["Stripe", "https://www.linkedin.com/company/posthog"],
  "maxResults": 25
}
```

#### Example output

```json
{
  "fullName": "Pat Lee",
  "jobTitle": "Customer Success Manager",
  "currentCompany": "Stripe",
  "currentRoleStart": "Jan 2026",
  "location": "London, England, United Kingdom",
  "profileUrl": "https://www.linkedin.com/in/pat-lee",
  "companyMatch": "profileCurrentJob",
  "companyMatchEvidence": "Stripe",
  "seniorityLevel": "Manager",
  "jobFunction": "Customer Success",
  "searchEngine": "google",
  "searchQuery": "Stripe"
}
```

The same row also carries photo, followers, about text, education, past positions and the other opened-profile fields; this example is made up.

### Compared with other company employee Actors

The rivals: one run each on one small company, 2026-11-01, so treat these as indicative. Our column comes from our runs of 2026-11-02 at 25-100 people per company.

| | Signed-in list Actor | Public-index Actors | This Actor |
|---|---|---|---|
| Your LinkedIn cookie or a hosted login | Runs on a signed-in source | No | No |
| Depth | 2,500 per query | Tens to hundreds | Hundreds; a partial list |
| Job title on rows | 8 of 8 | 1 of 10, 5 of 9 | 36-90% |
| When the role started | Tenure months, 7 of 8 | None | 56-73% from Google, 23-59% on deep runs, none from Yahoo |
| How the company was confirmed | Not on the row | Grade, or a verified flag | `companyMatch` on every row |
| First row, from run start, image already cached | 5.8 s | 6.0 s, about 118 s | 2.7-4.9 s by name, 3.8-5.4 s by URL |
| First row on a fresh image | Not measured | Not measured | 5.6-11.4 s by name (the image pull alone was 3-6.6 s), 7.3-7.8 s by URL |

### How it works

The run asks Google for profiles that show the company with "Present", walks the results to the end, then asks again with a role or a place added, because each extra phrase lists other people. A company's first few people come from Yahoo, so its first row doesn't wait for Google; those rows have no role start date. If Google goes quiet partway, Yahoo fills in beside it instead of the run waiting. If there is still room after Google it reads Yahoo again, a second source without dates, and stops once that source stops delivering, so a tiny company doesn't pay for a long read. If Google stops answering, the run moves to Yahoo and its status message says so. A person found twice is delivered and charged once.

### FAQ

**Do I need a LinkedIn account or cookies?** No.

**Can I get emails?** No. This Actor returns what public profiles show.

**Why do some rows have no job title?** The logged-out profile hides it, and that person's search result didn't show one. The row still has the name, the company proof and the profile.

**What's the run summary?** The OUTPUT record lists, per company, how many results were read, how many were left out and why, and what each query added.

### Related Actors

- [LinkedIn People Search](https://apify.com/deepmine/linkedin-people-search): people by job title, place and keywords across companies.
- [LinkedIn Company Details API](https://apify.com/deepmine/linkedin-company-pages): the employer's website, size and headquarters.
- [LinkedIn Jobs Search](https://apify.com/deepmine/linkedin-jobs-search): the roles a company is hiring for.

Found it useful? A review on the Store helps other buyers find it.

# Actor input Schema

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

Company names or LinkedIn company URLs, one per line, e.g. <code>Stripe</code> or <code>https://www.linkedin.com/company/posthog</code>. Use the URL for a name that is also a common word: it tells a company called Clay from people called Clay.

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

How many people to collect and pay for per company. It's a good partial list, not a full roster: public search lists part of a company's staff.

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

Only people with this role, e.g. <code>Account Executive</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.

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

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

Open each person's public LinkedIn profile for photo, exact place, followers, about, schools and the company link. Included in the price. Off gives the search result's fields only, for companies given by name. A company URL always opens its profiles, because only the profile's company link proves the match.

## `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
{
  "companies": [
    "Stripe",
    "HubSpot"
  ],
  "maxResults": 25,
  "strictLocation": true,
  "enrichProfiles": 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 = {
    "companies": [
        "Stripe",
        "HubSpot"
    ],
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/linkedin-company-employees").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 = {
    "companies": [
        "Stripe",
        "HubSpot",
    ],
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/linkedin-company-employees").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 '{
  "companies": [
    "Stripe",
    "HubSpot"
  ],
  "maxResults": 25
}' |
apify call deepmine/linkedin-company-employees --silent --output-dataset

```

## MCP server setup

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

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/qsdm9lSgnT6W9WcZm/builds/whXt6UmQQV2FyuR0t/openapi.json
