# LinkedIn Employees Scraper (`axiomworks/linkedin-company-employees-scraper`) Actor

Find public LinkedIn employee profiles for a company, given its LinkedIn URL or slug, via public Google search results. Returns name, profile URL, headline or job title as shown in search, location and followers, plus company industry, size and HQ. Coverage is partial. No login.

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

## Pricing

from $2.38 / 1,000 results

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

### What does LinkedIn Employees Scraper do?

This Actor finds people who work at a LinkedIn company and returns them as clean, structured records. You give it one or more LinkedIn company page URLs (or just the company slug, such as `stripe`) and it returns each employee's name, public profile URL, headline, job title, location, current company and follower count, together with basic facts about the company: industry, size, headquarters and follower count.

It needs no LinkedIn account, no cookies and no session token. LinkedIn does not show employee lists to logged-out visitors, so the Actor works in two steps. First it reads the public company page to get the exact company name and company details. Then it runs Google searches restricted to public LinkedIn profile pages that mention that company, reads each search result, and resolves the result to the real profile address.

Because discovery relies on what Google has indexed, the list is a partial view of the company, not a complete headcount. Typical yields are a few hundred people per search query. Some results are former employees whose profile still mentions the company. The `strictCompanyMatch` option keeps only results that mention the company name, which removes most off-topic hits. This is stated plainly so you can judge whether the data fits your use case.

This Actor is an independent tool. It is not affiliated with, endorsed by or sponsored by LinkedIn or Google.

### What data can you get?

Each output record describes one person found for one company. Fields that a search result does not show are left empty rather than guessed.

| Field | Description |
|---|---|
| `id` | Stable identifier built from the company and the profile |
| `sourceUrl` | The Google search page the record came from |
| `profileUrl` | Public LinkedIn profile URL, normalised to www.linkedin.com |
| `publicIdentifier` | The profile handle at the end of the URL |
| `fullName` | Person's name as shown in the search result |
| `headline` | Profile headline, may end with an ellipsis |
| `jobTitle` | Job title from the result details or taken from the headline |
| `location` | Location shown for the person |
| `currentCompany` | Current company shown in the result details |
| `followers` | Approximate follower count, for example 1.6K becomes 1600 |
| `snippet` | Text excerpt shown under the result |
| `companyName` | Company name read from the company page |
| `companyUrl` | LinkedIn company page URL |
| `companyIndustry` | Industry of the company |
| `companySize` | Company size range |
| `companyHeadquarters` | Company headquarters |
| `companyFollowers` | Follower count of the company page |
| `searchQuery` | The exact search query that found the person |
| `searchPage` | Result page number within the query |
| `position` | Position of the result on that page |
| `scrapedAt` | ISO timestamp of the extraction |
| `about, experience, education, profileAccess` | Only with `includeProfileDetails`: profile details when LinkedIn shows them, and whether access was full, limited or unavailable |

Common uses include building a first list of people to research at a target company, mapping which job titles a company has, checking where a team is located, and preparing account research for sales or recruiting. Run the Actor with job title keywords to focus on a function such as engineering or sales.

### How to use

You can run the Actor from the Apify Console without writing code.

1. Open the Actor and go to the Input tab.
2. Add one or more company URLs or slugs under Companies. Both `https://www.linkedin.com/company/stripe/` and `stripe` work.
3. Set Max items. The Actor returns exactly that many people in total when that many can be found, split evenly across your companies. If one company runs out of results, the others fill the remaining places.
4. Optionally add job title keywords or locations. Each keyword or location runs as its own search, which also helps reach further into large companies because Google limits a single query to roughly 300 results.
5. Click Start. When the run finishes, open the Output tab to view, filter and download the dataset as JSON, CSV, Excel or HTML.

Runs take time because the Google search step is slow: expect roughly 20 seconds per result page of 10 people. A run for 50 people therefore takes a few minutes. Several pages are fetched in parallel where possible, and requests are rate limited to be polite to the sites involved.

Proxies: linkedin.com blocks datacenter addresses, so company pages are fetched through Apify residential proxies. Google searches use the Apify Google SERP proxy group, and link resolution uses a datacenter proxy. Your Apify account must have access to these proxy groups.

### Input

Only `companies` is required. A run with no valid companies fails immediately with a clear error message.

| Field | Type | Description |
|---|---|---|
| `companies` | array | LinkedIn company URLs or slugs to search |
| `maxItems` | integer | Maximum employees returned in total, split evenly across companies (1 to 10000, default 50) |
| `jobTitleKeywords` | array | Optional job title words, each run as its own search |
| `locations` | array | Optional locations, each run as its own search |
| `strictCompanyMatch` | boolean | Drop results that do not mention the company name (default true) |
| `includeProfileDetails` | boolean | Fetch each profile page for about, experience and education (default false) |
| `maxSearchPagesPerQuery` | integer | Google result pages read per query, 1 to 30 (default 10) |
| `proxyConfiguration` | object | Apify proxy used for linkedin.com, residential recommended |

Example input:

```json
{
  "companies": ["https://www.linkedin.com/company/stripe/", "openai"],
  "maxItems": 20,
  "jobTitleKeywords": ["engineer"],
  "strictCompanyMatch": true
}
```

### Output

Each dataset item looks like the following record, taken from a local test run for Stripe.

```json
{
  "id": "d51b5b6e3c5bed4a0c851dac0ae69d761bff695f9fbc066c57ee713e2c8e7cf7",
  "sourceUrl": "http://www.google.com/search?q=site%3Alinkedin.com%2Fin+%22Stripe%22&hl=en&gl=us&udm=14&start=0",
  "profileUrl": "https://www.linkedin.com/in/william-gaybrick-5730347",
  "publicIdentifier": "william-gaybrick-5730347",
  "fullName": "William Gaybrick",
  "headline": "President, Technology and Business at ...",
  "jobTitle": "President, Technology and Business",
  "location": "San Francisco, California, United States",
  "currentCompany": "Stripe",
  "followers": 10900,
  "snippet": "President, Technology and Business at Stripe · Experience: Stripe · Education: Yale Law School · Location: San Francisco · 500+ connections on LinkedIn.",
  "companyName": "Stripe",
  "companyUrl": "https://www.linkedin.com/company/stripe/",
  "companyIndustry": "Technology, Information and Internet",
  "companySize": "5,001-10,000 employees",
  "companyHeadquarters": "South San Francisco, California",
  "companyFollowers": 1738678,
  "searchQuery": "site:linkedin.com/in \"Stripe\"",
  "searchPage": 1,
  "position": 2,
  "scrapedAt": "2026-09-29T19:33:15.721Z"
}
```

### How much does it cost?

The Actor uses pay per event pricing. You are charged one result event for every employee record saved to the dataset, and an additional enriched result event only when `includeProfileDetails` is on and profile details were actually found for that person. Records dropped by the company match filter are not charged. See the Pricing tab of the Actor for the current price per result. Because you pay per record, setting `maxItems` gives you a hard cap on the cost of a run.

Apify's free plan includes monthly platform credits, so you can try the Actor on a small company before scaling up.

### Use with the API

You can start the Actor from code with the Apify API and clients. Set your API token in the `APIFY_TOKEN` environment variable.

Python:

```python
import os

from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("axiomworks/linkedin-company-employees-scraper").call(
    run_input={"companies": ["stripe"], "maxItems": 20}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["fullName"], item["profileUrl"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('axiomworks/linkedin-company-employees-scraper').call({
    companies: ['stripe'],
    maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => process.stdout.write(`${item.fullName} ${item.profileUrl}\n`));
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~linkedin-company-employees-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["stripe"], "maxItems": 20}'
```

You can also connect the Actor to schedules, webhooks and the standard Apify integrations to send results to spreadsheets, databases or automation tools after each run.

### Use with AI agents (MCP)

You can call this Actor from any MCP compatible AI assistant through the Apify MCP server. Add the Actor to the server URL like this:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=axiomworks/linkedin-company-employees-scraper"
    }
  }
}
```

Example prompts:

- "List 20 engineers at Stripe with their LinkedIn profile URLs and locations."
- "Find sales people at Vercel and group them by location."
- "Which job titles show up most often among people found for OpenAI?"

The input and dataset schemas describe every field, so an agent can choose the right arguments without extra guidance.

### FAQ

**Do I need a LinkedIn account or cookies?** No. The Actor never logs in and never uses cookies.

**Why do I get fewer people than the company's headcount?** LinkedIn hides employee lists from logged-out visitors. The Actor finds people through publicly indexed profile pages, so coverage is partial. Use job title keywords and locations to widen coverage.

**Why are some fields empty?** Search results do not always show a location, job title or current company. Empty fields are left empty. Job title is only filled when the search result shows a pattern such as "Title at Company"; otherwise it is null. `headline` comes from the Google result title and can be cut off with "...", and it is null when the title only shows the company name. `snippet` is null when Google shows the company's own description instead of text about the person.

**Can it return former employees?** Some results are people whose public profile still mentions the company. Keeping strict company match on reduces this but cannot remove it fully.

**What is deep mode?** With `includeProfileDetails` the Actor opens each public profile and reads the structured data LinkedIn shows to logged-out visitors. Many members show only a limited profile, so about, experience and education are best effort. The `profileAccess` field tells you what was available.

**A run failed. What now?** The Actor fails with an explicit message when the input is invalid, none of the companies exists on LinkedIn, a proxy group is not available or no employees could be found. A company slug that LinkedIn does not know is reported within seconds, and the other companies in the same run are still scraped. Check the run log, then retry, since search result quality can vary between requests.

**What happens if a run is about to time out?** The Actor stops starting new searches about a minute before the run timeout, so the people found so far stay in the dataset and the run finishes normally.

**Does it use AI?** No third party AI processor is used.

### Is it legal to scrape LinkedIn?

The Actor only reads pages and search results that are visible to anyone without logging in, and it collects no private data, no email addresses and no phone numbers. Even so, the data describes real people, so you are responsible for using it lawfully. Consider data protection laws such as GDPR and CCPA, the terms of the sites involved, and the purpose you have for the data. Do not use it for spam or harassment, and honour deletion requests. This is general information and not legal advice; consult a lawyer for your situation.

### Feedback

If a field is missing, results look off or you need another output field, open an issue from the Actor page on Apify. Reports that include the run ID and the input you used are the fastest to resolve.

# Actor input Schema

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

LinkedIn company page URLs or bare slugs to find employees for, e.g. 'https://www.linkedin.com/company/stripe/' or 'openai'.

## `maxItems` (type: `integer`):

Maximum employees returned in total across all companies, 1-10000, default 50. Split evenly across companies; if one runs out, the others fill the rest. Google caps a single query at about 300 results.

## `jobTitleKeywords` (type: `array`):

Optional job title words, each run as its own search, e.g. \['engineer','sales','recruiter']. Also helps reach more people at big companies.

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

Optional locations, each run as its own search, e.g. \['London','Berlin'].

## `strictCompanyMatch` (type: `boolean`):

If true, drop search results that do not mention the company name. Recommended to avoid off-topic people.

## `includeProfileDetails` (type: `boolean`):

If true, fetch each public profile page to add about, experience and education when LinkedIn shows them. Slower and costs extra per result (billed as an enriched result). Default false.

## `maxSearchPagesPerQuery` (type: `integer`):

Safety limit of Google result pages (10 results each) read per search query, 1-30, default 10.

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

Apify proxy used for linkedin.com pages. Residential proxies are required because LinkedIn blocks datacenter IPs.

## Actor input object example

```json
{
  "companies": [
    "https://www.linkedin.com/company/stripe/"
  ],
  "maxItems": 10,
  "strictCompanyMatch": true,
  "includeProfileDetails": false,
  "maxSearchPagesPerQuery": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (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": [
        "https://www.linkedin.com/company/stripe/"
    ],
    "maxItems": 10,
    "strictCompanyMatch": true,
    "maxSearchPagesPerQuery": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/linkedin-company-employees-scraper").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": ["https://www.linkedin.com/company/stripe/"],
    "maxItems": 10,
    "strictCompanyMatch": True,
    "maxSearchPagesPerQuery": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/linkedin-company-employees-scraper").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": [
    "https://www.linkedin.com/company/stripe/"
  ],
  "maxItems": 10,
  "strictCompanyMatch": true,
  "maxSearchPagesPerQuery": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call axiomworks/linkedin-company-employees-scraper --silent --output-dataset

```

## MCP server setup

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

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/D1klvNusRtiKh1MWz/builds/wzYGB1bESytGLw4Cq/openapi.json