# Company Hiring Signals by Domain (Multi-ATS) (`fxjima/company-hiring-signals`) Actor

Turn company domains into hiring signals: job board auto-discovery across Greenhouse, Lever, Ashby, Workday, Personio and Recruitee, open and new roles, departments, remote share.

- **URL**: https://apify.com/fxjima/company-hiring-signals.md
- **Developed by:** [mihai marin](https://apify.com/fxjima) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 company hiring profile resolveds

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 by Domain** turns a list of company websites into **hiring-intent data**. It finds each company's job board on its own, across **Greenhouse, Lever, Ashby, Workday, Personio and Recruitee**. For each company it returns **open roles**, **new roles in the last 7 and 30 days**, the mix of **functions and seniority**, **remote share** and **top locations**, plus an optional clean job list. It reads only the public job-board feeds those ATS products publish (no browser, no login), and **you pay only for companies whose job board was found and read**.

> **Try it in one click.** The input is prefilled with stripe.com, linear.app and bunq.com (Greenhouse, Ashby and Recruitee). Press **Start** and you get three hiring profiles in about 10–15 seconds.

### What does Company Hiring Signals do?

For every domain you provide, the Actor:

1. **Discovers the job board.** It reads the homepage and the careers page (including `careers.` / `jobs.` subdomains and "See open roles" links) and recognizes embedded or linked Greenhouse, Lever, Ashby, Workday, Personio and Recruitee boards.
2. **Falls back to a verified guess.** When a site hides its board behind JavaScript, it tries the board named after the domain (for example `stripe.com` → Greenhouse `stripe`). The guess is **only accepted after verification**: the board name matches, the postings reference the company's domain, or the board page links back to it. Name collisions are never billed.
3. **Reads the official public feed**: Greenhouse Job Board API, Lever Postings API, Ashby Posting API, the Workday career-site search, the Personio XML feed, or the Recruitee Careers API.
4. **Computes the signals.** Open roles, new roles (7/30 days), roles by function (Engineering, Data & AI, Product, Design, Sales, Marketing, Customer Success, Operations, Finance, Legal, People, IT), seniority (intern → leadership), remote share, top locations, median posting age and a hiring-intensity label.

It also recognizes 17 other ATS products (Workable, SmartRecruiters, BambooHR, Teamtailor, iCIMS, Taleo, SuccessFactors and more), so a free row can tell you which one a company uses.

### Why use hiring signals?

- 🎯 **Sales intelligence and intent scoring.** A company hiring five SDRs is about to buy sales tooling, and one hiring data engineers needs data infrastructure. Score accounts by function-level hiring before outreach.
- 📈 **Account monitoring.** Schedule weekly runs over your target accounts and watch `newRolesLast7d` and `totalOpenRoles` change. Hiring spikes and freezes are early signals of growth, funding or restructuring.
- 🧑‍💼 **Recruiting and staffing agencies.** Find companies hiring in your niche (for example remote backend roles in Europe) and see exactly which roles are open.
- 💼 **Investors and market research.** Use open roles and their function mix as a public proxy for headcount growth across a portfolio or sector.
- 🤖 **AI agents.** `compactOutput` returns one small JSON object per company, built for the Apify MCP server and LLM tool calls.

Unlike job-listing scrapers, this Actor starts from **your list of companies**. It answers *"is this account hiring, and for what?"* in one row per company, with the evidence of where the data came from (`discoveryMethod`, `matchEvidence`, `postedDateBasis`).

### What data does it return?

| Field | Example | Description |
|---|---|---|
| `status` | `resolved` | `resolved` is the only billable status. Every other status costs $0. |
| `isHiring` | `true` | At least one open role on the board. |
| `atsPlatform` / `atsBoardUrl` | `ashby`, `https://jobs.ashbyhq.com/linear` | Which ATS and its public board. |
| `discoveryMethod` / `matchConfidence` | `careers-page`, `high` | How the board was found (linked, hint, or verified guess). |
| `totalOpenRoles` | `32` | Open roles on the board. |
| `newRolesLast7d` / `newRolesLast30d` | `0` / `10` | Roles first published in the last 7 / 30 days. |
| `departmentBreakdown` | `{"Engineering": 8, "Sales": 7, …}` | Roles per normalized function. |
| `topDepartments` | `GTM: 18` | Department names exactly as the ATS reports them. |
| `seniorityBreakdown` | `{"senior": 6, "mid": 26, …}` | Intern / junior / mid / senior / leadership. |
| `remoteRolesCount` / `remoteShare` | `29` / `0.906` | Remote roles and their share. |
| `locations` | `North America: 17` | Top 10 locations by role count. |
| `hiringIntensity` | `high` | none / low / moderate / high / very_high. |
| `jobs[]` (optional) | title, function, seniority, location, remote, date, URL | Newest first. |

### How to get hiring signals for a list of companies

1. Click **Try for free** or **Start** on this page.
2. Paste company domains into **Company domains** (one per line). Full URLs work too, and duplicates are merged.
3. Optional: set **Only jobs posted within (days)** to focus on fresh roles, turn off **Include job list** for signal-only rows, or turn on **Compact output** for AI agents.
4. Click **Start**. Most companies take 1–5 seconds; very large Workday or Lever boards take longer.
5. Download the results as **JSON, CSV, Excel or HTML** from the **Output** tab. You can also use the **Jobs** view (one row per job) or fetch through the API, n8n, Make or MCP.

### How much does it cost?

This Actor uses **pay per event**, and you pay only for real results:

| Event | Price | When it is charged |
|---|---|---|
| Company resolved | **$0.004** per company ($4 per 1,000) | A supported job board was found **and** read (`status: resolved`), including boards with zero open roles. That is still a valid "not hiring" signal. |
| Anything else | **$0** | No board found, unsupported ATS, feed errors, blocked, unreachable or invalid domains. |

- The job list (up to `maxJobsPerCompany`, default 25) is included in the per-company price.
- Platform compute is included. You pay only the event price above.
- **Workday caveat:** some heavily rate-limited enterprise Workday tenants refuse requests from cloud servers. This Actor doesn't use proxies, so those companies come back as free `feed_error` rows (charged $0) with the board URL. You can retry them in a later run.
- The Apify **free plan's $5 monthly credit covers about 1,250 resolved companies**.
- The Actor respects your run's **maximum total charge**. When the limit is reached it stops, and every remaining company gets a free `skipped_charge_limit` row.

### Input

All options are in the **Input** tab. A typical API input:

```json
{
    "domains": ["stripe.com", "linear.app", "bunq.com"],
    "atsHintUrls": ["https://jobs.lever.co/palantir"],
    "includeJobs": true,
    "maxJobsPerCompany": 25,
    "postedWithinDays": 30,
    "compactOutput": false
}
```

- `atsHintUrls`: known job board URLs. A hint is attached to the domain whose name matches the board (for example `jobs.lever.co/palantir` → `palantir.com`). Unmatched hints are processed as their own rows.
- `postedWithinDays`: filters `jobs[]` and `sampleJobTitles` and adds `rolesInWindow`. Board totals and breakdowns always cover the whole board.
- `probeAtsBySlug` (default on): the verified guess described above. Turn it off to use only boards linked from the website.

### Output

Results are stored in a dataset. You can download it in various formats such as JSON, HTML, CSV or Excel. Below is a shortened record from a real test run:

```json
{
    "domain": "linear.app",
    "companyName": "Linear",
    "status": "resolved",
    "isHiring": true,
    "atsPlatform": "ashby",
    "atsBoardUrl": "https://jobs.ashbyhq.com/linear",
    "careersUrl": "https://linear.app/careers",
    "discoveryMethod": "careers-page",
    "matchConfidence": "high",
    "matchEvidence": "careers page /careers: jobs.ashbyhq.com/linear",
    "totalOpenRoles": 32,
    "newRolesLast7d": 0,
    "newRolesLast30d": 10,
    "postedDateBasis": "publishedAt",
    "hiringIntensity": "high",
    "departmentBreakdown": { "Engineering": 8, "Sales": 7, "Customer Success & Support": 5, "Design": 4, "Marketing": 4, "Product": 2, "Operations": 1, "Data & AI": 1 },
    "topDepartments": [{ "name": "GTM", "count": 18 }, { "name": "Product", "count": 12 }],
    "seniorityBreakdown": { "intern": 0, "junior": 0, "mid": 26, "senior": 6, "leadership": 0 },
    "remoteRolesCount": 29,
    "remoteShare": 0.906,
    "locations": [{ "name": "North America", "count": 17 }, { "name": "Europe", "count": 7 }, { "name": "Singapore", "count": 5 }],
    "medianRoleAgeDays": 105,
    "jobs": [
        {
            "title": "Field Marketing Manager, Europe",
            "department": "GTM",
            "function": "Marketing",
            "seniority": "mid",
            "location": "Europe",
            "isRemote": true,
            "postedAt": "2026-11-10T18:14:08.778Z",
            "url": "https://jobs.ashbyhq.com/linear/af8d37e8-624a-4f2c-af53-c599b97192a3"
        }
    ],
    "requestsMade": 5,
    "durationMs": 1657
}
```

The same kind of row with `compactOutput: true`:

```json
{ "input": "stripe.com", "domain": "stripe.com", "company": "Stripe", "status": "resolved", "isHiring": true, "ats": "greenhouse", "boardUrl": "https://job-boards.greenhouse.io/stripe", "openRoles": 770, "new7d": 59, "new30d": 247, "inWindow": null, "remoteRoles": 115, "functions": { "Sales": 275, "Engineering": 130, "Operations": 59, "Customer Success & Support": 52 }, "topLocations": ["Dublin", "Singapore", "London"], "sampleTitles": ["Account Executive, Amer Platform (Growth Velocity)", "Activations Specialist, Bridge", "Marketing Strategy & Operations Lead, Global Demand, Campaigns, Field Marketing"] }
```

A free row:

```json
{ "domain": "example.com", "status": "no_ats_detected", "failureReason": "no careers page or supported job board found", "requestsMade": 17 }
```

#### What do the statuses mean?

| Status | Billed | Meaning |
|---|---|---|
| `resolved` | ✅ | Job board found and read (also when it has zero open roles). |
| `no_ats_detected` | $0 | No supported job board linked from the site, and no verified board under the company's name. |
| `unsupported_ats` | $0 | The company uses another ATS (named in `atsPlatform`, e.g. `workable`). |
| `feed_error` | $0 | A board was found but its public feed failed or timed out (for example, an enterprise Workday tenant that rate-limits cloud servers). |
| `blocked` | $0 | The website showed bot protection. It is **never bypassed**. Boards can still be found by verified name. |
| `unreachable` / `invalid_input` / `robots_disallowed` | $0 | DNS or network errors, non-public or invalid hosts, or a robots.txt opt-out. |
| `skipped_charge_limit` | $0 | Your run's spending limit was reached before this company was processed. |

#### How reliable are the dates?

Each ATS publishes a different date. `postedDateBasis` names the field used: Greenhouse `first_published`, Lever `createdAt`, Ashby `publishedAt`, Recruitee `published_at`, Personio `createdAt`, or Workday's relative "Posted N Days Ago". Some boards refresh every posting date at once (many Workday sites show "Posted Today" on everything). In that case the Actor sets the 7/30-day counts to `null` and explains why in `postedDateBasis`, rather than reporting a misleading spike.

### Use it from AI agents (MCP)

Add this Actor as a tool through the hosted [Apify MCP server](https://mcp.apify.com):

```text
https://mcp.apify.com/?tools=fxjima/company-hiring-signals
```

**Claude Code:**

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=fxjima/company-hiring-signals"
```

**Claude Desktop, Cursor, VS Code** and other MCP clients:

```json
{
    "mcpServers": {
        "apify": { "url": "https://mcp.apify.com/?tools=fxjima/company-hiring-signals" }
    }
}
```

The server signs you in with OAuth. If your client can't do OAuth, add an `"headers": { "Authorization": "Bearer <APIFY_TOKEN>" }` header instead. Ask your agent to call the tool with `compactOutput: true` and `includeJobs: false` for the smallest responses.

### Use it with n8n, Make, Zapier or the API

- **n8n:** add the **Apify** node, choose *Run an Actor and get dataset items*, select `fxjima/company-hiring-signals`, and pass `{"domains": {{ $json.domains }}}`. Then route rows with `isHiring` and `newRolesLast7d` into your CRM, Slack or Google Sheets.
- **Make / Zapier:** use the Apify app's *Run an Actor* action, then *Get dataset items*.
- **HTTP API**: a synchronous call for small batches (under 5 minutes):

```bash
curl -X POST "https://api.apify.com/v2/acts/fxjima~company-hiring-signals/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"domains": ["stripe.com", "linear.app"], "compactOutput": true, "includeJobs": false}'
```

### Tips for better and cheaper runs

- Turn off **Include job list** when you only need the signals. Rows get much smaller, and the price is the same.
- If you already know a company's board URL, put it in **Job board URLs**. Discovery is then skipped and the match is certain.
- Set a **maximum total charge** on the run to cap your spend precisely.
- Schedule weekly runs on the same list and compare `newRolesLast7d` and `totalOpenRoles` week over week.

### FAQ

#### Which job boards are supported?

Greenhouse (including EU boards and embedded boards), Lever (US and EU), Ashby, Workday (`myworkdayjobs.com` and `myworkdaysite.com`), Personio (`.de` and `.com`) and Recruitee (including custom careers domains that load Recruitee). Other ATS products are recognized and reported for free as `unsupported_ats`.

**Workday caveat:** some heavily rate-limited enterprise Workday tenants answer cloud servers with HTTP 429 (Too Many Requests). The Actor runs without proxies and never works around rate limits. Those companies return a free `feed_error` row, charged $0, with `atsPlatform: "workday"` and the board URL in `atsBoardUrl`. You can retry them in a later run.

#### Does it scrape LinkedIn, Indeed or Glassdoor?

No. It reads only the public feeds of the company's own applicant-tracking system, the same data its careers page shows. It never logs in, never solves CAPTCHAs, and respects robots.txt and crawl delays.

#### Does it collect personal data?

No. Job postings are public business information. The Actor does not return recruiter names, emails or job description text. It returns only titles, departments, locations, dates and URLs.

#### Why is a company `no_ats_detected` although it is hiring?

The company may list jobs on its own CMS, or use an ATS that is not supported yet. If you know the board URL, add it to **Job board URLs**. If you'd like another ATS added, open an issue.

### Disclaimer and support

This Actor is ethical and does not extract private user data. It only reads job postings that companies publish on their public job boards. However, your results could contain personal data, which is protected by the GDPR in the European Union and by other regulations around the world. Do not process personal data unless you have a legitimate reason to do so. If you are unsure whether your reason is legitimate, consult your lawyers. Greenhouse, Lever, Ashby, Workday, Personio and Recruitee are trademarks of their respective owners. This Actor is not affiliated with or endorsed by them.

Found a company whose board was missed or matched incorrectly? Open an issue in the **Issues** tab with the domain, and it will usually be handled within a few days. For programmatic access, see the **API** tab.

# Actor input Schema

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

One company website per line: stripe.com, www.linear.app or https://bunq.com/en. Paths are ignored and duplicates are removed.

## `urls` (type: `array`):

Optional second list for API and workflow callers (n8n, Make, Zapier) that already hold full website URLs. Merged with Company domains.

## `atsHintUrls` (type: `array`):

Known job board URLs, e.g. https://jobs.lever.co/palantir or https://acme.wd5.myworkdayjobs.com/External. Each URL is attached to the domain whose name matches the board; unmatched URLs are processed as their own companies. Use this when a website hides its job board.

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

Adds a jobs\[] array (newest first) with title, department, job function, seniority, location, remote flag, posting date and URL. Same price per company.

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

How many jobs to return in jobs\[] when Include job list is on. Signals (counts, breakdowns) always use the whole board.

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

Optional. Limits jobs\[] and sample titles to roles posted in the last N days and adds rolesInWindow. Board totals and breakdowns are not filtered. Leave empty for no filter.

## `compactOutput` (type: `boolean`):

Returns one small, token-efficient object per company (status, ATS, open roles, new roles, functions, top locations, sample titles) instead of the full record. Ideal for MCP / LLM tool calls.

## `probeAtsBySlug` (type: `boolean`):

When the website does not link to a job board, try the boards named like the domain (stripe.com -> greenhouse 'stripe'). A guessed board is only used when it is verified to belong to the company (board name, company domain in the postings, or a link back to the domain).

## `maxJobsScannedPerCompany` (type: `integer`):

Upper bound of postings read from paginated job boards (Lever pages of 100, Workday pages of 20). Totals and department counts still cover the whole board where the ATS publishes them.

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

Stop after this many companies (0 = all). Useful for test runs and budget control together with the run's maximum total charge.

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

How many companies are processed at the same time. Requests to one host are always paced, and robots.txt crawl delays are honored.

## `requestTimeoutSecs` (type: `integer`):

Timeout for a single HTTP request. A timed-out request is retried once; rate-limited or failing requests twice.

## `respectRobotsTxt` (type: `boolean`):

When on (recommended), URLs disallowed by a site's robots.txt are skipped.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "linear.app",
    "bunq.com"
  ],
  "includeJobs": true,
  "maxJobsPerCompany": 25,
  "compactOutput": false,
  "probeAtsBySlug": true,
  "maxJobsScannedPerCompany": 1000,
  "maxItems": 0,
  "maxConcurrency": 5,
  "requestTimeoutSecs": 20,
  "respectRobotsTxt": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview table view of the dataset.

## `jobs` (type: `string`):

Flat job list across all companies.

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

All dataset items with every field.

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

Billable count, status breakdown, requests and downloaded data for the run.

## `keys` (type: `string`):

All records saved by the run (SUMMARY, STATE).

# 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": [
        "stripe.com",
        "linear.app",
        "bunq.com"
    ]
};

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

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

```

## MCP server setup

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