# Company Hiring Signals: Greenhouse, Lever, Ashby, Workable (`clarvith/hiring-signals`) Actor

Find a company's public job board from its domain and pull open roles from Greenhouse, Lever, Ashby or Workable. You get a hiring summary per company and optional job rows. No board found, no charge. Monitor mode tracks new and closed jobs.

- **URL**: https://apify.com/clarvith/hiring-signals.md
- **Developed by:** [Clarvith Team](https://apify.com/clarvith) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **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 with a public job boards

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 a company domain or a known job board and get a hiring snapshot from public Greenhouse, Lever, Ashby, or Workable data: where the board lives, how many roles are open, how they split by department and country, how many list a salary, and (optionally) one row per job.

Everything comes from public job-board APIs and career pages. No login, no scraping behind a wall, no API keys on your side.

**Author:** Clarvith Team

### Who uses this Actor

- **Sales and RevOps** — spot hiring spikes, new departments, or remote-first pushes before an outreach call.
- **VC and market research** — compare portfolio or competitor hiring in a dataset you can join to your own lists.
- **Recruiters** — pull structured postings across the four major ATS boards without maintaining four integrations.
- **AI agents and automations** — stable JSON in and out for monitors, CRM updates, or research pipelines.

### What you get

Each successful company yields a **`company_signal`** row: platform, board id, board URL, how the board was found, open job count, department and country breakdowns, remote share, jobs with a published salary, newest posted date, and monitor deltas when you use monitor mode.

With **Output individual jobs** enabled (default), each saved job is a **`job_posting`** row: title, department, team, locations, workplace type, employment type, dates, URL, compensation when Ashby or Lever publish it, and optional description text. Descriptions are **off by default**. When you turn them on, emails, phone numbers, and personal profile URLs are stripped.

Domains with no board, empty boards, and hosts that could not be read are **`company_status`** rows. Those are not charged.

Lever and Workable mark some public content with `ai-train=no`. Use the results for search and reference; do not use them to train or fine-tune models.

### Supported job boards

| Platform   | Slug format          | Example                                                  |
| ---------- | -------------------- | -------------------------------------------------------- |
| Greenhouse | `greenhouse:{token}` | `greenhouse:figma`                                       |
| Lever      | `lever:{site}`       | `lever:palantir` (or EU board URL on `jobs.eu.lever.co`) |
| Ashby      | `ashby:{board}`      | `ashby:linear`                                           |
| Workable   | `workable:{account}` | `workable:huggingface`                                   |

You can also pass the public board URL instead of `ats:slug`.

### How discovery works

When you pass a **domain** and no board:

1. A **known board** you listed is read directly (skips discovery).
2. A **cached discovery** from the last 30 days is reused, then re-checked.
3. The Actor scans the homepage and, when `robots.txt` allows, `/careers`, `/jobs`, and `/company/careers` for links to the four platforms. A link counts only if the board has open jobs.
4. If nothing matches, it tries the company name as a slug on each API. A guess is kept only when the board has jobs and the company name matches (Greenhouse and Workable require a name match; Lever and Ashby often match on the public board id in the job URL).

Confidence is **high** for a board you named or a careers-page link, **medium** for a slug guess.

### Input examples

**Two domains (Store prefill):** discovery on `linear.app` and `vercel.com`.

```json
{
  "domains": ["linear.app", "vercel.com"],
  "boards": [],
  "outputJobs": true,
  "includeDescription": false,
  "maxJobsPerCompany": 10
}
```

**Known boards only** — fastest runs, no discovery:

```json
{
  "domains": [],
  "boards": ["ashby:linear", "greenhouse:figma"],
  "maxJobsPerCompany": 20
}
```

**Filters:**

```json
{
  "domains": ["stripe.com"],
  "titleKeywords": ["engineer"],
  "countries": ["US", "GB"],
  "departments": ["Engineering"],
  "atsFilter": ["greenhouse", "lever"]
}
```

**Monitor mode** — same Monitor ID on a schedule; first run stores the baseline without charging for jobs:

```json
{
  "boards": ["lever:palantir"],
  "mode": "monitor",
  "monitorId": "palantir-weekly",
  "outputJobs": true
}
```

Other useful fields: **concurrency** (default 4 companies in parallel), **includeCompensation** (default true; Ashby/Lever only), **maxJobsPerCompany** (summary still shows the full filtered count).

You must send at least one domain or one board.

### Ready-made examples

On the Store, each **Task** below opens the Console with input already filled. Pick one, adjust the list if you need to, then run.

- [Get hiring signals from company domains](https://apify.com/clarvith/hiring-signals/examples/hiring-signals-from-domains) — Discovery on a domain list; one `company_signal` row per company that has a public board.
- [Export open jobs from a public Greenhouse board](https://apify.com/clarvith/hiring-signals/examples/greenhouse-public-board-jobs) — Known Greenhouse board token; saves `job_posting` rows for open roles.
- [Export open jobs from a public Ashby board](https://apify.com/clarvith/hiring-signals/examples/ashby-public-board-jobs) — Same pattern for a public Ashby job board slug.
- [Monitor new and closed jobs at target companies](https://apify.com/clarvith/hiring-signals/examples/monitor-new-and-closed-jobs) — `monitor` mode with a Monitor ID; the first run stores a baseline, later runs charge only new and closed jobs.
- [Find engineering jobs at companies you name](https://apify.com/clarvith/hiring-signals/examples/engineering-jobs-at-named-companies) — Domains plus a title keyword filter skewed toward engineering roles.
- [Find sales hiring leads from job postings](https://apify.com/clarvith/hiring-signals/examples/sales-hiring-leads-from-jobs) — Domains with filters aimed at sales-related titles for outbound research.

### Output example

Illustrative rows (counts and titles are examples; your run will match live boards).

**`company_signal`:**

```json
{
  "type": "company_signal",
  "domain": "linear.app",
  "companyName": "Linear",
  "ats": "ashby",
  "boardId": "linear",
  "boardUrl": "https://jobs.ashbyhq.com/linear",
  "discovery": {
    "method": "careers_link",
    "confidence": "high",
    "evidenceUrl": "https://linear.app/careers"
  },
  "openJobs": 33,
  "byDepartment": [{ "name": "Engineering", "count": 18 }],
  "byCountry": [{ "country": "US", "count": 12 }],
  "remoteShare": 0.42,
  "jobsWithSalary": 8,
  "newestPostedAt": "2026-11-10",
  "monitor": null,
  "fetchedAt": "2026-11-17T12:00:00.000Z"
}
```

**`job_posting`:**

```json
{
  "type": "job_posting",
  "domain": "linear.app",
  "ats": "ashby",
  "boardId": "linear",
  "jobId": "d3bc1ced-3ce4-4086-a050-555055dbb1ff",
  "title": "Senior / Staff Fullstack Engineer",
  "department": "Engineering",
  "team": "Product",
  "locations": [{ "text": "Europe", "country": null }],
  "workplaceType": "remote",
  "employmentType": "full_time",
  "postedAt": "2026-10-01",
  "url": "https://jobs.ashbyhq.com/linear/d3bc1ced-3ce4-4086-a050-555055dbb1ff",
  "compensation": null,
  "description": null,
  "change": null,
  "fetchedAt": "2026-11-17T12:00:00.000Z"
}
```

**`company_status` (not charged):**

```json
{
  "type": "company_status",
  "domain": "example.com",
  "companyName": null,
  "ats": null,
  "boardId": null,
  "status": "no_board",
  "reason": "not_found",
  "message": "No public Greenhouse, Lever, Ashby or Workable board with open jobs was found for this domain.",
  "fetchedAt": "2026-11-17T12:00:00.000Z"
}
```

The dataset has table views for companies and jobs; filter on `type` to separate signals, postings, and status rows.

### Pricing

Pay per event. Bronze list prices (Free, Silver, and Gold tiers are set in Apify Console from `pricing.json` in the repo):

| Event               | When it is charged                    | Bronze (USD)    |
| ------------------- | ------------------------------------- | --------------- |
| `company-signal`    | One company whose board has open jobs | $5.00 per 1,000 |
| `job-posting`       | One job row saved in the dataset      | $2.50 per 1,000 |
| `apify-actor-start` | Once per run (platform)               | $0.05 per 1,000 |

A domain with no public board costs nothing. An empty Workable account does not count as a found board.

In **monitor** mode, the first run with a Monitor ID stores the baseline and does not charge for job rows. Later runs charge only **new** and **closed** jobs (each saved row is one event).

The run stops when it hits your Apify spending limit and keeps everything already saved.

### Monitor mode

Use `mode: "monitor"` with a stable **Monitor ID** per schedule or webhook. The first run records all open jobs as baseline state in storage (no job-posting charges). The next run compares ids, emits `change: "new"` or `change: "closed"` on job rows, and updates counts on the company signal.

Use **snapshot** when you want the full current list every time.

### Integrations

- **API** — start runs from the Apify API with the same JSON as the Console input.
- **Schedules** — run nightly or weekly on a domain list or board list; pair with monitor mode for deltas.
- **Webhooks** — notify your stack when a run finishes; download the dataset from the run URL.
- **Exports** — download the dataset as JSON, CSV, Excel, or plug it into another Actor.

### FAQ

**Is this legal?**\
The Actor only reads public job-board endpoints and public career pages, the same data a candidate sees without logging in.

**Do you respect robots.txt?**\
Yes. The User-Agent is `ClarvithBot/1.0` with details at [clarvith.com/bot](https://clarvith.com/bot). Per RFC 9309: a valid `robots.txt` is followed; 4xx means fetch allowed; 5xx, timeouts, and unreachable hosts block that host; 429 pauses the host.

**Why are job descriptions off by default?**\
Descriptions are long, change often, and may contain contact details. With descriptions on, PII is stripped; for most lists, title, location, and URL are enough.

**What is not included?**\
No LinkedIn, no private greenhouse embed pages disallowed by robots.txt, no Greenhouse per-job pay-transparency calls beyond what the public board returns, and no Workable salary field (the public widget has none).

**Rate limits**\
About 1 request per second for Lever, Workable, and company sites; about 3 per second for Greenhouse and Ashby, including parallel companies. A second Workable 429 stops that host for the rest of the run.

### Support

- Email: <support@clarvith.com>
- Actor page: [clarvith.com/actors/hiring-signals](https://clarvith.com/actors/hiring-signals)

### Technical sources

| Platform   | Public endpoint                                                         |
| ---------- | ----------------------------------------------------------------------- |
| Greenhouse | `boards-api.greenhouse.io/v1/boards/{token}/departments`                |
| Lever      | `api.lever.co/v0/postings/{site}?mode=json`                             |
| Ashby      | `api.ashbyhq.com/posting-api/job-board/{name}?includeCompensation=true` |
| Workable   | `apply.workable.com/api/v1/widget/accounts/{slug}`                      |

Greenhouse job text uses `jobs?content=true` only when **Include job description text** is on. The `/embed/` path is never used.

# Changelog

This Actor's version history is a separate document: https://apify.com/clarvith/hiring-signals/changelog.md

# Actor input Schema

## `domains` (type: `array`):

Company websites. The Actor looks for a Greenhouse, Lever, Ashby or Workable job board. Domains with no board are saved as status rows and are not charged.

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

Format ats:slug, for example greenhouse:figma, lever:palantir, ashby:linear, workable:huggingface. Board URLs also work.

## `atsFilter` (type: `array`):

Platforms to read. Boards outside this list are skipped.

## `outputJobs` (type: `boolean`):

Save one dataset row per job. Each saved job is an extra paid event. In monitor mode only new and closed jobs are saved.

## `titleKeywords` (type: `array`):

Optional title filter. A job is kept when its title contains any of these strings, case-insensitive.

## `departments` (type: `array`):

Optional department filter. Matching is case-insensitive and exact.

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

Optional country filter using ISO 3166-1 alpha-2 codes, for example US or DE. A job matches when any of its locations is in the list.

## `includeCompensation` (type: `boolean`):

Ashby and Lever sometimes publish a salary range. Greenhouse pay-transparency calls and Workable salaries are not included.

## `includeDescription` (type: `boolean`):

Off by default. When on, emails, phone numbers and personal profile URLs are removed. The text is for search and reference, not for training AI models.

## `maxJobsPerCompany` (type: `integer`):

Maximum number of job rows saved for one company. The company summary still reports the full filtered count.

## `concurrency` (type: `integer`):

How many companies are fetched in parallel. Each host still keeps its own rate limit, and charges stay inside the spending cap.

## `mode` (type: `string`):

snapshot writes the current open jobs. monitor compares them with the previous run of the same Monitor ID and only writes new and closed jobs.

## `monitorId` (type: `string`):

Names the stored state. Use one ID per scheduled task so different watches do not overwrite each other.

## Actor input object example

```json
{
  "domains": [
    "linear.app",
    "vercel.com"
  ],
  "boards": [],
  "atsFilter": [
    "greenhouse",
    "lever",
    "ashby",
    "workable"
  ],
  "outputJobs": true,
  "includeCompensation": true,
  "includeDescription": false,
  "maxJobsPerCompany": 10,
  "concurrency": 4,
  "mode": "snapshot",
  "monitorId": "default"
}
```

# Actor output Schema

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

Company signals, job postings, and no-charge status rows for domains with no board.

## `summary` (type: `string`):

Counts of boards found, jobs written, and sources whose response format changed.

# 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 = {
    "domains": [
        "linear.app",
        "vercel.com"
    ],
    "boards": [],
    "maxJobsPerCompany": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("clarvith/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 = {
    "domains": [
        "linear.app",
        "vercel.com",
    ],
    "boards": [],
    "maxJobsPerCompany": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("clarvith/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 '{
  "domains": [
    "linear.app",
    "vercel.com"
  ],
  "boards": [],
  "maxJobsPerCompany": 10
}' |
apify call clarvith/hiring-signals --silent --output-dataset

```

## MCP server setup

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