# LinkedIn New Hires Finder (`agnes.developer.queen/linkedin-new-hires-finder`) Actor

Takes a company LinkedIn URL or name and returns decision makers who started there recently, with the month they started and the company they left. Charges only when the current employer matches and the start month is inside your window. No login, no cookies.

- **URL**: https://apify.com/agnes.developer.queen/linkedin-new-hires-finder.md
- **Developed by:** [Agnes Maina](https://apify.com/agnes.developer.queen) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## LinkedIn New Hires Finder

LinkedIn New Hires Finder is an Apify Actor that takes a company website, name, or LinkedIn URL and returns decision makers who started at that company recently, with the month they started and the company they left, only when the current-employer match clears the bar.

### Pricing

| Event | Price | You pay when |
| --- | --- | --- |
| Actor start | $0.00005 | Once when the run begins |
| New decision maker | $0.025 | The person is a decision maker, currently at the company you named, and their start month is inside your tenure window |

**$25 per 1,000 billed new decision makers**, plus the start fee.

Rows that fail the bar still emit. They are free.

### The differentiator

Harvest-style scrapers dump a roster. This actor dumps a trigger.

```json
{
  "fullName": "Jane Doe",
  "title": "VP of Sales",
  "company": "stripe",
  "isDecisionMaker": true,
  "seniorityBand": "vp",
  "department": "sales",
  "startedAt": "2026-03",
  "tenureMonths": 6,
  "previousCompany": "HubSpot",
  "previousTitle": "Director of Sales",
  "whyNow": "new-decision-maker",
  "confidence": "medium",
  "charged": true,
  "profileUrl": "https://www.linkedin.com/in/jane-doe"
}
```

`whyNow` is `new-decision-maker` only on billed rows. Stale tenures and missing dates stay `stale-tenure` or `unknown-tenure` and are not charged.

### How it works

```
company URL or name
        |
        v
Google public index of LinkedIn profiles (decision-maker titles)
        |
        v
headline names the company?  no -> emit free
        |
       yes
        |
        v
decision maker (owner, founder, C level, VP, director)?  no -> skip before charge
        |
       yes
        |
        v
start month inside window (from indexed text, else public profile)?  no -> emit free
        |
       yes
        |
        v
charge new-hire, push the trigger row
```

Discovery uses Apify Google SERP proxies. Date enrichment uses Apify residential. No LinkedIn login. No cookies. No Sales Navigator.

### What is NOT returned

- emails
- phone numbers
- Sales Navigator rows
- guessed hires from "first time we crawled this profile"
- departures
- full work history beyond current start month and previous company

### Quick start

1. Paste one or more company LinkedIn URLs or names.
2. Keep `maxTenureMonths` at 12 unless you want a tighter buying window.
3. Run.
4. Filter the dataset on `whyNow = new-decision-maker` and `charged = true`.

```json
{
  "companies": ["https://www.linkedin.com/company/stripe/"],
  "maxTenureMonths": 12,
  "maxDecisionMakersPerCompany": 10
}
```

### Input

JSON example first. Field names match the live schema.

| Field | What it does |
| --- | --- |
| companies | LinkedIn company URLs or names |
| maxTenureMonths | Charge window, default 12 |
| enrichHireDates | Fetch public profiles when Google hid the start month |
| seniorityBands | owner, partner, cxo, vp, director |
| departments | optional function filter |
| maxDecisionMakersPerCompany | cap per company |

### Output

One full record is in **The differentiator** above. `charged` is the billing flag. `startedAt` is `YYYY-MM`.

### Use from any MCP agent

```
https://mcp.apify.com/?tools=agnes.developer.queen/linkedin-new-hires-finder
```

Ask the agent for decision makers who started at a named company this year. It should read `whyNow`, `startedAt`, and `previousCompany`, not a raw employee dump.

### Integrations

Works from the Apify API, `apify-client`, scheduled tasks, and webhooks. Save a task and run it weekly if you want the same accounts watched.

### Use cases

**Outbound agency.** A new VP of Sales at a target account is a first-line personalization ("saw you left HubSpot for Stripe") and a reason to email this week, not a name on a 400-row roster.

**Founder doing their own outbound.** Same trigger, smaller list. Filter `department = sales` or `seniorityBand = vp`.

**Agent pipeline.** Domain in, this actor, then your sequencer. Skip rows where `charged` is false.

### FAQ

#### Does this return employees?

No. It returns the buying committee, and it only charges the ones whose start month is inside your window. Use a roster scraper when you need everyone.

#### Do I need LinkedIn cookies?

No.

#### What if Google does not show a start month?

The actor fetches the public profile through Apify residential and reads experience dates. If the date is still missing, the row emits free with `whyNow = unknown-tenure`.

#### Why was a row free?

Either the headline did not name the company you asked for, the start month is older than `maxTenureMonths`, or no start month could be parsed. Read `whyNow` and `confidence`.

# Actor input Schema

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

LinkedIn company URLs such as https://www.linkedin.com/company/openai/ or plain company names. Mix both freely. Up to 200 companies per run. Large lists finish gracefully with partial coverage on the default 20 minute timeout, so split very large lists.

## `seniorityBands` (type: `array`):

Which decision maker bands to deliver and charge. Everyone outside the decision maker set (managers, seniors, individual contributors, interns) is always skipped before any charge.

## `departments` (type: `array`):

Leave empty for every department. Pick some to deliver and charge only decision makers in those functions, for example sales and marketing for a GTM list.

## `maxTenureMonths` (type: `integer`):

Only charge decision makers whose current role started within this many months. Default 12. Rows outside the window are still emitted and are free.

## `enrichHireDates` (type: `boolean`):

When Google does not expose a start month, fetch the public LinkedIn profile through Apify residential to read experience dates. Turn off to stay on indexed text only.

## `maxDecisionMakersPerCompany` (type: `integer`):

Stop after this many rows per company. Between 1 and 50.

## `targetTitles` (type: `array`):

Titles used to expand the Google search per company. Leave empty for the built in set (CEO, CTO, CFO, COO, CMO, President, Founder, Co-Founder, Owner, Managing Director plus Spanish equivalents). Pass your own list, for example Head of Sales and VP Marketing, for a narrower ICP. Up to 30 titles.

## `location` (type: `string`):

Optional location phrase added to the search, for example United States or Berlin.

## `searchQuery` (type: `string`):

Optional extra keyword added to the base company search, for example fintech or supply chain.

## `compareWithPreviousRun` (type: `boolean`):

On a scheduled run, adds one free company-diff-summary row per company listing the decision makers who appeared since your previous run, the ones who left the list and title changes. Snapshots live in a key value store in your own account and are never charged.

## `maxConcurrency` (type: `integer`):

Companies processed in parallel. Between 1 and 10.

## `proxyConfiguration` (type: `object`):

Discovery runs through the Apify GOOGLE\_SERP proxy group. Country routing is honored. Custom proxy URLs and other groups are ignored.

## Actor input object example

```json
{
  "companies": [
    "https://www.linkedin.com/company/stripe/"
  ],
  "seniorityBands": [
    "owner",
    "partner",
    "cxo",
    "vp",
    "director"
  ],
  "departments": [],
  "maxTenureMonths": 12,
  "enrichHireDates": true,
  "maxDecisionMakersPerCompany": 10,
  "targetTitles": [],
  "compareWithPreviousRun": false,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

## `newHires` (type: `string`):

Charged rows are current-company decision makers whose start month is inside the tenure window. Other rows are free.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companies": [
        "https://www.linkedin.com/company/stripe/"
    ],
    "seniorityBands": [
        "owner",
        "partner",
        "cxo",
        "vp",
        "director"
    ],
    "departments": [],
    "targetTitles": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "GOOGLE_SERP"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("agnes.developer.queen/linkedin-new-hires-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 = {
    "companies": ["https://www.linkedin.com/company/stripe/"],
    "seniorityBands": [
        "owner",
        "partner",
        "cxo",
        "vp",
        "director",
    ],
    "departments": [],
    "targetTitles": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["GOOGLE_SERP"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("agnes.developer.queen/linkedin-new-hires-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 '{
  "companies": [
    "https://www.linkedin.com/company/stripe/"
  ],
  "seniorityBands": [
    "owner",
    "partner",
    "cxo",
    "vp",
    "director"
  ],
  "departments": [],
  "targetTitles": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}' |
apify call agnes.developer.queen/linkedin-new-hires-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,agnes.developer.queen/linkedin-new-hires-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/06BsP927xdmUoI1up/builds/zrt9lqotrzkXXRjuf/openapi.json