# Hiring Velocity B2B Pipeline: Indeed + Domain + Email (`scrapemint/hiring-velocity-pipeline`) Actor

Find companies hiring senior engineers in your skill area, scored by hiring velocity, enriched with verified domain and likely contact emails. Chains Indeed search with HTTP HEAD reachability, DNS MX verification, and email pattern inference. For dev tool sellers. Pay per qualified hiring company.

- **URL**: https://apify.com/scrapemint/hiring-velocity-pipeline.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Velocity B2B Pipeline

Companies hiring senior engineers in your skill area are a high confidence buying signal for dev tools, observability, infra, and developer experience products. This pipeline pulls Indeed jobs by skill, groups by company, scores hiring velocity, verifies each company's domain, and returns one row per qualified buyer.

### What you get per row

| Field | Description |
|---|---|
| `companyName`, `industry`, `headcountBand` | Core company identity from Indeed |
| `companyWebsite` | Company website surfaced by Indeed |
| `domain` | Root domain of the website |
| `websiteReachable` | True when HTTP HEAD returns < 500 |
| `mxFound` | True when the domain has a valid MX record |
| `likelyContactEmails` | Inferred `info@`, `careers@`, `hello@`, and any emails surfaced |
| `openRolesCount` | Number of matching postings during the run window |
| `roleTitles` | Sample of titles found (deduplicated) |
| `topSkills` | Most common skills across the company's postings |
| `seniorPostingsCount` | How many of the postings are senior level or higher |
| `hiringVelocityScore` | Composite 0 to 100 score combining role count, recency, and seniority mix |
| `daysSinceLastPosting` | Recency signal |
| `firstPostingDate`, `lastPostingDate` | Window of activity captured this run |
| `indeedCompanyUrl` | Link back to the Indeed company page for verification |
| `qualityTier` | `qualified` or `basic` based on your input rules |

### How qualification works

A row is **qualified** when ALL of the following hold:
- The company has at least `minPostingsPerCompany` matching postings (default 2)
- If `requireWebsite` is on (default): website is reachable AND domain has an MX record

Everything else that came back from Indeed is returned as **basic**.

### Pricing

- `qualified_hiring_company` $0.20 each. First 3 per run are free.
- `basic_company` $0.05 each.

Apify auto-applies 20% margin. You see net.

#### What you actually pay per company

This actor chains the Indeed Jobs Intelligence actor under the hood. Your run will show two line items on the Apify billing breakdown.

| Quality tier | Indeed stage | This pipeline | Total per company |
|---|---|---|---|
| Basic | ~$0.05 (varies by jobs scraped) | $0.05 | **~$0.10** |
| Qualified | ~$0.05 | $0.20 | **~$0.25** |

The Indeed cost scales with `maxJobsTotal`, not company count. Increasing the job cap finds more companies but the per company unit cost stays roughly the same.

For comparison, B2B engineering-org leads with verified emails run $1 to $5 per record on Apollo and Clay. You are paying 4x to 20x less for a row that already includes a hiring intent signal, domain MX, and email patterns.

### Two patterns of use

**Daily watch:** schedule a run every morning with `datePosted: 1` (last 24 hours) and your skill list. New companies entering active hiring become leads the same day they post.

**Vertical sweep:** one off run with `datePosted: 14`, `maxJobsTotal: 500`, and 3 to 5 skills covering a vertical (e.g., `kubernetes`, `terraform`, `prometheus` for infra teams). Returns a full ranked list of companies hiring in that vertical right now.

### Common use cases

- Dev tool sellers (observability, IDE, CI, infra) prospecting active hiring orgs
- Recruiters and staffing agencies tracking openings by skill
- Investors mapping which startups are scaling engineering teams
- Outbound sales teams prioritizing accounts by hiring intent

### Tips

- Start with `maxJobsTotal: 100` and `senior_level` experience to validate output before scaling.
- Drop the `requireWebsite` gate when prospecting smaller companies that use third party careers sites (Lever, Greenhouse) and may not surface a homepage to Indeed.
- Tune `minPostingsPerCompany` up to 3 or 5 for stronger signal at the cost of fewer companies returned.

### Built on

- Indeed Jobs Intelligence (sister actor) for job and company data
- DNS level MX verification (no third party API)
- Email pattern inference from canonical domain

PAY_PER_EVENT on the Apify BRONZE plan.

# Actor input Schema

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

Skills, technologies, or role keywords to search on Indeed. Examples: ["kubernetes", "react", "go developer", "data platform engineer"]. Each runs an independent search.
## `country` (type: `string`):

Indeed regional domain.
## `locations` (type: `array`):

Optional locations to constrain each keyword search. Leave empty for nationwide. Examples: ["San Francisco, CA", "Remote"].
## `datePosted` (type: `string`):

Filter by recency. Last 14 days catches active hiring without old stale roles.
## `experienceLevel` (type: `string`):

Senior level is the strongest buying signal (companies with budget for senior hires also have budget for tools).
## `maxJobsPerSearch` (type: `integer`):

Cap on Indeed results pulled per keyword. Higher values find more companies but cost more time.
## `maxJobsTotal` (type: `integer`):

Hard cap on jobs processed per run. Controls total cost.
## `minPostingsPerCompany` (type: `integer`):

Companies with fewer than this many matching postings are still returned as basic, but cannot qualify. Default 2 filters out one off opportunistic listings and surfaces companies in active hiring mode.
## `requireWebsite` (type: `boolean`):

Qualified companies must have a company website on Indeed that resolves and has a valid MX record. Recommended on for outbound use cases.
## `proxyConfiguration` (type: `object`):

Apify proxy passed through to the Indeed stage. Residential strongly recommended.

## Actor input object example

```json
{
  "keywords": [
    "kubernetes",
    "react"
  ],
  "country": "US",
  "locations": [],
  "datePosted": "14",
  "experienceLevel": "senior_level",
  "maxJobsPerSearch": 50,
  "maxJobsTotal": 200,
  "minPostingsPerCompany": 2,
  "requireWebsite": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# 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": [
        "kubernetes",
        "react"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/hiring-velocity-pipeline").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": [
        "kubernetes",
        "react",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/hiring-velocity-pipeline").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": [
    "kubernetes",
    "react"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapemint/hiring-velocity-pipeline --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hiring Velocity B2B Pipeline: Indeed + Domain + Email",
        "description": "Find companies hiring senior engineers in your skill area, scored by hiring velocity, enriched with verified domain and likely contact emails. Chains Indeed search with HTTP HEAD reachability, DNS MX verification, and email pattern inference. For dev tool sellers. Pay per qualified hiring company.",
        "version": "0.1",
        "x-build-id": "cRbWIaDuclWcPaBBl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~hiring-velocity-pipeline/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-hiring-velocity-pipeline",
                "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/scrapemint~hiring-velocity-pipeline/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-hiring-velocity-pipeline",
                "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/scrapemint~hiring-velocity-pipeline/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-hiring-velocity-pipeline",
                "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": "Skill keywords",
                        "type": "array",
                        "description": "Skills, technologies, or role keywords to search on Indeed. Examples: [\"kubernetes\", \"react\", \"go developer\", \"data platform engineer\"]. Each runs an independent search.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "DE",
                            "FR",
                            "IN"
                        ],
                        "type": "string",
                        "description": "Indeed regional domain.",
                        "default": "US"
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional locations to constrain each keyword search. Leave empty for nationwide. Examples: [\"San Francisco, CA\", \"Remote\"].",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "datePosted": {
                        "title": "Date posted",
                        "enum": [
                            "any",
                            "1",
                            "3",
                            "7",
                            "14"
                        ],
                        "type": "string",
                        "description": "Filter by recency. Last 14 days catches active hiring without old stale roles.",
                        "default": "14"
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "enum": [
                            "any",
                            "entry_level",
                            "mid_level",
                            "senior_level"
                        ],
                        "type": "string",
                        "description": "Senior level is the strongest buying signal (companies with budget for senior hires also have budget for tools).",
                        "default": "senior_level"
                    },
                    "maxJobsPerSearch": {
                        "title": "Max jobs per search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on Indeed results pulled per keyword. Higher values find more companies but cost more time.",
                        "default": 50
                    },
                    "maxJobsTotal": {
                        "title": "Max jobs per run",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on jobs processed per run. Controls total cost.",
                        "default": 200
                    },
                    "minPostingsPerCompany": {
                        "title": "Minimum postings per company (qualified tier)",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Companies with fewer than this many matching postings are still returned as basic, but cannot qualify. Default 2 filters out one off opportunistic listings and surfaces companies in active hiring mode.",
                        "default": 2
                    },
                    "requireWebsite": {
                        "title": "Require a working website for qualified tier",
                        "type": "boolean",
                        "description": "Qualified companies must have a company website on Indeed that resolves and has a valid MX record. Recommended on for outbound use cases.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy passed through to the Indeed stage. Residential strongly recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
