LinkedIn Employee Scraper — Find Company Staff by Name, with Department & Seniority, No Cookies

Type one company name and get its staff — engineers, analysts, designers, recruiters, accountants, coordinators, support and sales ICs — each with a LinkedIn URL, role, location and headline, plus a derived department (Technology, Sales, Marketing, Finance, HR, Product, Operations, Legal, Business) and a derived seniority band (Senior IC → Entry-Level / Intern). No LinkedIn account, no cookies, no li_at. Runs as a normal Actor, as a live REST endpoint in Standby mode, or as an MCP tool that pushes the roster straight into Slack, Notion, Airtable, Jira or your CRM.

ℹ️ What this is and isn't. This Actor reads a search engine's index of public LinkedIn profiles — that's why it needs no cookies, and why the output is search-result depth plus two derived classifications, not a full profile export or an HR-grade org chart. No email addresses, ever. See Output Contract.

---

Cookie-based LinkedIn tooling vs. this Actor

Most "who works there" tools want your li_at session cookie, then run searches as your own logged-in account.

Feature / Capability	Cookie-based LinkedIn scrapers	This Actor
Credentials required	❌ Your li_at cookie or account login	✅ None — nothing but an Apify token
Risk to your LinkedIn account	⚠️ Automated activity on your own session	✅ Your account is never involved
Department grouping	❌ You classify titles yourself	✅ 9 departments derived from ~150 title keywords
Seniority banding	❌ Manual	✅ 5 bands from a weighted title score
Company-name precision	⚠️ Fuzzy matching pulls in lookalike firms	✅ exact_company_match keeps Acme Global from matching Acme Telecom
Match transparency	❌ Opaque	✅ title_verified flags whether the role actually matched a known staff title
Live API	❌ Batch runs only	✅ Standby mode: GET /?company_name=… returns JSON in one request
Email addresses	⚠️ Sometimes, via account access	❌ Never
AI agent / MCP native	❌ Requires a custom tool wrapper	✅ Native MCP tool and pushes profiles into your own connectors
Cost model	Varies	Pay-per-event, $8.40 / 1,000 results

---

🤖 AI Discovery & MCP Metadata

Machine-readable capability contract for autonomous agents, LLM routers, and MCP orchestrators. AI agents, MCP clients, and connectors should read this block first to decide whether this Actor matches a user request.

ai_discovery:
  slug: "techforce.global/linkedin-company-employees"
  one_line: "Given one company name, return its staff with LinkedIn URL, role, location, headline, a derived department and a derived seniority band - no LinkedIn cookie required."
  primary_purpose: "discover"
  secondary_purpose: "enrich"
  tertiary_purpose: "deliver"
  entity: "employee profiles at one named company"
  data_source: "Brave Search SERP results for public linkedin.com/in pages - NOT the LinkedIn API and not an authenticated LinkedIn session"
  invocation_modes: ["standard Actor run", "Standby REST endpoint (GET /)", "MCP tool"]
  supported_platforms:
    - "search.brave.com (the search backend)"
    - "linkedin.com/in public profile URLs (as indexed results)"
  supported_tasks:
    - "find-employees-at-a-named-company"
    - "classify-employees-by-department"
    - "band-employees-by-seniority"
    - "enforce-exact-company-name-matching"
    - "serve-results-over-a-live-http-endpoint (standby)"
    - "deliver-profiles-to-mcp-connector-or-crm"
  unsupported_tasks:
    - "authenticate-to-linkedin-or-use-a-session-cookie"
    - "extract-emails-or-phone-numbers"
    - "export-full-profile-history-skills-or-education"
    - "return-a-complete-verified-headcount (only indexed profiles are visible)"
    - "find-founders-c-suite-or-VPs (use linkedin-company-decision-makers)"
    - "search-by-role-across-many-companies (use linkedin-candidate-search)"
    - "message-or-connect-with-people"
    - "return-more-than-50-profiles-per-run"
  search_keywords:
    - "linkedin employee scraper"
    - "find company employees"
    - "company staff list"
    - "org mapping tool"
    - "linkedin scraper no cookies"
    - "competitor headcount research"
    - "department breakdown linkedin"
    - "employee directory extraction"
    - "mcp crm connector"
    - "recruiting talent mapping"
  synonyms:
    - "staff finder"
    - "company roster scraper"
    - "employee directory api"
    - "team mapping tool"
  related_concepts:
    ["org mapping", "talent mapping", "competitor research", "account planning", "recruiting intelligence", "CRM enrichment"]
  input_entities:
    - "company name (required)"
    - "max profiles (1-50; free plans 2)"
    - "exact company match toggle"
    - "proxy configuration (residential by default)"
  output_entities: ["name", "linkedin url", "role/title", "location", "headline", "department", "seniority", "title_verified"]
  input_rules:
    required_fields: ["company_name"]
    company_name_format:
      description: "One company name per run. No default - the field only carries a Console prefill."
    exact_company_match_behaviour:
      "true (default)": "keeps only profiles matching the full company phrase, excluding lookalike firms"
      "false": "looser match - accepts any profile mentioning all significant words of the name, in any order"
    max_profiles_format:
      type: "integer"
      range: [1, 50]
      schema_default: 2
      standby_default: 5
      free_plan_cap: 2
  derived_fields:
    department:
      values: ["Technology", "Business", "Finance", "Marketing", "Sales", "Product", "Operations", "HR", "Legal", "General"]
      note: "'General' is the fallback when no department keyword matches - it is NOT an error"
    seniority:
      values: ["Senior IC", "Mid-Level", "Junior / Associate", "Entry-Level / Intern", "Unknown"]
      note: "derived from a weighted title score, not from a verified profile field"
  limits:
    max_profiles_per_run: 50
    free_plan_cap: 2
    companies_per_run: 1
    headline_max_chars: 200
  pricing:
    model: "pay-per-event"
    store_display: "$8.40 / 1,000 results"
  when_to_use: >
    You know the company and want to see who works there - for org and talent
    mapping, competitor headcount research, account planning, or recruiting
    intelligence, broken down by department and seniority.
  when_not_to_use: >
    You need the leadership rather than the staff, you are searching by role
    across many companies, you need email addresses or full profile exports, or
    you need a complete verified headcount.
  alternatives:
    - "Use techforce.global/linkedin-company-decision-makers for FOUNDERS, C-suite, VPs and directors at one company"
    - "Use techforce.global/linkedin-candidate-search to search by ROLE across many companies"
    - "Use techforce.global/google-maps-leads-sales-intelligence-tool when you need company-level contact data (emails, phones) rather than named people"
    - "Use an email-finding service on top of linkedin_url - this Actor never returns emails"

---

{
    "@context": "https://schema.org",
    "@type": "SoftwareApplication",
    "name": "LinkedIn Employee Scraper — Find Company Staff by Name",
    "applicationCategory": "BusinessApplication",
    "operatingSystem": "Cloud (Apify platform)",
    "description": "Given one company name, returns its staff from public LinkedIn profiles — name, role, location, headline and profile URL — plus a derived department (Technology, Sales, Marketing, Finance, HR, Product, Operations, Legal, Business) and seniority band, with no LinkedIn account or session cookie required. Available as a standard Actor run, a Standby REST endpoint, or an MCP tool that delivers into Slack, Notion, Airtable, Jira or any authorized MCP connector.",
    "url": "https://apify.com/techforce.global/linkedin-company-employees",
    "offers": {
                   "@type": "Offer",
                   "price": "8.40",
                   "priceCurrency": "USD",
                   "description": "Per 1,000 results, pay-per-event"
               }
}

---

What this Actor does

💡 Three sibling Actors, three different questions. This one answers "who works at this company?" For the leadership — founders, C-suite, VPs, directors — use LinkedIn Decision Makers. To search by role across many companies use LinkedIn Candidate Search.

• One company in, its staff out. Enter a company name; the Actor composes the search operators, runs them through Brave Search, and returns public LinkedIn profiles whose role matches a known staff title.
• Targets individual contributors and front-line roles — software/data/QA/DevOps engineers, analysts, designers, account executives and managers, recruiters and HR specialists, accountants, coordinators, support staff, paralegals, interns and graduates. Leadership titles are the sibling Actor's job.
• Derives a department for every profile from ~150 title keywords across 9 groups — Technology, Business, Finance, Marketing, Sales, Product, Operations, HR, Legal — falling back to General when nothing matches.
• Derives a seniority band from a weighted title score: Senior IC → Mid-Level → Junior / Associate → Entry-Level / Intern → Unknown.
• Tells you when it's guessing. title_verified is true only when the role string actually matched a known staff title, so you can filter out the soft matches instead of trusting everything equally.
• Filters out lookalike companies. exact_company_match (on by default) requires the full company phrase. Turn it off for a looser all-significant-words match.
• Deduplicates by normalised LinkedIn URL, so one person can't arrive twice from two different queries.
• Runs three ways: a normal Actor run, a Standby REST endpoint (GET /?company_name=… → JSON, no run polling), or an MCP tool an agent can call.
• Routes through residential Apify Proxy by default — datacenter IPs are routinely blocked by search-engine anti-bot checks.
• Keeps names and URLs out of the run log unless you switch on debug — the dataset is the record, not the log.
• Optionally pushes profiles to an authorized MCP connector (Slack, Notion, Airtable, Jira, HubSpot, Linear, Sheets, or any MCP-compatible connector) per profile or as one digest. The dataset is always saved regardless of delivery settings.

When to use it — and when not to

Scenario	Fit
Org / talent mapping at a target company	✅ Strong (the core use case)
Competitor headcount and team-shape research	✅ Strong — department + seniority breakdown
Recruiting intelligence: who does this company employ in Technology?	✅ Strong — filter department
Account planning: find the practitioners, not just the buyers	✅ Strong
CRM enrichment against an existing account record	✅ Strong (deliveryMode: "perProfile")
A live lookup inside an app or agent	✅ Strong — Standby REST endpoint
Distinguishing a company from similarly-named firms	✅ Strong — exact_company_match
Founders, C-suite, VPs and directors	❌ Staff-level titles — use Decision Makers
Searching a role across many companies	❌ One company per run — use Candidate Search
A complete, verified headcount	❌ Only search-indexed profiles are visible — treat counts as a sample
Email addresses or phone numbers	❌ Never returned
Full profile exports (history, skills, education)	❌ Search-result depth only
Messaging or connecting with people	❌ Not supported — read-only
More than 50 profiles per run	⚠️ Hard cap of 50 (2 on free plans)

---

⚡ Execution Rules (Avoid Common Agent Failures)

1. company_name is required and has no default. The Console shows a prefill, which is not the same thing — an API or MCP call that omits the field is rejected, and the Standby endpoint returns HTTP 400.
2. max_profiles defaults to just 2 in the input schema, matching the free-plan cap — even though the code's own DEFAULT_MAX_PROFILES is 50. Paid runs should set it explicitly, up to 50. The Standby endpoint defaults to 5. Three different defaults live in this Actor; always pass the value.
3. Free Apify plans are capped at 2 profiles per run, whatever you ask for. That is a successful run, not a failure.
4. This is not a headcount. You see only profiles a search engine has indexed and that matched a staff title. A 500-person company may return 20 people. Never present count as the company's size.
5. department and seniority are derived, not authoritative. They come from keyword matching and a weighted score over the role string — not from any LinkedIn field. Spot-check before reporting them as fact.
6. department: "General" is the fallback, not an error. It means no department keyword matched the title. Expect it for unusual or vague roles.
7. seniority: "Unknown" means the score was too low to band, not that the person is junior.
8. title_verified: false marks a soft match — the profile was kept but its role didn't cleanly match a known staff title. Filter on this field when precision matters.
9. exact_company_match is ON by default, and that is the recommended setting. Turning it off widens the match to any profile mentioning all significant words of the name in any order.
10. One company per run. There is no multi-company input; loop from your orchestration layer.
11. No email addresses, at any setting. The output is eight fields; there is no contact-data option to enable.
12. headline is truncated at 200 characters — it's the search snippet (or the result title as a fallback).
13. Keep the residential proxy on. The default is Apify Proxy with the RESIDENTIAL group; datacenter IPs get blocked. Residential groups require a paid Apify plan.
14. debug prints names and LinkedIn URLs into the run log. Off by default for exactly that reason — switch it on only while diagnosing a zero-result run, and remember run logs are retained.
15. deliveryMode defaults to perProfile, not none. With a connector selected, a 50-profile run makes 50 connector calls. There is no chunked mode here — only perProfile, summary, none.

dependencies:
  - rule: "company_name is required (400 in standby, validation error in a normal run)"
    note: "the Console prefill is not a default"
  - rule: "max_profiles has three different defaults"
    detail: "input schema 2, standby endpoint 5, code constant 50 - all capped at 50, and at 2 on free plans"
  - rule: "department and seniority are derived from the title string"
    on_violation: "treating them as verified HR data will misclassify unusual roles"
  - rule: "title_verified false means the role did not cleanly match a staff title"
    note: "filter on it when precision matters more than recall"
  - rule: "exact_company_match ON requires the full company phrase"
    on_violation: "turning it OFF admits lookalike companies sharing significant words"
  - rule: "delivery requires mcpConnector AND mcpTool"
    on_violation: "delivery step is skipped with a warning; the dataset is still written in full"
  - rule: "mcpArguments must reference {message} for the rendered template to appear anywhere"
    on_violation: "message body is empty; the tool is still called"
  - rule: "mcpConnector only resolves when the Actor runs on the Apify platform"
    on_violation: "local runs log 'APIFY_MCP_PROXY_URL is not set' and skip delivery; the dataset is unaffected"
  - rule: "debug logging writes personal data (names, LinkedIn URLs) to the run log"
    note: "leave it off outside active troubleshooting"
authentication:
  actor_input: none
  platform: "Apify API token required for API / SDK / MCP / standby invocation; paid plan required for residential proxy groups"
  target_site: "no LinkedIn account, cookie or session token required - and none is accepted"

---

📥 Input Contract

.actor/input_schema.json is authoritative — if any table on this page disagrees with the schema files, the schema files win.

Parameters

Field	Type	Required	Default	Allowed Values / Format	Example
company_name	string	✅ Yes	none (Console prefill only)	One company name	Acme Corporation
max_profiles	integer	⬜ No	2	1–50; free plans capped at 2	50
exact_company_match	boolean	⬜ No	true	true = full-phrase match · false = all-significant-words	false
proxyConfiguration	object	⬜ No	Apify Proxy, RESIDENTIAL	Apify proxy editor object	see below
debug	boolean	⬜ No	false	Verbose per-result decisions — logs names and URLs	true

Recommended proxy block (also the default):

{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}

Which roles this Actor looks for

A profile is kept when its role matches a known staff title. Representative coverage:

Department	Example titles matched
Technology	Software / Backend / Frontend / Full Stack Developer · Data Engineer · Data Scientist · Data Analyst · ML / AI Engineer · DevOps · QA / Test Engineer · SDET · SRE · Cloud / Network / Systems Engineer · iOS / Android / Mobile Developer · UI / UX / Product Designer · System / Network / Database Administrator · IT Support · Helpdesk
Sales	Account Executive · Sales Executive · Account Manager · SDR · BDR
Marketing	Marketing / SEO / Content Specialist · Copywriter · Content Writer · Social Media Manager · Marketing Analyst
Finance	Accountant · Bookkeeper · Payroll Specialist · Accounts Payable / Receivable · Financial Analyst
HR	Recruiter · Talent Acquisition Specialist · Talent Sourcer · HR Generalist / Specialist / Coordinator · People Operations · Onboarding · L&D · Compensation & Benefits
Operations	Operations Associate / Analyst / Coordinator · Logistics / Project / Program Coordinator · Customer Support · Technical Support · Support Engineer · Customer Success Manager
Product	Product Designer · UX / UI Designer
Legal	Paralegal · Legal Assistant
Business	Associate · Assistant · Executive Assistant · Office Manager
General	Fallback when no department keyword matches

Leadership titles (Founder, CEO, VP, Director, Head of…) are not this Actor's target — see LinkedIn Decision Makers.

Seniority bands

Band	Meaning
Senior IC	Senior individual contributor titles
Mid-Level	Established practitioner titles
Junior / Associate	Junior and associate-level titles
Entry-Level / Intern	Interns, trainees, graduates, entry roles
Unknown	The title score was too low to band — not a claim that the person is junior

Examples

Default posture — a small sample of staff:

{
  "company_name": "Acme Corporation",
  "max_profiles": 20,
  "exact_company_match": true,
  "deliveryMode": "none"
}

Full sweep, paid plan:

{
  "company_name": "Siemens Healthineers",
  "max_profiles": 50,
  "exact_company_match": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] },
  "deliveryMode": "none"
}

Looser matching for an abbreviated company name:

{
  "company_name": "Acme Corp",
  "exact_company_match": false,
  "max_profiles": 40,
  "deliveryMode": "none"
}

Diagnosing a zero-result run (writes names and URLs to the log):

{
  "company_name": "Some Small Studio",
  "max_profiles": 10,
  "exact_company_match": false,
  "debug": true,
  "deliveryMode": "none"
}

MCP Delivery Configuration (Optional)

Delivery pushes profiles into your own tools. It never contacts anyone.

Parameter	Type	Default	Description
mcpConnector	string	""	Authorized MCP connector on your Apify account (Slack, Notion, Airtable, Jira, HubSpot, Linear, Sheets, …). Leave empty for dataset-only runs.
deliveryMode	enum	perProfile	perProfile (one call per employee) · summary (one call with all profiles) · none.
mcpTool	string	""	Tool name on the connector: create_page, send_message, create_record, create_issue. Run once with a connector selected — the log lists the connector's available tools.
mcpArguments	object	{}	Arguments passed to the tool. String leaves support {placeholders}.
mcpMessageTemplate	string	""	Template rendered and exposed to mcpArguments as {message}.

Placeholders: the output fields per profile — {name}, {linkedin_url}, {location}, {title}, {headline}, {department}, {seniority} — plus {message}.

One Airtable record per employee, keeping the derived fields:

{
  "company_name": "Acme Corporation",
  "max_profiles": 50,
  "mcpConnector": "<your-authorized-airtable-connector>",
  "deliveryMode": "perProfile",
  "mcpTool": "create_record",
  "mcpArguments": {
    "fields": {
      "Name": "{name}",
      "Role": "{title}",
      "Department": "{department}",
      "Seniority": "{seniority}",
      "Location": "{location}",
      "LinkedIn": "{linkedin_url}"
    }
  }
}

One Slack digest for the account:

{
  "company_name": "Acme Corporation",
  "max_profiles": 50,
  "mcpConnector": "<your-authorized-slack-connector>",
  "deliveryMode": "summary",
  "mcpTool": "send_message",
  "mcpArguments": { "channel": "#account-research", "text": "{message}" },
  "mcpMessageTemplate": "Staff found at Acme:\n\n{message}"
}

One Notion page per employee:

{
  "company_name": "Siemens Healthineers",
  "max_profiles": 30,
  "mcpConnector": "<your-authorized-notion-connector>",
  "deliveryMode": "perProfile",
  "mcpTool": "notion-create-pages",
  "mcpArguments": {
    "parent": { "page_id": "<your-page-id>" },
    "pages": [
      {
        "properties": { "title": "{name} — {title}" },
        "content": "{department} · {seniority} · {location}\n{linkedin_url}\n\n{headline}"
      }
    ]
  }
}

---

📤 Output Contract & Data Structure

Storage: Apify Dataset (one JSON object per employee) plus a run summary in the key-value store. Pagination: limit & offset on the dataset items endpoint. Duplicates: deduplicated within a run by normalised LinkedIn URL. Across runs, dedupe on linkedin_url.

Dataset item — eight fields

Field	Type	Derived?	Meaning
name	string	—	Person's name, extracted from the search-result title
linkedin_url	string	—	Normalised public LinkedIn /in/ URL — use as the dedupe key
location	string	—	Location as exposed by the search result
title	string	—	The role string found for the profile
headline	string	—	Search snippet, truncated to 200 characters (falls back to the result title)
department	string	✅ derived	Technology · Business · Finance · Marketing · Sales · Product · Operations · HR · Legal · General
seniority	string	✅ derived	Senior IC · Mid-Level · Junior / Associate · Entry-Level / Intern · Unknown
title_verified	boolean	✅ derived	true when the role cleanly matched a known staff title; false marks a softer match

No email, no phone, no company field (you supplied the company), no skills or history. The two derived fields come from keyword matching over the title string — useful for grouping, not authoritative HR data.

Example dataset item

{
  "name": "Rohit Deshpande",
  "linkedin_url": "https://www.linkedin.com/in/rohit-deshpande-4f7a1c",
  "location": "Pune, Maharashtra, India",
  "title": "Senior Software Engineer",
  "headline": "Senior Software Engineer at Acme Corporation · Java, Spring Boot, Kafka · Platform team",
  "department": "Technology",
  "seniority": "Senior IC",
  "title_verified": true
}

Useful groupings

Because department and seniority are pre-derived, the interesting analysis is a two-line group-by:

from collections import Counter
print(Counter(i["department"] for i in items))   # team shape
print(Counter(i["seniority"] for i in items))    # senior-vs-junior mix

What a successful run looks like

{
  "status": "SUCCEEDED",
  "defaultDatasetId": "<datasetId>",
  "stats": { "itemCount": 34 }
}

itemCount below max_profiles is normal and common — only indexed profiles that matched a staff title can be returned, and exact_company_match may have correctly excluded lookalikes. itemCount: 0 is a valid empty result: try exact_company_match: false, or check the company name. On free plans, itemCount stops at 2.

Do not read itemCount as headcount. It is a sample of what a search engine has indexed, not the size of the company.

---

▶️ Invocation & Integration

Lifecycle: Discover → Understand → Configure → Execute → Retrieve → Validate. Authenticate every call with Authorization: Bearer <APIFY_TOKEN>.

Standby mode — a live REST endpoint

This Actor runs in Standby mode, so you can query it like an API instead of starting a run and polling. It answers a readiness probe and serves one endpoint:

GET /?company_name=<name>&max_profiles=<1-50>

Parameter	Required	Default	Notes
company_name	✅ Yes	—	Missing or empty → HTTP 400
max_profiles	⬜ No	5	1–50 — differs from the input schema's default of 2

curl -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  'https://techforce-global--linkedin-company-employees.apify.actor/?company_name=Acme%20Corporation&max_profiles=25'

Response:

{
  "company": "Acme Corporation",
  "count": 2,
  "employees": [
    {
      "name": "Rohit Deshpande",
      "linkedin_url": "https://www.linkedin.com/in/rohit-deshpande-4f7a1c",
      "location": "Pune, Maharashtra, India",
      "title": "Senior Software Engineer",
      "headline": "Senior Software Engineer at Acme Corporation · Java, Spring Boot",
      "department": "Technology",
      "seniority": "Senior IC"
    }
  ]
}

ℹ️ Copy the exact Standby URL from the Actor’s Standby tab in the Console. The <username>--<actor-name>.apify.actor form above follows Apify's Standby convention, but the hostname for your account and build is shown there.

Apify Console

Open the Actor → Input tab → type a Company Name → set Max Profiles → leave Exact company match on → keep the residential proxy → (optional) pick an MCP connector, tool and template → Start → export from the Dataset tab (JSON, CSV, Excel, XML).

Model Context Protocol (MCP)

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=techforce.global/linkedin-company-employees"

Python (apify-client)

import os
from collections import Counter
from apify_client import ApifyClient

client = ApifyClient(os.getenv("APIFY_TOKEN"))

run = client.actor("techforce.global/linkedin-company-employees").call(run_input={
    "company_name": "Acme Corporation",
    "max_profiles": 50,            # 50 is the ceiling; free plans stop at 2
    "exact_company_match": True,
    "deliveryMode": "none",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(f"{len(items)} employees found (a sample, not a headcount)")

# department and seniority are pre-derived - group straight away.
print(Counter(i["department"] for i in items))
print(Counter(i["seniority"] for i in items))

# title_verified flags the clean matches; filter when precision matters.
confident = [i for i in items if i.get("title_verified")]
print(f"{len(confident)} with a verified staff title")

for person in confident[:5]:
    print(f'{person["department"]:<12} {person["seniority"]:<22} {person["title"]}')

JavaScript / TypeScript (apify-client)

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('techforce.global/linkedin-company-employees').call({
  company_name: 'Siemens Healthineers',
  max_profiles: 50,
  exact_company_match: true,   // keeps lookalike companies out
  deliveryMode: 'none',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const engineers = items.filter((i) => i.department === 'Technology');
const senior = engineers.filter((i) => i.seniority === 'Senior IC');
console.log(`${engineers.length} in Technology, ${senior.length} senior ICs`);

cURL — synchronous run (returns items directly; 300s limit)

curl -X POST \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  -d '{"company_name":"Acme Corporation","max_profiles":20,"exact_company_match":true,"deliveryMode":"none"}' \
  'https://api.apify.com/v2/acts/techforce.global~linkedin-company-employees/run-sync-get-dataset-items'

For a single lookup, the Standby endpoint above is simpler — no run lifecycle at all.

cURL — asynchronous with a spend cap (recommended for production)

# 1. Start execution with a hard spend limit
curl -X POST -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  -d '{"company_name":"Acme Corporation","max_profiles":50,"deliveryMode":"none"}' \
  'https://api.apify.com/v2/acts/techforce.global~linkedin-company-employees/runs?maxTotalChargeUsd=0.50'

# 2. Poll
curl -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  'https://api.apify.com/v2/actor-runs/<runId>'

# 3. Retrieve when SUCCEEDED
curl -H 'Authorization: Bearer <YOUR_APIFY_TOKEN>' \
  'https://api.apify.com/v2/datasets/<DATASET_ID>/items?clean=true&format=json'

---

⚠️ Autonomous Agent Error Handling & Resolution Matrix

Error Code	Detection Condition	Underlying Cause	Deterministic Agent Action
AUTH_INVALID	HTTP 401	Missing or malformed APIFY_TOKEN	Abort & Prompt User: request a valid API token.
RATE_LIMITED	HTTP 429	Apify API rate / concurrency limits	Retry: exponential backoff (2s, 4s, 8s).
SYNC_TIMEOUT	HTTP 408 on the sync endpoint	Run exceeded the 300s synchronous ceiling	Reconfigure: use Standby, or async POST /runs + polling.
MISSING_COMPANY_NAME	Input validation rejection, or HTTP 400 in Standby	company_name is required and has no default	Modify Input: send company_name.
DEFAULT_DRIFT	You get 2, 5 or 50 profiles depending on entry point	Three defaults exist: schema 2, standby 5, code constant 50	Modify Input: always pass max_profiles explicitly.
FREE_PLAN_CAP	itemCount stops at 2 with the upgrade banner in the log	Free Apify plan caps the run at 2 profiles	Prompt User: upgrade for full-volume runs.
HEADCOUNT_MISREAD	A consumer treats count as company size	Only indexed, title-matched profiles are returned	Fix Expectation: report it as a sample, never as headcount.
EMPTY_RESULTS	SUCCEEDED, itemCount: 0	Nothing indexed matched, or exact_company_match excluded everything	Retry once with exact_company_match: false; then verify the company name.
LOOKALIKE_COMPANY	Results are people at a similarly-named firm	exact_company_match was false	Modify Input: set it back to true.
WRONG_GRANULARITY_LEADERSHIP	User wanted founders / C-suite / VPs	This Actor targets staff titles	Re-route: LinkedIn Decision Makers.
WRONG_GRANULARITY_ROLE_SEARCH	User wanted a role across many companies	This Actor takes one company	Re-route: LinkedIn Candidate Search.
DEPARTMENT_GENERAL	Many items show department: "General"	No department keyword matched those titles	Not an error. Read title directly for those rows.
SENIORITY_UNKNOWN	seniority: "Unknown"	The title score was too low to band	Not an error, and not a claim about the person's level.
SOFT_TITLE_MATCH	Roles look off for some rows	title_verified: false marks a softer match	Filter on title_verified when precision matters.
NO_CONTACT_DATA	No email / phone in any item	Never returned — the output is 8 fields	Fix Expectation: enrich from linkedin_url elsewhere.
STALE_ROLE	title disagrees with the person's current role	The role comes from a search snippet, which can lag	Verify on the profile before acting.
PROXY_BLOCKED	Thin or empty results, search pages not loading	Datacenter IP hit a search-engine anti-bot check	Reconfigure: enable the RESIDENTIAL proxy group (the default).
PROXY_UNAVAILABLE	Proxy setup warning in the log	Residential groups need a paid Apify plan	Prompt User: upgrade, or accept a higher block rate.
DEBUG_PII_IN_LOG	Names and LinkedIn URLs appear in the run log	debug: true was set	Modify Input: turn debug off outside troubleshooting; run logs are retained.
DELIVERY_SKIPPED	Log no tool name was provided	mcpConnector set but mcpTool empty	Modify Input: set mcpTool; the dataset is already saved.
DELIVERY_TOOL_UNKNOWN	Log Tool 'x' is not available on this connector	Wrong tool name for that connector	Modify Input: pick a name from the Available tools: list in the same log line.
DELIVERY_EMPTY	Connector called, body empty	mcpArguments omitted the {message} placeholder	Modify Input: map {message} inside mcpArguments.
DELIVERY_FLOOD	Up to 50 connector calls per run	deliveryMode defaults to perProfile	Reconfigure: use summary.
MCP_PROXY_MISSING	Log APIFY_MCP_PROXY_URL is not set	Running locally instead of on the platform	Reconfigure: apify push and run on the platform.
CHARGE_LIMIT	Run aborted before max_profiles reached	maxTotalChargeUsd spend threshold reached	Prompt User: confirm a higher spend cap.

Reading run status: SUCCEEDED with an empty dataset is a valid outcome here, not a failure — only a FAILED status is a platform-level problem. Every Actor-side row, quoted message and field condition in the table above comes from this Actor’s own behaviour; the 401/408/429 rows are standard Apify API responses.

---

🗣️ Natural Language → Actor Mapping

User says	Intent	Constructed Actor input
"Who works at Acme Corporation?"	Org mapping	{"company_name":"Acme Corporation","max_profiles":50}
"How big is this company's engineering team?"	Team shape	{"company_name":"<company>","max_profiles":50} then group department == "Technology"
"Which engineers does our competitor employ?"	Competitor research	{"company_name":"<competitor>","max_profiles":50} then filter department
"Show me their senior people, not the juniors"	Seniority filter	run, then filter seniority == "Senior IC"
"Do they have an in-house recruiter?"	Function check	run, then filter department == "HR"
"Map their sales team"	GTM research	run, then filter department == "Sales"
"I keep getting people from a similarly-named company"	Precision fix	{"exact_company_match":true}
"Their name is abbreviated everywhere — loosen it"	Recall fix	{"exact_company_match":false}
"Look up staff live from our app"	Live API	➡️ Use the Standby endpoint: GET /?company_name=…
"Push the roster into Airtable with departments"	CRM delivery	{"mcpConnector":"airtable","deliveryMode":"perProfile","mcpTool":"create_record"} incl. {department} / {seniority}
"Post the team breakdown to Slack"	Digest delivery	{"mcpConnector":"slack","deliveryMode":"summary","mcpTool":"send_message"}
"Why did this company return nobody?"	Diagnosis	{"exact_company_match":false,"debug":true} — note debug logs names and URLs
"Who are the decision makers there?"	Leadership	➡️ Route to LinkedIn Decision Makers
"Find senior Java developers in Pune"	Role search	➡️ Route to LinkedIn Candidate Search
"Exactly how many people work there?"	Headcount	⚠️ Not answerable — this is an indexed sample, not a headcount
"Get their email addresses"	Contact enrichment	❌ Out of scope — eight fields, no contact data
"Message these people for me"	Outreach	❌ Out of scope — read-only

Should NOT route here: founders, C-suite, VPs and directors (→ Decision Makers) · a role searched across many companies (→ Candidate Search) · verified headcount or HR-grade org charts · email addresses or phone numbers · full profile exports · messaging or connecting · anything requiring a LinkedIn session cookie · more than 50 profiles in one run.

---

🧭 Agent Execution & Routing Logic

[Input User Query]
       │
       ▼
1. Is the goal finding PEOPLE at a company?           NO  → Route to a company/lead Actor
       │ YES
       ▼
2. What granularity?
       ├── the STAFF of one named company        → stay here
       ├── the LEADERSHIP of one named company   → Route to LinkedIn Decision Makers
       └── a ROLE across many companies          → Route to LinkedIn Candidate Search
       ▼
3. Needs emails / full profiles / verified headcount / messaging?  YES → Abort (none are supported)
       │ NO
       ▼
4. Do we have an exact company name?                  NO  → Ask the user. company_name is REQUIRED
       │ YES                                                (400 in standby, validation error otherwise)
       ▼
5. Does the company have common-word lookalikes?
       ├── YES → exact_company_match: true  (the default)
       └── the name is abbreviated in the wild → exact_company_match: false, then sanity-check
       ▼
6. One lookup, or a batch?
       ├── one live lookup   → use the STANDBY endpoint: GET /?company_name=…&max_profiles=…
       └── a batch / pipeline → normal run; loop one company per run
       ▼
7. Set max_profiles EXPLICITLY (schema default 2, standby default 5, ceiling 50, free plans 2)
       ▼
8. Deliver to a connector?                            YES → mcpConnector + mcpTool + {message}
       │                                                    perProfile (≤50 calls) or summary
       │ NO  → set deliveryMode "none" (it defaults to perProfile)
       ▼
9. Leave debug OFF unless diagnosing — it writes names and URLs to the run log
       ▼
[Execute]
       │
       ├──► SUCCEEDED ──► itemCount == 0? → retry once with exact_company_match false, then verify the name
       │                  else → group on department / seniority; filter title_verified for precision;
       │                         dedupe on linkedin_url; report as a SAMPLE, never as headcount
       └──► FAILED / 400 ──► missing company_name is the usual cause

---

💰 Cost Control & Pricing Transparency

• Pay-per-event pricing: $8.40 per 1,000 results on the entry tier, discounted at higher Apify subscription tiers. No monthly subscription.
• Free Apify plans are capped at 2 profiles per run.
• Autonomous spend caps: pass maxTotalChargeUsd as a query parameter on the run endpoint for a hard per-execution ceiling.

Profiles returned	Cost at $8.40 / 1,000
2 profiles (free-plan cap)	$0.02
20 profiles	$0.17
50 profiles (per-run ceiling)	$0.42
500 profiles (10 companies)	$4.20
1,000 profiles (20 companies)	$8.40

Platform usage is billed on top at your plan's rates. Two things drive it here: a real browser against a search engine, and residential proxy traffic metered per GB. A company that yields 3 profiles costs nearly as much in platform usage as one yielding 50, because the search work is the same.

Cost levers: set max_profiles to what you will actually use; prefer Standby for one-off lookups (no cold-start browser per request); and set maxTotalChargeUsd for a hard ceiling.

ℹ️ Always confirm the live rate on the Actor’s Apify Store page before committing to a large run. The Store listing is what bills you; the figures above are a worked example at the advertised rate. Apify platform usage is billed separately.

---

🔍 Companion machine-readable files

File	Purpose
.actor/actor.json	Identity, version, memory limits (512–1024 MB), usesStandbyMode: true, and the inline dataset view (incl. department, seniority and title_verified columns)
.actor/input_schema.json	Authoritative typed input contract — company_name (required), max_profiles (1–50), exact_company_match, proxy, deliveryMode enum, debug
.actor/openapi.json	The Standby REST contract — GET / (findCompanyEmployees), its query parameters and response shape
.actor/dataset_schema.json	Standalone dataset view, kept in sync with the inline one in actor.json
.actor/key_value_store_schema.json	Declares the run-summary record
.actor/output_schema.json	Declares where results are stored
my_actor/main.py	Query composition, Brave Search navigation, title/company matching, department and seniority derivation, standby web server, MCP delivery
my_actor/connector.py	MCP connector session handling through the Apify MCP Proxy

Note: this Actor has no pay_per_event.json — billing is configured entirely on the Store listing.

If any table on this page disagrees with the schema files, the schema files win.

---

🛠️ Troubleshooting

#	Symptom you see	Most likely cause	Fix
1	Input rejected, or HTTP 400 from Standby	company_name is required and has no default — the Console prefill isn't one	Always send company_name.
2	Exactly 2 profiles every run	Free Apify plan cap	Upgrade the plan; the log prints the upgrade banner.
3	Only 2 profiles on a paid plan	max_profiles defaults to 2 in the input schema	Set it explicitly, up to 50.
4	Standby returned 5 when you expected 2 (or 50)	Standby defaults max_profiles to 5; the code constant is 50; the schema says 2	Pass max_profiles in the query string.
5	Far fewer people than the company employs	Only search-indexed, title-matched profiles are visible	Expected. Treat the result as a sample, not a headcount.
6	Zero results for a company you know exists	exact_company_match excluded everything, or nothing is indexed	Retry with exact_company_match: false, then check the spelling.
7	People from a similarly-named company	exact_company_match was false	Set it back to true.
8	Lots of department: "General"	No department keyword matched those titles	Expected for unusual roles. Read title for those rows.
9	seniority: "Unknown"	The title score was too low to band	Not an error, and not a statement about the person's level.
10	Some roles look wrong	title_verified: false marks a softer match	Filter on title_verified when precision matters.
11	title disagrees with the person's current role	The role comes from a search snippet, which can lag	Verify on the profile before acting.
12	No email or phone anywhere	The output is eight fields — contact data is never returned	Enrich from linkedin_url with a separate service.
13	Thin results, search pages not loading	Datacenter IP hit a search-engine anti-bot check	Keep the RESIDENTIAL proxy group (the default).
14	Proxy warning in the log	Residential groups require a paid Apify plan	Upgrade, or expect a higher block rate.
15	Names and LinkedIn URLs in the run log	debug: true	Turn it off — run logs are retained.
16	headline looks truncated	It is capped at 200 characters	Expected. Open the profile for the full text.
17	Department / seniority columns missing in the Console	An older build's dataset view listed only five fields	Rebuild — the current views include department, seniority and title_verified.
18	Up to 50 connector calls per run	deliveryMode defaults to perProfile	Switch to summary.
19	Slack / Notion / Airtable received nothing	Delivery needs both mcpConnector and mcpTool	Set both. The dataset is still written in full.
20	Connector fired but the message body is empty	mcpArguments did not reference {message}	Map {message} in mcpArguments and populate mcpMessageTemplate.
21	Log: APIFY_MCP_PROXY_URL is not set	You ran locally; connectors only resolve on the platform	Deploy with apify push and run on the platform.
22	HTTP 408 on run-sync-get-dataset-items	The synchronous endpoint has a hard 300-second ceiling	Use Standby, or async POST /runs → poll → fetch.
23	HTTP 401 / 403	Missing, expired, or malformed APIFY_TOKEN	Regenerate in Apify Console → Settings → API & Integrations.
24	HTTP 429	Apify account concurrency / rate limits	Retry with exponential backoff (2s → 4s → 8s).

Diagnostic checklist before opening an issue

1. Baseline run. A well-known company, max_profiles: 10, exact_company_match: true, residential proxy, deliveryMode: "none".
2. Results returned? If yes, the pipeline is fine — the earlier company was either misspelled or thinly indexed.
3. Still zero? Retry with exact_company_match: false. If that works, company-name matching was the issue.
4. Still zero? Set debug: true for one run to see which results were considered and why each was dropped — then turn it back off.
5. Check the proxy — a residential group is the default for a reason; a blocked search page yields nothing to parse.

If the issue survives all five steps, open an Issues ticket on the Actor page (or email support) with the run ID, the exact input JSON, and the company name you searched.

❓ FAQ

Setup & access

Do I need a LinkedIn account, cookie or li_at token?

No — and none is accepted. The Actor reads a search engine's index of public profile pages, so your LinkedIn account is never involved.

Where does the data come from?

Brave Search results for public linkedin.com/in pages. The Actor composes the operators, runs the search in a real browser through a residential proxy, and parses the results.

Is this the official LinkedIn API?

No. This is an independent Actor, not affiliated with, endorsed by, or sponsored by LinkedIn or Brave.

Can I use it as a live API?

Yes — that's Standby mode: GET /?company_name=…&max_profiles=… returns JSON in one request, with no run to start or poll.

Can I plug it into Claude, Cursor, or a LangChain agent?

Yes — it is a native MCP tool:

claude mcp add --transport http apify "https://mcp.apify.com?tools=techforce.global/linkedin-company-employees"

Coverage & accuracy

Is this a complete employee list?

No, and it can't be. Only profiles a search engine has indexed — and whose role matched a known staff title — can be returned. Use it as a representative sample for team shape and talent mapping, never as a headcount.

How are department and seniority decided?

By keyword matching over the role string: ~150 title keywords mapped to 9 departments, and a weighted title score bucketed into 5 seniority bands. They're derived signals for grouping, not verified HR fields.

What does title_verified: false mean?

The profile was kept, but its role didn't cleanly match a known staff title — so treat the title, department and seniority on that row with more caution. Filter on this field when you need precision over recall.

Why is someone's department General?

No department keyword matched their title. Common for unusual, hybrid or vaguely-worded roles.

Does it include the CEO and VPs?

Not by design — this Actor targets staff titles. Use LinkedIn Decision Makers for leadership.

Output & data

Can I get email addresses?

No, at any setting. Use an email-finding service on linkedin_url if you need contact data — and mind the applicable privacy rules.

Why is headline cut off?

It is the search snippet, truncated at 200 characters.

Can I search several companies at once?

No — one company per run. Loop from your orchestration layer, or use Standby for rapid sequential lookups.

Pricing

How is this billed?

Pay-per-event, $8.40 per 1,000 results, less on higher Apify subscription tiers. Apify platform usage — compute units and residential proxy GB — is billed separately.

Why did a 3-profile run cost nearly as much as a 50-profile one?

Because the search work is the same either way; platform usage tracks browser and proxy traffic, not the number of matches.

How do I guarantee an agent never overspends?

Pass maxTotalChargeUsd as a query parameter on the run endpoint — a hard per-execution ceiling.

---

🔗 Related Actors

LinkedIn people, cookie-free — the same family

All three read public search results rather than an authenticated LinkedIn session. The difference is what you anchor on, and which part of the org you want.

Actor	Anchored on	Returns	Why pick it over this one
This Actor	One named company	Staff / ICs, with derived department and seniority	Org and talent mapping (1–50 per run, $8.40 / 1,000)
LinkedIn Decision Makers	One named company	Leadership only, seniority-ranked	You want the people who can say yes — founders, C-suite, VPs, directors (1–20 per run, from $5.00 / 1,000)
LinkedIn Candidate Search	A role / tech stack, across employers	Candidates matching a brief	Recruiting where the employer doesn't matter (1–50 per run, $1.00 / 1,000)

Pick by intent: the whole org chart → this Actor · who decides → Decision Makers · a role anywhere → Candidate Search.

ℹ️ Running this Actor and Decision Makers on the same company gives you both halves of the org — practitioners and buyers — with no overlap, since they match disjoint title sets.

Enrichment & downstream pipeline

Actor	Use it for
Google Maps Business Leads & Sales Intelligence	Company-level contact data (emails, phones) and a website grade for the account you're researching
GOV.UK Business Scraper	Match a UK company against Companies House records, incl. PSC / beneficial ownership
Advanced Website Crawling Actor	Crawl the company's own site for team and careers pages alongside the LinkedIn view

Suggested pipeline patterns

🗺️ Full org map This Actor for the staff + Decision Makers for the leadership → merge on linkedin_url → one roster covering practitioners and buyers.

📊 Competitor team shape Run across several competitors → group by department and seniority → compare where each is investing headcount.

🎯 Talent mapping for recruiting Filter department == "Technology" and seniority == "Senior IC" → deliveryMode: "perProfile" into your ATS → a recruiter reviews before any approach.

⚡ Live enrichment Standby endpoint called from your CRM when an account is created → staff roster attached within seconds, no run orchestration.

Browse all Actors by Techforce Global at scraper.techforce.global.

---

🔐 Compliance & Data Privacy

This is an independent Actor. It is not affiliated with, endorsed by, or sponsored by LinkedIn or Brave Search. "LinkedIn" is a trademark of LinkedIn Corporation.

This Actor reads publicly indexed search results for public LinkedIn profile pages. It does not log in, does not use or accept a session cookie, and does not access anything behind LinkedIn's authentication.

The output is personal data about identifiable individuals — named employees, their roles, locations and profile URLs, plus two inferred attributes. Four things follow:

• You become a data controller when you store it. GDPR, UK GDPR and CCPA/CPRA apply. Have a lawful basis (legitimate interest is the usual route for B2B research, and it requires a balancing assessment), record it, set a retention period, and be ready to honour access, objection and erasure requests.
• department and seniority are inferences about a person, not facts they published. Inferred personal data is still personal data, and a wrong inference attached to a named individual is a data-quality obligation under GDPR Art. 5(1)(d). Don't present them as verified, and don't use them to make consequential decisions about someone.
• Outreach and recruiting are regulated. Before contacting anyone identified here, satisfy the applicable anti-spam and e-marketing rules (GDPR Art. 6/21, ePrivacy/PECR, CAN-SPAM, CASL). If you use this for recruiting, keep a human in the loop and the criteria job-related — automated candidate screening carries extra obligations under GDPR Art. 22 and rules such as NYC Local Law 144.
• debug writes personal data into your run log. Run logs are retained and shareable — leave it off outside active troubleshooting, and keep the dataset as the system of record.

You are responsible for ensuring your use complies with LinkedIn's and Brave's terms of service and all applicable data-protection, employment and marketing law.

---

🆘 Support & Custom Pipeline Engineering

Need batch lookups across an account list, ATS or CRM integration, email enrichment on top of the roster, or a full talent-intelligence pipeline?

• Email: bhavin.shah@techforceglobal.com
• Custom Enterprise Integrations: Book a 15-Minute Technical Consultation
• Maintained by: Techforce Global — Specialists in High-Performance Web Scrapers and Agentic Workflows.

---

Made with ❤️ by Techforce Global Specialists in High-Performance B2B Contact Data Extraction and AI Automation.

---

🏷️ Structured data for search & AI discovery

{
  "@context": "https://schema.org",
  "@type": "SoftwareApplication",
  "name": "LinkedIn Employee Scraper — Find Company Staff by Name",
  "applicationCategory": "BusinessApplication",
  "operatingSystem": "Cloud (Apify platform)",
  "description": "Given one company name, returns its staff from public LinkedIn profiles — name, role, location, headline and profile URL — plus a derived department (Technology, Sales, Marketing, Finance, HR, Product, Operations, Legal, Business) and seniority band, with no LinkedIn account or session cookie required. Available as a standard Actor run, a Standby REST endpoint, or an MCP tool that delivers into Slack, Notion, Airtable, Jira or any authorized MCP connector.",
  "url": "https://apify.com/techforce.global/linkedin-company-employees",
  "offers": {
    "@type": "Offer",
    "price": "8.40",
    "priceCurrency": "USD",
    "description": "Per 1,000 results, pay-per-event"
  }
}

{
    "@context": "https://schema.org",
    "@type": "FAQPage",
    "mainEntity": [
                       {
                           "@type": "Question",
                           "name": "Do I need a LinkedIn account, cookie or li_at token?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "No - and none is accepted. The Actor reads a search engine's index of public profile pages, so your LinkedIn account is never involved."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "Where does the data come from?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "Brave Search results for public linkedin.com/in pages. The Actor composes the operators, runs the search in a real browser through a residential proxy, and parses the results."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "Is this the official LinkedIn API?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "No. This is an independent Actor, not affiliated with, endorsed by, or sponsored by LinkedIn or Brave."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "Can I use it as a live API?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "Yes - that's Standby mode: GET /?company_name=&max_profiles= returns JSON in one request, with no run to start or poll."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "Can I plug it into Claude, Cursor, or a LangChain agent?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "Yes - it is a native MCP tool:"
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "Is this a complete employee list?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "No, and it can't be. Only profiles a search engine has indexed - and whose role matched a known staff title - can be returned. Use it as a representative sample for team shape and talent mapping, never as a headcount."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "How are department and seniority decided?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "By keyword matching over the role string: ~150 title keywords mapped to 9 departments, and a weighted title score bucketed into 5 seniority bands. They're derived signals for grouping, not verified HR fields."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "What does title_verified: false mean?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "The profile was kept, but its role didn't cleanly match a known staff title - so treat the title, department and seniority on that row with more caution. Filter on this field when you need precision over recall."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "Why is someone's department General?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "No department keyword matched their title. Common for unusual, hybrid or vaguely-worded roles."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "Does it include the CEO and VPs?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "Not by design - this Actor targets staff titles. Use LinkedIn Decision Makers for leadership."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "Can I get email addresses?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "No, at any setting. Use an email-finding service on linkedin_url if you need contact data - and mind the applicable privacy rules."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "Why is headline cut off?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "It is the search snippet, truncated at 200 characters."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "Can I search several companies at once?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "No - one company per run. Loop from your orchestration layer, or use Standby for rapid sequential lookups."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "How is this billed?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "Pay-per-event, $8.40 per 1,000 results, less on higher Apify subscription tiers. Apify platform usage - compute units and residential proxy GB - is billed separately."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "Why did a 3-profile run cost nearly as much as a 50-profile one?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "Because the search work is the same either way; platform usage tracks browser and proxy traffic, not the number of matches."
                                              }
                       },
                       {
                           "@type": "Question",
                           "name": "How do I guarantee an agent never overspends?",
                           "acceptedAnswer": {
                                                  "@type": "Answer",
                                                  "text": "Pass maxTotalChargeUsd as a query parameter on the run endpoint - a hard per-execution ceiling."
                                              }
                       }
                   ]
}