# Hiring Signal Lead Scraper - Job Boards + Email Enrichment (`conceivable_extension/hiring-signal-lead-scraper`) Actor

Scrapes job boards to find companies actively hiring in target roles — the top B2B buying signal. Returns leads with verified emails via Hunter.io. Covers Indeed, LinkedIn, Greenhouse, Lever, and Workable. Built for cold email agencies, SDR teams, and n8n/Make workflows.

- **URL**: https://apify.com/conceivable\_extension/hiring-signal-lead-scraper.md
- **Developed by:** [joseph fadero](https://apify.com/conceivable_extension) (community)
- **Categories:** Lead generation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 lead founds

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Signal Lead Scraper - Job Boards + Email Enrichment

### What does Hiring Signal Lead Scraper do?

Hiring Signal Lead Scraper identifies companies actively hiring across multiple job boards and enriches the results with verified contact emails. This actor scrapes job postings to find B2B buying signals—companies posting for roles like VP of Sales, Head of Marketing, and other key positions that indicate budget and decision-making activity.

Hiring Signal Lead Scraper can scrape:

- Company names and hiring information
- Job titles and role descriptions
- Job posting URLs and posting dates
- Application links and hiring platform details
- Location and industry data
- Verified contact emails via Hunter.io enrichment

The actor supports job boards including Indeed, LinkedIn Jobs, Greenhouse, Lever, and Workable.

### Why scrape job boards for hiring signals?

Job boards are one of the strongest indicators of active buying intent in B2B sales. When a company posts a role like VP of Sales or Head of Marketing, they have allocated budget and are making immediate hiring decisions. This makes job boards an invaluable source of leads for sales teams and outreach agencies.

Here are just some of the ways you could use hiring signal data:

- Build targeted outreach lists for cold email campaigns
- Identify companies in growth mode before competitors do
- Research decision-makers at companies actively hiring
- Feed lead lists into n8n or Make automation workflows
- Track hiring activity trends in specific industries or regions
- Prioritize prospects based on hiring velocity and role seniority
- Create custom audience segments for advertising and outreach

If you would like more inspiration on how scraping job boards could help your business or organization, check out our [industry pages](https://apify.com/industries).

### How to scrape job boards for hiring signals

It's easy to scrape job boards with Hiring Signal Lead Scraper. Just follow these few steps and you'll get your enriched lead list in a few minutes.

1. Click on **Try for free**
2. Enter the job titles or keywords you want to target (e.g., "VP of Sales", "Head of Marketing")
3. Optionally specify locations, industries, or job boards to search
4. Enable email enrichment via Hunter.io (requires Hunter.io API key)
5. Click on **Run**
6. When Hiring Signal Lead Scraper has finished, preview or download your data from the **Dataset** tab

Your results will include company information, job details, and verified contact emails ready for outreach.

### How much will it cost to scrape job boards?

Apify gives you $5 free usage credits every month on the [Apify Free plan](https://apify.com/pricing). Depending on the scope of your search, you can scrape hundreds of job listings and get enriched contact data completely free!

But if you need to collect hiring signals regularly, we recommend grabbing an Apify subscription. The [$49/month Starter plan](https://apify.com/pricing) gives you plenty of credits for consistent weekly or monthly scraping campaigns.

For high-volume lead generation operations, the [Scale plan](https://apify.com/pricing) at $499/month provides enterprise-level capacity and priority support.

### Results

Here's an example of the data structure you'll receive:

```json
{
  "companyName": "Acme Corporation",
  "jobTitle": "VP of Sales",
  "jobDescription": "We are seeking an experienced VP of Sales to lead our enterprise sales team...",
  "jobUrl": "https://www.indeed.com/jobs?q=vp+of+sales",
  "jobBoard": "Indeed",
  "postedDate": "2024-01-15",
  "location": "San Francisco, CA",
  "industry": "SaaS",
  "companyWebsite": "https://acme.com",
  "contactName": "John Smith",
  "contactEmail": "john.smith@acme.com",
  "contactTitle": "Hiring Manager",
  "emailVerified": true,
  "enrichmentSource": "Hunter.io"
}
````

### Tips for scraping job boards

- Use specific job titles to find higher-quality leads—generic searches return more noise
- Target multiple job boards to get a comprehensive view of hiring activity
- Set up recurring runs to track companies posting multiple roles (strong hiring signal)
- Use location filters to focus on your target markets and reduce irrelevant results
- Monitor posting dates to prioritize freshly posted roles for faster response times
- Combine results with company research tools to identify decision-maker contact information
- Test your outreach message on a small batch before scaling up your lead generation

### Is it legal to scrape job boards?

Note that personal data is protected by GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

Job board scraping for B2B sales outreach generally falls within legitimate business purposes, but always verify the terms of service for each job board you're scraping and ensure compliance with local data protection laws.

We also recommend that you read our blog post: [is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

# Actor input Schema

## `keywords` (type: `array`):

Job title keywords to search for. Each keyword is searched independently. Example: 'VP Sales', 'Head of Marketing', 'Account Executive'

## `locations` (type: `array`):

Locations to search. Use city names, regions, or 'Remote'. Example: 'United Kingdom', 'London', 'Remote'

## `sources` (type: `array`):

Which job boards to scrape. Options: indeed, linkedin, greenhouse, lever, workable

## `maxResultsPerSource` (type: `integer`):

Maximum number of job postings to return per source per keyword combination. Higher = more leads, higher cost.

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

If enabled, attempts to find and verify a contact email for each company using Hunter.io. Requires hunterApiKey. Increases cost per result.

## `hunterApiKey` (type: `string`):

Required only if 'Enrich with Verified Emails' is enabled. Get your key at hunter.io

## `filterPostedWithinDays` (type: `integer`):

Only return jobs posted within this many days. Set to 0 to disable filtering.

## `deduplicateByCompany` (type: `boolean`):

If enabled, returns only one result per company per keyword (the most recent posting). Reduces duplicates.

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

Proxy settings for scraping. Recommended to use Apify Residential proxy for LinkedIn.

## Actor input object example

```json
{
  "keywords": [
    "VP Sales",
    "Head of Marketing"
  ],
  "locations": [
    "United Kingdom",
    "Remote"
  ],
  "sources": [
    "indeed",
    "linkedin"
  ],
  "maxResultsPerSource": 25,
  "enrichEmails": false,
  "filterPostedWithinDays": 30,
  "deduplicateByCompany": true
}
```

# 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 = {
    "keywords": [
        "VP Sales",
        "Head of Marketing"
    ],
    "locations": [
        "United Kingdom",
        "Remote"
    ],
    "sources": [
        "indeed",
        "linkedin"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("conceivable_extension/hiring-signal-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 = {
    "keywords": [
        "VP Sales",
        "Head of Marketing",
    ],
    "locations": [
        "United Kingdom",
        "Remote",
    ],
    "sources": [
        "indeed",
        "linkedin",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("conceivable_extension/hiring-signal-lead-scraper").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 '{
  "keywords": [
    "VP Sales",
    "Head of Marketing"
  ],
  "locations": [
    "United Kingdom",
    "Remote"
  ],
  "sources": [
    "indeed",
    "linkedin"
  ]
}' |
apify call conceivable_extension/hiring-signal-lead-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=conceivable_extension/hiring-signal-lead-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hiring Signal Lead Scraper - Job Boards + Email Enrichment",
        "description": "Scrapes job boards to find companies actively hiring in target roles — the top B2B buying signal. Returns leads with verified emails via Hunter.io. Covers Indeed, LinkedIn, Greenhouse, Lever, and Workable. Built for cold email agencies, SDR teams, and n8n/Make workflows.",
        "version": "1.0",
        "x-build-id": "ImQrafe0EqJ8SLOfQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/conceivable_extension~hiring-signal-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-conceivable_extension-hiring-signal-lead-scraper",
                "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/conceivable_extension~hiring-signal-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-conceivable_extension-hiring-signal-lead-scraper",
                "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/conceivable_extension~hiring-signal-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-conceivable_extension-hiring-signal-lead-scraper",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Job Title Keywords",
                        "minItems": 1,
                        "type": "array",
                        "description": "Job title keywords to search for. Each keyword is searched independently. Example: 'VP Sales', 'Head of Marketing', 'Account Executive'",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Locations to search. Use city names, regions, or 'Remote'. Example: 'United Kingdom', 'London', 'Remote'",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sources": {
                        "title": "Job Board Sources",
                        "type": "array",
                        "description": "Which job boards to scrape. Options: indeed, linkedin, greenhouse, lever, workable",
                        "default": [
                            "indeed",
                            "linkedin"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerSource": {
                        "title": "Max Results Per Source Per Keyword",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of job postings to return per source per keyword combination. Higher = more leads, higher cost.",
                        "default": 25
                    },
                    "enrichEmails": {
                        "title": "Enrich with Verified Emails",
                        "type": "boolean",
                        "description": "If enabled, attempts to find and verify a contact email for each company using Hunter.io. Requires hunterApiKey. Increases cost per result.",
                        "default": false
                    },
                    "hunterApiKey": {
                        "title": "Hunter.io API Key",
                        "type": "string",
                        "description": "Required only if 'Enrich with Verified Emails' is enabled. Get your key at hunter.io"
                    },
                    "filterPostedWithinDays": {
                        "title": "Filter: Posted Within Days",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Only return jobs posted within this many days. Set to 0 to disable filtering.",
                        "default": 30
                    },
                    "deduplicateByCompany": {
                        "title": "Deduplicate by Company",
                        "type": "boolean",
                        "description": "If enabled, returns only one result per company per keyword (the most recent posting). Reduces duplicates.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Recommended to use Apify Residential proxy for LinkedIn."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```