# LinkedIn Decision-Maker Finder | No Cookies, No Account (`tqm/linkedin-decisionmaker-finder`) Actor

Give it a company name, get the decision-makers: full name, headline and public LinkedIn profile URL. It never touches LinkedIn - no cookie, no session, no account of yours at risk. Every row shows its own match evidence, so you set your own precision bar instead of trusting ours.

- **URL**: https://apify.com/tqm/linkedin-decisionmaker-finder.md
- **Developed by:** [TQM](https://apify.com/tqm) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

# README

Give it a company name. Get back the people at that company who hold a decision-making title — full name, headline and public LinkedIn profile URL.

**It never touches LinkedIn.** No cookie, no `li_at` session, no login, no account to be banned. It queries the public search index for indexed LinkedIn profiles, which is why it cannot get your LinkedIn account restricted — you never give it one.

### Why "no LinkedIn account" matters

Most LinkedIn people-search tools ask you for a session cookie. That works, and it puts *your* account at risk: an account ban is not a retryable error, and it takes your network with it.

This actor was built the other way round after measuring the alternatives against live pages:

| Approach | Result |
|---|---|
| `linkedin.com/company/<slug>` | HTTP 200, but the employees block yields ~1 person; other profile links on the page are incidental mentions, not employees |
| `linkedin.com/company/<slug>/people/` | HTTP 200 and **zero** profile links — the list is client-rendered |
| Authenticated with a session cookie | Works, and risks the account |
| **Public search index for indexed profiles** | **18 unique profiles from one query**, each with a full name and headline |

The last one wins on yield *and* on risk, so that is what this actor does.

### What data do I get?

| Field | Description |
|---|---|
| `fullName` | The person's full name |
| `firstName` / `lastName` | Name split into parts, ready for mail-merge |
| `headline` | Their public headline — usually role and company |
| `profileUrl` | Public LinkedIn profile URL |
| `companyName` | The company you searched for |
| `matchedTitle` | Which of your `titles` queries produced this person |
| `titleMatched` | Whether their headline actually matches that title |
| `seniorityMatched` | Whether the headline carries a decision-making seniority signal |
| `companyMatched` | Whether their **current** employer could be confirmed as your target company |
| `looksPastRole` | Flag for headlines that read like a *former* role at the company |
| `scrapedAt` | When this run collected the row |

**The four boolean flags are the product.** People-search tools normally hand you a list and leave you to work out which rows are real. This one shows its work per row, so you can set your own precision bar — take only `companyMatched && !looksPastRole` for outreach, or keep everything for research.

### How do I use it?

1. Click **Try for free**.
2. Set `companyName` — this is the only required input.
3. Optionally set `companyDomain` to sharpen the match, and `titles` to the roles you care about.
4. Click **Save & Start**.
5. Export as JSON, CSV, Excel or XML from the **Storage** tab.

#### Input sample

```json
{
  "companyName": "Northwind Labs",
  "companyDomain": "northwindlabs.com",
  "titles": ["CTO", "VP Engineering", "Head of Infrastructure", "Head of Platform"],
  "maxResults": 25,
  "includeUnmatched": true
}
```

### Input reference

| Option | Type | Default | What it does |
|---|---|---|---|
| `companyName` | string | **required** | The company to find decision-makers at. Used both as the search term and as the match key. |
| `companyDomain` | string | *(none)* | Strengthens the company match only — it is **never** used as a search term. |
| `titles` | array | engineering and infrastructure leadership | One search per title. More titles means more searches and more coverage. |
| `maxResults` | integer | `25` | Hard cap on people returned across all title queries, up to 200. |
| `includeUnmatched` | boolean | `true` | Keep people whose current employer could not be confirmed, flagged `companyMatched: false`. On by default so you can measure precision yourself rather than trusting ours. |

### Output sample

```json
{
  "fullName": "Dana Whitfield",
  "firstName": "Dana",
  "lastName": "Whitfield",
  "headline": "VP of Engineering at Northwind Labs",
  "profileUrl": "https://www.linkedin.com/in/dana-whitfield",
  "companyName": "Northwind Labs",
  "matchedTitle": "VP Engineering",
  "titleMatched": true,
  "seniorityMatched": true,
  "companyMatched": true,
  "looksPastRole": false,
  "scrapedAt": "2026-09-04T09:22:07.443Z"
}
```

### How many people will it find?

**It depends on the company, and the honest answer is a range.**

Across a 156-company batch, this actor resolved decision-makers at **119 of them — 76%**. Large and mid-size companies with a public engineering presence resolve well. Very small companies, stealth startups and companies whose staff keep low-visibility profiles resolve poorly, and no tool can fix that: if the profiles are not publicly indexed, they cannot be found without an account.

`maxResults` caps the total across all title queries. Each title in `titles` is one search, so more titles means broader coverage.

### Who is this for?

- **B2B sales and lead generation** — turn a list of target companies into named decision-makers with profile URLs to reference.
- **Recruiters** mapping the leadership of companies they are sourcing from.
- **Founders doing outbound**, who need the right person rather than a generic `info@` inbox.
- **Market and competitive research** — who runs engineering at the companies in your category.

Pair it with any company-list source: feed company names in, get decision-makers out.

### FAQ

#### Will my LinkedIn account get banned?

You never give it one. There is no cookie, no session and no login anywhere in this actor. That is the entire design.

#### Do I need a LinkedIn account at all?

No.

#### How accurate is the company match?

Every row tells you. `companyMatched` is true only when the person's current employer could be confirmed as your target; `looksPastRole` flags headlines that read like a former role. With `includeUnmatched: true` (the default) you get the unconfirmed rows too, clearly flagged, so you can decide your own bar rather than inheriting ours.

For outreach, filter to `companyMatched === true && looksPastRole === false`.

#### Does it return email addresses?

No. It returns names, headlines and public profile URLs. It does not guess, generate or enrich email addresses.

#### Is this legal? What about GDPR?

This actor returns **personal data** — named individuals and their public profile URLs. That is what it is for, and it means you carry real obligations.

It collects only what is already publicly indexed and accessible without an account, and it bypasses no login or access control. But publicly available does not mean unregulated: if you are in the EU or processing EU residents' data, **GDPR applies**, and you need a lawful basis (legitimate interest, for most B2B outreach), you must be able to honour access and erasure requests, and you should not retain data longer than you need it.

We are not able to give you legal advice, and this README is not it. If you are unsure whether your use qualifies, consult your lawyers before you run this at scale. Apify has useful background on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) and on [ethical scraping](https://blog.apify.com/what-is-ethical-web-scraping-and-how-do-you-do-it/).

#### Can I export to Excel or Google Sheets?

Yes — JSON, CSV, XML and Excel from the **Storage** tab, plus a direct Google Sheets integration.

### Integrations and API

Trigger runs and collect results via the [Apify API](https://docs.apify.com/api/v2), the JavaScript or Python client, or Apify's integrations — **Zapier, Make, Slack, Google Drive, GitHub and webhooks**. The common pattern is to drive it from a list of target companies and push confirmed decision-makers straight into your CRM.

### Support

Missing a title pattern, or seeing a match you disagree with? Open an issue on this actor's **Issues** tab — the match flags are tunable and real examples help.

# Actor input Schema

## `companyName` (type: `string`):

The company to find decision-makers at. Used both as the search term and as the match key.

## `companyDomain` (type: `string`):

Strengthens the company match only -- it is never used as a search term.

## `titles` (type: `array`):

One search per title, so more titles means broader coverage and a longer run. Leave empty to use the seven engineering and infrastructure leadership titles prefilled here.

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

Hard cap on people returned across all title queries.

## `includeUnmatched` (type: `boolean`):

Keep people whose current employer could not be confirmed, flagged companyMatched=false. On by default: a caller measuring precision needs to see the misses.

## Actor input object example

```json
{
  "titles": [
    "Head of Engineering",
    "VP of Engineering",
    "Director of Engineering",
    "CTO",
    "Head of Infrastructure",
    "Head of Platform",
    "DevOps Lead"
  ],
  "maxResults": 25,
  "includeUnmatched": true
}
```

# Actor output Schema

## `results` (type: `string`):

Every decision-maker this run resolved at the target company - name, headline, public profile URL and the four match-evidence flags, one row each.

# 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 = {
    "titles": [
        "Head of Engineering",
        "VP of Engineering",
        "Director of Engineering",
        "CTO",
        "Head of Infrastructure",
        "Head of Platform",
        "DevOps Lead"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tqm/linkedin-decisionmaker-finder").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 = { "titles": [
        "Head of Engineering",
        "VP of Engineering",
        "Director of Engineering",
        "CTO",
        "Head of Infrastructure",
        "Head of Platform",
        "DevOps Lead",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("tqm/linkedin-decisionmaker-finder").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 '{
  "titles": [
    "Head of Engineering",
    "VP of Engineering",
    "Director of Engineering",
    "CTO",
    "Head of Infrastructure",
    "Head of Platform",
    "DevOps Lead"
  ]
}' |
apify call tqm/linkedin-decisionmaker-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tqm/linkedin-decisionmaker-finder"
        }
    }
}

```

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/uvIofuVutJcotWgek/builds/BiMz6XwIsIYElvfxc/openapi.json