# Live ATS Jobs API (`structlabs/live-ats-jobs-api`) Actor

Live ATS jobs API for Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Personio and BambooHR. Search 4,129 validated company job boards, normalize salary, remote status and seniority. Zero proxies.

- **URL**: https://apify.com/structlabs/live-ats-jobs-api.md
- **Developed by:** [Mohit Tripathi](https://apify.com/structlabs) (community)
- **Categories:** Jobs
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.13 / 1,000 job 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/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

## Live ATS Jobs API

Search **live job postings** straight from company ATS boards — Greenhouse, Ashby, Lever, Workable, SmartRecruiters, Recruitee, Personio, and BambooHR. No proxies, no browsers, no LinkedIn/Indeed scraping. Every record comes from the employer's own public JSON or XML feed.

Bundled with **4,129 live, validated company boards**, tiered tech-first so the default 300-board scan starts with AI/SaaS/tech companies instead of staffing chains., so keyword searches work immediately without supplying board URLs.

### What it does

- Pulls live postings from 8 ATS platforms over public endpoints.
- Normalizes **annualized salary** (min/max/currency), **remote/hybrid/onsite**, **seniority**, department, employment type, posted date and apply URL.
- Filters by title keyword and remote-only.
- Supports **`onlyNewJobs`** with a named key-value store, so daily agent runs only return jobs they have not seen before.
- Bills **per pushed job** only. 404 boards, empty boards, and filtered-out jobs are free.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array | `["AI Engineer"]` | Match any query; every word must appear in title or description. Empty = all jobs. |
| `remoteOnly` | boolean | `false` | Keep only remote roles. |
| `providers` | array | Greenhouse, Ashby, Lever, BambooHR | ATS platforms to scan. |
| `companies` | array | `[]` | Optional slugs (e.g. `stripe`, `openai`); provider auto-detected. Empty = bundled seed. |
| `maxCompanies` | integer | `300` | Board cap. Seed is sorted by active job count; raise to 4,129 for full coverage. |
| `maxJobs` | integer | `200` | Stop after this many matching jobs. |
| `dedupeWorkableLocations` | boolean | `true` | Merge Workable multi-location clones by company + normalized title; bill once per role. |
| `onlyNewJobs` | boolean | `false` | Skip job IDs returned by earlier runs. |
| `includeDescriptions` | boolean | `false` | Include full cleaned descriptions. |
| `requestTimeoutSecs` | integer | `8` | Per-board timeout. |
| `maxConcurrency` | integer | `100` | Boards fetched in parallel; heavy providers have lower internal caps. |

Example:

```json
{
  "queries": ["AI Engineer", "Machine Learning"],
  "remoteOnly": true,
  "providers": ["greenhouse", "ashby", "lever"],
  "maxCompanies": 120,
  "maxJobs": 100,
  "onlyNewJobs": true
}
```

### Output

```json
{
  "id": "greenhouse:databricks:817251",
  "provider": "greenhouse",
  "company": "Databricks",
  "company_slug": "databricks",
  "title": "AI Engineer – Forward Deployed Engineering",
  "location": "United States",
  "remote_status": "unknown",
  "seniority": "unknown",
  "salary_min": null,
  "salary_max": null,
  "salary_currency": null,
  "salary_period": null,
  "department": "Engineering",
  "employment_type": null,
  "posted_at": "2026-11-19T10:00:00Z",
  "url": "https://databricks.com/company/careers/open-positions/job?gh_jid=817251",
  "description": null,
  "fetched_at": "2026-11-20T06:20:00+00:00"
}
```

Salary is annualized when the ATS publishes it: hourly × 2,080, monthly × 12, daily × 260. If no salary is published, the fields are `null` — never guessed.

### Pricing (pay per event)

| Event | Price | Charged when |
|---|---:|---|
| `apify-actor-start` | $0.05 / 1,000 runs | Synthetic start, automatic |
| `job-scraped` | **$2.50 / 1,000 jobs** | Per matching job written to the dataset |

**Unit economics:** 1,000 jobs × $0.0025 = $2.50. Apify keeps 20% → $2.00. Zero proxy cost; compute and data transfer are well under $0.02. **Net ≈ 79.5–80% of gross.**

### MCP / AI-agent use

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--actors",
        "structlabs/live-ats-jobs-api"
      ],
      "env": {
        "APIFY_TOKEN": "<your token>"
      }
    }
  }
}
```

### Limits and honest notes

- The seed has **4,129 live boards**; the default scan reads 300. Raise `maxCompanies` to widen coverage, and expect longer runs and more bandwidth. Heavy providers (Lever, Ashby, Workable, Recruitee) are capped per run to keep 300-board searches under 12 seconds.
- **Salary is only returned when the ATS publishes it.** Greenhouse often hides pay ranges behind job detail; Lever/Ashby/Recruitee expose structured ranges more often.
- `remote_status` is heuristic when the ATS has no explicit workplace field.
- **No proxies and no browser.** If an ATS changes its public endpoint, that provider returns nothing until patched.
- Respect each ATS's terms and applicable employment-data rules.

### Local test

```bash
apify run -i '{"queries":["AI Engineer"],"maxCompanies":40,"maxJobs":50}'
ACTOR_TEST_PAY_PER_EVENT=true apify run --input-file test_input_20.json
```

### Changelog

- **0.6** — Hardened the dataset write path: required fields are coerced to non-empty strings, records without an `id` or `title` are skipped and logged, optional fields are nullable, and a batch `schema-validation-error` now isolates only the invalid items instead of crashing the run.
- **0.5** — Workable multi-location dedupe with merged `locations[]` (one billed job), tech-first stratified seed tiers, 200-job run 10.2s, prefill 4.9s.
- **0.4** — 4,129 live validated boards, 300-board default with early stop, 8s board timeout, per-provider caps, orjson parsing, 20/20 gate, 300-board search 10.7–11.5s, prefill 4.9s.
- **0.1** — First release: 8 ATS adapters, 2,477-company seed, salary/remote/seniority normalization, KVS delta, per-job PPE.

### Pricing source

Canonical store-discount ladder (FREE/BRONZE/SILVER/GOLD/PLATINUM/DIAMOND) lives in `pricing.json`. Apify `actor.json` cannot carry pricing and `apify push` does not change account pricing; after any manual API change, the newest `pricingInfos` record must match `pricing.json`.

### n8n Workflow & MCP Quickstart

Run this Actor from an AI agent over MCP, or import the ready-made n8n workflow:

- n8n workflow, MCP config and quickstarts: https://github.com/structlabs-hq/live-ats-jobs-api-n8n-mcp
- MCP endpoint: https://mcp.apify.com/?actors=structlabs/live-ats-jobs-api

# Actor input Schema

## `queries` (type: `array`):

Match any query. Every word in a query must appear in the job title, description or department. Leave empty to return all jobs.

## `remoteOnly` (type: `boolean`):

Keep only jobs whose location or ATS metadata marks them as remote. Hybrid and onsite are excluded.

## `providers` (type: `array`):

Which ATS platforms to scan. The bundled seed has 4,129 live boards across all eight providers.

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

Optional company slugs such as stripe or openai. The provider is auto-detected across all eight ATS platforms. Leave empty to use the bundled 2,477-company seed.

## `maxCompanies` (type: `integer`):

Hard cap on ATS boards fetched. The seed is sorted by active job count, so the first 300 are high-volume boards. Raising this increases coverage and runtime.

## `maxJobs` (type: `integer`):

Stop after this many matching jobs. Each pushed job is one job-scraped event.

## `onlyNewJobs` (type: `boolean`):

Use a named key-value store to skip job IDs returned by earlier runs. Ideal for daily agent routines.

## `includeDescriptions` (type: `boolean`):

Include the full cleaned job description in each output item. Off by default to keep payloads small and fast.

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

Timeout per ATS board request. 8s keeps a 300-board scan under 12 seconds.

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

How many ATS boards are fetched in parallel. 100 is the default for 300-board coverage; Workable and Ashby have lower internal caps to avoid rate limits.

## `dedupeWorkableLocations` (type: `boolean`):

Group jobs by company + normalized title + department, merge locations, and bill once per role. Applies to all providers; Workable is the main source of clones.

## Actor input object example

```json
{
  "queries": [
    "AI Engineer"
  ],
  "remoteOnly": false,
  "providers": [
    "greenhouse",
    "ashby",
    "lever",
    "bamboohr"
  ],
  "maxCompanies": 60,
  "maxJobs": 50,
  "onlyNewJobs": false,
  "includeDescriptions": false,
  "requestTimeoutSecs": 8,
  "maxConcurrency": 100,
  "dedupeWorkableLocations": true
}
```

# Actor output Schema

## `results` (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 = {
    "queries": [
        "AI Engineer"
    ],
    "providers": [
        "greenhouse",
        "ashby",
        "lever",
        "bamboohr"
    ],
    "maxCompanies": 60,
    "maxJobs": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("structlabs/live-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 = {
    "queries": ["AI Engineer"],
    "providers": [
        "greenhouse",
        "ashby",
        "lever",
        "bamboohr",
    ],
    "maxCompanies": 60,
    "maxJobs": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("structlabs/live-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 '{
  "queries": [
    "AI Engineer"
  ],
  "providers": [
    "greenhouse",
    "ashby",
    "lever",
    "bamboohr"
  ],
  "maxCompanies": 60,
  "maxJobs": 50
}' |
apify call structlabs/live-ats-jobs-api --silent --output-dataset

```

## MCP server setup

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