LinkedIn Company Employees : Org & Department Analytics Scraper

LinkedIn Company Employees Scraper — Seniority & Department Analytics

This Actor scrapes a public LinkedIn company page and every discoverable employee profile behind it, returning one structured row per employee plus career history (experience, education, skills). It layers a rule-based classifier on top: each employee gets a seniority tier and department bucket, and each company gets a roll-up row with headcount, department breakdown, and decision-maker percentage. Every response is structured JSON — ready to pass directly to an LLM, index into a vector store, or feed a monitoring pipeline. No LinkedIn login or Sales Navigator seat is required.

What is LinkedIn Company Employees : Org & Department Analytics Scraper?

LinkedIn Company Employees : Org & Department Analytics Scraper takes one or more LinkedIn company URLs or plain company-name keywords and discovers, scrapes, and classifies that company's public employee profiles. Instead of a flat name-and-title list, every employee row carries a rule-based seniority_level tier and department bucket, and each company gets an optional org_summary roll-up row summarizing headcount, department mix, and decision-maker share. It runs fully logged out — no LinkedIn account, session cookie, or Sales Navigator seat is required.

• Discovers employees via the company's own page, /people/, and /about/ paths, plus a Google site:linkedin.com/in/ fallback search
• Harvests career history (experience, education, skills) from each profile's own embedded structured data, at no extra request cost
• Classifies every employee into a 10-tier seniority level and a 10-category department bucket using rule-based headline matching
• Computes an optional org-composition roll-up row per company (profiles scraped/classified, seniority & department breakdown, decision-maker count/percentage)
• Filters output by seniority tier, department, or decision-maker status before it ever reaches the dataset
• Runs on Apify's residential proxy by default to reduce blocks, with the proxy configuration fully overridable

What data can you get with LinkedIn Company Employees : Org & Department Analytics Scraper?

The Actor returns two result types in the same dataset: an employee profile row for every scraped person, and (optionally) one org roll-up row per company.

Result Type	Extracted Fields	Primary Use Case
Employee profile (type: "employee")	fullname, first_name, last_name, headline, public_identifier, profile_url, profile_picture_url, location, current_company, companies_detected, personal_website, experience, education, skills, seniority_level, seniority_rank, department, is_decision_maker, is_creator, is_influencer, follower_count, show_follower_count, recommendations_received, other_contact_details, contact_elements, created_timestamp, scraped_at, error	Per-person org research, recruiting, prospecting
Org roll-up (type: "org_summary")	company_url, profiles_scraped, profiles_classified, seniority_breakdown, department_breakdown, decision_makers_count, decision_makers_pct, scraped_at	Company-level workforce composition snapshot

Note: first_name, last_name, and seniority_rank are written to every employee row but are not part of the default dataset table view — open the "Employees & org roll-up table" view's column settings, or pull the raw dataset via the API, to see them.

Seniority & department analytics

Every employee row carries two derived fields most public LinkedIn employee scrapers don't compute: seniority_level, from a 10-tier taxonomy modeled on LinkedIn Sales Navigator's own public seniority facet (Owner, Partner, CXO, Vice President, Director, Experienced Manager, Entry Manager, Senior, Entry, In Training), and department, matched against a 10-category rule set (Engineering, Sales, Marketing, HR, Finance, Operations, Product, Design, Legal, Support). Both are matched with regular expressions against the employee's own headline text — no extra request, no authenticated Sales Navigator facet. is_decision_maker is then derived from the tier (Owner/Partner/CXO/VP/Director). When includeOrgRollup is on, the Actor also pushes one org_summary row per company that aggregates every classified profile into seniority_breakdown, department_breakdown, and a decision_makers_pct — a company-level snapshot without any post-processing.

{
  "type": "org_summary",
  "is_org_summary": true,
  "company_url": "https://www.linkedin.com/company/google",
  "profiles_scraped": 15,
  "profiles_classified": 12,
  "seniority_breakdown": { "Experienced Manager": 4, "Senior": 5, "Director": 2, "Entry": 1 },
  "department_breakdown": { "Engineering": 8, "Sales": 2, "Marketing": 2 },
  "decision_makers_count": 2,
  "decision_makers_pct": 16.7
}

Career history (experience, education, skills)

Each employee's own profile page already embeds a Person JSON-LD block LinkedIn renders for SEO. The Actor parses it for worksFor (experience: company name, URL, location, role description, start/end date), alumniOf (education: school name, URL, start/end date), and knowsAbout (skills, as a plain string list) — with includeCareerHistory on (default), at zero additional HTTP requests. Coverage depends on what the profile owner has made public; masked or hidden values are returned as empty rather than guessed.

Why not build this yourself?

LinkedIn does not publish a self-serve API for listing a company's employees, let alone one that returns seniority tier, department, or decision-maker classification — official LinkedIn API access (Marketing Developer Platform, Talent Solutions) is gated behind a Partner Program application and doesn't cover this use case for arbitrary companies. Building an equivalent pipeline yourself means solving several problems this Actor already handles in its source: employee discovery has to fall back to a Google site:linkedin.com/in/ search when a company's /people/ page doesn't return enough profiles; every profile fetch has to detect and back off from authwall/login redirects and HTTP 999 (LinkedIn's block signal), with retry and jittered delay logic tuned to avoid tripping it further; and residential proxying is close to mandatory once request volume rises. On top of the scraping layer, you'd still need to design and maintain the seniority/department taxonomy and its regex rules, then write the two-pass aggregation that turns per-employee rows into a company roll-up. This Actor ships that whole stack — discovery, extraction, classification, and aggregation — as one input form.

What's the difference between a LinkedIn org chart and org-structure analytics?

A LinkedIn org chart implies a reporting-line hierarchy — who manages whom, drawn as a tree. This Actor does not produce that: LinkedIn does not expose manager/reports-to relationships on public profile or company pages, so no scraper working from public data alone can build a true reporting-line chart. What this Actor produces instead is org-structure analytics: every employee classified into a seniority_level tier and a department bucket from their headline text, then rolled up per company into seniority_breakdown, department_breakdown, and decision_makers_pct counts. That distinction matters because the two answer different questions — a reporting-line chart answers "who reports to whom," while this Actor answers "how is this company's headcount distributed across seniority and function, and who are the likely decision-makers." Both department/seniority_level (per-employee) and the org_summary roll-up (per-company) arrive as plain JSON fields, not a rendered chart image. If your workflow needs an actual reporting hierarchy, this Actor's headline-based classification is not a substitute for that — it's a composition snapshot, not an org tree.

How to scrape LinkedIn employee data with LinkedIn Company Employees : Org & Department Analytics Scraper?

1. Open the Actor's page on the Apify Store (scrapier/linkedin-company-employees-org-department-analytics-scraper) and click Try for free / Start.
2. Paste one or more LinkedIn company URLs or plain company-name keywords into companyTargets, one per line — no input field is schema-required, but at least one entry is needed or the run fails.
3. Set employeesPerCompany (default 10, up to 10,000) and toggle includeCareerHistory, includeOrgRollup, senioritiesToInclude, departmentsToInclude, and decisionMakersOnly as needed.
4. Start the run.
5. Download the results as JSON, CSV, Excel, or another Apify dataset export format, or read them through the Apify API.

Example run input:

{
  "companyTargets": ["https://www.linkedin.com/company/google"],
  "employeesPerCompany": 15,
  "includeCareerHistory": true,
  "includeOrgRollup": true,
  "decisionMakersOnly": false
}

How to run multiple companies in one job

companyTargets accepts one entry per line — mix LinkedIn company URLs and plain company-name keywords freely in a single run. The Actor processes each entry sequentially: for a full company URL it scans the company's own page, /people/, and /about/ for employee links, then supplements with a Google site:linkedin.com/in/ search; for a bare keyword it uses the Google search alone. employeesPerCompany applies per entry, not per run, so ten companies at 50 each discovers up to 500 profiles in one job.

⬇️ Input

Parameter	Required	Type	Description	Example Value
companyTargets	No	array of strings	One entry per line: full LinkedIn company URLs or plain keywords/company names for discovery. Also accepts the base actor's urls key.	["https://www.linkedin.com/company/google"]
employeesPerCompany	No	integer	How many employee profiles to discover, scrape, and classify per company/keyword (1–10,000). Also accepts max_employees.	15
includeCareerHistory	No	boolean	Parses each profile's already-fetched page for experience, education, and skills — zero extra requests. Default true.	true
includeOrgRollup	No	boolean	Pushes one extra org_summary row per company with seniority/department counts and decision-maker %. Default true.	true
senioritiesToInclude	No	array (select)	Only push employee rows whose seniority_level matches a selected tier; empty keeps every row. The roll-up row is unaffected.	["Director", "Vice President"]
departmentsToInclude	No	array (select)	Only push employee rows whose department matches a selected bucket; empty keeps every row.	["Engineering", "Sales"]
decisionMakersOnly	No	boolean	Only push employees with is_decision_maker: true (Owner/Partner/CXO/VP/Director). Default false.	false
proxyConfiguration	No	object	Apify proxy configuration editor. Residential recommended for fewer blocks; if omitted, defaults to residential (US).	{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US"}

Example JSON input

{
  "companyTargets": ["https://www.linkedin.com/company/google"],
  "employeesPerCompany": 15,
  "includeCareerHistory": true,
  "includeOrgRollup": true,
  "senioritiesToInclude": [],
  "departmentsToInclude": [],
  "decisionMakersOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}

Common pitfall: no field is marked required in the input schema, but the Actor checks at runtime — if companyTargets (or the legacy urls key) resolves to zero entries, the run fails immediately with a "Missing input" error rather than starting. Always supply at least one company URL or keyword. Separately, only successful employee rows are billed under the row_result event; rows with a non-empty error field and the org_summary roll-up row are pushed to the dataset but not charged — filter them out of billing analysis with error == null && is_org_summary == false.

⬆️ Output

Output is typed, normalized JSON with a consistent schema across runs, exportable as JSON, CSV, Excel, or any other Apify dataset format.

Scraped results

[
  {
    "company_url": "https://www.linkedin.com/company/google",
    "profile_url": "https://www.linkedin.com/in/example-person-1",
    "fullname": "Example Person",
    "headline": "Senior Engineering Manager at Google",
    "location": { "country": "United States", "city": "Mountain View", "full": "Mountain View, California, United States", "country_code": "US" },
    "current_company": "Google",
    "experience": [
      { "company_name": "Google", "company_url": "https://www.linkedin.com/company/google", "location": "Mountain View, CA", "role_description": "Engineering Manager", "start_date": "2021-03", "end_date": "" }
    ],
    "education": [
      { "school_name": "Stanford University", "school_url": "", "start_date": "2012", "end_date": "2016" }
    ],
    "skills": ["Distributed Systems", "Engineering Management"],
    "seniority_level": "Experienced Manager",
    "seniority_rank": 6,
    "department": "Engineering",
    "is_decision_maker": false,
    "scraped_at": "2026-07-25T00:00:00Z",
    "type": "employee",
    "is_org_summary": false
  },
  {
    "company_url": "https://www.linkedin.com/company/google",
    "profile_url": "https://www.linkedin.com/in/example-person-2",
    "fullname": "Jordan Sample",
    "headline": "VP of Sales at Google",
    "location": { "country": "United States", "city": "New York", "full": "New York, New York, United States", "country_code": "US" },
    "current_company": "Google",
    "experience": [],
    "education": [],
    "skills": [],
    "seniority_level": "Vice President",
    "seniority_rank": 4,
    "department": "Sales",
    "is_decision_maker": true,
    "scraped_at": "2026-07-25T00:00:00Z",
    "type": "employee",
    "is_org_summary": false
  },
  {
    "company_url": "https://www.linkedin.com/company/google",
    "profile_url": "https://www.linkedin.com/in/example-person-3",
    "fullname": "Alex Doe",
    "headline": "Marketing Coordinator at Google",
    "location": { "country": "United States", "city": "Austin", "full": "Austin, Texas, United States", "country_code": "US" },
    "current_company": "Google",
    "experience": [],
    "education": [],
    "skills": [],
    "seniority_level": "Entry",
    "seniority_rank": 10,
    "department": "Marketing",
    "is_decision_maker": false,
    "scraped_at": "2026-07-25T00:00:00Z",
    "type": "employee",
    "is_org_summary": false
  },
  {
    "type": "org_summary",
    "is_org_summary": true,
    "company_url": "https://www.linkedin.com/company/google",
    "profiles_scraped": 15,
    "profiles_classified": 12,
    "seniority_breakdown": { "Experienced Manager": 4, "Senior": 5, "Director": 2, "Vice President": 1, "Entry": 1 },
    "department_breakdown": { "Engineering": 8, "Sales": 2, "Marketing": 2 },
    "decision_makers_count": 2,
    "decision_makers_pct": 16.7,
    "scraped_at": "2026-07-25T00:00:00Z"
  }
]

How can I use the data extracted with LinkedIn Company Employees : Org & Department Analytics Scraper?

• Recruiting and org research: pull experience, education, and skills for every employee at a target company to pre-screen candidates or map hiring gaps by department before outreach.
• Sales and business development: set decisionMakersOnly: true to filter straight to is_decision_maker employees (Owner/Partner/CXO/VP/Director) at a target account, ready for a CRM import.
• AI engineers and LLM developers: an agent issues a companyTargets query, receives structured employee and org_summary JSON back, and passes it to the model as grounded context instead of relying on stale training data.
• Competitive workforce analysis: run the same companyTargets list across several companies and compare their department_breakdown and decision_makers_pct roll-up rows side by side to see where competitors are staffing up.

How do you monitor headcount and department growth over time?

Headcount and department-mix monitoring means running the same companyTargets list on a schedule and comparing each company's org_summary row to its previous run rather than re-reading the employee list from scratch each time. Because includeOrgRollup always aggregates over every successfully scraped profile — regardless of any senioritiesToInclude/departmentsToInclude/decisionMakersOnly filter — the roll-up row is a stable baseline to diff run over run. The fields worth tracking between runs: profiles_scraped and profiles_classified (is coverage improving or degrading), seniority_breakdown and department_breakdown (which tiers or functions are growing or shrinking), and decision_makers_count/decision_makers_pct (is the leadership layer changing). At the employee-row level, comparing the set of public_identifier values between runs surfaces joiners and leavers, and comparing department/seniority_level for a public_identifier present in both runs surfaces promotions or role changes. A practical loop: schedule a run per company (or company list) weekly or monthly, store each run's org_summary row keyed by company_url and scraped_at, and alert when department_breakdown for a tracked function moves outside your expected range. This Actor has no scheduler of its own — set up the recurring run with Apify's own Scheduler against this Actor, and pull each run's dataset through the Apify API for the diff step.

Integrate LinkedIn Company Employees : Org & Department Analytics Scraper and automate your workflow

LinkedIn Company Employees : Org & Department Analytics Scraper works with any language or tool that can send an HTTP request.

REST API with Python

import requests

TOKEN = "YOUR_APIFY_TOKEN"
ACTOR = "scrapier~linkedin-company-employees-org-department-analytics-scraper"

resp = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={
        "companyTargets": ["https://www.linkedin.com/company/google"],
        "employeesPerCompany": 15,
        "decisionMakersOnly": True,
    },
)
rows = resp.json()
employees = [r for r in rows if r.get("type") == "employee"]
print(f"{len(employees)} employee rows returned")

MCP for query-grounded AI agents

This Actor, like any Actor in the Apify Store, is callable as a tool through Apify's hosted Actors MCP Server — no separate integration code required. An MCP-compatible client (Claude Desktop, Claude Code, or another MCP agent framework) connects to Apify's MCP endpoint, discovers this Actor by its store ID (scrapier/linkedin-company-employees-org-department-analytics-scraper), and calls it with a companyTargets argument. The agent gets back structured employee and org-summary JSON to ground its answer, instead of guessing from training data.

Scheduled monitoring and delivery

Apify's own Scheduler can trigger this Actor on a cron-style interval directly from the Actor's page — no separate infrastructure needed. Combine it with an Apify webhook on the run-succeeded event to push each run's dataset to your own endpoint automatically, or poll the Apify API for the latest dataset items after each scheduled run.

Is it legal to scrape LinkedIn employee data?

Yes — scraping publicly visible LinkedIn company and profile pages is generally lawful in the US after hiQ Labs, Inc. v. LinkedIn Corp. (9th Cir., 2019), which held that scraping data a website makes freely visible to any visitor, logged out, does not violate the Computer Fraud and Abuse Act. This Actor only reads what LinkedIn already serves to a logged-out visitor — no login, session cookie, or Sales Navigator seat. Employee names, headlines, and derived seniority/department classifications are still personal data once collected, so GDPR (if you process EU residents' data) and CCPA (California residents) obligations apply to what you do with the output — lawful basis, retention limits, and data-subject rights don't disappear because the source was public. Scraping for a one-off monitoring check carries a different risk profile than bulk-storing profiles to train a model. Consult your legal team for commercial use cases involving bulk data storage.

Frequently asked questions

Can I control where requests originate from?

Yes — proxyConfiguration accepts an Apify proxy group and country (defaults to residential, US). If you turn useApifyProxy off, requests go direct, which increases block risk since LinkedIn's own detection is IP-based.

How do I filter results to specific seniority tiers, departments, or decision-makers?

Set senioritiesToInclude and/or departmentsToInclude to the tiers/buckets you want (leave empty to keep every row), or set decisionMakersOnly: true to keep only Owner/Partner/CXO/VP/Director rows. These filters only affect which employee rows are pushed — the org_summary roll-up is always computed over every scraped profile regardless of these filters.

How is seniority and department classification actually determined?

By regular-expression pattern matching against each employee's own headline text — a 10-tier seniority ladder (checked most-senior pattern first) and a 10-category department list, both modeled on LinkedIn Sales Navigator's own public facet names. It is a heuristic, not LinkedIn's private authenticated facet data: a headline with no recognizable keyword returns null for seniority_level/department, and the org_summary roll-up buckets those profiles as "Unclassified" rather than dropping them.

How does this Actor handle LinkedIn's anti-bot measures?

It runs fully logged out through Apify's residential proxy by default, applies randomized delays between requests, and retries failed fetches with increasing backoff. When LinkedIn returns HTTP 999 (its block signal) or redirects to an authwall/login/challenge page, the Actor logs it as a block, records an uncharged error row, and — for HTTP 999 specifically — skips further retries on that URL rather than hammering a permanently blocked request.

Does this Actor extract org-structure and department analytics?

Yes. Every employee row carries seniority_level and department, and when includeOrgRollup is on (default), each company also gets one org_summary row with seniority_breakdown, department_breakdown, decision_makers_count, and decision_makers_pct. The roll-up is skipped only if no profile for that company was scraped successfully.

How many employees does this Actor return per company?

Up to whatever you set in employeesPerCompany, from 1 to 10,000 (default 10). The actual count can be lower if fewer public employee profiles are discoverable for that company through its people page or the Google fallback search.

How do I monitor headcount and department growth over time?

Schedule a run across the same companyTargets list on a recurring basis using Apify's Scheduler, then compare each run's org_summary fields (profiles_scraped, seniority_breakdown, department_breakdown, decision_makers_pct) against the previous run and alert on the deltas you care about.

Does this Actor work with Claude, ChatGPT, and AI agent frameworks?

Yes on both counts: it's reachable through Apify's Actors MCP Server for MCP-compatible clients like Claude Desktop and Claude Code, and it's callable as a plain HTTP endpoint by any agent framework that can send a request — enabling grounded agents that retrieve live employee and org data before answering.

How does this Actor compare to other LinkedIn employee scrapers?

Most public LinkedIn employee scrapers return a flat name-and-title list, and tools that offer richer fields typically require an authenticated li_at session cookie or a paid Sales Navigator seat. This Actor works fully logged out and adds career history plus rule-based seniority/department classification and a company roll-up on top of the base employee list, without requiring LinkedIn credentials.

Can I use this Actor without managing proxies or LinkedIn credentials?

Yes — no LinkedIn login, cookie, or Sales Navigator seat is needed, and Apify's residential proxy is used by default so you don't have to source or rotate proxies yourself. You only need an Apify account to run the Actor.

Your feedback

Found a bug or missing a field? Let us know via the Issues tab on this Actor's Apify Store page — it's the fastest way to reach the Scrapier team and signals what to fix in the next update.