# LinkedIn Company Employees — Staff List + Full Profiles ✅ (`sputnikapi/company-employees`) Actor

List the current employees of any company from its website domain, then pick how much to return: the roster row at $1.50 per 1,000, the full profile at $3.20, or the profile plus recorded emails and phones at $8 — every tier under the shelf price. Each employee once. No cookies, no 2,500-row cap.

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

## Pricing

from $1.50 / 1,000 employee rows

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/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 — the full staff list by website domain

> **$1.50 per 1,000 employees for the roster row, $3.20 for the full profile,
> $8 with recorded emails and phones — every tier below the busiest Actor on
> this shelf, on every Apify plan.** Each employee is delivered once: the
> store keeps historical snapshots of the same person, and you are not
> charged for the copies.

### What it costs against the shelf

Per 1,000 employees, same three modes the shelf sells:

| What you get | Shelf price | Here |
|---|---|---|
| Roster row — name, title, seniority, freshness | $3.00 | **$1.50** |
| Full profile — the whole career card | $8.00 | **$3.20** |
| Full profile **+ recorded emails and phones** | $12.00 | **$8.00** |
| Run start fee | $20.00 per 1,000 runs | **$1.00 per 1,000 runs** |

(Read off the public Apify listing on 2026-09-18. Those are its prices on the
plans most buyers are on; its discounts start at the higher subscription
tiers. Ours is one flat price on every plan, free tier included.)

List the current employees of any company by its site domain. Get names,
current titles, seniority buckets, headlines, reachability flags, and
LinkedIn profile links — with freshness stamps on every row telling you when the
profile *and the position itself* were last re-confirmed.

This is a **database lookup, not a live scrape**: rosters return in seconds
from a database of over one billion professional profiles. "Current" means
the position is confirmed current at the record's freshness stamp — stale
records are filtered on our side, not left for you to discover.

### Input

```json
{
  "companies": ["stripe.com", "figma.com"],
  "roles": ["cxo", "vp"],
  "profileDetail": "profile",
  "maxRows": 500
}
```

- `companies` — site domains, or numeric company ids from a previous run.
- `roles` — optional seniority filter: `cxo`, `founder`, `vp`, `director`,
  `manager`, `other`. Empty = whole roster. The filter is free.
- `profileDetail` — how much to return per employee:

  - `roster` (default, **$0.0015/row**) — the staff list below;
  - `profile` (**$0.0032/row**) — the same row plus the employee's whole
    career card: every position with dates and descriptions, education,
    skills, languages, certifications;
  - `contacts` (**$0.008/row**) — the complete 164-field document, including
    the recorded email addresses and phone numbers.

  The richer tiers pull the profiles in the same run — no second Actor, no
  paying twice for the same list — and cap a run at 10,000 employees. An
  employee the profile store cannot answer for still ships, as a roster row
  charged at the roster price; the `_detail` column on every row says which
  tier it actually carries. If the profile store is unreachable for the whole
  run, one free `detail_unavailable` row says so rather than letting a roster
  export pass for a profile export.

### What you get — every row is a confirmed current employee

| Group | Fields |
|---|---|
| Identity | full name, first/last name, headline, profile URL, slug |
| Role | current title, seniority bucket (`cxo` … `other`), in-role-since year |
| Location | city, country code |
| Reachability | `hasPersonalEmail`, `hasWorkEmail` — know who is contactable before enriching |
| Network size | connection count |
| Career depth | first position year (career start) |
| Freshness | `personUpdatedAt` **and** `positionUpdatedAt` — when the profile and this exact position were last re-parsed — plus the `_freshness` bucket |
| Honesty | `incompleteExperience` flag, free `unresolved_domain` rows for domains no company record vouches for, explicit `skipped_row_budget` rows when `maxRows` truncates a roster, a free `detail_unavailable` row when a richer tier could not be served |
| Upsell | `_fullData` — the person's complete 164-field document via the direct API |

A row (anonymized sample of the shape):

```json
{
  "_status": "found",
  "_input": { "company": 456123 },
  "_freshness": "fresh_90d",
  "fullName": "Jane Doe",
  "firstName": "Jane",
  "lastName": "Doe",
  "title": "VP Engineering",
  "seniority": "vp",
  "headline": "VP Engineering at Acme",
  "locality": "Amsterdam",
  "countryCode": "nl",
  "connectionsCount": 1147,
  "hasPersonalEmail": true,
  "hasWorkEmail": true,
  "positionStartYear": 2021,
  "personUpdatedAt": "2026-08-14T09:12:44Z",
  "positionUpdatedAt": "2026-08-14T09:12:44Z",
  "profileUrl": "https://www.linkedin.com/in/…"
}
```

The **Output tab** shows two views: *Overview* (one line per employee) and
*Reachability & freshness* (email flags + re-check timestamps for ranking).

### Pricing — you pay per employee row

| Event | Price | When |
|---|---|---|
| Employee row | $0.0015 | after the row landed in your dataset |
| Repeat of an employee already delivered | **$0** | never reaches your dataset |
| Unresolved domain / invalid entry | **$0** | always free, named in the output |

**$1.50 per 1,000 employees — one row per person.** The store keeps
historical snapshots of a person under separate ids, so a raw roster walk
returns the same employee several times (measured on full rosters at
13.5–21.7% of rows). This Actor delivers each person once, so the price per
thousand rows is also the price per thousand people. No 2,500-row
source-site cap — up to **50,000 rows per run**; set `maxRows` to cap the
spend.

### FAQ

**How do I get emails for the roster?** Every row carries the reachability
flags; feed the `profileUrl` column to our **Bulk People Enrichment (CSV)**
actor (`fullOutput: true` includes the contact block), or name + domain to
the **Work Email Finder** for verified work addresses.

**A domain came back `unresolved_domain` — do I pay?** No. It is a free
row telling you no company record vouches for that domain; the rest of your
list still answered.

### The family

Same engine, other doors: **Reverse Email Lookup** (email → person),
**Profile Lookup** (URL → profile), **Work Email Finder** (name + domain →
email), **People/Company Database Search** (filters → lists),
**Name-to-Profile**, **Social Handle Lookup**, **Bulk People Enrichment**
(CSV, 50k rows). One data core, one billing promise: misses are free.

### Disclaimer

This Actor is an independent product and is not affiliated with, endorsed
by, or sponsored by LinkedIn Corporation. It does not access, crawl, or
scrape LinkedIn at run time — answers come from our own database of
publicly available professional data; "LinkedIn" is used only to describe
the kind of public profile data the database covers. Removal requests are
honored via the Issues tab.

# Actor input Schema

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

One company per line: a site domain (acme.com) or a numeric company id from a previous run. Domains that match no company come back as free "unresolved\_domain" rows.

## `roles` (type: `array`):

Keep only these seniority buckets. Leave empty for the whole roster.

## `profileDetail` (type: `string`):

The roster row is the cheap staff list. The two richer tiers pull each employee's profile document in the same run — no second actor, no re-paying for the list. Rows the profile store cannot answer ship as roster rows and are charged as roster rows. The richer tiers cap a run at 10,000 employees.

## `maxRows` (type: `integer`):

Stop after this many employee rows across all companies (default 1000; maximum 50000 on roster rows, 10000 on the profile tiers). Companies left unqueried when the cap hits are reported as free skipped\_row\_budget rows.

## Actor input object example

```json
{
  "companies": [
    "stripe.com"
  ],
  "roles": [
    "cxo"
  ],
  "profileDetail": "roster",
  "maxRows": 100
}
```

# 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": [
        "stripe.com"
    ],
    "roles": [
        "cxo"
    ],
    "profileDetail": "roster",
    "maxRows": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("sputnikapi/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.com"],
    "roles": ["cxo"],
    "profileDetail": "roster",
    "maxRows": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("sputnikapi/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.com"
  ],
  "roles": [
    "cxo"
  ],
  "profileDetail": "roster",
  "maxRows": 100
}' |
apify call sputnikapi/company-employees --silent --output-dataset

```

## MCP server setup

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