# LinkedIn Company Employees Scraper · No Cookies · $1/1k ✅ (`linkedintel/linkedin-company-employees-scraper-no-cookies`) Actor

Find LinkedIn employees who self-identify their employer in their profile headline. No cookies, no login. Best for famous distinctive company names. $1/1k per matched employee.

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

## Pricing

$1.00 / 1,000 employee match extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## LinkedIn Company Employees Scraper — Find people who work at any company

Find LinkedIn profiles of people who **self-identify their employer in their headline** — the way most LinkedIn users do. Clean structured JSON output. **No LinkedIn login, no cookies, no browser session, no account ban risk.**

Built for **B2B sales prospecting at named accounts, recruiting target-company outreach lists, competitive talent intelligence, ABM contact-discovery, and investor portfolio-company research**.

---

### Honest scope: who this catches and who it misses

Most LinkedIn-employees scrapers claim to return "the full employee list" of a company. Truthfully — that requires either a logged-in scrape (account ban risk) or a paid LinkedIn Premium / Sales Navigator integration. Neither is cookieless.

**This actor takes a different approach**: it finds employees who **publicly self-identify** their employer in their LinkedIn headline (e.g., `"Senior Engineer at Microsoft"`, `"Microsoft Architect"`, `"@ Microsoft"`). That's how most professionals format their headlines — so for famous companies this finds the majority of public-facing employees.

| Approach | Coverage | Trade-off |
|---|---|---|
| Logged-in scrape | ~100% (full list) | Account ban risk, requires cookie, brittle |
| **This actor (headline match)** | **40-70% for famous companies** | Cookieless, safe, $1/1k |
| Paid LinkedIn Sales Navigator API | ~100% | $$$ + corporate-only access |

**Best for**: famous distinctive company names (Microsoft, OpenAI, Apple, Stripe). **Less effective for**: ambiguous names ("Apple" matches fruit-related profiles too) or small companies where few employees write their employer in their headline.

### What you get — 1 record per matching employee

For each company you provide, the actor:

1. Resolves the company slug → canonical name + ID via `/companies/company/universal-name-to-id` + `/companies/company/info-v2`
2. Searches `/search/people` with the company name as keyword
3. Filters results client-side: emit only people whose headline contains the company name (case-insensitive)
4. Excludes "Ex-", "Former", "Previously at" entries client-side
5. Emits a `companyEmployee` record per match

#### `companyEmployee` record (16 fields)
- **Company back-refs**: `companyId`, `companyName`, `companyUniversalName`, `companyLinkedinUrl`
- **Identity**: `fullName`, `firstName`, `lastName`, `profileId`, `profileUrn`, `profileUrl`
- **Public bio**: `headline`, `location`, `isPremium`, `profilePictureUrl`
- **Tracking**: `sourceInput`, `scrapedAt`

Plus `diagnostic` (1 per zero-match company) and `summary` (1 per run).

### Use cases (top 7)

#### 1. B2B sales — find decision-makers at target accounts
Feed your top-100 accounts as `companyUrls`. Add a `roleFilter` like `"VP Sales"` or `"Head of Marketing"`. Get an instant prospect list with profile URLs ready for personalized outreach.

#### 2. Recruiting — competitor talent extraction
Need to recruit data scientists from OpenAI? Feed `openai` + `roleFilter: "Data Scientist"`. You get a list of public-facing OpenAI data scientists in seconds.

#### 3. Competitive intelligence — see who's hiring whom
Track a competitor's headcount-by-LinkedIn-headline over time. New senior hires show up in your monthly cron job. Departures show up as headline changes.

#### 4. ABM (account-based marketing) — multi-contact targeting
For each target account, get the public buying-committee members (CMO, CRO, COO, CISO). Pipe into your ABM tool for coordinated multi-touch outreach.

#### 5. Investor research — portfolio-company team mapping
Map the public-facing teams of your portfolio companies. Useful for board-meeting prep, BD intros, and tracking team growth quarter-over-quarter.

#### 6. Conference / event organizer — speaker bench-building
Need speakers from a specific company? Feed the company URL + role-filter for "Director" or above. Returns potential keynote candidates in seconds.

#### 7. Customer success — relationship-mapping at customer accounts
Map every public LinkedIn-visible person at your top customer accounts. Detect when key contacts change roles or leave (headline updates) so you can trigger your offboarding/transition playbooks.

### How it works

1. Set `companyUrls` — LinkedIn company URLs (or slugs). Schools and showcase pages also supported.
2. Set `maxEmployeesPerCompany` (1-1000, default 100).
3. Optionally set `roleFilter` (e.g., `"Software Engineer"`, `"CEO"`) — passes through to vendor's title filter.
4. Optionally set `aliases` (comma-separated) — alternate names that might appear in headlines (e.g., `"MSFT, Azure"` for Microsoft).

For each company: resolve slug → canonical name → search → client-filter on headline → emit matches.

**Cost-control**: customer pays only for MATCHED records, not the candidates scanned. We scan up to 1000 candidates per company at no extra charge; you pay $1/1k for the matches.

No login required. No cookies. Cookieless via managed vendor partnership — no account ban risk.

### Example input

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/microsoft/",
    "openai",
    "anthropic"
  ],
  "maxEmployeesPerCompany": 100,
  "roleFilter": "Software Engineer"
}
````

This returns up to 300 employee records (100 × 3 companies) of software engineers who self-identify these companies in their headlines.

### Pricing — pay only for matched results

**$1.00 per 1,000 matched employees. Pay-per-result.**

- ✅ No subscription
- ✅ No charge for scanned-but-not-matched candidates (we scan up to 1000 per company at no cost)
- ✅ No charge for companies with zero matches (clean diagnostic record)
- ✅ Apify's free tier ($5/month platform credit) covers ~5,000 matched records to start

**Cost comparison: build a 10,000-employee prospect list (across 100 target accounts × 100 employees each):**

| Approach | Cost |
|---|---|
| LinkedIn Sales Navigator (enterprise tier) | ~$1,500+/month |
| harvestapi people search (no company filter) | $20+ (post-filter manually) |
| **This actor** | **$10 (one-shot, cookieless)** |

### Combine with other LinkedIn actors

Build a complete LinkedIn-account-intelligence pipeline:

1. **This actor** → find public-headline employees at named accounts
2. **LinkedIn Profile Scraper** (a17) → pipe `profileUrl` for full firmographic enrichment per employee
3. **LinkedIn Post Scraper** (a16) → pull each employee's recent post activity (engagement signals)
4. **LinkedIn Profile Reactions Scraper** (a9) → see what each employee reacts to (interest signals)
5. **LinkedIn Company Scraper** (a11) → pull full firmographics on the target companies

### FAQ

**Q: Why don't all Microsoft employees appear?**
Many people don't put their employer in their LinkedIn headline (e.g., "Senior PM" without "at Microsoft"). Our cookieless approach catches the ones who do — typically 40-70% of public-facing employees at famous companies. For 100% coverage you'd need a logged-in scrape, which has account-ban risk and breaks our "no cookies" principle.

**Q: What about ex-employees showing "Ex-Microsoft" in their headline?**
Filtered out automatically. We exclude common patterns: `"ex-X"`, `"ex X"`, `"former X"`, `"formerly X"`, `"previously X"`, `"prev X"`, `"past X"`.

**Q: My company name has multiple spellings or variants?**
Use the `aliases` input — comma-separated list of alternate names. Example: `"MSFT, Azure"` for Microsoft. Any of those appearing in a headline counts as a match.

**Q: Can I filter by role / job title?**
Yes. Use `roleFilter` (e.g., `"VP Engineering"`, `"Head of Sales"`). This passes through to the vendor's title filter to narrow the search.

**Q: How accurate is the match?**
We exclude obvious ex-employees but include all current-employee headlines that mention the company. For ambiguous company names (Apple → fruit-related profiles), you may get false positives. Use `aliases` defensively for these cases.

**Q: Can I get the full LinkedIn employees-list of a company?**
No cookieless scraper can. LinkedIn auth-gates the full employees-list page. Our approach trades comprehensiveness for safety (no account-ban risk).

**Q: Is this safe to use vs my LinkedIn account?**
Yes. No login, no cookies, no browser session. The actor never authenticates as you.

### Privacy & compliance

This actor surfaces **publicly self-identified employer information** from LinkedIn profile headlines — content that any logged-out visitor can read.

LinkedIn user data may be subject to LinkedIn's Terms of Use and applicable data protection laws (GDPR, CCPA, etc.). Customers are responsible for compliance when processing or contacting scraped individuals, especially for outreach (CAN-SPAM, GDPR Article 6, etc.).

Not affiliated with, endorsed by, or sponsored by LinkedIn Corporation or Microsoft Corporation.

# Actor input Schema

## `companyUrls` (type: `array`):

List of LinkedIn company URLs (https://www.linkedin.com/company/<slug>/) or bare slugs. Schools and showcase pages also supported.

## `maxEmployeesPerCompany` (type: `integer`):

Hard cap on matching employee records per company. Vendor scans up to 1000 candidates per query; expect 40-70% match rate for famous companies.

## `roleFilter` (type: `string`):

Narrow to employees with this title in their profile (e.g., 'CEO', 'Software Engineer', 'Head of Sales'). Passes through to the vendor /search/people title filter.

## `aliases` (type: `string`):

Comma-separated alternate names for the company that might appear in employee headlines instead of the canonical name. Example: for Microsoft you might add 'MSFT, Azure'. Useful for parent/subsidiary cases.

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.linkedin.com/company/microsoft/"
  ],
  "maxEmployeesPerCompany": 100
}
```

# 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 = {
    "companyUrls": [
        "https://www.linkedin.com/company/microsoft/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("linkedintel/linkedin-company-employees-scraper-no-cookies").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 = { "companyUrls": ["https://www.linkedin.com/company/microsoft/"] }

# Run the Actor and wait for it to finish
run = client.actor("linkedintel/linkedin-company-employees-scraper-no-cookies").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companyUrls": [
    "https://www.linkedin.com/company/microsoft/"
  ]
}' |
apify call linkedintel/linkedin-company-employees-scraper-no-cookies --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=linkedintel/linkedin-company-employees-scraper-no-cookies",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Company Employees Scraper · No Cookies · $1/1k ✅",
        "description": "Find LinkedIn employees who self-identify their employer in their profile headline. No cookies, no login. Best for famous distinctive company names. $1/1k per matched employee.",
        "version": "1.0",
        "x-build-id": "19lbUSq35HEOBXV0z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/linkedintel~linkedin-company-employees-scraper-no-cookies/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-linkedintel-linkedin-company-employees-scraper-no-cookies",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/linkedintel~linkedin-company-employees-scraper-no-cookies/runs": {
            "post": {
                "operationId": "runs-sync-linkedintel-linkedin-company-employees-scraper-no-cookies",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/linkedintel~linkedin-company-employees-scraper-no-cookies/run-sync": {
            "post": {
                "operationId": "run-sync-linkedintel-linkedin-company-employees-scraper-no-cookies",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "companyUrls"
                ],
                "properties": {
                    "companyUrls": {
                        "title": "Company URLs",
                        "type": "array",
                        "description": "List of LinkedIn company URLs (https://www.linkedin.com/company/<slug>/) or bare slugs. Schools and showcase pages also supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmployeesPerCompany": {
                        "title": "Max employees per company",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on matching employee records per company. Vendor scans up to 1000 candidates per query; expect 40-70% match rate for famous companies.",
                        "default": 100
                    },
                    "roleFilter": {
                        "title": "Role / title filter (optional)",
                        "type": "string",
                        "description": "Narrow to employees with this title in their profile (e.g., 'CEO', 'Software Engineer', 'Head of Sales'). Passes through to the vendor /search/people title filter."
                    },
                    "aliases": {
                        "title": "Company name aliases (optional)",
                        "type": "string",
                        "description": "Comma-separated alternate names for the company that might appear in employee headlines instead of the canonical name. Example: for Microsoft you might add 'MSFT, Azure'. Useful for parent/subsidiary cases."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```