# Hiring Intent Lead Scraper — Verified Decision-Maker Email (`qualifyops/hiring-intent-leads-verified-email`) Actor

Hiring-intent lead generation: turn a LinkedIn job search into companies hiring now, the decision-maker to pitch, and a verified deliverable email. SMTP-checked, no bounces. B2B leads with buying intent for cold email and sales. Pay only per verified lead.

- **URL**: https://apify.com/qualifyops/hiring-intent-leads-verified-email.md
- **Developed by:** [QualifyOps](https://apify.com/qualifyops) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 verified leads

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

### Hiring-Intent Leads — Verified Decision-Maker Email (Send-Ready)

**You give:** a public LinkedIn job-search URL (a role + location) — your ideal-customer profile.
**You get:** one **CRM-ready row per hiring company** with a **verified decision-maker email**, marked **SEND_NOW** or **SKIP** — so you email only addresses that will actually land.
**You pay:** **only for verified `SEND_NOW` leads.** Companies with no verifiable email are free.

Companies that are hiring are companies that are spending. This Actor finds them the moment the job goes live, resolves the person who owns the budget, **verifies their email is deliverable**, and hands you a row you can paste straight into your sequencer.

---

#### Why "verified" is the whole point
Raw scrapers hand you guessed addresses and you eat the bounces. Bounces wreck your domain reputation and your open rates. Here, every `SEND_NOW` email has been through:

> syntax → MX record → **live SMTP mailbox check** → catch-all detection → confidence score

Only addresses that a real mail server **accepts** and that are **not catch-all** are marked `SEND_NOW`. Everything else is `SKIP` with a reason — never a silent guess.

#### What each row gives you
| Column | Meaning |
|---|---|
| `action` | **SEND_NOW** (verified deliverable) or **SKIP** (with reason) |
| `company` | The hiring company |
| `verified_email` | The deliverable decision-maker address (only on SEND_NOW) |
| `decision_maker` / `decision_maker_role` | Who it reaches (name when public, always the target role) |
| `confidence` | 0–1 deliverability confidence |
| `why_now` | The commercial reason they're hiring (your opener) |
| `roles_hiring` | The open roles that triggered the signal |
| `evidence_url` | The live job post — proof, not a guess |

#### How it works
1. Pulls fresh hiring signals from the public LinkedIn job market (proven upstream scraper).
2. Groups them into **one record per company** and classifies the hiring signal (sales / marketing / engineering / ops / new-site / clinical expansion).
3. Extracts the company's **public** contacts and picks the best route to the decision-maker for that signal.
4. **Verifies the email** via a dedicated deliverability check.
5. Returns SEND_NOW-first rows. **You are charged only for verified SEND_NOW leads.**

#### Honest by design
- We **never invent** `first.last@company.com` and label it verified. We only propose addresses a company actually exposes publicly, then verify them.
- Catch-all domains (which accept everything and confirm nothing) are marked `SKIP`, not passed off as deliverable.
- Every lead carries the evidence job URL so you can audit the signal.

#### For agents & automation
Call it via the Apify API/MCP. One run returns deduped, verified, CRM-ready rows. Schedule it for a recurring verified-lead feed into your CRM or sequencer.

---
*Input: paste a LinkedIn job-search URL for your ICP. Optional: role keyword filter, freshness window, max companies, `sendNowOnly` to return verified leads only.*

# Actor input Schema

## `jobSearchUrls` (type: `array`):

One or more public LinkedIn job-search result URLs describing your ideal customer (role + location).
## `maxJobs` (type: `integer`):

Upper bound on raw job rows requested from the upstream scraper. Start small (10–25) for a fast first run, then raise it.
## `roleKeywords` (type: `array`):

Only keep jobs whose title contains one of these keywords.
## `freshnessDays` (type: `integer`):

Only keep jobs posted within this many days.
## `maxCompanies` (type: `integer`):

Return only the top N companies by opportunity score. Start small (3–5) for a fast first run, then raise it.
## `sendNowOnly` (type: `boolean`):

If on, SKIP rows are omitted and you get only verified, send-ready leads.
## `verifyDeliverability` (type: `boolean`):

Run the SMTP deliverability check (recommended). Off = candidate emails without verification.
## `verifierActorId` (type: `string`):

Store validator used for the SMTP check. Default is a proven high-volume validator.
## `requestTimeoutSecs` (type: `integer`):

How long to wait for each company web page.
## `maxPagesPerSite` (type: `integer`):

Pages scanned per company site for public contacts.
## `maxConcurrency` (type: `integer`):

How many company sites to scan in parallel.

## Actor input object example

```json
{
  "jobSearchUrls": [
    {
      "url": "https://www.linkedin.com/jobs/search/?keywords=marketing%20manager&location=Australia"
    }
  ],
  "maxJobs": 10,
  "roleKeywords": [],
  "freshnessDays": 30,
  "maxCompanies": 3,
  "sendNowOnly": false,
  "verifyDeliverability": true,
  "verifierActorId": "michael.g/email-verifier-validator",
  "requestTimeoutSecs": 10,
  "maxPagesPerSite": 2,
  "maxConcurrency": 5
}
````

# 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 = {
    "jobSearchUrls": [
        {
            "url": "https://www.linkedin.com/jobs/search/?keywords=marketing%20manager&location=Australia"
        }
    ],
    "maxJobs": 10,
    "roleKeywords": [],
    "freshnessDays": 30,
    "maxCompanies": 3,
    "requestTimeoutSecs": 10,
    "maxPagesPerSite": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("qualifyops/hiring-intent-leads-verified-email").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 = {
    "jobSearchUrls": [{ "url": "https://www.linkedin.com/jobs/search/?keywords=marketing%20manager&location=Australia" }],
    "maxJobs": 10,
    "roleKeywords": [],
    "freshnessDays": 30,
    "maxCompanies": 3,
    "requestTimeoutSecs": 10,
    "maxPagesPerSite": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("qualifyops/hiring-intent-leads-verified-email").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "jobSearchUrls": [
    {
      "url": "https://www.linkedin.com/jobs/search/?keywords=marketing%20manager&location=Australia"
    }
  ],
  "maxJobs": 10,
  "roleKeywords": [],
  "freshnessDays": 30,
  "maxCompanies": 3,
  "requestTimeoutSecs": 10,
  "maxPagesPerSite": 2
}' |
apify call qualifyops/hiring-intent-leads-verified-email --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=qualifyops/hiring-intent-leads-verified-email",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hiring Intent Lead Scraper — Verified Decision-Maker Email",
        "description": "Hiring-intent lead generation: turn a LinkedIn job search into companies hiring now, the decision-maker to pitch, and a verified deliverable email. SMTP-checked, no bounces. B2B leads with buying intent for cold email and sales. Pay only per verified lead.",
        "version": "0.1",
        "x-build-id": "IhFe3mtUhZ4MUoskV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/qualifyops~hiring-intent-leads-verified-email/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-qualifyops-hiring-intent-leads-verified-email",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/qualifyops~hiring-intent-leads-verified-email/runs": {
            "post": {
                "operationId": "runs-sync-qualifyops-hiring-intent-leads-verified-email",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/qualifyops~hiring-intent-leads-verified-email/run-sync": {
            "post": {
                "operationId": "run-sync-qualifyops-hiring-intent-leads-verified-email",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "jobSearchUrls"
                ],
                "properties": {
                    "jobSearchUrls": {
                        "title": "LinkedIn job-search URLs",
                        "type": "array",
                        "description": "One or more public LinkedIn job-search result URLs describing your ideal customer (role + location).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxJobs": {
                        "title": "Maximum jobs to fetch",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Upper bound on raw job rows requested from the upstream scraper. Start small (10–25) for a fast first run, then raise it."
                    },
                    "roleKeywords": {
                        "title": "Role keywords (optional filter)",
                        "type": "array",
                        "description": "Only keep jobs whose title contains one of these keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "freshnessDays": {
                        "title": "Freshness window (days)",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Only keep jobs posted within this many days."
                    },
                    "maxCompanies": {
                        "title": "Maximum companies",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Return only the top N companies by opportunity score. Start small (3–5) for a fast first run, then raise it."
                    },
                    "sendNowOnly": {
                        "title": "Return verified SEND_NOW leads only",
                        "type": "boolean",
                        "description": "If on, SKIP rows are omitted and you get only verified, send-ready leads.",
                        "default": false
                    },
                    "verifyDeliverability": {
                        "title": "Verify email deliverability",
                        "type": "boolean",
                        "description": "Run the SMTP deliverability check (recommended). Off = candidate emails without verification.",
                        "default": true
                    },
                    "verifierActorId": {
                        "title": "Verifier actor (advanced)",
                        "type": "string",
                        "description": "Store validator used for the SMTP check. Default is a proven high-volume validator.",
                        "default": "michael.g/email-verifier-validator"
                    },
                    "requestTimeoutSecs": {
                        "title": "Website request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "How long to wait for each company web page.",
                        "default": 20
                    },
                    "maxPagesPerSite": {
                        "title": "Max pages scanned per website",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Pages scanned per company site for public contacts.",
                        "default": 4
                    },
                    "maxConcurrency": {
                        "title": "Website scan concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many company sites to scan in parallel.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
