# LinkedIn Company Employees Scraper ✅ NO COOKIES (`atomus/linkedin-company-employees`) Actor

Get a company's employees as rich, structured profiles from a LinkedIn URL or domain. Each result is a full profile: work history, education, skills, certifications, badges, plus company firmographics. Filter by title, seniority, location, department. Optional verified email. Pay per result.

- **URL**: https://apify.com/atomus/linkedin-company-employees.md
- **Developed by:** [Atomus APIs](https://apify.com/atomus) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 4 total users, 3 monthly users, 93.8% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $6.00 / 1,000 employee founds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

A **LinkedIn company employees scraper** that turns one company into a list of its employees as **rich, structured profiles**. Give it a company's **LinkedIn URL or website domain**, narrow with filters (job title, seniority, location, department, keywords), and get back full profiles: **name, headline, current title, complete work history, education, skills, certifications, LinkedIn badges, follower counts, and full company firmographics**. **No LinkedIn account, login, or cookies required.**

**Pay only for the employees returned** — set **Max results** to cap your spend. Optionally add a **verified work email** for each employee.

> 💡 **More LinkedIn tools by Atomus:** https://apify.com/atomus
>
> 📚 **Full docs, examples & guides:** https://atomusapi.dev

***

### What does this LinkedIn Company Employees Scraper do?

Give it one company and it returns a rich JSON record for each matching employee, ready to load into a CRM, spreadsheet, or AI agent.

| Feature | Description |
|---------|-------------|
| 👥 **Employees from one company** | Paste a LinkedIn company URL (`https://www.linkedin.com/company/<slug>`) or a domain (`example.com`) and get its people. |
| 📋 **Rich, complete profiles** | Every result is a full profile: full name, headline, current title, complete work history, education, skills, certifications, industry, and profile links — not just a name and a title. |
| 🎯 **Precise filters** | Job title (smart / whole-word / exact), seniority, department / function, location, and free-text keywords. Filter on the employee's **current** title. |
| 🏢 **Full company firmographics** | Each row carries the company's industry, headcount, founding year, funding, tech stack, and HQ. |
| 📧 **Verified work email (add-on)** | Optional: a real-time, verified work email per employee. Billed only when an email is **found**. |
| 💰 **Pay only for results** | You are charged **per employee returned**. No matches = free. **Max results** is your hard spend cap. |
| 🔐 **No cookies needed** | No LinkedIn account, cookies, or risk of bans. |

***

### How do I scrape a company's employees?

1. **Open the Actor** and paste one company into the `company` field — a LinkedIn company URL or a domain.
2. **Add filters (optional).** Job titles, seniority, department, location, keywords. Leave them empty to get everyone.
3. **Set Max results.** This caps how many employees you get back — and your spend.
4. **Click Start.** The Actor pages through the matches and pushes one record per employee.
5. **Read the results.** Each record has a `status` (`success` | `not_found` | `error`); successful records carry the full profile.

No login, no browser session, no cookies — a company in, structured employee data out.

***

### Input

#### Basic usage

```json
{
  "company": "https://www.linkedin.com/company/stripe",
  "title": ["Software Engineer"],
  "location": ["Ireland"],
  "maxResults": 100
}
```

#### All input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `company` | string | ✅ Yes | (none) | LinkedIn company URL (`https://www.linkedin.com/company/<slug>`) or website domain (`example.com`). A domain also matches subsidiaries; the LinkedIn URL is the most precise. |
| `title` | string\[] | No | (all) | Match employees whose **current** title contains any of these, e.g. `"Software Engineer"`. |
| `titleMatchMode` | string | No | `SMART` | `SMART` (fuzzy, catches "Sr. Software Engineer"), `WORD` (whole words), or `STRICT` (exact). |
| `seniority` | string\[] | No | (all) | Keep only these levels: `c_suite`, `vp`, `director`, `manager`, `senior`, `mid-level`, `entry`, `intern`, `owner`, `founder`, `head`, `partner`. |
| `department` | string\[] | No | (all) | Keep only these departments/functions, e.g. `engineering`, `sales`, `marketing`, `product_management`. |
| `location` | string\[] | No | (all) | Keep only employees in these locations (country, region, or continent), e.g. `"United States"`, `"Ireland"`. |
| `keyword` | string\[] | No | (none) | Free-text keywords matched in the employee's headline / summary / skills. |
| `maxResults` | integer | No | `100` | Hard cap on employees returned — your spend cap. Stops at this or when matches run out. |
| `findEmail` | boolean | No | `false` | ⚠️ **Costs extra, paid plans only.** Also return a verified work email per employee, billed as a separate event **only when an email is found**. Employees without a verifiable email are free. |

***

### Output

Each employee is one dataset record:

```json
{
  "status": "success",
  "full_name": "Leonardo Specht",
  "headline": "SWE @ Stripe | Ex Amazon, Meta",
  "title": "Software Engineer",
  "company_name": "Stripe",
  "location": "Dublin, County Dublin, Ireland, Europe",
  "seniority": "senior",
  "linkedin_url": "https://www.linkedin.com/in/leospecht",
  "last_updated": "2026-07-20",
  "email": "lspecht@stripe.com",
  "email_status": "VALID",
  "raw": { "profile": { "...": "full profile: work history, education, skills, certifications, badges, and full company firmographics" } }
}
```

- `email` / `email_status` appear only when the **Find work email** add-on is on and an email was found.
- The `raw` field carries the complete profile object (work history, education, skills, certifications, LinkedIn badges, follower counts, and the full company firmographic block).
- `status: "not_found"` means no employees matched. `status: "error"` carries a `reason`.

***

### How much does it cost to scrape a company's employees?

- **Per employee returned** — you pay only for employees the Actor delivers. No matches and errors are always free.
- **Find work email add-on** — billed as a separate event **only for each email actually found**. Employees without a verifiable email are free.
- **Max results** is a hard cap, so your cost per run is predictable and fully under your control.

***

### How it works

The Actor searches a continuously refreshed database of 400M+ enriched LinkedIn profiles — no scraping of your own, no cookies, no account, no ban risk. Because it filters on the employee's **current** title and company, results are the people who work there **now**. Data freshness is shown per record in `last_updated`.

***

### LinkedIn Company Employees Scraper vs cookie-based tools vs the official API

| | This Actor | Cookie / session tools | Official LinkedIn API |
|---|---|---|---|
| **LinkedIn account needed** | No | Yes (your account is at risk) | Yes (approved partner) |
| **Ban / detection risk** | None | High — sessions get flagged | None |
| **Employee search by filters** | Yes (title, seniority, location, department) | Varies, often manual | No public employee-list endpoint |
| **Full profile per employee** | Yes (work history, education, skills, company firmographics) | Usually limited fields | Minimal, permissioned fields |
| **Verified work email** | Optional add-on | Rare | No |
| **Pricing** | Pay per employee returned | Monthly seat / credits | Enterprise contract |

***

### Frequently asked questions

**Is there an official LinkedIn API to list a company's employees?**
No. LinkedIn's official API does not expose a public "list this company's employees" endpoint, which is why teams use a scraper. This Actor returns that list without your own LinkedIn account.

**Do I need LinkedIn cookies or an account?**
No. There are no cookies, no login, and no session — so there is no account-ban risk.

**How fresh is the data?**
Each record carries a `last_updated` date. Profiles come from a continuously refreshed database and reflect the employee's current company and title.

**How am I charged?**
Per employee returned. Runs that match nothing, and errors, are free. The optional work-email add-on is charged only for each email actually found. Set **Max results** to cap your spend.

**Is it legal to scrape LinkedIn?**
The Actor returns publicly available professional data and does not use your LinkedIn account. You are responsible for using the data in line with applicable laws (e.g. GDPR/CCPA) and your own policies.

***

### Other LinkedIn tools by Atomus

- **[LinkedIn Profile Scraper](https://apify.com/atomus/linkedin-profile-scraper)** — enrich individual profile URLs into full records.
- **[LinkedIn Reactions Scraper](https://apify.com/atomus/linkedin-reactions-scraper)** — everyone who reacted to a post.
- **[LinkedIn Posts Scraper](https://apify.com/atomus/linkedin-posts-scraper)** — a profile's or company's posts.
- **[LinkedIn Comments Scraper](https://apify.com/atomus/linkedin-comments-scraper)** — all comments on a post.

> 📚 More tools and full documentation: https://apify.com/atomus · https://atomusapi.dev

# Actor input Schema

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

The company whose employees you want. Paste its LinkedIn company URL (https://www.linkedin.com/company/<slug>) OR its website domain (example.com). LinkedIn URL is the most precise; a domain also matches subsidiaries.

## `title` (type: `array`):

Match employees whose CURRENT title contains any of these, e.g. "Software Engineer", "Account Executive". Leave empty for all titles.

## `titleMatchMode` (type: `string`):

SMART = fuzzy (recommended, catches "Sr. Software Engineer"). WORD = whole words. STRICT = exact title only.

## `seniority` (type: `array`):

Keep only these seniority levels. Leave empty for all.

## `department` (type: `array`):

Keep only these departments/functions. Leave empty for all.

## `location` (type: `array`):

Keep only employees in these locations, using AI Ark location names (country, region, or continent), e.g. "United States", "Ireland", "California". Leave empty for all.

## `keyword` (type: `array`):

Free-text keywords matched in the employee's headline/summary/skills, e.g. "kubernetes", "payments". Leave empty to skip.

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

Hard cap on how many employees to return — this is your spend cap (you pay per employee returned). The run stops once it hits this or runs out of matches. LinkedIn/AI Ark surfaces at most a few thousand per query.

## `findEmail` (type: `boolean`):

⚠️ THIS ADDS COST. When enabled, each returned employee also includes a real-time, BounceBan-verified work email, billed as a SEPARATE paid event for every email found (on top of the per-employee charge). You are charged ONLY when an email is actually found — employees without a verifiable email are free. Available on PAID Apify plans only (a free-tier run with this on is rejected without charge). Leave OFF unless you specifically want emails.

## Actor input object example

```json
{
  "company": "https://www.linkedin.com/company/stripe",
  "titleMatchMode": "SMART",
  "maxResults": 100,
  "findEmail": false
}
```

# Actor output Schema

## `employees` (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 = {
    "company": "https://www.linkedin.com/company/stripe",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("atomus/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 = {
    "company": "https://www.linkedin.com/company/stripe",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("atomus/linkedin-company-employees").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 '{
  "company": "https://www.linkedin.com/company/stripe",
  "maxResults": 100
}' |
apify call atomus/linkedin-company-employees --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/w0684cqqGaFYvxSOh/builds/aQs4Sq8JWGo2q61Ro/openapi.json