# Hiring Intent Lead Finder — Companies Actively Hiring (`signalengine/hiring-intent-lead-finder`) Actor

Find companies actively hiring a given role — hiring is a buying signal. Get a sales-ready lead per company: role, location, job link and a ready-to-send opener. Optional decision-maker email via your own Prospeo key.

- **URL**: https://apify.com/signalengine/hiring-intent-lead-finder.md
- **Developed by:** [James Taylor](https://apify.com/signalengine) (community)
- **Categories:** Lead generation, Jobs
- **Stats:** 2 total users, 1 monthly users, 25.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 hiring 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.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 Intent Lead Finder — Companies Actively Hiring

Find **companies that are actively hiring** a given role in a given place — and turn each one into a sales-ready B2B lead. A company advertising a *"Marketing Manager, London"* is telling you three things at once: it has **budget**, it has a **gap right now**, and you know **exactly what that gap is**. That's the strongest cold-outreach trigger there is. This actor surfaces those companies and hands you back the role, the location, the job link, and a ready-to-send opener — optionally with a **decision-maker's verified work email**.

It's built for **agencies, B2B sales teams, recruiters and founders** who want **hiring-intent leads** — prospects with a live buying signal — instead of a cold, untriggered list.

### Why hiring-intent beats a cold list

Most lead lists are a flat dump of companies in a category. There's no reason to reach out *today* and nothing to say. A **hiring signal** fixes both: the company is spending money on the exact problem you solve, and the job ad is your opener. The classic play for agencies and service businesses: *"Before you hire a £30k in-house Marketing Manager, here's what our team does for a fraction of that."* The role and location are the hook; this actor finds them at scale.

### What it does

- Takes your **roles** (e.g. `Marketing Manager`, `Sales Executive`) and **locations** (e.g. `London UK`) and finds companies advertising those jobs.
- Returns one **lead per company**: the **role** they're hiring, the **location**, the **job-post URL**, a **role tier** (leadership / growth), and a one-line **opener** you can paste into an email.
- Searches **Indeed, LinkedIn and Glassdoor** — *through Google*, reading public search results. It never logs into or directly scrapes those sites, so it **can't be blocked** by their anti-bot.
- Dedupes by company, so a firm hiring three roles is **one lead** (the rest land in `otherRoles`).
- **Optional email enrichment:** turn on `findEmails` and, for each company, it finds a **decision-maker** (owner / founder / director) from public LinkedIn results and enriches their **verified work email** using *your own* [Prospeo](https://prospeo.io/?via=james) key *(referral link)*.

### Who it's for

- **Agencies & freelancers** running the "don't hire — outsource it to us" play against companies hiring marketers, designers or sales staff.
- **B2B sales teams** who want trigger-event leads (hiring = growth = budget) instead of a cold ICP dump.
- **Recruiters** sourcing companies actively hiring a role they place for.
- **Founders** doing targeted outbound where every lead comes with a reason to reach out.

### Input

Provide **`roles`** (and usually **`locations`**). Everything else has sensible defaults.

| Field | Type | Default | Description |
|---|---|---|---|
| `roles` | array | `[]` | Job titles a company hiring for signals intent, e.g. `["Marketing Manager","Sales Executive"]`. **Required.** |
| `locations` | array | `[]` | Cities/areas, e.g. `["London UK","Manchester UK"]`. Qualify with the country for accurate local results. Empty = nationwide. |
| `jobBoards` | array | `["indeed","linkedin","glassdoor"]` | Which boards to search. Use the keys `indeed`/`linkedin`/`glassdoor`, or add a raw host like `reed.co.uk`. |
| `maxResultsPerQuery` | integer | `15` | Results parsed per role+location query before deduping (1–50). |
| `maxLeads` | integer | `100` | Hard cap on leads output/charged — caps your spend (1–1000). |
| `searchEngine` | string | `"google"` | `google` (default, falls back to Bing) or `bing`. |
| `maxConcurrency` | integer | `3` | Parallel searches during discovery (1–10). |
| `findEmails` | boolean | `false` | Find a decision-maker + verified email per company (uses your Prospeo key). Off by default. |
| `emailProvider` | string | `"prospeo"` | `prospeo` (recommended — matches on the decision-maker's LinkedIn URL, no company domain needed). `hunter` is accepted but needs a company domain this actor doesn't resolve. |
| `emailApiKey` | string (secret) | — | Your own Prospeo key. Only used when `findEmails` is on; you pay your provider directly. |
| `decisionMakerRoles` | array | `["owner","founder","CEO","director","head of marketing"]` | Who to look for when finding a contact to pitch. |
| `emailThrottleMs` | integer | `1100` | Delay between Prospeo lookups (its free tier rate-limits — rate-limited calls return no email). |
| `proxyConfiguration` | object | `GOOGLE_SERP` | Defaults to Apify's GOOGLE_SERP proxy (needed to read Google results). Residential is used for the Bing fallback. |

#### Example input

**Find companies hiring marketers in two cities, no email enrichment:**

```json
{
  "roles": ["Marketing Manager", "Marketing Executive"],
  "locations": ["London UK", "Manchester UK"],
  "maxLeads": 100
}
````

**With decision-maker emails (bring your own Prospeo key):**

```json
{
  "roles": ["Head of Sales", "Sales Manager"],
  "locations": ["London UK"],
  "findEmails": true,
  "emailProvider": "prospeo",
  "emailApiKey": "YOUR_PROSPEO_KEY"
}
```

### How to run

1. Click **Try for free** (or open the actor in your Apify Console).
2. Add your **roles** and **locations**.
3. (Optional) Turn on **`findEmails`** and paste your **Prospeo** key for decision-maker emails.
4. Set **`maxLeads`** to cap your spend.
5. Click **Start**. When it finishes, open the **Dataset** tab and export to JSON/CSV/Excel, or pull it via the API (below).

Run it on a **schedule** to catch fresh postings each week, or call it from **Make / Zapier / n8n** via Apify's integrations.

### Output

Each dataset item is one hiring company:

```json
{
  "type": "hiring_lead",
  "company": "Spotify",
  "role": "Marketing Manager",
  "otherRoles": ["Brand Marketing Lead"],
  "location": "London UK",
  "jobUrl": "https://uk.linkedin.com/jobs/view/marketing-manager-at-spotify-4400000000",
  "source": "linkedin",
  "roleTier": "leadership",
  "roleWeight": 40,
  "opener": "Hi Jane — saw Spotify is hiring a Marketing Manager in London UK.",
  "decisionMaker": { "name": "Jane Smith", "title": "Head of Marketing", "profileUrl": "https://www.linkedin.com/in/janesmith" },
  "email": "jane@spotify.com",
  "emailStatus": "VERIFIED",
  "emailConfidence": null,
  "query": "\"Marketing Manager\" \"London UK\" (site:indeed.com/viewjob OR site:linkedin.com/jobs/view OR site:glassdoor.com/job-listing)"
}
```

Field notes:

- **`company`** is extracted from the job-post title (and, for LinkedIn, the URL slug). **`jobUrl`** is the live posting — always there for you to verify the company and role in one click.
- **`role`** is the role that matched; **`otherRoles`** holds additional roles the same company is advertising. **`roleTier`** / **`roleWeight`** rank the signal (leadership 40 > growth 30 > other 10) so you can sort the hottest leads first.
- **`opener`** is a ready-to-paste first line built from the company, role and location (and the decision-maker's first name when found).
- **`decisionMaker`** / **`email`** / **`emailStatus`** are populated only when `findEmails` is on **and** a confident match is found; otherwise `null`. **`emailConfidence`** is a Hunter-only score and stays `null` with Prospeo (use `emailStatus`, e.g. `VERIFIED`, instead).
- **`source`** is the board the lead came from: `indeed`, `linkedin` or `glassdoor`.

#### Export & API

```bash
## Last run's dataset items as JSON
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json&token=<APIFY_TOKEN>"
```

Or use **run-sync-get-dataset-items** to run-and-wait in a single call.

### How it works (and what to expect)

It reads **public Google search results** for individual job postings on Indeed, LinkedIn and Glassdoor (`site:linkedin.com/jobs/view`, `site:indeed.com/viewjob`, `site:glassdoor.com/job-listing`), parses the company from each result, and only keeps postings whose title actually matches the role you searched. No logins, no cookies, no direct scraping of the job boards.

**Company-name quality is highest for LinkedIn and Glassdoor**, whose titles read *"Company hiring Role…"* or *"Role – Company"*. Indeed adds breadth (great for SMB and local roles) but its titles are less consistent, so a minority of Indeed rows may carry a role descriptor instead of a clean company name — that's why **every lead includes the `jobUrl`**: one click confirms the company. The actor works best for **named professional roles** (marketing, sales, operations, finance, design, engineering) where the company is stated in the posting.

### Limitations

- **Search-snippet based.** Coverage is what Google indexes for your role + location — a focused **hit-list**, not an exhaustive ATS dump. Run more roles, cities and boards for breadth.
- **Company extraction isn't perfect** on noisy job-board titles (especially Indeed). Use the `jobUrl` to verify; LinkedIn/Glassdoor rows are cleanest.
- **Email enrichment** (Prospeo) is **best-effort** and gated to **distinctively-named companies** to avoid mis-attributing a contact. Match rate depends on Prospeo's data and your plan's rate limits — raise `emailThrottleMs` on the free tier.
- **Location precision.** A bare city can match the wrong country — qualify it (`"Manchester UK"`).

### Compliance

This actor reads **public search results and public job postings** only, identifies itself with a normal browser User-Agent, and never logs in or uses cookies. Any contact details come from your own Prospeo lookups, which you run under your own key and account. You're responsible for using the output in line with the privacy and outreach laws that apply to you (GDPR, PECR, CAN-SPAM, etc.).

### FAQ

**How do I find companies that are hiring?** Give it `roles` (e.g. `Marketing Manager`) and `locations` (e.g. `London UK`). It searches Indeed, LinkedIn and Glassdoor via Google, and returns one lead per hiring company with the role, location and job link.

**Can it get me the decision-maker's email?** Yes — turn on `findEmails` and add your own [Prospeo](https://prospeo.io/?via=james) key *(referral link)*. For each distinctively-named company it finds an owner/founder/director from public LinkedIn results and enriches their verified work email. You pay Prospeo directly for the lookups.

**Why Prospeo and not Hunter?** Prospeo can match a person from their LinkedIn URL alone — no company domain required, which is exactly what this actor has. Hunter needs a company domain this actor doesn't resolve, so Prospeo is the recommended provider here.

**Will I get blocked or banned?** No. The actor only reads public Google results — it never logs into Indeed, LinkedIn or Glassdoor, so there's no account to ban and no cookies to expire.

**Why does a row sometimes show a role instead of a company?** Some job-board titles (mostly Indeed) don't state the company cleanly. The actor filters out the obvious non-companies, but a few may slip through — the `jobUrl` lets you confirm in one click. LinkedIn and Glassdoor rows are the cleanest.

**How is it priced?** Apify Pay-Per-Event — you're charged **per hiring lead** returned, plus a small fee **per email** only when `findEmails` actually finds one. Set `maxLeads` to cap the run.

**Can I use other job boards?** Yes — add a host to `jobBoards` (e.g. `reed.co.uk`). The big three (Indeed, LinkedIn, Glassdoor) are on by default.

***

#### Want the whole outbound loop done for you?

This actor finds companies with a live hiring signal and the person to pitch. If you'd like the **entire loop** — discovery, contact enrichment, AI-personalised outreach that opens with their hiring signal, and reply handling — run for you, that's what we build at **[SignalEngine](https://engine.signalsprint.io)**. It's speed-to-lead in a box; this actor is a taste of the engine that powers it.

Need named decision-makers and emails by company or role instead of by hiring signal? See our **LinkedIn Profile & Email Finder**. Want to grade local-business websites for lead-readiness? See our **Local Business Website Audit**.

# Actor input Schema

## `roles` (type: `array`):

Job titles a company hiring for signals buying intent, e.g. \["Marketing Manager","Sales Executive"]. Required.

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

Cities/areas to search, e.g. \["Leeds UK","Manchester UK"]. Qualify with the country (e.g. "Manchester UK") for accurate local results. Leave empty to search nationwide.

## `jobBoards` (type: `array`):

Which job boards to search via Google. Use the keys indeed, linkedin, glassdoor, or add a raw host like "reed.co.uk".

## `maxResultsPerQuery` (type: `integer`):

How many job-board results to parse per role+location query before deduping.

## `maxLeads` (type: `integer`):

Hard cap on total leads output/charged this run (caps your spend).

## `searchEngine` (type: `string`):

Which engine to use. Google is default; the actor falls back to Bing when Google returns nothing.

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

Parallel search requests during discovery (kept modest).

## `findEmails` (type: `boolean`):

For each hiring company, find a decision-maker (owner/founder/director) from public LinkedIn snippets and enrich their verified work email using YOUR Prospeo key. Off by default. Adds a search + a provider call per lead.

## `emailProvider` (type: `string`):

Which email-finder your key is for. Prospeo matches on the decision-maker's LinkedIn URL (no company domain needed) and is recommended for this actor. Hunter requires a company domain this actor does not resolve, so it returns nothing here.

## `emailApiKey` (type: `string`):

Your own Prospeo (or Hunter) API key. Only used when findEmails is on. You pay your provider directly for lookups.

## `decisionMakerRoles` (type: `array`):

Titles to look for when finding who to pitch at each hiring company (used only when findEmails is on).

## `emailThrottleMs` (type: `integer`):

Delay between provider lookups. Prevents rate-limiting (Prospeo's free tier rate-limits — rate-limited calls silently return no email). Lower to 0 on a paid plan to speed up large runs.

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

Defaults to Apify's GOOGLE\_SERP proxy group (required to read Google search results reliably). Residential is used for the Bing fallback.

## Actor input object example

```json
{
  "roles": [
    "Marketing Manager"
  ],
  "locations": [
    "London UK"
  ],
  "jobBoards": [
    "indeed",
    "linkedin",
    "glassdoor"
  ],
  "maxResultsPerQuery": 15,
  "maxLeads": 100,
  "searchEngine": "google",
  "maxConcurrency": 3,
  "findEmails": false,
  "emailProvider": "prospeo",
  "decisionMakerRoles": [
    "owner",
    "founder",
    "CEO",
    "director",
    "head of marketing"
  ],
  "emailThrottleMs": 1100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

## `leads` (type: `string`):

Companies actively hiring, with role, location and opener.

# 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 = {
    "roles": [
        "Marketing Manager"
    ],
    "locations": [
        "London UK"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("signalengine/hiring-intent-lead-finder").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "roles": ["Marketing Manager"],
    "locations": ["London UK"],
}

# Run the Actor and wait for it to finish
run = client.actor("signalengine/hiring-intent-lead-finder").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 '{
  "roles": [
    "Marketing Manager"
  ],
  "locations": [
    "London UK"
  ]
}' |
apify call signalengine/hiring-intent-lead-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hiring Intent Lead Finder — Companies Actively Hiring",
        "description": "Find companies actively hiring a given role — hiring is a buying signal. Get a sales-ready lead per company: role, location, job link and a ready-to-send opener. Optional decision-maker email via your own Prospeo key.",
        "version": "0.1",
        "x-build-id": "48Ej5iB4wdfnSvJpW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/signalengine~hiring-intent-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-signalengine-hiring-intent-lead-finder",
                "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/signalengine~hiring-intent-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-signalengine-hiring-intent-lead-finder",
                "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/signalengine~hiring-intent-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-signalengine-hiring-intent-lead-finder",
                "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",
                "properties": {
                    "roles": {
                        "title": "Roles to hunt",
                        "type": "array",
                        "description": "Job titles a company hiring for signals buying intent, e.g. [\"Marketing Manager\",\"Sales Executive\"]. Required.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities/areas to search, e.g. [\"Leeds UK\",\"Manchester UK\"]. Qualify with the country (e.g. \"Manchester UK\") for accurate local results. Leave empty to search nationwide.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobBoards": {
                        "title": "Job boards",
                        "type": "array",
                        "description": "Which job boards to search via Google. Use the keys indeed, linkedin, glassdoor, or add a raw host like \"reed.co.uk\".",
                        "default": [
                            "indeed",
                            "linkedin",
                            "glassdoor"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many job-board results to parse per role+location query before deduping.",
                        "default": 15
                    },
                    "maxLeads": {
                        "title": "Max leads (run cap)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on total leads output/charged this run (caps your spend).",
                        "default": 100
                    },
                    "searchEngine": {
                        "title": "Search engine",
                        "enum": [
                            "google",
                            "bing"
                        ],
                        "type": "string",
                        "description": "Which engine to use. Google is default; the actor falls back to Bing when Google returns nothing.",
                        "default": "google"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Parallel search requests during discovery (kept modest).",
                        "default": 3
                    },
                    "findEmails": {
                        "title": "Find decision-maker emails",
                        "type": "boolean",
                        "description": "For each hiring company, find a decision-maker (owner/founder/director) from public LinkedIn snippets and enrich their verified work email using YOUR Prospeo key. Off by default. Adds a search + a provider call per lead.",
                        "default": false
                    },
                    "emailProvider": {
                        "title": "Email provider",
                        "enum": [
                            "prospeo",
                            "hunter"
                        ],
                        "type": "string",
                        "description": "Which email-finder your key is for. Prospeo matches on the decision-maker's LinkedIn URL (no company domain needed) and is recommended for this actor. Hunter requires a company domain this actor does not resolve, so it returns nothing here.",
                        "default": "prospeo"
                    },
                    "emailApiKey": {
                        "title": "Email provider API key",
                        "type": "string",
                        "description": "Your own Prospeo (or Hunter) API key. Only used when findEmails is on. You pay your provider directly for lookups."
                    },
                    "decisionMakerRoles": {
                        "title": "Decision-maker roles",
                        "type": "array",
                        "description": "Titles to look for when finding who to pitch at each hiring company (used only when findEmails is on).",
                        "default": [
                            "owner",
                            "founder",
                            "CEO",
                            "director",
                            "head of marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "emailThrottleMs": {
                        "title": "Email lookup throttle (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between provider lookups. Prevents rate-limiting (Prospeo's free tier rate-limits — rate-limited calls silently return no email). Lower to 0 on a paid plan to speed up large runs.",
                        "default": 1100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Defaults to Apify's GOOGLE_SERP proxy group (required to read Google search results reliably). Residential is used for the Bing fallback.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "GOOGLE_SERP"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
