# Company Hiring Signals — Open Roles & Growth Enrichment (`leohryndev/company-hiring-signals`) Actor

Turn company names/domains into hiring intelligence: auto-discovers each firm's job board across Greenhouse, Lever, Ashby, Workable, Recruitee, SmartRecruiters, then computes open roles, hiring by function, remote share, seniority mix, and velocity. B2B lead scoring from hiring data.

- **URL**: https://apify.com/leohryndev/company-hiring-signals.md
- **Developed by:** [Leo Hryn](https://apify.com/leohryndev) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 company analyzeds

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

## Company Hiring Signals — Open Roles & Growth Enrichment

Turn a plain list of **company names or domains** into **hiring intelligence**. For each company, this Actor auto-discovers their job board across the major ATS platforms (Greenhouse, Lever, Ashby, Workable, Recruitee, SmartRecruiters, Breezy HR, BambooHR, Teamtailor, Personio — plus detection of Workday and iCIMS) and computes a full hiring-signal profile from live, public job postings.

**Hiring is the strongest public buying signal a company emits.** A company posting 12 sales roles is scaling go-to-market. One hiring "Head of Data" is about to buy data tooling. One posting nothing in 90 days tells you something too.

### Input → Output

Input: `["stripe.com", "openai.com", "Blueground", ...]` — domains or names; the Actor figures out the rest.

One row per company:

```json
{
    "company": "openai.com",
    "atsDetected": "ashby",
    "boardUrl": "https://jobs.ashbyhq.com/openai",
    "hiring": {
        "openRoles": 728,
        "rolesByFunction": { "engineering": 391, "sales": 78, "marketing": 24, "product": 61, "support": 32, "operations": 89, "other": 53 },
        "engineeringShare": 0.54,
        "remoteRoles": 118, "remoteShare": 0.16,
        "seniorRoles": 244, "seniorShare": 0.34,
        "rolesAddedLast30d": 92, "rolesAddedLast90d": 233,
        "rolesWithSalary": 705,
        "topLocations": [ { "location": "San Francisco", "count": 512 } ],
        "topDepartments": [ { "department": "Research", "count": 133 } ],
        "sampleTitles": ["Technical Program Manager, Compute Infrastructure", "..."]
    },
    "checkedAt": "2026-07-12T21:40:00.000Z"
}
````

Set `includeJobList: true` to also get the normalized role list per company (titles, locations, URLs, salary where the board exposes it).

### Who uses this

- **B2B sales & lead scoring** — enrich your prospect list: who's scaling sales? Who's hiring for the function your product serves? Route hot accounts first.
- **Recruiting & talent intel** — who's growing engineering, where, how senior, how remote.
- **Investors & analysts** — hiring velocity (`rolesAddedLast30d/90d`) as a growth proxy across a portfolio or market segment.
- **Competitive intelligence** — your competitors' org priorities, published daily on their own job boards.

Schedule it weekly over a fixed account list and diff the numbers — headcount ambitions in a spreadsheet.

### How discovery works

1. **Slug probing**: derives likely board identifiers from the domain/name and checks each supported ATS's public feed directly (fast, exact).
2. **Careers-page sniffing**: if probing misses, it reads the company's `/careers`, `/jobs`, and homepage and extracts the ATS board link — including boards we detect but can't read publicly (Workday, BambooHR, iCIMS), where you still get the ATS + board URL as a signal.
3. All data comes from **official public job-board feeds** — no logins, no personal data, no HTML-scraping fragility.

Companies on fully custom career systems return an honest `"No supported ATS board discovered"` row (still charged as analyzed — the negative result is information).

### Pricing

Pay per company analyzed. A 1,000-account enrichment run costs $5 — compare that to a data vendor's per-record enrichment pricing.

### Scheduling & integrations

Console Schedules · API/SDKs · Google Sheets export · n8n / Make / Zapier (pipe hot accounts to your CRM) · **MCP tool** for AI agents ("which of these 50 accounts increased sales hiring this quarter?").

### FAQ

**Legal?** Yes — public job-board feeds each ATS exposes for the companies' own career pages. No logins bypassed, no personal data collected.

**Why did a company return no ATS?** Either they use a custom/unsupported system, or their board identifier differs too much from their name/domain. Pass their careers URL to the companion Actor **[Job Postings Scraper](https://apify.com/leohryndev/ats-job-postings-scraper)** for direct extraction, or file an issue and we'll add the pattern.

**Data freshness?** Live — every run reads the boards at execution time.

**How is this different from LinkedIn headcount data?** LinkedIn tells you who a company *has*; live job boards tell you who they're *about to hire* — intent, not history. It's also structured by function/seniority/remote from the source, updates the moment a role is posted, and costs a fraction of enrichment-vendor pricing.

**Can I use this to prioritize a CRM account list?** That's the primary use case: feed your account domains in weekly, pipe `rolesByFunction` and `rolesAddedLast30d` back to CRM fields via n8n/Make/Zapier, and sort your pipeline by who's actually scaling the function you sell into.

**Which signal predicts a deal best?** Depends what you sell: sales-role velocity for GTM tooling, engineering share for dev infrastructure, first HR hire for HR software. The output gives you all functions so you can pick your trigger.

***

*More data tools from this developer: [apify.com/leohryndev](https://apify.com/leohryndev) — the companion Job Postings Scraper (10 ATSs), AI-search brand monitoring, Bluesky & Telegram data.*

*Keywords: hiring signals, company enrichment, job postings API, lead scoring, sales intelligence, hiring velocity, headcount growth data, ATS detection, Greenhouse Lever Ashby Workable, B2B buying signals, recruiting intelligence, talent market data.*

# Actor input Schema

## `companies` (type: `array`):

One per line: a company website domain (`stripe.com`) or a company name (`Stripe`). Domains work best — they enable careers-page discovery as a fallback.

## `includeJobList` (type: `boolean`):

Besides the signal metrics, include the normalized list of open roles (titles, locations, URLs — descriptions excluded to keep rows compact).

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

Companies processed in parallel.

## Actor input object example

```json
{
  "companies": [
    "stripe.com",
    "openai.com",
    "spotify.com"
  ],
  "includeJobList": false,
  "maxConcurrency": 4
}
```

# 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 = {
    "companies": [
        "stripe.com",
        "openai.com",
        "spotify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("leohryndev/company-hiring-signals").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 = { "companies": [
        "stripe.com",
        "openai.com",
        "spotify.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("leohryndev/company-hiring-signals").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 '{
  "companies": [
    "stripe.com",
    "openai.com",
    "spotify.com"
  ]
}' |
apify call leohryndev/company-hiring-signals --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Company Hiring Signals — Open Roles & Growth Enrichment",
        "description": "Turn company names/domains into hiring intelligence: auto-discovers each firm's job board across Greenhouse, Lever, Ashby, Workable, Recruitee, SmartRecruiters, then computes open roles, hiring by function, remote share, seniority mix, and velocity. B2B lead scoring from hiring data.",
        "version": "1.0",
        "x-build-id": "sGXISbduVfT6cZDdQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/leohryndev~company-hiring-signals/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-leohryndev-company-hiring-signals",
                "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/leohryndev~company-hiring-signals/runs": {
            "post": {
                "operationId": "runs-sync-leohryndev-company-hiring-signals",
                "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/leohryndev~company-hiring-signals/run-sync": {
            "post": {
                "operationId": "run-sync-leohryndev-company-hiring-signals",
                "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": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies (names or website domains)",
                        "minItems": 1,
                        "type": "array",
                        "description": "One per line: a company website domain (`stripe.com`) or a company name (`Stripe`). Domains work best — they enable careers-page discovery as a fallback.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeJobList": {
                        "title": "Include the full job list per company",
                        "type": "boolean",
                        "description": "Besides the signal metrics, include the normalized list of open roles (titles, locations, URLs — descriptions excluded to keep rows compact).",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Companies processed in parallel.",
                        "default": 4
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```