# Hiring Intent Lead Scraper — Job Posting Buying Signals (`samstorm/hiring-intent-lead-scraper`) Actor

Find companies actively hiring and get decision-maker emails. Scrapes job postings as B2B buying signals, then enriches with verified contact data.

- **URL**: https://apify.com/samstorm/hiring-intent-lead-scraper.md
- **Developed by:** [Sam Kleespies](https://apify.com/samstorm) (community)
- **Categories:** Lead generation
- **Stats:** 99 total users, 12 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 enriched hiring intent leads

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Hiring Intent Lead Scraper — Job Posting Buying Signals to B2B Leads

Turn job postings into verified B2B leads — automatically. This actor scrapes **hiring intent signals** from Google Jobs, extracts the hiring company's website, discovers decision-maker contact emails, verifies deliverability, and outputs CRM-ready records in one pipeline.

**Keywords:** hiring intent data, job posting buying signals, intent data scraper, sales intelligence from job postings, companies actively hiring, B2B hiring leads, job posting lead generation, outbound prospecting by hiring signal

***

### Why Hiring Intent Works

A job posting is one of the strongest B2B buying signals available publicly. When a company posts for a "VP of Marketing," they're signaling:

- Budget is allocated for that function
- A decision-maker is about to be onboarded (or is already there)
- The company is actively investing in a pain point your product may solve

This actor captures that signal at scale and converts it into actionable, verified contact data — before your competitors do.

***

### What It Does

The pipeline runs end-to-end in a single actor run:

1. Searches Google Jobs for your target job title and location
2. Extracts the hiring company name and website from each posting
3. Crawls each company's website to find publicly listed contact emails
4. Verifies each email via DNS MX lookup and SMTP handshake (no external API needed)
5. Outputs structured, CRM-ready records in Full Detail, HubSpot, or Salesforce format

No manual prospecting. No stitching together three tools. One run, verified contacts.

***

### Who This Is For

- **SaaS SDR teams** building outbound sequences triggered by real-time hiring signals
- **Staffing and recruiting agencies** finding companies that need talent acquisition support
- **Cold email marketers** building intent-based lists instead of spray-and-pray
- **RevOps teams** enriching CRM records with live hiring context for better lead scoring
- **B2B consultants and agencies** identifying clients actively investing in a specific function
- **Market researchers** tracking which industries are growing headcount in a given role

***

### Sample Output

```json
{
  "companyName": "Acme Corp",
  "companyWebsite": "https://acmecorp.com/",
  "jobTitle": "VP of Marketing",
  "jobLocation": "San Francisco, CA",
  "jobSource": "Google Jobs",
  "jobUrl": "https://jobs.lever.co/acme/12345",
  "hiringSignal": "Hiring VP of Marketing",
  "email": "sarah@acmecorp.com",
  "emailVerified": true,
  "phone": "",
  "allEmails": [
    { "address": "sarah@acmecorp.com", "verified": true, "status": "deliverable" },
    { "address": "info@acmecorp.com", "verified": true, "status": "dns_verified" }
  ],
  "scrapedAt": "2026-03-22T10:22:00Z"
}
```

The `hiringSignal` field is ready to use as personalization in cold outreach — "I saw you're hiring a VP of Marketing" — without any additional enrichment step.

***

### Inputs

| Field | Type | Required | Default | Description |
|-|-|-|-|-|
| `jobTitle` | string | Yes | `VP of Marketing` | Job title to use as hiring intent signal (e.g., "Sales Engineer", "Head of Data") |
| `location` | string | Yes | `San Francisco, CA` | City, state, region, or "Remote" |
| `maxResults` | integer | No | `50` | Max job postings to process (1–200) |
| `enrichEmails` | boolean | No | `true` | Crawl company websites to find contact emails |
| `verifyEmails` | boolean | No | `true` | Verify emails via DNS MX + SMTP check |
| `outputFormat` | string | No | `full` | Output format: `full`, `hubspot`, or `salesforce` |

**Example input — SaaS targeting companies scaling sales:**

```json
{
  "jobTitle": "Sales Engineer",
  "location": "Austin, TX",
  "maxResults": 50,
  "enrichEmails": true,
  "verifyEmails": true,
  "outputFormat": "hubspot"
}
```

**Example input — Staffing agency finding finance hiring:**

```json
{
  "jobTitle": "Controller",
  "location": "Chicago, IL",
  "maxResults": 100,
  "enrichEmails": true,
  "verifyEmails": true,
  "outputFormat": "full"
}
```

***

### Output Fields

| Field | Type | Example |
|-|-|-|
| `companyName` | string | `Acme Corp` |
| `companyWebsite` | string | `https://acmecorp.com` |
| `jobTitle` | string | `VP of Marketing` |
| `jobLocation` | string | `San Francisco, CA` |
| `jobSource` | string | `Google Jobs` |
| `jobUrl` | string | `https://jobs.lever.co/acme/12345` |
| `hiringSignal` | string | `Hiring VP of Marketing` |
| `email` | string | `sarah@acmecorp.com` |
| `emailVerified` | boolean | `true` |
| `allEmails` | array | All emails found with verification status |
| `phone` | string | `+1 415 555 0100` |
| `scrapedAt` | string | `2026-03-22T10:22:00Z` |

***

### Output Formats

**Full Detail** (`outputFormat: "full"`)
All fields including raw email arrays and metadata. Best for custom workflows, data warehouses, or tools like Clay and n8n.

**HubSpot Import** (`outputFormat: "hubspot"`)
Columns mapped to HubSpot's standard contact and company import format. Download the dataset as CSV and import directly — no column remapping needed.

**Salesforce Import** (`outputFormat: "salesforce"`)
Fields mapped to Salesforce Lead object conventions. Ready for standard Salesforce data loader or CSV import.

***

### Use Cases

**Outbound prospecting by role (SaaS targeting)**
Search "Sales Engineer" in "New York" to find SaaS companies scaling their sales team. These companies are actively investing in sales capacity — strong signal for sales enablement tools, sales training, or recruiting services.

**Staffing agency lead generation**
A staffing firm specializing in finance can run "Controller" or "CFO" searches across multiple metros weekly. Every result is a company with an open finance seat and a verified contact to pitch.

**Competitor displacement**
Search for job titles that signal stack transitions — "Salesforce Administrator" at a company you know runs HubSpot, or "HubSpot Manager" at an enterprise expanding into CRM. The hiring signal tells you when to time your outreach.

**Intent-based email sequences**
Feed verified emails directly into cold email tools (Instantly, Smartlead, Apollo). The `hiringSignal` field provides a ready-made first-line opener — no manual research required for personalization at scale.

**Market research and TAM analysis**
Aggregate hiring data across a job title over 30 days to identify which industries and geographies are growing in a specific function. Useful for territory planning and TAM sizing.

***

### Email Verification

When `verifyEmails` is enabled, each discovered email goes through two checks:

1. **DNS MX lookup** — confirms the domain has valid mail exchange records
2. **SMTP handshake** — connects to the mail server and checks if the mailbox exists, without sending a message

The `emailVerified: true` flag means the email passed both checks. Sending only to verified emails keeps bounce rates below the 2% threshold most cold email platforms (Instantly, Smartlead, Mailreach) enforce before flagging or suspending your sending domain.

***

### Cost Comparison

Hiring intent data platforms charge enterprise prices for the same underlying signal this actor provides at Apify's pay-per-event rate.

| Tool | Monthly Cost | What You Get |
|-|-|-|
| PredictLeads | ~$490/mo | Hiring signals, job data API |
| LoneScale | $300–$500/mo | Intent signals + enrichment |
| Clay | $149–$720/mo | Data enrichment with hiring triggers |
| **This actor** | Pay-per-result | Job postings + emails + verification, no subscription |

No seats. No contracts. Run it when you need it, pay only for what you scrape.

***

### Pricing

This actor uses Apify's pay-per-event model. You pay per job posting processed with no monthly subscription. Costs scale linearly with `maxResults`.

Estimated cost for a 50-result run with email enrichment and verification: under $1.00.

Check the **Pricing** tab on the Apify Store for current per-event rates.

***

### Limitations

- Job data is sourced from Google Jobs. Availability varies by location and role.
- Email discovery depends on what is publicly listed on the company website. Not every company will have a contactable email.
- SMTP verification checks mailbox existence but cannot guarantee deliverability for every provider (some servers block port 25 probes from cloud IPs — those emails are marked `dns_verified` instead).
- Maximum 200 job postings per run. For larger list builds, run multiple searches with different locations or job title variants.

***

### Frequently Asked Questions

**How do I find companies actively hiring for a specific role?**
Enter the job title in `jobTitle` (e.g., "VP of Sales", "Head of Engineering", "Salesforce Administrator") and set `location` to your target metro or "Remote". The actor searches Google Jobs, extracts the hiring companies, and returns verified decision-maker emails — one pipeline, no manual research.

**What is hiring intent data and why does it matter for B2B sales?**
Hiring intent data treats job postings as buying signals. When a company posts for a role, they're signaling budget allocation, team investment, and active pain points — before any sales conversation happens. It's one of the most reliable real-time triggers for outbound prospecting because it reveals *why* a company is a good fit *right now*.

**How does this compare to PredictLeads, LoneScale, or Clay for hiring intent?**
PredictLeads starts at ~$490/month, LoneScale at $300–$500/month, and Clay at $149–$720/month for enrichment workflows that include hiring signals. This actor delivers the same job-posting signal plus verified contact emails at Apify's pay-per-result rate — a 50-result run with full enrichment typically costs under $1.00 with no subscription.

**Can I export hiring intent leads to HubSpot or Salesforce?**
Yes. Set `outputFormat` to `hubspot` or `salesforce` before running. The exported CSV maps to standard CRM fields in both platforms and is ready for direct import. The `hiringSignal` field is preserved as a lead note so your reps have immediate personalization context.

**How accurate are the verified contact emails?**
Each email passes a two-stage check: DNS MX lookup confirming the domain accepts mail, and an SMTP handshake confirming the mailbox exists without sending a message. The `emailVerified: true` flag means both checks passed. Sending exclusively to verified addresses keeps bounce rates below the 2% threshold enforced by most cold email platforms.

**How is this different from buying a contact list from Apollo or ZoomInfo?**
Apollo and ZoomInfo provide static contact lists with no context about *why* a company is a good fit right now. This actor surfaces companies at the moment they signal budget and intent through a job posting — giving you a ready-made personalization angle for first-touch outreach without additional research.

**Can I find companies replacing a specific software tool?**
Yes. Search for job titles tied to competitor tools: "Salesforce Administrator" at companies running HubSpot, or "HubSpot Manager" at companies expanding to enterprise. These postings signal a stack evaluation or migration, making the timing for a competitive displacement pitch nearly ideal.

**Can staffing agencies use this to find hiring clients?**
Absolutely — this is one of the top use cases. Run weekly searches by role specialty (e.g., "Controller", "Staff Accountant", "RN Case Manager") across your target metros. Each result is a company with an open seat and a verified contact to pitch your staffing services.

***

### Related Actors

If you need leads by business type rather than hiring activity, see the other actors in this portfolio:

- [Dentist Lead Scraper](https://apify.com/samstorm/dentist-lead-scraper)
- [Contractor Lead Scraper](https://apify.com/samstorm/contractor-lead-scraper)
- [Real Estate Agent Lead Scraper](https://apify.com/samstorm/real-estate-agent-lead-scraper)

# Actor input Schema

## `jobTitle` (type: `string`):

Job title keyword to use as a hiring intent signal. The role reveals what the company is investing in — e.g. 'VP of Marketing' signals need for marketing tools, 'Sales Engineer' signals a scaling GTM motion, 'Head of Data' signals analytics stack investment.

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

City, state, or region to filter job postings. Use 'Remote' for remote-first companies worldwide, or a metro like 'New York', 'Austin, TX', or 'London, UK' to target a specific geography.

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

Maximum number of job postings to process. Each posting = one hiring company lead. Start with 10–20 to preview results, then scale up to 200 for bulk list builds.

## `enrichEmails` (type: `boolean`):

Crawl each company's website to discover publicly listed contact emails. Checks the homepage, /contact, /contact-us, /about, and /about-us pages. Disable to get a faster run with company data only (no emails).

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

Run a two-stage deliverability check on each discovered email: (1) DNS MX lookup confirms the domain accepts mail, (2) SMTP handshake confirms the mailbox exists without sending a message. Keeps bounce rates below the 2% threshold most cold email platforms enforce.

## `outputFormat` (type: `string`):

Choose the output structure. 'Full Detail' includes all fields and raw email arrays. 'HubSpot Import' maps to HubSpot standard contact/company columns — download as CSV and import directly. 'Salesforce Import' maps to Salesforce Lead object fields for standard data loader import.

## Actor input object example

```json
{
  "jobTitle": "VP of Marketing",
  "location": "San Francisco, CA",
  "maxResults": 3,
  "enrichEmails": true,
  "verifyEmails": true,
  "outputFormat": "full"
}
```

# Actor output Schema

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

No description

# 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 = {
    "jobTitle": "VP of Marketing",
    "location": "San Francisco, CA",
    "maxResults": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("samstorm/hiring-intent-lead-scraper").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 = {
    "jobTitle": "VP of Marketing",
    "location": "San Francisco, CA",
    "maxResults": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("samstorm/hiring-intent-lead-scraper").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 '{
  "jobTitle": "VP of Marketing",
  "location": "San Francisco, CA",
  "maxResults": 3
}' |
apify call samstorm/hiring-intent-lead-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,samstorm/hiring-intent-lead-scraper"
        }
    }
}

```

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/SbCglJ6T4IzZYtJ87/builds/o7N60SL89m7kxV8ir/openapi.json