# Company Hiring Signals: Open Roles & Velocity (`veltrixlabs/company-hiring-signals`) Actor

Turn a list of companies into hiring signals: open roles, roles opened in the last 7/30/90 days, department mix, leadership hires and tech keywords from public job boards. Flat price per company, whatever its size. Companies not found are free. Every open job as a row is optional.

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

## Pricing

from $25.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/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

## Company Hiring Signals

Give it a list of companies. Find out which ones are hiring, how fast, and for what.

Hiring tells you where a company is putting its budget. A company opening a batch of security roles this month is a better prospect for a security product than one that opened none. This Actor turns that into one row per company, so you can sort an account list instead of checking careers pages one at a time.

**$0.025 per company, however many jobs it has. Companies with no public job board are free.**

### What you get for each company

| Field | What it tells you |
|---|---|
| `hiringIntensity` | `surging`, `active`, `steady` or `quiet` (see below) |
| `openRoles` | How many roles are open now |
| `opened7d`, `opened30d`, `opened90d` | How many of them opened in each period |
| `departments`, `locations` | Where the roles are, largest first |
| `leadershipRoles`, `remoteRoles` | Director-and-above roles, and roles marked remote |
| `keywordHits` | How many job ads mention each word you chose, with links |
| `newestRoles` | The 10 newest roles, with title, team, location and link |
| `provider`, `boardUrl`, `boardCompanyName` | Which job board this came from, so you can check it |
| `matchMethod`, `confidence` | How the company was matched |

### Example

Input:

```json
{
  "companies": ["linear.app", "Ramp", "https://jobs.lever.co/spotify"],
  "keywords": ["typescript", "postgres"]
}
```

Part of a real result, read on 5 November 2026:

```json
{
  "input": "linear.app",
  "status": "found",
  "hiringIntensity": "steady",
  "openRoles": 31,
  "opened7d": 1,
  "opened30d": 9,
  "opened90d": 13,
  "remoteRoles": 29,
  "departments": [{ "name": "GTM", "roles": 16 }, { "name": "Product", "roles": 13 }],
  "keywordHits": { "typescript": { "roles": 7 }, "postgres": { "roles": 6 } },
  "provider": "ashby",
  "boardUrl": "https://jobs.ashbyhq.com/linear",
  "matchMethod": "company_website",
  "confidence": "high"
}
```

### Who uses this kind of data

- **Sales teams:** rank target accounts, and open an email with something specific and true.
- **Recruiters and agencies:** find companies opening roles in your specialty.
- **Vendors:** see which companies mention your product or a competitor in their job ads.
- **Investors and analysts:** compare hiring across a list of companies, week by week.

To monitor a list, put this on an [Apify schedule](https://docs.apify.com/platform/schedules) and compare the numbers between runs.

### What you pay

| Event | Price | When |
|---|---|---|
| Company analyzed | $0.025 | A job board was found and read |
| Job row | $0.001 | Only if you turn on "Also output every open job" |

Companies that aren't found and lookups that fail are free. A list of 200 companies costs at most $5 a run. If you set a spending limit on a run, it stops cleanly when it reaches the limit.

### How hiring intensity is decided

Open roles skew recent because old ones get filled, so a large share of new roles is normal. We measured 65 live job boards in November 2026. The middle company had 37% of its roles opened in the last 30 days, and the top tenth had about 51%.

| Label | Meaning |
|---|---|
| `surging` | At least 50% of roles opened in the last 30 days, with at least 10 opened in that time |
| `active` | At least 30% opened in the last 30 days, and not surging |
| `steady` | Under 30% |
| `quiet` | Roles are open, but none opened in the last 30 days |
| `none` | The board has no open roles |
| `unknown` | The job board gives no dates |

The labels are a starting point for sorting. Counts rely on the dates companies publish, and reposting a role can make it look new.

### How companies are found

Enter a website, a name or a job board link.

1. **Job board link:** used directly.
2. **Website:** we look for a job board link on the company's own careers pages, honoring `robots.txt`. A match this way is marked `high` confidence.
3. **Name, or a website with no link found:** we check whether a job board exists under that name. These are marked `medium` confidence, because another company could have the same name.

Check `boardUrl` and `boardCompanyName` if a match matters. Some job boards don't report a company name.

### What it can and can't read

**Supported:** Greenhouse, Lever, Ashby, SmartRecruiters, Workable and Recruitee.

**Not supported:** Workday, iCIMS and careers sites a company built itself. Those show as `not_found`, and you aren't charged. In a test of 96 well-known tech companies by name, 71 were found. Expect a lower rate for large traditional employers, which often use Workday.

**Other limits:**

- SmartRecruiters boards are read up to 1,000 roles. `openRoles` still shows the true total, and `rolesAnalyzed` shows how many were read, so recent counts on those boards are minimums.
- SmartRecruiters keyword matches look at job titles only.

### Where the data comes from

Only public job postings, read from the public job board feeds companies publish so that people can find their jobs. No logins, no LinkedIn, no anti-bot workarounds, and no collection of personal data. You are responsible for using the results in line with the laws and rules that apply to you, including rules on sales outreach.

### Questions

**Why is a company I know is hiring marked `not_found`?** It probably uses a job board this Actor can't read yet, such as Workday. Try its job board link if it uses a supported one.

**Why does `status` say `error`?** A job board didn't respond or refused the request. You aren't charged, and the `error` field gives the reason. Run that company again later.

**Why is a company with a non-Latin name marked `not_found`?** Job boards use Latin letters in their addresses, so we can't look up a name like "Яндекс". Use the company's website or job board link instead.

**Can it remember the last run and show only what changed?** Not yet. `opened7d` covers most of that need on a weekly schedule. If you want more, open an issue on the Issues tab.

# Actor input Schema

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

Company websites, names or job board links. Up to 5,000 per run. With a website, we also look for the job board link on the company's own careers pages, which confirms the match.

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

Optional, up to 50. Reports how many open roles mention each term, e.g. a competitor or a technology you sell into. Matches whole words, case-insensitive. SmartRecruiters boards are matched on job titles only.

## `includeJobs` (type: `boolean`):

Adds one row per open job, billed per job row. Leave off to pay only the flat per-company price.

## Actor input object example

```json
{
  "companies": [
    "figma.com",
    "linear.app",
    "Ramp"
  ],
  "keywords": [
    "kubernetes",
    "snowflake"
  ],
  "includeJobs": false
}
```

# Actor output Schema

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

One row per company, plus one row per job if you turned that on.

# 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": [
        "figma.com",
        "linear.app",
        "Ramp"
    ],
    "keywords": [
        "kubernetes",
        "snowflake"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("veltrixlabs/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": [
        "figma.com",
        "linear.app",
        "Ramp",
    ],
    "keywords": [
        "kubernetes",
        "snowflake",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("veltrixlabs/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 '{
  "companies": [
    "figma.com",
    "linear.app",
    "Ramp"
  ],
  "keywords": [
    "kubernetes",
    "snowflake"
  ]
}' |
apify call veltrixlabs/company-hiring-signals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,veltrixlabs/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/0AX2Tfe2XKMTY3xWg/builds/Zrt6vY4HGGzVBG2HC/openapi.json