# Job Postings API · Live, All ATS · Greenhouse, Lever, Ashby +3 (`samikok/job-postings-api-all-ats`) Actor

Live job postings from any company as clean JSON — fetched directly from the ATS, zero lag.

- **URL**: https://apify.com/samikok/job-postings-api-all-ats.md
- **Developed by:** [Samuel Elsner](https://apify.com/samikok) (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.20 / 1,000 job results

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/platform/actors/running/actors-in-store#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

## Job Postings API — Greenhouse, Lever, Ashby, Workable & more

**Get every job posting from any company as clean, unified JSON — live from the
ATS, just paste the company's domain.** The actor auto-detects which ATS
(applicant tracking system) each company uses, pulls all open postings directly
from the official public job-board API at run time — no stale database, zero
lag — and returns them in one consistent schema. Turn on **monitor mode** and
schedule it daily to receive only *new* postings — a live hiring-signal feed.

### Why this actor

- ⚡ **Live, not a database** — every run fetches straight from the ATS API the
  moment you call it. Job databases refresh on a lag of hours; a posting that
  went up five minutes ago is already in your results here.
- 🔎 **Auto-detect** — input `stripe.com`, a careers URL, a board slug, or a
  company name. No need to know whether they use Greenhouse or Lever.
- 🧩 **One schema for 6 ATS providers** — Greenhouse, Lever, Ashby, Workable,
  Recruitee, SmartRecruiters. Every job has the same fields; no per-provider
  parsing on your side.
- 📡 **Monitor mode** — each scheduled run returns only postings never seen
  before. Perfect for sales triggers ("company X is hiring SDRs → they're
  scaling sales"), recruiting intel, and job boards.
- 🛡️ **No scraping brittleness** — data comes from the vendors' official,
  public, documented job-board APIs. No headless browsers, no anti-bot
  cat-and-mouse, no broken runs after a site redesign.
- 🎯 **Filters** — remote-only, title contains/excludes, location, department.

### See it in action

Three domains in, 1,457 live jobs out — in 4 seconds:

![Run succeeded: 1,457 jobs from 3 companies in 4 seconds](https://raw.githubusercontent.com/Semjuel19/apify-listing-assets/main/store-1-run-success.jpg)

Just paste domains — auto-detect does the rest:

![Input form: bare domains plus monitor mode and filters](https://raw.githubusercontent.com/Semjuel19/apify-listing-assets/main/store-3-input-form.jpg)

One clean, unified schema across all ATS providers:

![Dataset preview: unified job schema](https://raw.githubusercontent.com/Semjuel19/apify-listing-assets/main/store-2-dataset-preview.jpg)

### Use cases

| Who | How |
| --- | --- |
| **Sales / lead gen** | Hiring is buying intent. Monitor your target accounts daily; route new postings that match your trigger words to your CRM. |
| **Recruiters & sourcing** | Track competitor hiring, spot which teams are growing, feed your talent CRM. |
| **Job boards & aggregators** | Pull structured postings (title, location, remote, salary when published, apply URL) for hundreds of companies without maintaining scrapers. |
| **Market research** | Headcount-growth signals by company, department, and geography over time. |
| **AI agents** | Call this actor via Apify's MCP server to give any agent live jobs data. |

### Input

```json
{
  "companies": ["stripe.com", "figma.com", "openai.com", "https://jobs.lever.co/plaid"],
  "monitorMode": true,
  "remoteOnly": false,
  "titleIncludes": ["engineer", "developer"]
}
```

`companies` accepts domains, careers-page URLs, board slugs, company names, or
explicit `{"provider": "greenhouse", "slug": "stripe"}` objects.

### Output (unified schema — every field always present)

```json
{
  "id": "5364702004",
  "key": "greenhouse:figma:5364702004",
  "provider": "greenhouse",
  "company": { "slug": "figma", "name": null, "domain": "figma.com" },
  "title": "Account Executive, Emerging Enterprise",
  "url": "https://boards.greenhouse.io/figma/jobs/5364702004",
  "applyUrl": "https://boards.greenhouse.io/figma/jobs/5364702004",
  "location": { "raw": "Berlin, Germany", "city": "Berlin", "country": "Germany", "remote": false },
  "department": "Sales",
  "team": null,
  "employmentType": null,
  "salary": { "min": null, "max": null, "currency": null, "interval": null, "raw": null },
  "postedAt": "2024-11-01T10:05:10.000Z",
  "updatedAt": "2026-06-20T12:00:00.000Z",
  "descriptionText": "Figma is looking for…"
}
```

Salary is populated when the company publishes it (Lever structured ranges,
Ashby compensation summaries). SmartRecruiters descriptions require one extra
API call per posting — the actor does this automatically when
`includeDescription` is on; turn it off for faster, cheaper runs.

### Monitor mode

With `monitorMode: true` the actor remembers every job it has delivered (in its
key-value store) and emits **only new postings** on each run. Schedule it daily
against your account list and connect the dataset to Zapier/Make/webhooks —
that's a hiring-signal pipeline in two clicks. First run delivers the full
current board (your baseline); subsequent runs deliver only the delta.

### Supported providers

| Provider | Detection | Source |
| --- | --- | --- |
| Greenhouse | ✅ auto | official public boards API |
| Lever | ✅ auto | official public postings API |
| Ashby | ✅ auto | official public posting API |
| Workable | ✅ auto | official public widget API |
| Recruitee | ✅ auto | official public offers API |
| SmartRecruiters | ✅ auto | official public postings API |

More providers (Teamtailor, Personio, BambooHR) are on the roadmap — tell us
which one you need in the Issues tab.

### Pricing & fairness notes

Pay-per-event: a small per-run start fee plus a per-job-result fee. Use
`titleIncludes`/`remoteOnly` filters and `includeDescription: false` to keep
result counts (and your cost) down. If a company can't be resolved to any ATS,
you are not charged for it.

### FAQ

**Is this legal?** The actor reads the same public, unauthenticated job-board
APIs each ATS vendor provides precisely so postings can be embedded and read.
No logins, no personal data, no rate-limit evasion.

**A company isn't detected.** Some companies use an ATS we don't support yet, a
custom careers site, or a non-standard board slug. Pass an explicit careers URL
(e.g. `https://boards.greenhouse.io/theirslug`) — or open an issue and we'll
add detection.

**How fresh is the data?** Live — every run hits the ATS APIs directly.

# Actor input Schema

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

Companies to fetch jobs from. Accepts <b>anything</b>: a domain (<code>stripe.com</code>), a careers URL (<code>https://jobs.lever.co/netflix</code>), a board slug (<code>openai</code>), or a company name. The actor auto-detects which ATS each company uses.

## `monitorMode` (type: `boolean`):

When enabled, each run returns only postings not seen in previous runs — schedule this actor daily to get a feed of fresh job postings (hiring signals).

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

Optional allow-list. Leave empty to detect across all supported providers.

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

Keep only postings detected as remote.

## `titleIncludes` (type: `array`):

Keep postings whose title contains ANY of these (case-insensitive), e.g. <code>engineer</code>, <code>sales</code>.

## `titleExcludes` (type: `array`):

Drop postings whose title contains ANY of these (case-insensitive).

## `locationIncludes` (type: `array`):

Keep postings whose location contains ANY of these (case-insensitive), e.g. <code>berlin</code>, <code>united states</code>.

## `departmentIncludes` (type: `array`):

Keep postings whose department or team contains ANY of these (case-insensitive).

## `monitorId` (type: `string`):

Only relevant with monitor mode. Runs sharing the same ID share one "already seen" memory. Use different IDs to run independent monitoring feeds (e.g. <code>sales-accounts</code> and <code>competitors</code>).

## `includeDescription` (type: `boolean`):

Include the plain-text job description (truncated to 5,000 chars). Disable for smaller, cheaper datasets.

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

Safety cap per company.

## Actor input object example

```json
{
  "companies": [
    "stripe.com",
    "figma.com",
    "openai.com"
  ],
  "monitorMode": false,
  "remoteOnly": false,
  "monitorId": "default",
  "includeDescription": true,
  "maxJobsPerCompany": 2000
}
```

# Actor output Schema

## `jobs` (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 = {
    "companies": [
        "stripe.com",
        "figma.com",
        "openai.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("samikok/job-postings-api-all-ats").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 = { "companies": [
        "stripe.com",
        "figma.com",
        "openai.com",
    ] }

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/zkR4ZI2IvHHe1l0ZZ/builds/6e5VyrTcyjniBuj5p/openapi.json