# Job Postings API — Greenhouse, Lever & Ashby in one (`esco.api/ats-job-postings`) Actor

Pull live job postings for any list of companies from Greenhouse, Lever, and Ashby public job boards — one normalized schema, salary data where published, and a new-only mode so scheduled runs return (and charge for) only new postings.

- **URL**: https://apify.com/esco.api/ats-job-postings.md
- **Developed by:** [Francesco Freedman](https://apify.com/esco.api) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Job Postings API — Greenhouse, Lever & Ashby in one

Pull **live job postings for any list of companies** across the three most popular tech ATS platforms — Greenhouse, Lever, and Ashby — in one run, with one normalized schema. Salary data where published, remote flags, full descriptions, and a **new-only mode** that makes scheduled runs return (and charge for) *only postings you haven't seen before*.

### Why this actor

- **Three ATS platforms, one schema.** Stop juggling separate scrapers — mix `greenhouse:stripe`, `https://jobs.lever.co/palantir`, and `ashby:openai` in one input. Same columns out, whatever the source.
- **Auto-detection.** Don't know which ATS a company uses? Just give the bare slug (`duolingo`, `notion`) — the actor probes all three platforms and finds the board.
- **Official public APIs, not scraping.** Greenhouse, Lever, and Ashby publish these job-board APIs for public consumption — fast, stable, no proxies, no breakage when a careers page is redesigned.
- **You only pay for new postings.** With `newOnly` (default), a daily scheduled run returns just the jobs posted since your last run. Perfect for job alerts, talent-market tracking, and hiring-signal lead generation.
- **Salary data where it exists.** Structured min/max/currency/interval from Lever, published ranges from Ashby (`$185K – $325K`), plus remote flags and employment type.

### Output example

```json
{
    "platform": "ashby",
    "company": "openai",
    "title": "Forward Deployed Software Engineer - SF",
    "department": "Model Deployment for Business",
    "location": "San Francisco",
    "remote": true,
    "salary_text": "$185K - $325K",
    "posted_at": "2025-11-15T01:25:39.198Z",
    "url": "https://jobs.ashbyhq.com/openai/00207abc-...",
    "description_text": "..."
}
````

### Who uses this

- **Recruiters & sourcers** — track competitor and client hiring across hundreds of companies daily.
- **Sales teams** — hiring is the strongest budget signal there is: a company adding SDRs is buying sales tools; one hiring DevOps is buying infrastructure.
- **Job boards & aggregators** — clean, normalized feed for your niche board (remote-only, AI companies, fintech…).
- **Job seekers & career coaches** — daily alerts on new roles at target companies, before they hit LinkedIn.
- **Analysts & researchers** — headcount growth, salary benchmarking, team-structure signals.

### Inputs

| Field | Default | Notes |
|---|---|---|
| `companies` | demo list | Careers URLs, `platform:slug` pairs, or bare slugs (auto-detected) |
| `newOnly` | `true` | Skip postings delivered by previous runs |
| `postedSinceDays` | `0` (all open roles) | e.g. `7` = only jobs first published in the last week |
| `includeDescription` | `true` | Disable for lighter rows |
| `maxResults` | `0` (no cap) | Handy for test runs |

### Recommended setup: daily hiring feed

1. Create a **Schedule** in Apify Console (daily).
2. Input: your company list, `newOnly: true`.
3. Add an integration (email, Slack, webhook, Google Sheets, Make/Zapier) — every morning you get only the new postings.

First run returns each company's full board (that's your baseline); every run after that returns only what's new.

### Notes & limits

- Boards that don't exist (or companies not on these three platforms) are skipped with a warning — the run continues and the status message lists any failures.
- Greenhouse does not expose salary via its public board API; salary fields are null there.
- More ATS platforms (SmartRecruiters, Workable, Recruitee…) are added by demand — **open an issue and tell me which one you need**.

### Data & fair-use notes

Job postings are published by companies specifically for public distribution, via APIs the ATS vendors provide for that purpose. The actor queries them politely (paced, identified) and stores no personal data.

# Actor input Schema

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

Companies to pull job boards for. Accepts: a careers-page URL (https://boards.greenhouse.io/stripe, https://jobs.lever.co/palantir, https://jobs.ashbyhq.com/openai), an explicit platform prefix (greenhouse:stripe, lever:palantir, ashby:openai), or a bare slug (stripe) which is auto-detected across all three platforms.

## `postedSinceDays` (type: `integer`):

0 = all currently open postings (default). Set e.g. 7 to only get jobs first published within the last week.

## `newOnly` (type: `boolean`):

When enabled, postings already returned by previous runs of this actor are skipped — a scheduled run only yields (and only charges for) job postings you haven't seen before. Perfect for daily new-job alerts and hiring-signal tracking.

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

Disable for lighter rows (titles, locations, salaries, URLs only).

## `maxResults` (type: `integer`):

Hard cap on total results across all companies (0 = no cap). Useful for test runs.

## Actor input object example

```json
{
  "companies": [
    "greenhouse:stripe",
    "lever:palantir",
    "ashby:openai"
  ],
  "postedSinceDays": 0,
  "newOnly": true,
  "includeDescription": true,
  "maxResults": 0
}
```

# 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": [
        "greenhouse:stripe",
        "lever:palantir",
        "ashby:openai"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("esco.api/ats-job-postings").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": [
        "greenhouse:stripe",
        "lever:palantir",
        "ashby:openai",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("esco.api/ats-job-postings").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": [
    "greenhouse:stripe",
    "lever:palantir",
    "ashby:openai"
  ]
}' |
apify call esco.api/ats-job-postings --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Job Postings API — Greenhouse, Lever & Ashby in one",
        "description": "Pull live job postings for any list of companies from Greenhouse, Lever, and Ashby public job boards — one normalized schema, salary data where published, and a new-only mode so scheduled runs return (and charge for) only new postings.",
        "version": "0.1",
        "x-build-id": "UQbeckKaOA4G9ZImm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/esco.api~ats-job-postings/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-esco.api-ats-job-postings",
                "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/esco.api~ats-job-postings/runs": {
            "post": {
                "operationId": "runs-sync-esco.api-ats-job-postings",
                "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/esco.api~ats-job-postings/run-sync": {
            "post": {
                "operationId": "run-sync-esco.api-ats-job-postings",
                "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",
                        "type": "array",
                        "description": "Companies to pull job boards for. Accepts: a careers-page URL (https://boards.greenhouse.io/stripe, https://jobs.lever.co/palantir, https://jobs.ashbyhq.com/openai), an explicit platform prefix (greenhouse:stripe, lever:palantir, ashby:openai), or a bare slug (stripe) which is auto-detected across all three platforms.",
                        "default": [
                            "greenhouse:stripe",
                            "lever:palantir",
                            "ashby:openai"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "postedSinceDays": {
                        "title": "Only jobs posted in the last N days",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "0 = all currently open postings (default). Set e.g. 7 to only get jobs first published within the last week.",
                        "default": 0
                    },
                    "newOnly": {
                        "title": "New results only (dedupe across runs)",
                        "type": "boolean",
                        "description": "When enabled, postings already returned by previous runs of this actor are skipped — a scheduled run only yields (and only charges for) job postings you haven't seen before. Perfect for daily new-job alerts and hiring-signal tracking.",
                        "default": true
                    },
                    "includeDescription": {
                        "title": "Include full job description text",
                        "type": "boolean",
                        "description": "Disable for lighter rows (titles, locations, salaries, URLs only).",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total results across all companies (0 = no cap). Useful for test runs.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
