# ATS Jobs Aggregator 🎯 (hiring signals from any company list) (`tagadanar/ats-jobs-aggregator`) Actor
Turn a list of company names or domains into hiring signals. Auto-detects each company's Greenhouse, Lever, Ashby, Workable or SmartRecruiters job board and returns clean job postings data: title, department, location, remote flag, posted date, description. $2.50 per 1,000 jobs.
- **URL**: https://apify.com/tagadanar/ats-jobs-aggregator.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.75 / 1,000 job posting scrapeds
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/docs.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Jobs Aggregator
Turn any list of companies into hiring signals. Give this actor company names, domains or career page URLs, and it finds each company's job board by itself across the five big applicant tracking systems (Greenhouse, Lever, Ashby, Workable and SmartRecruiters), then returns clean job postings data: title, department, location, remote flag, posting date, direct link and the job description. One input, one flat table, five ATS providers.
Most job scrapers make you find the board first and only cover a single ATS. Here you paste the company list you already have (from a CRM export, a lead list, another scraper) and the actor works out where each company hosts its jobs. Companies where no board is found show up as a free status row, so you always know what was checked. You only pay for jobs actually delivered.
No login, no API key, no proxy setup. The data comes from each ATS provider's own public job board API, which is fast and does not break when a careers page changes its layout.
### What you get
One record per job posting:
| Field | Description |
| --- | --- |
| `company` | Company name (as resolved from the board, or your input) |
| `companyInput` | The exact entry from your input this row came from |
| `ats` | Where the job was found: `greenhouse`, `lever`, `ashby`, `smartrecruiters` or `workable` |
| `boardSlug` | The board identifier on that ATS |
| `boardUrl` | The company's public job board |
| `detection` | `auto-detected` (found from the name or domain) or `board-url` (you gave the board link) |
| `jobId` | Job id on the ATS |
| `title` | Job title |
| `department` | Department or team |
| `location` | Primary location |
| `locations` | All listed locations |
| `remote` | `true` / `false`, or `null` when the ATS does not state it |
| `employmentType` | Full-time, Contract, and so on, when stated |
| `postedAt` | When the job was published (ISO date) |
| `updatedAt` | Last update (Greenhouse only) |
| `url` | Direct link to the posting |
| `applyUrl` | Direct link to the application form |
| `description` | Job description as plain text (long ones are truncated) |
| `retrievedAt` | When the row was collected |
Companies where nothing was returned get one **free** status row instead (`recordType: "company-status"`), with a `status` of `no_board_found`, `no_open_jobs` or `no_new_jobs`, the board that was detected (if any) and the slugs that were probed. You are never charged for a company that produced no jobs.
### Who uses this
- **Sales and GTM teams:** a company hiring for "Head of Data" or ramping up an engineering team is showing budget and intent. Feed your account list in, get open roles per account, and time your outreach on real hiring signals instead of guesswork.
- **Recruiters and sourcing agencies:** track every open role at the companies you work, spot new searches the day they go live, and see which departments are growing.
- **Investors and analysts:** headcount plans leak through job boards long before press releases. Monitor a portfolio or a watchlist and chart hiring velocity by company and department.
- **Job seekers and talent communities:** follow the exact companies you want to join, across whichever ATS each one uses, in one table.
- **Data teams:** a single normalized schema across five ATS providers, ready for a warehouse, a dashboard or enrichment.
### How the auto-detection works
For each entry the actor derives likely board identifiers (from the company name or the domain) and checks them against the public job board APIs of Greenhouse, Lever, Ashby, SmartRecruiters and Workable, in that order, until a board with live postings answers. A board that exists but has zero open jobs is still reported, as a status row. Every probe is free; the `detection` and `triedSlugs` fields show exactly what was found and how.
If you already know the board, paste its URL (for example `https://boards.greenhouse.io/stripe` or `https://jobs.lever.co/palantir`) or the bare slug, and the actor uses it directly.
Ambiguous or very generic company names can miss or, rarely, match a similarly named company. For those, pass the domain or the board URL instead, which is precise.
### Input examples
Copy any of these into the JSON input, or use the form.
**Mixed names, domains and slugs, auto-detected:**
```json
{
"companies": ["stripe", "Palantir Technologies", "openai.com", "Blueground", "Bosch Group"],
"maxJobsPerCompany": 50
}
````
**A daily hiring-signal monitor for your account list (only new postings):**
```json
{
"companies": ["stripe.com", "openai.com", "figma.com", "ramp.com"],
"monitorMode": true,
"monitorName": "target-accounts",
"maxResults": 500
}
```
Schedule it daily. The first run returns the current postings, every later run returns only what is new since the previous one. Use different `monitorName` values to track separate lists independently.
**Exact board URLs, no detection needed:**
```json
{
"companies": [
"https://boards.greenhouse.io/stripe",
"https://jobs.lever.co/palantir",
"https://jobs.ashbyhq.com/openai"
],
"maxJobsPerCompany": 100
}
```
You can also pipe a dataset from another actor straight in: entries that are objects are read through their usual keys (`company`, `companyName`, `name`, `domain`, `website`, `url`), so a lead list or a scraper's output works without reshaping.
### Pricing
You pay per job returned. Platform usage is included in the price, so there is no separate compute or proxy bill.
| Event | Price |
| --- | --- |
| Actor start | $0.001 per run |
| Job scraped | $2.50 per 1,000 |
Detection probes, companies with no board, boards with no open jobs and monitor runs that find nothing new are all free. The tiny start fee covers runs that return nothing; on any normal run it is noise next to the per-job price.
### FAQ
**Which ATS providers are covered?**
Greenhouse, Lever, Ashby, Workable and SmartRecruiters, which between them host the job boards of a large share of tech and scale-up companies. Coverage of additional providers is planned; ask via the Issues tab if you need one.
**Do I need to know which ATS a company uses?**
No, that is the point. Give the company name or domain and the actor finds the board. Every row tells you which ATS it came from.
**What happens when a company is not found?**
You get a free status row with `status: "no_board_found"` and the list of identifiers that were probed. If you know the company has a board on one of the five providers, pass its board URL or exact slug and it will be used directly.
**Can I get only new postings?**
Yes. Switch on **Monitor mode** and schedule the actor. It remembers what it already reported (per monitor name) and each run returns only postings it has not seen before. Companies with nothing new produce a free status row, not charges.
**Where does the data come from?**
From each ATS provider's own public job board API, the same source that powers the company's careers page. No HTML parsing of career sites, so the fields are stable and the posting dates are the real ones.
**Does it collect personal data?**
No. It collects public job postings and the hiring company only: no applicants, no recruiter profiles, no personal information.
**How fresh is the data?**
It is read live at run time. Whatever the company's board lists at that moment is what you get, including the posting date the ATS reports.
**A big company returns thousands of jobs. Can I cap it?**
Yes. **Max jobs per company** caps each company (default 100) so one large employer cannot eat your run budget, and **Max jobs total** caps the run. For SmartRecruiters boards, up to 1,000 postings per company are read.
**Is the output the same shape for every ATS?**
Yes, one flat schema across all five. Fields an ATS genuinely does not provide are `null` rather than guessed.
**Can I pipe in my CRM or lead list?**
Yes. The `companies` field accepts plain strings, comma or newline separated lists, and arrays of objects with the usual name/domain/url keys, so exports and other actors' datasets work as-is.
### Related actors
- [LinkedIn Jobs Scraper](https://apify.com/tagadanar/linkedin-jobs-scraper): search jobs by keyword and location across all companies, with applicant counts.
- [Naukri Scraper](https://apify.com/tagadanar/naukri-scraper): India's largest job board, with salaries and company ratings.
- [French Company Email Finder](https://apify.com/tagadanar/french-company-contacts): turn a French hiring company into dirigeants and contact emails for outreach.
***
Hiring signals, job postings data, ATS scraper, Greenhouse jobs API, Lever postings API, Ashby job board, Workable jobs, SmartRecruiters postings, company job openings by domain, jobs by company list, new job postings monitor, hiring intent data, sales intelligence signals, recruiting intelligence, headcount growth tracking, job board aggregator, career page scraper.
# Actor input Schema
## `companies` (type: `array`):
One entry per company. Accepts a company name (Palantir Technologies), a domain (openai.com), a job board slug (stripe), or a board URL (https://jobs.lever.co/palantir). The actor finds the right ATS job board automatically.
## `maxJobsPerCompany` (type: `integer`):
Cap per company, so one large employer cannot eat the whole run budget when you track many companies at once.
## `maxResults` (type: `integer`):
Total jobs to return across all companies.
## `monitorMode` (type: `boolean`):
Remember postings seen on previous runs and return only new ones. Combine with a schedule for a hiring-signal feed: each run reports just what changed.
## `monitorName` (type: `string`):
Label for the remembered-postings set. Use different names to track different company lists independently.
## Actor input object example
```json
{
"companies": [
"stripe",
"palantir",
"openai"
],
"maxJobsPerCompany": 25,
"maxResults": 100,
"monitorMode": false,
"monitorName": "default"
}
```
# Actor output Schema
## `jobs` (type: `string`):
One item per job posting (plus one uncharged status row per company where no postings were returned) in the default dataset.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"companies": [
"stripe",
"palantir",
"openai"
],
"maxJobsPerCompany": 25
};
// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/ats-jobs-aggregator").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"companies": [
"stripe",
"palantir",
"openai",
],
"maxJobsPerCompany": 25,
}
# Run the Actor and wait for it to finish
run = client.actor("tagadanar/ats-jobs-aggregator").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 '{
"companies": [
"stripe",
"palantir",
"openai"
],
"maxJobsPerCompany": 25
}' |
apify call tagadanar/ats-jobs-aggregator --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=tagadanar/ats-jobs-aggregator",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "ATS Jobs Aggregator 🎯 (hiring signals from any company list)",
"description": "Turn a list of company names or domains into hiring signals. Auto-detects each company's Greenhouse, Lever, Ashby, Workable or SmartRecruiters job board and returns clean job postings data: title, department, location, remote flag, posted date, description. $2.50 per 1,000 jobs.",
"version": "0.1",
"x-build-id": "UCQ08twgdtCM2Zsxn"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/tagadanar~ats-jobs-aggregator/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-tagadanar-ats-jobs-aggregator",
"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/tagadanar~ats-jobs-aggregator/runs": {
"post": {
"operationId": "runs-sync-tagadanar-ats-jobs-aggregator",
"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/tagadanar~ats-jobs-aggregator/run-sync": {
"post": {
"operationId": "run-sync-tagadanar-ats-jobs-aggregator",
"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": [
"companies"
],
"properties": {
"companies": {
"title": "Companies",
"minItems": 1,
"type": "array",
"description": "One entry per company. Accepts a company name (Palantir Technologies), a domain (openai.com), a job board slug (stripe), or a board URL (https://jobs.lever.co/palantir). The actor finds the right ATS job board automatically.",
"items": {
"type": "string"
}
},
"maxJobsPerCompany": {
"title": "Max jobs per company",
"minimum": 1,
"maximum": 5000,
"type": "integer",
"description": "Cap per company, so one large employer cannot eat the whole run budget when you track many companies at once.",
"default": 100
},
"maxResults": {
"title": "Max jobs total",
"minimum": 1,
"maximum": 50000,
"type": "integer",
"description": "Total jobs to return across all companies.",
"default": 100
},
"monitorMode": {
"title": "Monitor mode (only new postings)",
"type": "boolean",
"description": "Remember postings seen on previous runs and return only new ones. Combine with a schedule for a hiring-signal feed: each run reports just what changed.",
"default": false
},
"monitorName": {
"title": "Monitor name",
"type": "string",
"description": "Label for the remembered-postings set. Use different names to track different company lists independently.",
"default": "default"
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```