# ATS Hiring Monitor API | 💵$2/1K (`webdata_labs/ats-hiring-monitor-api`) Actor

\[💵 $2.00 / 1K] Monitor company ATS career pages and return NEW, REMOVED, and REOPENED job signals across Workday, Greenhouse, Lever, Ashby, SmartRecruiters, Recruitee, and Personio.

- **URL**: https://apify.com/webdata\_labs/ats-hiring-monitor-api.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 hiring monitor rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## ATS Hiring Monitor API

**Detect company hiring changes - not another full job-board dump.** Monitor public ATS career pages and receive `NEW`, `REMOVED`, and `REOPENED` job signals in one canonical schema.

### ✅ What you get / ❌ What this isn't

- ✅ Change events ready for alerts, CRM enrichment, recruiting, and sales signals.
- ✅ Company-level summaries even when nothing changed.
- ✅ Persistent snapshots isolated by `monitorName`.
- ❌ Not LinkedIn, Indeed, or private applicant data.
- ❌ Not a guarantee that a removed posting represents a filled role.

### 🔎 Why use this Actor

The Actor supports Workday, Greenhouse, Lever, Ashby, SmartRecruiters, Recruitee, and Personio. It normalizes their different job identifiers and compares each run with the previous successful snapshot. Failed sources do not overwrite good state, preventing a temporary outage from creating false mass-removal events.

### 📊 What data you get

| Field | Description |
|---|---|
| `changeType` | `NEW`, `REMOVED`, or `REOPENED` |
| `company`, `ats` | Normalized source identity |
| `jobId`, `title`, `location` | Job identity and core attributes |
| `url`, `applyUrl` | Public job and application URLs |
| `detectedAt` | Time the change was observed |
| `monitorName` | Snapshot namespace used for comparison |

### 👥 Who it's for

- Recruiters watching target employers.
- B2B sales teams using hiring activity as an account signal.
- Investors and analysts tracking company growth or contraction.
- Niche job boards that need scheduled change feeds.

### ⚙️ How to monitor company hiring

1. Add company ATS slugs or career-page URLs.
2. Choose a stable `monitorName` and keep it unchanged.
3. Run once to establish a baseline.
4. Schedule the Actor daily or hourly.
5. Send change rows to a webhook, Make, Zapier, Sheets, or your data warehouse.

### 📥 Input

```json
{
  "monitorName": "ai-companies",
  "companies": ["greenhouse:stripe", "ashby:ramp"],
  "emitInitialSnapshot": true
}
````

Use full Workday URLs when possible because they include the tenant host and career-site identifier.

### 📤 Output

```json
{
  "recordType": "hiring_change",
  "changeType": "NEW",
  "company": "stripe",
  "ats": "greenhouse",
  "jobId": "12345",
  "title": "Machine Learning Engineer",
  "location": "London",
  "detectedAt": "2026-07-14T12:00:00+00:00"
}
```

### 💵 How much does it cost?

The pricing hypothesis is $2 per 1,000 output rows.

### 🔁 Run it on the Apify platform

Use schedules for recurring monitoring and webhooks or integrations for immediate delivery.

### ⚠️ Limits and caveats

- A removed posting means it disappeared from the public ATS snapshot; it may be filled, paused, moved, or unpublished.
- Removal detection is suppressed when `maxJobsPerCompany` truncates a snapshot, preventing false removals.
- First runs can emit the current snapshot as `NEW`, or establish a silent baseline.
- Changing `monitorName` creates a new independent baseline.
- Workday discovery is more request-intensive than explicit Workday career-page URLs.

### 🧩 Related Actors

- ATS Jobs Scraper - export the complete current job inventory.
- Buyer Fit Brief API - score and prioritize company leads.

### ❓ FAQ

#### Does it monitor private applicant data?

No. It reads only public company job postings.

#### Can I monitor multiple watchlists?

Yes. Give each watchlist a different `monitorName`.

### 🛠️ Support

Include the run URL, redacted input, company identifier, and expected change when reporting an issue.

# Actor input Schema

## `monitorName` (type: `string`):

Stable state namespace. Reuse the same name on every scheduled run.

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

ATS slugs, forced identifiers such as greenhouse:stripe, or supported career-page URLs.

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

Maximum current postings fetched from each company per run.

## `emitInitialSnapshot` (type: `boolean`):

Turn off to establish a silent baseline; company summaries are still returned.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy configuration. Public ATS endpoints normally work without a proxy.

## Actor input object example

```json
{
  "monitorName": "prefill-company-watchlist",
  "companies": [
    "greenhouse:stripe",
    "ashby:ramp"
  ],
  "maxJobsPerCompany": 500,
  "emitInitialSnapshot": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

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

No description

# 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 = {
    "monitorName": "prefill-company-watchlist",
    "companies": [
        "greenhouse:stripe",
        "ashby:ramp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/ats-hiring-monitor-api").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 = {
    "monitorName": "prefill-company-watchlist",
    "companies": [
        "greenhouse:stripe",
        "ashby:ramp",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/ats-hiring-monitor-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "monitorName": "prefill-company-watchlist",
  "companies": [
    "greenhouse:stripe",
    "ashby:ramp"
  ]
}' |
apify call webdata_labs/ats-hiring-monitor-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=webdata_labs/ats-hiring-monitor-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ATS Hiring Monitor API | 💵$2/1K",
        "description": "[💵 $2.00 / 1K] Monitor company ATS career pages and return NEW, REMOVED, and REOPENED job signals across Workday, Greenhouse, Lever, Ashby, SmartRecruiters, Recruitee, and Personio.",
        "version": "0.1",
        "x-build-id": "HRh4LjtLWcc7r47hf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~ats-hiring-monitor-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-ats-hiring-monitor-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/webdata_labs~ats-hiring-monitor-api/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-ats-hiring-monitor-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/webdata_labs~ats-hiring-monitor-api/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-ats-hiring-monitor-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "monitorName",
                    "companies"
                ],
                "properties": {
                    "monitorName": {
                        "title": "Monitor name",
                        "type": "string",
                        "description": "Stable state namespace. Reuse the same name on every scheduled run.",
                        "default": "my-company-watchlist"
                    },
                    "companies": {
                        "title": "Companies or career pages",
                        "type": "array",
                        "description": "ATS slugs, forced identifiers such as greenhouse:stripe, or supported career-page URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxJobsPerCompany": {
                        "title": "Max open jobs per company",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum current postings fetched from each company per run.",
                        "default": 500
                    },
                    "emitInitialSnapshot": {
                        "title": "Emit existing jobs as NEW on first run",
                        "type": "boolean",
                        "description": "Turn off to establish a silent baseline; company summaries are still returned.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration. Public ATS endpoints normally work without a proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
