# ◉ Hiring signal leads - Full LinkedIn profiles + Verified email (`jordanesanson/hiring-signal-leads`) Actor

Pay only for delivered profiles. No account needed. Find companies with open jobs for the roles you choose and get their decision makers, checked one by one, with 45+ person and company fields and optional real-time email verification.

- **URL**: https://apify.com/jordanesanson/hiring-signal-leads.md
- **Developed by:** [Jordane Sanson](https://apify.com/jordanesanson) (community)
- **Categories:** Lead generation, AI, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Hiring Signal Leads: decision makers at companies hiring for the roles you choose

**Tell us which jobs the companies should be hiring for. Get the decision makers of the companies that posted them, checked one by one and enriched with 45+ person and company fields, with emails verified in real time on demand. You only pay for profiles that match.**

A company that is hiring has a budget, a need and a deadline. A company hiring SDRs is building its sales machine. A company hiring data engineers is investing in data. This Actor turns those job posts into a ready-to-contact list of the people who own the decision, not the recruiter who posted the ad.

### Why this Actor

| | Hiring Signal Leads | Job scrapers | Hiring manager finders |
|---|---|---|---|
| What you get | Decision makers at companies hiring for your roles, with the actual job post | Job posts, then you find the people yourself | One contact per job post you paste |
| Input | The job titles companies are hiring for. That's it. | Search URLs or keywords | Job post URLs, one by one |
| Quality control | Every person checked against the role you want to reach before delivery, off-target people removed | None | None |
| Who you reach | The leaders of the hiring team (VP Sales for a sales hire, CTO for an engineering hire) plus founders, or the roles you choose | The recruiter or nobody | Usually the recruiter |
| Emails | Optional real-time verification, pay only for verified ones | Rarely | Often $25 to $30 per 1,000 extra |
| LinkedIn account or cookies | Not needed | Sometimes | Often required |
| Speed | About 10 to 20 profiles in about a minute | Varies | One post at a time |

**Best fit for:**

- agencies selling recruiting, staffing or outsourced teams (SDR, dev, design, support)
- SaaS selling to teams that are growing (sales tools to companies hiring sellers, data tools to companies hiring data engineers)
- consultants and freelancers who want to reach companies with a real, current need
- any outbound campaign where timing matters

### Quick start

1. List the jobs the companies should be hiring for, for example *Sales Development Representative* and *Account Executive*.
2. Choose how many qualified profiles you want, and run. Everything else is optional.

### How it works

1. **Companies with matching job posts are found** among recent LinkedIn job posts, in the countries you choose, if any.
2. **Each company is matched with care in a database of hundreds of millions of B2B profiles**, so a hiring signal is never attributed to a homonym.
3. **The right people are selected:** by default the leaders of the department that is hiring (deduced from the job titles) plus founders and CEOs, or the roles you choose.
4. **Recruitment agencies and job boards are excluded by default**, because they post jobs for their clients and are not the company with the need (`includeRecruitmentAgencies` to keep them). **Off-target profiles are removed too, at no cost to you:** companies outside your exact size range, generic titles that are not a role, and everything you excluded.
5. **Every remaining candidate is checked** against the role you want to reach. Only the right people are delivered, each with the hiring signal of their company.

### Input

Only the first field is required.

| Field | Description |
|---|---|
| `jobOpenings` | **Required.** Job titles of the open positions, one per line. Typos, abbreviations (SDR, AE) and other languages are fine: titles are corrected and common variants are added automatically. |
| `maxResults` | Number of qualified profiles you want, from 10 to 2000 (default 50, 100 maximum on the free Apify plan). |
| `postedWithinDays` | Only job posts from the last 24 hours, 7 days, 30 days (default), or any job still open. |

#### Optional sections

| Section | Fields |
|---|---|
| **Who to contact** | `contactRoles`: job titles of the people to contact. Default: leaders of the hiring department plus founders and CEOs. |
| **Emails** | `verifyEmails` (paying users only): verify every delivered email in real time. |
| **Refine your targeting** | `countries`, `companySizes`: only companies in these countries and size ranges. `includeRecruitmentAgencies`: keep staffing firms and job boards (excluded by default). `maxPerCompany`: people per company, 3 by default (1 for one contact per company). |
| **Exclusions** | `excludeCompanies` (customers, competitors), `excludeLinkedinUrls` (people already contacted), `excludePreviousResults` (datasets of your previous runs: nobody is delivered twice). |

#### Examples

Sales leaders at US companies building their sales team:

```json
{
  "jobOpenings": ["Sales Development Representative", "Account Executive"],
  "countries": ["United States"],
  "companySizes": ["11-50", "51-200", "201-500"],
  "maxResults": 100
}
```

CTOs of French companies hiring data engineers this month, verified emails, one contact per company:

```json
{
  "jobOpenings": ["Data Engineer", "Analytics Engineer"],
  "countries": ["France"],
  "companySizes": ["51-200", "201-500", "501-1000"],
  "contactRoles": ["CTO", "VP Engineering", "Head of Data"],
  "postedWithinDays": "30",
  "maxPerCompany": 1,
  "verifyEmails": true
}
```

Every week, only new companies:

```json
{
  "jobOpenings": ["Customer Success Manager"],
  "countries": ["United Kingdom"],
  "postedWithinDays": "7",
  "excludePreviousResults": ["<dataset ID of last week's run>"]
}
```

#### Tips

- Don't worry about the exact wording: "acount executiv", "AE" or "commercial" all work. Each title is corrected and its common variants are searched too (Account Executive also finds Sales Executive). You can still list several different roles.
- You get **up to 3 people per company** by default, so large companies that post many jobs cannot fill your list. Set `maxPerCompany` to 1 for one contact per company, or raise it.
- **Set a country**: the job post and the decision maker are then in the same market. Without a country, the search is worldwide.
- A **shorter window** (24 hours or 7 days) gives the freshest intent, "Any open job" gives the most volume.
- Schedule the Actor weekly with `excludePreviousResults` to get only the companies that started hiring since your last run.

### Output

One row per decision maker, the same 46 columns everywhere: console table, CSV and Excel exports, JSON.

| Group | Fields |
|---|---|
| Hiring signal | `intentSignal` (the actual job post: title, posting date, other matching open roles), `jobPostUrl` (link to the job post), `roleMatch` |
| Person | `fullName`, `firstName`, `lastName`, `linkedinUrl`, `email`, `emailStatus` |
| Current role | `headline`, `jobTitle`, `seniority`, `department`, `jobStartDate`, `timeInRole`, `jobDescription` |
| Location | `location`, `region`, `country` |
| Company | `companyName`, `companyWebsite`, `companyDomain`, `companyLinkedinUrl`, `companyIndustry`, `companySubIndustry`, `companyEmployees`, `companySizeRange`, `companyFounded`, `companyType`, `companyMarket` (B2B / B2C), `companyHqCity`, `companyHqCountry`, `companyDescription`, `companyFollowers`, `companyNewHires6m`, `companyTechnologies`, `companyLogoUrl` |
| Background | `about`, `yearsOfExperience`, `pastExperiences`, `education`, `skills`, `languages`, `connections` |
| Technical | `linkedinUsername`, `profilePictureUrl`, `profileUpdatedAt` |

#### Output example

```json
{
  "intentSignal": "Hiring: Senior Account Executive, North America (posted 2026-09-30), +2 other matching open roles",
  "jobPostUrl": "https://www.linkedin.com/jobs/view/1234567890",
  "roleMatch": true,
  "fullName": "Daniel Brooks",
  "firstName": "Daniel",
  "lastName": "Brooks",
  "linkedinUrl": "https://www.linkedin.com/in/daniel-brooks-example",
  "email": "daniel.brooks@example-cloud.com",
  "emailStatus": "verified",
  "headline": "VP Sales at Example Cloud",
  "jobTitle": "Vice President of Sales",
  "seniority": "Executive Leadership",
  "department": "Sales",
  "country": "United States",
  "companyName": "Example Cloud",
  "companyWebsite": "https://example-cloud.com",
  "companyDomain": "example-cloud.com",
  "companyEmployees": 240,
  "companySizeRange": "201-500",
  "companyHqCountry": "United States",
  "companyDescription": "Example Cloud builds scheduling software for field service teams."
}
```

The example is shortened: every row has all 46 columns. The run's `OUTPUT` record contains the search plan, the number of hiring companies found and matched, the candidates reviewed and removed, and why the run stopped.

### Accuracy

The matching and quality-control engine is shared with our Leads Finder Actor, where an independent review of 240 delivered profiles across 8 targets in 4 countries judged **more than 8 out of 10 on target**. On hiring signals specifically, every delivered profile now comes with the actual job post (title, date and link), so the signal can be checked in one click. Companies are matched to their job posts through their LinkedIn company page: 94 to 100% of hiring companies matched in our tests.

### Pricing

Pay per event:

| Event | Price | When it is charged |
|---|---|---|
| Qualified profile | $15 per 1,000 | For each profile delivered, hiring signal included. Candidates reviewed and rejected cost you nothing. |
| Verified email | $8 per 1,000 | Only when `verifyEmails` is on, and only for emails that come back `verified`. Catch-all, invalid and unknown emails are never charged. |

Your Apify spending limit is respected: the run stops cleanly as soon as it is reached.

#### Email statuses

| `emailStatus` | Meaning |
|---|---|
| `verified` | The mailbox exists and accepts email. Safe to send. |
| `catch-all` | The domain accepts every address, so the mailbox cannot be confirmed. Send with care. |
| `invalid` | The mailbox does not exist. The email is removed from the row. |
| `unknown` | The mail server did not answer in time. |
| `unverified` | `verifyEmails` was off: the email is the best guess available, not checked. |

#### Free Apify plan

Try the Actor on the free Apify plan with up to **100 qualified profiles per run**. Email verification is reserved for paid plans. These limits are set by the Actor developer, not by Apify, and the run tells you when one applies.

### Send your leads anywhere

Use Apify integrations to send every new list to your CRM, your sequencing tool, a Google Sheet or a webhook: Make, Zapier, n8n, Google Sheets, Slack, HubSpot and more, from the **Integrations** tab of the Actor. Combined with a weekly schedule, you get a steady flow of companies that just started hiring.

### For AI agents and automations

Use this Actor when the task is to **find people to contact at companies that are currently hiring for given roles**. Examples: find sales leaders at companies hiring SDRs, find CTOs at companies hiring engineers, build a list of companies with open jobs and their decision makers.

- **Main input:** `jobOpenings`, a list of job titles in English. Optionally narrow with `countries` and `companySizes`.
- **Output:** a dataset of already-checked decision makers, each with a LinkedIn URL, the current role, company data and the hiring signal of their company.
- **Freshness:** `postedWithinDays` = `"1"`, `"7"`, `"30"` (default) or `"any"`.
- **Emails:** set `verifyEmails` to `true` for cold email and keep rows where `emailStatus` is `verified`.
- **No duplicates across runs:** pass the dataset IDs of previous runs in `excludePreviousResults`.

Call through the API:

```bash
curl -X POST "https://api.apify.com/v2/acts/jordanesanson~hiring-signal-leads/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"jobOpenings": ["Account Executive"], "countries": ["United States"], "maxResults": 50}'
```

### FAQ

**Who do I get: the recruiter or the decision maker?**
The decision maker. By default the leaders of the department that is hiring (deduced from the job titles) plus founders and CEOs, never the recruiter. Set `contactRoles` to choose the exact roles.

**How recent are the job posts?**
You choose: last 24 hours, 7 days, 30 days, or any job still open. Each profile comes with the actual job post in `intentSignal` (title and posting date) and its link in `jobPostUrl`.

**Why do I get fewer profiles than requested?**
Only companies with a matching recent job post can be delivered. Add similar job titles, choose a longer window, or remove country and size filters. You only pay for what was delivered.

**Do I need a LinkedIn account, cookies or Sales Navigator?**
No. Nothing runs on your LinkedIn account.

**Are the emails verified?**
Only if you turn on `verifyEmails`: each delivered email is then checked in real time, invalid ones are removed, and you pay only for verified ones. Phone numbers are not provided.

**What if I misspell a job title or use another language?**
It still works: titles are corrected, translated to the wording companies use in job posts, and common variants are searched too. The `intentSignal` column shows the actual job post found.

**Which countries are supported?**
All of them: use `countries` to choose.

**What are the minimum and maximum per run?**
10 to 2000 qualified profiles per run on paid Apify plans, 10 to 100 on the free plan.

# Actor input Schema

## `jobOpenings` (type: `array`):

Job titles of the open positions, one per line (e.g. Sales Development Representative, Account Executive, Data Engineer). Typos, abbreviations (SDR, AE) and other languages are fine: titles are corrected and common variants are added automatically.

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

How many profiles scoring 50/100 or more you want (10 to 2000, 100 maximum on the free Apify plan). You only pay for these.

## `postedWithinDays` (type: `string`):

Only companies whose matching job post is recent enough. Shorter windows mean fresher intent but fewer results.

## `contactRoles` (type: `array`):

Job titles of the people to contact (e.g. VP Sales, Head of Sales). Leave empty to get the leaders of the hiring department plus founders and CEOs.

## `verifyEmails` (type: `boolean`):

Check every delivered email in real time. Invalid emails are removed, each email gets a status (verified, catch-all, invalid, unknown), and you pay only for emails that come back verified.

## `countries` (type: `array`):

Only companies whose job posts and decision makers are in these countries, in English (e.g. United States, France). Remove all countries to search worldwide.

## `companySizes` (type: `array`):

Only companies in these employee ranges. Leave empty for all sizes.

## `maxPerCompany` (type: `integer`):

Maximum number of profiles delivered for the same company (default 3, 1 for one contact per company). Best-matching people are picked first. Large companies post many jobs and would otherwise fill your list.

## `includeRecruitmentAgencies` (type: `boolean`):

Off by default: staffing firms, recruitment agencies and job boards post jobs for their clients, so they are not the company with the need.

## `excludeCompanies` (type: `array`):

Customers, competitors or partners to never include. One per line: website or domain, LinkedIn company URL, or exact company name.

## `excludeLinkedinUrls` (type: `array`):

LinkedIn profile URLs of people already contacted, one per line.

## `excludePreviousResults` (type: `array`):

Pick the datasets of your previous runs of this Actor: nobody already delivered will be delivered again.

## Actor input object example

```json
{
  "jobOpenings": [
    "Sales Development Representative",
    "Account Executive"
  ],
  "maxResults": 50,
  "postedWithinDays": "30",
  "verifyEmails": false,
  "countries": [
    "United States"
  ],
  "maxPerCompany": 3,
  "includeRecruitmentAgencies": false
}
```

# Actor output Schema

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

One item per decision maker at a company hiring for your roles, with the hiring signal, person, current role, company and email fields.

## `runSummary` (type: `string`):

Search plan deduced from your description, candidates reviewed and removed, companies not found, and why the run stopped.

# 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 = {
    "jobOpenings": [
        "Sales Development Representative",
        "Account Executive"
    ],
    "countries": [
        "United States"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jordanesanson/hiring-signal-leads").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 = {
    "jobOpenings": [
        "Sales Development Representative",
        "Account Executive",
    ],
    "countries": ["United States"],
}

# Run the Actor and wait for it to finish
run = client.actor("jordanesanson/hiring-signal-leads").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 '{
  "jobOpenings": [
    "Sales Development Representative",
    "Account Executive"
  ],
  "countries": [
    "United States"
  ]
}' |
apify call jordanesanson/hiring-signal-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jordanesanson/hiring-signal-leads"
        }
    }
}
```

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/DnUriOdDIYXh1fGyv/builds/Ii6tLi40CDsld5YCq/openapi.json