# Company Hiring Signals from Job Boards (`datahyena/company-hiring-signals`) Actor

Find companies that are hiring right now. Leadership openings, founding hires, sales and engineering team scaling, technology hiring and hard-to-fill roles, read from companies' own job boards (Greenhouse, Lever, Ashby and more) and careers pages, with every role behind the signal.

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

## Pricing

from $60.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

<div align="center">

<img src="https://datahyena.com/static/images/logo.png" alt="Datahyena" height="64" />

## Company Hiring Signals from Job Boards

**Find companies that are hiring right now. Leadership openings, founding hires, sales and engineering team scaling, technology hiring and hard-to-fill roles, read from companies' own job boards (Greenhouse, Lever, Ashby and more) and careers pages, with every role behind the signal.**

`No API key` · `No signup` · Powered by [Datahyena](https://datahyena.com?utm_source=apify\&utm_medium=readme\&utm_content=company-hiring-signals)

</div>

***

Hiring signals read from companies' own job boards and careers pages: leadership openings, founding roles, team scaling, technology hiring and hard-to-fill roles. Each record has the company, the signal, and every open role behind it with title, seniority, location, salary and technologies. Every signal is read from the company's own job board or careers page and resolved to a canonical company, with every open role behind it, so you get one row per signal instead of one per job post. Set your filters, run it, and pay only for the records you get back. No API key, no signup, no sales call.

Use it for hiring signals, job postings data, companies hiring, job board data, hiring intent, recruiting data, leadership hiring.

### What you get

Every record carries all of the below. The table view shows the columns that scan best; the full record is in the JSON, CSV, and Excel exports.

- **Signal.** type (leadership opening, founding role, team scaling, technology hiring, hard-to-fill roles and more), function, role family, seniority, technologies, the date it started, whether it is still open, and the board it was read from.
- **Roles.** every open role behind the signal: title, function, seniority, location, posted date, link to the posting, salary where the posting states it, and technologies named.
- **Company.** a full company: name, domain, description, LinkedIn URL and handle, HQ city and country, industry group, industry sub-tags, verticals, employee count, founded year, and business model.

Results export to JSON, CSV, or Excel, or stream straight to your database via the Apify API.

### Common use cases

- **Sales and prospecting.** Reach companies opening a new team or a leadership seat, while the budget behind the hire is fresh. A first SDR hire or a new Head of RevOps is a buying window.
- **Recruiting and staffing.** Find companies with hard-to-fill roles and growing teams, with every open role, location and salary range.
- **Market and competitor research.** See which companies are building sales, engineering or AI teams, and which technologies they hire for.
- **Data enrichment.** Add live hiring activity to your CRM or warehouse, next to funding and leadership changes.

### Filters

| Input | Description |
|---|---|
| `maxItems` | Max records (default 100) |
| `cursor` | Advanced: resume from a previous run's `NEXT_CURSOR` to paginate ahead |
| `since` | Only records on or after this date (YYYY-MM-DD), e.g. 2026-01-01. ISO-8601 timestamps also work. This is what makes the Actor a feed rather than an export: schedule it daily with `since` set to the day before, and each run returns only what is new. |
| `until` | Only records on or before this date (YYYY-MM-DD, inclusive). ISO-8601 timestamps also work. |
| `countries` | Filter by company HQ country. Select several to cover a whole region in one run instead of one run per country. About a quarter of companies have no HQ country on record, so add "Not disclosed" to keep those deals in. |
| `eventType` | Which hiring signals to return. Leave empty for all. Build-outs, surges, freezes, location expansion and filled leadership roles need two reads of a board and appear as weekly history builds up. |
| `function` | Which job functions the signal is about, for example sales or engineering. |
| `seniority` | Keep signals with at least one open role at these levels. |
| `roleFamily` | Narrower than function, for example SDRs, RevOps or ML engineers. |
| `technologies` | Keep signals whose roles name one of these technologies. Use lowercase names such as salesforce, hubspot, snowflake, dbt, kubernetes or gong. |
| `activeOnly` | Skip signals whose roles have all closed. |

Leave everything empty to get the newest records first, or narrow by the filters above. One run fetches up to **Max records** for you, so there is no paging to do by hand.

### Run it on a schedule

Most people want hiring signals as they happen rather than one export. Set your filters, save the run as a task, and schedule it daily. Set `since` to the day before and each run returns only what is new, so you pay for new records instead of re-fetching the same ones.

That is the difference between a one-off list and a live feed, and it is the way this Actor is meant to be used. Apify's own [Schedules](https://docs.apify.com/platform/schedules) run the task for you; every run appends to its own dataset, and you can send each one onward with an [integration](https://docs.apify.com/platform/integrations) to Slack, Google Sheets, a webhook, or your warehouse.

If a run ever stops early, at a charge limit for example, it saves a `NEXT_CURSOR` in its key-value store. Pass that back as `cursor` to pick up exactly where it stopped. It is a resume point, not something you need for normal use.

#### Example output

```json
{
  "id": "01a13efe-713f-7b54-8c5c-9b2cc19f9f5b",
  "eventType": "leadership_opening",
  "company": {
    "id": "019e5448-f9ff-733b-9fae-efc4fa46c809",
    "name": "Jetson Home",
    "domain": "jetsonhome.com",
    "description": "Jetson Home provides fast, affordable all-electric heat pump installation and home electrification solutions.",
    "linkedinUrl": "https://www.linkedin.com/company/jetson-home",
    "hqCity": "North Vancouver",
    "hqCountry": {
      "code": "CA",
      "name": "Canada"
    },
    "industryGroup": "Consumer Services",
    "naicsCode": "81",
    "naicsLevel": 2,
    "industrySubTags": [
      "consumer-services"
    ]
  },
  "function": "operations",
  "seniority": "vp_level",
  "roleFamily": null,
  "country": null,
  "technologies": [
    "hubspot"
  ],
  "announcedAt": "2026-10-05",
  "endedAt": null,
  "active": true,
  "roleCount": 3,
  "roles": [
    {
      "title": "Vice President, Field Operations",
      "function": "operations",
      "seniority": "vp_level",
      "roleFamily": null,
      "location": "Remote, USA",
      "postedAt": "2026-10-08",
      "url": "https://job-boards.greenhouse.io/jetsonhome/jobs/4431895009",
      "salary": {
        "min": 190000,
        "max": 220000,
        "currency": "USD",
        "interval": "year"
      },
      "technologies": [
        "hubspot"
      ]
    },
    {
      "title": "Director of Technical Service",
      "function": "operations",
      "seniority": "director",
      "roleFamily": null,
      "location": "North Vancouver, BC",
      "postedAt": "2026-10-05",
      "url": "https://job-boards.greenhouse.io/jetsonhome/jobs/4408738009",
      "salary": {
        "min": 165000,
        "max": 200000,
        "currency": "USD",
        "interval": "year"
      },
      "technologies": [
        "hubspot"
      ]
    }
  ],
  "board": "greenhouse",
  "discoveredAt": "2026-10-15T09:57:04.882Z"
}
```

### What it costs

You pay per record returned, **$0.07 each**, dropping to $0.06 on higher Apify plans. Nothing is charged for a run that returns nothing, and filters that match no records cost you nothing at all.

| Records | Cost |
|---|---|
| 10 | $0.70 |
| 100 | $7.00 |
| 1,000 | $70.00 |
| 10,000 | $700.00 |

Set **Max records** to cap any single run, so a run can never cost more than you intended.

### What this Actor does not cover

It tracks hiring signals for companies that raise, get acquired, or hire — venture-backed and growth companies, worldwide. It is **not** a general business directory: local service businesses, restaurants, airports, and similar establishments are not in here. If you need every business in a city, this is the wrong tool.

### FAQ

**What data does this actor return?**

Hiring signals read from companies' own job boards and careers pages: leadership openings, founding roles, team scaling, technology hiring and hard-to-fill roles. Each record has the company, the signal, and every open role behind it with title, seniority, location, salary and technologies. Fields: Company, Domain, Signal, Function, Seniority, Roles, Since, Open, Technologies, Country, Industry, Company LinkedIn. Each one is matched to a canonical company.

**Is this a Crunchbase, PitchBook, or Coresignal alternative?**

Yes. It is a self-serve, API-first alternative to Crunchbase, PitchBook, Coresignal, and Harmonic, with no annual contract and no sales call.

**How fresh is the data?**

Most records are available the same day they are announced. Across the last 30 days, the median gap between a public announcement and the record being available was under one day.

**Can I monitor hiring signals on a schedule?**

Yes. Save your filters as a task and use Apify's scheduler to run it daily or weekly, with "since" set to the date of your last run.

**Some records have an empty field. Can I still get those?**

Yes. Not every announcement states every detail, and where a value was never disclosed the field is left empty rather than guessed. Filters that can be empty offer a **Not disclosed** option (HQ country and industry, plus funding round where it applies). Select it to include those records instead of dropping them from a filtered run.

**How is the data deduplicated?**

Each real-world event is matched across every outlet that reported it and resolved to one canonical company (and investors), so you never get the same round or deal twice.

**How do I get the next batch of records?**

Each run saves a `NEXT_CURSOR` to its key-value store. Pass it as the `cursor` input on the next run to continue where you left off. For new records over time, use the `since` filter.

**Is there a free way to try it?**

Free Apify accounts get a one-time sample of 50 records from this Actor, so you can see the shape and quality of the data before paying. It is per Actor, it does not reset, and it is meant for evaluation rather than for collecting a dataset.

Beyond the sample this Actor is for paid Apify plans, where you pay only for the records you get back.

### Terms of use

Records returned by this Actor are licensed for use inside your own products and workflows. Building on the data is encouraged. Reselling, redistributing or republishing the records as data, in raw or substantially raw form, is not permitted, and neither is systematic extraction to reconstruct the dataset.

Full terms: [datahyena.com/terms](https://datahyena.com/terms?utm_source=apify\&utm_medium=readme\&utm_content=company-hiring-signals)

***

<div align="center">
Built by <a href="https://datahyena.com?utm_source=apify&utm_medium=readme&utm_content=company-hiring-signals">Datahyena</a>. Company-event signals as an API.
</div>

# Actor input Schema

## `maxItems` (type: `integer`):

Maximum records to fetch. You are charged per record returned. Free Apify accounts get a one-time 50-record sample of this Actor; paid plans have no such limit.

## `since` (type: `string`):

Only records on or after this date (YYYY-MM-DD), e.g. 2026-01-01. ISO-8601 timestamps also work. This is what makes the Actor a feed rather than an export: schedule it daily with `since` set to the day before, and each run returns only what is new.

## `until` (type: `string`):

Only records on or before this date (YYYY-MM-DD, inclusive). ISO-8601 timestamps also work.

## `countries` (type: `array`):

Filter by company HQ country. Select several to cover a whole region in one run instead of one run per country. About a quarter of companies have no HQ country on record, so add "Not disclosed" to keep those deals in.

## `eventType` (type: `array`):

Which hiring signals to return. Leave empty for all. Build-outs, surges, freezes, location expansion and filled leadership roles need two reads of a board and appear as weekly history builds up.

## `function` (type: `array`):

Which job functions the signal is about, for example sales or engineering.

## `seniority` (type: `array`):

Keep signals with at least one open role at these levels.

## `roleFamily` (type: `array`):

Narrower than function, for example SDRs, RevOps or ML engineers.

## `technologies` (type: `array`):

Keep signals whose roles name one of these technologies. Use lowercase names such as salesforce, hubspot, snowflake, dbt, kubernetes or gong.

## `activeOnly` (type: `boolean`):

Skip signals whose roles have all closed.

## `cursor` (type: `string`):

Only needed if a run stopped early. Pass back the NEXT_CURSOR saved in that run's key-value store to continue from where it stopped. For new records on a schedule, use "since" instead. Leave empty to start from the newest records.

## Actor input object example

```json
{
  "maxItems": 100
}
```

# Actor output Schema

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

Company Hiring Signals from Job Boards records (the run's default dataset).

## `nextCursor` (type: `string`):

Set only when the run stopped before the feed was exhausted, usually at a charge limit. Pass it back as "cursor" to continue from that point. To pull new records on a schedule use the "since" filter instead.

## `inputError` (type: `string`):

Present only when a filter was rejected. The run ends successfully having fetched and charged nothing; this record says which value to change.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("datahyena/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("datahyena/company-hiring-signals").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call datahyena/company-hiring-signals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datahyena/company-hiring-signals"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/qyFd7fJpL3bQc4tEM/builds/GyStbhQ7fBuaKotiS/openapi.json
