# Greenhouse, Lever, Ashby, Workable, Teamtailor Jobs API | $1/1K (`feedworks/ats-jobs-api`) Actor

Track jobs across Greenhouse, Lever, Ashby, Workable, Teamtailor and SmartRecruiters from one API. Pass company domains, not board tokens — detection is automatic. First run returns every job; later runs return only changes: posted, closed, salary. $1 per 1,000 jobs.

- **URL**: https://apify.com/feedworks/ats-jobs-api.md
- **Developed by:** [Vladymyr Postnov](https://apify.com/feedworks) (community)
- **Categories:** Jobs, Lead generation, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 job indexeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Greenhouse, Lever, Ashby, Workable, Teamtailor Jobs API

One API for 6 applicant tracking systems: **Greenhouse, Lever, Ashby, Workable, Teamtailor and SmartRecruiters**.

Full job data on the first run. On every run after that you get **only what changed** — jobs posted, jobs closed, salary changed — plus derived hiring signals. Straight from the source ATS endpoints, so nothing is stale and nothing is duplicated by a job board in between.

### What you get

| Event | Meaning |
|---|---|
| `job_indexed` | Baseline: an open role captured on the first run |
| `job_posted` | A new opening appeared |
| `job_closed` | An opening disappeared |
| `job_changed` | Title, location, department or employment type changed |
| `salary_changed` | Compensation changed |
| `hiring_accelerating` | This month's postings are 2x or more the recent average — the company is expanding a function |
| `first_role_in_function` | First ever hire in sales, AI/ML, security, data — a new budget line opened |
| `hiring_freeze` | Postings dropped to zero after steady hiring |

Every record carries provenance: source URL, HTTP status, fetch time, job count, truncation flag and a `confidence` value — so an agent can act on it, not just read it.

### Input

The simple way — just name the companies:

```json
{ "domains": ["stripe.com", "spotify.com", "pleo.io"] }
```

The Actor works out which applicant tracking system each company uses, remembers it, and starts tracking. You never have to know what an ATS is.

If you already know the board tokens, skip detection:

```json
{ "sources": [
    { "ats": "greenhouse", "company": "stripe" },
    { "ats": "teamtailor", "company": "oneflow" }
] }
```

Companies whose jobs cannot be reached return a `source_unresolved` record explaining why, instead of failing silently.

### Why it stays cheap when you watch hundreds of companies

Every source is polled with `If-None-Match`. When nothing changed the ATS answers `304` with no body, so a check costs a fraction of a cent. Measured on this Actor: a run that finds no changes across two sources uses 0.00034 compute units. You pay for signal, not for polling.

### What it deliberately does not do

- **No personal data.** Recruiter names, emails and phone numbers are stripped at parse time and never stored.
- **No headless browser, no proxies.** Only public ATS endpoints that answer with JSON.
- **No false layoffs.** If a source response may be truncated by paging, `job_closed` events are suppressed — a paging artefact must never look like a company shutting down hiring.

### Roadmap

Recruitee and Personio are next. They are not listed above because they are not verified yet, and this Actor does not claim coverage it cannot deliver.

# Actor input Schema

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

The simple way: just list company websites, e.g. "stripe.com". The Actor works out which applicant tracking system each company uses (Greenhouse, Lever, Ashby, Workable, Teamtailor, SmartRecruiters) and remembers it. Use this if you do not already know the board tokens.

## `sources` (type: `array`):

Skip auto-detection by naming the ATS and board token directly: \[{"ats":"greenhouse","company":"stripe"}]. Valid ats values: greenhouse, lever, ashby, workable, teamtailor, smartrecruiters. The company value is the token in the ATS URL, e.g. boards.greenhouse.io/<token>.

## `deriveSignals` (type: `boolean`):

Also emit interpreted signals on top of raw changes: hiring\_accelerating (postings 2x above the recent average), first\_role\_in\_function (first hire in sales, AI/ML, security...), hiring\_freeze.

## `includeEvidence` (type: `boolean`):

Attach full provenance to every record: source URL, HTTP status, fetch duration, job count, truncation flag. Use when the caller has to verify a record before acting on it.

## `maxSources` (type: `integer`):

Hard cap on how many companies one run may process. Protects against runaway cost.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "spotify.com"
  ],
  "deriveSignals": true,
  "includeEvidence": false,
  "maxSources": 200
}
```

# Actor output Schema

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

Baseline jobs, detected changes, derived hiring signals, unresolved sources and the run summary.

# 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",
        "spotify.com"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("feedworks/ats-jobs-api").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",
    "spotify.com"
  ]
}' |
apify call feedworks/ats-jobs-api --silent --output-dataset

```

## MCP server setup

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

```

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/U5P1Icun58fnalJVK/builds/Ut0elHFCz5wSRfdWg/openapi.json