# Careers Page & ATS Detector (`henryklimes/careers-ats-detector`) Actor

Use this when you have company domains and need each company's careers page, the ATS it uses (Greenhouse, Lever, Ashby, Workday and 20 more), the job board ID and the open-job count. Input domains. This detects the ATS; it does not scrape the postings themselves. $3 per 1,000 domains.

- **URL**: https://apify.com/henryklimes/careers-ats-detector.md
- **Developed by:** [Jindrich Klimes](https://apify.com/henryklimes) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 domain checkeds

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

## Careers Page & ATS Detector

**Which ATS does a company use? Careers Page & ATS Detector answers it in bulk. Give it a list of company domains. Get back each company's careers page, the applicant tracking system (ATS) it uses, the job-board ID and how many jobs are open right now.**

Built for sales teams selling to HR and recruiting, recruiting-tech vendors, job aggregators and anyone who wants to feed job boards into [ATS Jobs Feed](https://apify.com/henryklimes/ats-jobs-feed) or [Workday Jobs Feed](https://apify.com/henryklimes/workday-jobs-feed).

### What it detects

**25 applicant tracking systems:** Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Workday, BambooHR, Personio, Teamtailor, Jobvite, iCIMS, Breezy HR, JazzHR, Pinpoint, Rippling, Taleo, SAP SuccessFactors, Oracle Recruiting Cloud, Gem, Homerun, JOIN, Dover, Freshteam and Comeet.

For each domain you get:

- ✅ **Careers page URL** on the company's own site
- ✅ **ATS name and board ID** (e.g. Greenhouse board `stripe`, Workday `nvidia/NVIDIAExternalCareerSite`)
- ✅ **Open-job count** from the ATS's public API (Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Workday)
- ✅ **Confidence and method** — found on the homepage, on the careers page, via redirect, or by probing public ATS APIs
- ✅ **Other boards** — some companies run several (e.g. a separate early-careers board)

### How it works

1. Reads the homepage and looks for job-board links, embeds and scripts.
2. Follows the best "Careers / Jobs / Join us" link (and one "View open positions" link), plus `/careers`, `/jobs`, `careers.` and `jobs.` subdomains as fallbacks.
3. If the site doesn't reveal a board (JavaScript-only careers pages), it optionally tries the company name on public ATS APIs and keeps the board with the most jobs — rejecting boards that publish a different company name.
4. Confirms the board exists and counts open jobs.

It reads only public pages, identifies itself as `CleanrowsBot`, honours robots.txt and fetches at most a handful of pages per domain. No login, no personal data.

### Input

```json
{
  "domains": ["stripe.com", "notion.so", "huggingface.co", "adobe.com"],
  "probeAtsApis": true,
  "verifyBoards": true,
  "maxPagesPerDomain": 6,
  "maxConcurrency": 10
}
```

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `domains` | Array | — | Company domains or URLs. Duplicates are removed. |
| `probeAtsApis` | Boolean | `true` | Try the company name on public ATS APIs when the site has no board link |
| `verifyBoards` | Boolean | `true` | Confirm the board and count open jobs |
| `maxPagesPerDomain` | Integer | `6` | Company pages fetched per domain (1–15) |
| `maxConcurrency` | Integer | `10` | Domains processed in parallel (1–25) |

### Output

```json
{
  "domain": "notion.so",
  "input": "notion.so",
  "company_name": "Notion",
  "homepage_url": "https://www.notion.com/",
  "careers_url": "https://www.notion.com/careers",
  "ats": "ashby",
  "ats_identifier": "notion",
  "ats_board_url": "https://jobs.ashbyhq.com/notion",
  "job_count": 166,
  "detection_method": "careers_page",
  "confidence": "high",
  "other_boards": [],
  "pages_checked": 2,
  "status": "ok",
  "error": null,
  "checked_at": "2026-11-14T17:30:00.000Z"
}
```

`status` is `ok`, `blocked` (the site refused us or robots.txt disallows it), `unreachable` or `invalid`. A summary with counts per ATS is saved as the `OUTPUT` record.

### Which ATS does a company use? Check thousands of domains at once

Checking one company by hand means opening its careers page, clicking Apply and reading the URL. This Actor does that for a whole list: paste domains (or URLs) into `domains`, and each row tells you the ATS, how it was found (`detection_method`) and how sure it is (`confidence`). Duplicates are removed, and domains are processed in parallel (`maxConcurrency`, up to 25).

### How to find a company's Greenhouse, Lever or Ashby board token

The `ats_identifier` field is the board token or slug the ATS uses, for example `stripe` on Greenhouse or `notion` on Ashby, and `ats_board_url` is the public board. For Workday it is `tenant/site`, e.g. `nvidia/NVIDIAExternalCareerSite`. Use these directly with ATS APIs, [ATS Jobs Feed](https://apify.com/henryklimes/ats-jobs-feed) or [Workday Jobs Feed](https://apify.com/henryklimes/workday-jobs-feed).

### Build a list of companies using Greenhouse, Lever, Workday or Ashby

Run your account list through the detector, then filter the dataset by `ats` (for example `ats = lever` and `job_count >= 50`). The `OUTPUT` record also has a count of companies per ATS for the run. This works only for the domains you provide: the Actor checks your list, it doesn't come with a ready-made directory of companies.

### How to find a company's careers page automatically

The Actor reads the homepage, follows the best "Careers / Jobs / Join us" link, and falls back to `/careers`, `/jobs` and `careers.` / `jobs.` subdomains. The result is in `careers_url`, even when the company runs its own careers system and no ATS is found.

### Open-job counts as a hiring signal for sales and Clay

With `verifyBoards` on, `job_count` holds the number of open jobs from the ATS's public API (Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Workday). Schedule a run to track hiring over time, or call the Actor through the Apify API to fill a CRM or Clay table.

### Use cases

- **Sales prospecting for HR tech** — segment accounts by ATS ("all Lever customers with 50+ open jobs")
- **Competitive intelligence for ATS vendors** — see who uses which platform
- **Job aggregation** — turn a list of company domains into job-board IDs, then pull jobs with ATS Jobs Feed / Workday Jobs Feed
- **Hiring signals** — open-job counts as a growth signal in your CRM or Clay table

### Ready-made example tasks

Open one, check the prefilled input, and run it in one click:

- [Find which ATS a company uses](https://apify.com/henryklimes/careers-ats-detector/examples/find-which-ats-a-company-uses)
- [Find careers pages for a list of company domains](https://apify.com/henryklimes/careers-ats-detector/examples/find-careers-pages-for-domains)
- [Count open jobs per company for sales prospecting](https://apify.com/henryklimes/careers-ats-detector/examples/companies-hiring-signal-job-counts)

### Pricing

Pay per result: **$3.00 per 1,000 domains** ($0.003 per domain). You're charged only for domains we could read or where a board was found. Invalid domains and unreachable sites with no board are free.

### FAQ

**Why is a company's ATS missing?** Some careers pages are rendered entirely by JavaScript or use an in-house system. With `probeAtsApis` on, most Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee boards are still found. Custom systems are reported as "no ATS found" with the careers page URL.

**What does confidence mean?** `high`: the board is linked from the company's site and confirmed, or found by probing and the board's own company name matches. `medium`: found by probing an ATS that doesn't publish a company name, or the ATS API was temporarily unreachable. `low`: linked on the site but the ATS says the board doesn't exist (often an old link).

**Does it respect robots.txt?** Yes. Pages that robots.txt disallows are skipped; if the homepage itself is disallowed, the domain is marked `blocked`.

### Support

Report issues or request an ATS in the Issues tab of this Actor.

# Actor input Schema

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

Company website domains or URLs, e.g. stripe.com, https://www.notion.so. Duplicates are removed.

## `probeAtsApis` (type: `boolean`):

If no job board is linked on the site, try the company's name on the public Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee APIs. Boards that publish a different company name are rejected.

## `verifyBoards` (type: `boolean`):

Confirm the detected board exists and count its open jobs via the ATS public API.

## `maxPagesPerDomain` (type: `integer`):

Company web pages fetched per domain (homepage, careers page, open-positions page, fallbacks).

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

Domains processed in parallel.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "notion.so",
    "huggingface.co",
    "adobe.com"
  ],
  "probeAtsApis": true,
  "verifyBoards": true,
  "maxPagesPerDomain": 6,
  "maxConcurrency": 10
}
```

# Actor output Schema

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

Careers page, ATS, board ID and open jobs per domain

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

Counts by ATS and status

# 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",
        "notion.so",
        "huggingface.co",
        "adobe.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("henryklimes/careers-ats-detector").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",
        "notion.so",
        "huggingface.co",
        "adobe.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("henryklimes/careers-ats-detector").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",
    "notion.so",
    "huggingface.co",
    "adobe.com"
  ]
}' |
apify call henryklimes/careers-ats-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,henryklimes/careers-ats-detector"
        }
    }
}
```

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/YRUNV4SJ0eKvQclLK/builds/zIfZtfqaEHChad8jp/openapi.json
