# Hiring Signals Tracker (`arched_friend/hiring-signals-tracker`) Actor

Know which companies are actively recruiting and for what. Turns any list of companies into a live feed of their open roles, with department, location, salary and apply link.

- **URL**: https://apify.com/arched\_friend/hiring-signals-tracker.md
- **Developed by:** [Peach O](https://apify.com/arched_friend) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 role returneds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Signals Tracker

**Track which companies are hiring, and for which roles, from any list of companies.**

Hiring is the earliest public signal of where budget is moving. A company opening five sales roles has money to spend. One building a data team is about to buy data tools. This Actor turns a list of companies into a structured feed of their open roles, pulled live from Greenhouse, Lever, Ashby and Workable.

Use it for sales buying signals, recruitment intelligence, competitor headcount tracking or a daily job alert feed.

### How it works

```mermaid
flowchart LR
    A[Your company list] --> B{Detect job board}
    B --> C[Greenhouse]
    B --> D[Lever]
    B --> E[Ashby]
    B --> F[Workable]
    C & D & E & F --> G[One clean schema]
    G --> H[Filters]
    H --> I[(Your results)]
```

Every source is an official public job board API. No browser, no proxies, nothing that breaks when a page layout changes.

### What people use it for

```mermaid
flowchart TD
    A[New role appears] --> B[Sales: budget signal, time the outreach]
    A --> C[Recruiting: company staffing up in your niche]
    A --> D[Research: headcount direction across a sector]
    A --> E[Job search: catch the posting on day one]
```

### Input

Give it companies as board URLs or the short `provider:slug` form.

```json
{
  "boards": ["greenhouse:airtable", "lever:spotify", "ashby:ramp"],
  "keywords": ["sales", "account executive"],
  "location": "United States",
  "postedWithinDays": 14
}
```

| Option | Does |
| --- | --- |
| `boards` | Required. The companies to check. |
| `keywords` | Keep roles whose title matches one of these. |
| `location` | Keep roles matching a location. |
| `department` | Keep roles in a department or team. |
| `postedWithinDays` | Keep only recently posted roles. |
| `remoteOnly` | Keep only remote roles. |
| `maxRoles` | Cap the run, for cost control. |

### Output

One row per open role, same shape from every job board.

```json
{
  "companyName": "Ramp",
  "roleTitle": "Security Engineer, Cloud",
  "department": "Engineering",
  "location": "New York, NY (HQ)",
  "remote": true,
  "salary": "$211.4K to $290.6K",
  "postedAt": "2026-04-07T17:12:35.753Z",
  "applyUrl": "https://jobs.ashbyhq.com/ramp/34413f8d.../application",
  "ats": "ashby"
}
```

Export to JSON, CSV or Excel, or send it straight to your CRM.

### Run it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~hiring-signals-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"boards": ["greenhouse:airtable"], "keywords": ["engineer"]}'
```

Schedule it daily, diff the results, and you have a new roles alert feed for your whole target account list.

### Supported job boards

| Board | Input format |
| --- | --- |
| Greenhouse | `greenhouse:slug` or `boards.greenhouse.io/slug` |
| Lever | `lever:slug` or `jobs.lever.co/slug` |
| Ashby | `ashby:slug` or `jobs.ashbyhq.com/slug` |
| Workable | `workable:slug` or `apply.workable.com/slug` |

A board that cannot be reached is reported in the run summary and never stops the rest of the run.

### Common questions

**How much does it cost?**
You pay per role returned, so a filtered run that surfaces three relevant openings costs cents. Doing this by hand across 100 career pages takes hours a week. Hiring data vendors start around $500 a month on annual contracts.

**How do I find a company's job board?**
Open their careers page. The URL usually gives it away, for example `boards.greenhouse.io/figma`. Paste that URL straight in.

**How fresh is the data?**
It reads the live job board every run. `postedAt` uses the first published date where the board exposes one, so recency filtering reflects when a role actually opened rather than when it was last edited.

**Can I monitor companies on a schedule?**
Yes. Schedule the Actor daily or weekly and compare runs to catch new postings.

**Is this legal?**
It reads public job listings that companies publish to attract applicants. No logins, no candidate data, no personal information.

**What if a company uses a different job board?**
Greenhouse, Lever, Ashby and Workable cover a large share of startup and mid market employers. Open an issue with the board you need and it can be added.

### Related products

- **Tech Stack Checker** to see the technology every hiring company runs
- **Website Lead Extractor** to pull contact details for those companies
- **Lead Enrichment Pipeline** to run the whole sequence into CRM ready rows

# Actor input Schema

## `boards` (type: `array`):

One entry per company. Paste the public job board URL (Greenhouse, Lever, Ashby or Workable), or use the short form provider:slug such as lever:netflix.

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

Only return roles whose title contains one of these words. Leave empty to return every open role.

## `location` (type: `string`):

Only return roles whose location contains this text, for example Berlin or United States.

## `department` (type: `string`):

Only return roles in a matching department or team, for example Engineering or Marketing.

## `postedWithinDays` (type: `integer`):

Only return roles first published within this many days. Roles with no publish date are excluded when this is set.

## `remoteOnly` (type: `boolean`):

Keep only roles flagged as remote by the job board or with remote in the location.

## `maxRolesPerBoard` (type: `integer`):

Cap how many roles are returned per company. Leave empty for no cap.

## `maxRoles` (type: `integer`):

Hard cap on the total number of roles returned by the run. Useful for controlling cost.

## Actor input object example

```json
{
  "boards": [
    "greenhouse:airtable"
  ],
  "keywords": [
    "sales",
    "account executive"
  ],
  "remoteOnly": false
}
```

# Actor output Schema

## `roles` (type: `string`):

Every open role found across the requested company job boards, one row per role.

## `runSummary` (type: `string`):

Counts of boards processed and roles returned, plus any boards that could not be reached.

# 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 = {
    "boards": [
        "greenhouse:airtable",
        "lever:spotify",
        "ashby:ramp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/hiring-signals-tracker").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 = { "boards": [
        "greenhouse:airtable",
        "lever:spotify",
        "ashby:ramp",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("arched_friend/hiring-signals-tracker").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 '{
  "boards": [
    "greenhouse:airtable",
    "lever:spotify",
    "ashby:ramp"
  ]
}' |
apify call arched_friend/hiring-signals-tracker --silent --output-dataset

```

## MCP server setup

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

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/wJ1gZ27Cur2BNdq9J/builds/Bd5DZIsKNDRBjfcCz/openapi.json