# ATS Job Scraper: Extract Greenhouse, Lever & Ashby Jobs (`dev_web_col/ats-job-index`) Actor

Search live jobs across thousands of company career pages. Includes a pre-built company-to-ATS index, so you don't need to know which companies to query. Extract thousands of job postings directly from Greenhouse, Lever, Ashby, and Workable. Clean, fast, and structured JSON data. Try it for free!

- **URL**: https://apify.com/dev\_web\_col/ats-job-index.md
- **Developed by:** [Diseño Web de Colombia](https://apify.com/dev_web_col) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **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 returneds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## ATS Job Index — Greenhouse, Lever, Ashby & Workable Job Scraper

**Search live jobs across thousands of company career pages — without knowing which companies to query.**

Every other ATS scraper makes you bring your own list of company board tokens. If you already knew that Stripe is `greenhouse:stripe` and Ramp is `ashby:ramp`, you probably wouldn't need a scraper. This actor ships with a **pre-built, validated company-to-ATS index**, so you can just ask for "backend engineer, remote, posted this week" and get answers.

### Why this instead of LinkedIn or Indeed scrapers

These jobs come straight from the company's own applicant tracking system — the same feed that powers their careers page. That means:

- **Earlier.** Roles appear here before they are syndicated to job boards, and many never get syndicated at all.
- **Cleaner.** No recruiter spam, no duplicate reposts, no expired listings.
- **Legit.** Greenhouse, Lever, Ashby and Workable publish these as public JSON endpoints so companies can embed job boards on their own sites. No login walls, no anti-bot circumvention.
- **Salary data included** wherever the ATS publishes it.

### What you get

| Field | Description |
|---|---|
| `id` | Stable unique key: `ats:companyToken:externalId` |
| `ats` | `greenhouse` · `lever` · `ashby` · `workable` |
| `companyToken` | The company's board token |
| `companyName` | Company name |
| `externalId` | The job's ID in the source ATS |
| `title` | Job title |
| `department` | Department or team |
| `location` | Location as published |
| `isRemote` | Boolean, from the ATS flag plus location/title detection |
| `employmentType` | Full-time, contract, etc. (where published) |
| `compensationText` | Salary range as published, e.g. `$230K • Offers Equity` |
| `postedAt` | ISO 8601 publish date |
| `applyUrl` | Direct link to the job |
| `descriptionText` | Full description as plain text |

#### Example output

```json
{
  "id": "ashby:revenuecat:8f2c...",
  "ats": "ashby",
  "companyToken": "revenuecat",
  "companyName": "RevenueCat",
  "title": "Senior Backend Engineer",
  "department": "Engineering",
  "location": "Remote",
  "isRemote": true,
  "employmentType": "FullTime",
  "compensationText": "$230K • Offers Equity",
  "postedAt": "2026-07-14T09:12:44.000Z",
  "applyUrl": "https://jobs.ashbyhq.com/revenuecat/8f2c...",
  "descriptionText": "About RevenueCat\n\nWe help developers..."
}
```

### Try it first

`previewMode` is **on by default**: you get up to 20 real results with **no per-result charges** — you only pay the run start. Turn it off for a full run.

### Common uses

- **Job boards and job-search apps** that need fresh, structured inventory
- **Recruiters** tracking which companies are hiring for a niche, right now
- **Sales and GTM teams** using hiring activity as a buying signal
- **Market researchers and investors** tracking hiring velocity across a sector

### Speed

Querying 250 company boards returns roughly 7,400 jobs in **under 7 seconds**. There is no headless browser and no proxy layer — just public JSON endpoints — so runs are fast and cheap.

### Bring your own companies (optional)

Already know who you want? Pass `companyTokens` and the index is bypassed:

```json
{
  "companyTokens": [
    "greenhouse:stripe",
    "lever:ro",
    "ashby:ramp",
    "https://apply.workable.com/zego/"
  ]
}
```

Both `ats:token` and job board URLs are accepted.

### Known limits

Stated plainly, because they come from the source APIs and no scraper can work around them:

- Greenhouse's board API does not publish employment type or salary.
- Workable rate-limits aggressively, so it is queried slowly and covers fewer companies per run than the other three.
- `postedSince` excludes jobs with no publish date, since recency cannot be proven for them.

### Notes

Only public, unauthenticated job board endpoints are used — the ones each ATS provides for embedding careers pages. No personal data about recruiters or applicants is collected or returned.

# Actor input Schema

## `searchKeyword` (type: `string`):

Filter by job title, e.g. "backend engineer", "product designer", "account executive". Leave empty to get every job.

## `searchScope` (type: `string`):

Job title only is precise. Adding the description finds more, but also matches jobs that merely mention the keyword.

## `location` (type: `string`):

Free text match against the job location, e.g. "New York", "London", "Germany".

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

Keep only jobs the company flags as remote.

## `department` (type: `string`):

Free text match against the department or team, e.g. "Engineering", "Sales".

## `postedSince` (type: `integer`):

Only jobs published within this many days. Leave empty for no date limit. Jobs without a publish date are excluded when this is set.

## `atsPlatforms` (type: `array`):

Which applicant tracking systems to search. Leave empty to search all of them.

## `companyTokens` (type: `array`):

Only if you want specific companies instead of the built-in index. Accepts "greenhouse:stripe" or a job board URL like https://jobs.lever.co/ro

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

Higher means broader coverage and a slower run. Companies with the most open roles are queried first.

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

Caps how many jobs land in the dataset. You are charged per job returned.

## `previewMode` (type: `boolean`):

ON by default so you can try the actor for the price of a single run start. No per-result charges apply. Turn it OFF for a full run.

## Actor input object example

```json
{
  "searchKeyword": "backend engineer",
  "searchScope": "title",
  "remoteOnly": false,
  "postedSince": 7,
  "atsPlatforms": [],
  "companyTokens": [
    "greenhouse:stripe",
    "lever:ro",
    "ashby:ramp"
  ],
  "maxCompanies": 200,
  "maxResults": 1000,
  "previewMode": true
}
```

# Actor output Schema

## `jobs` (type: `string`):

Every matching job posting, one dataset item per job, in the unified schema.

# 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 = {
    "searchKeyword": "backend engineer",
    "postedSince": 7,
    "companyTokens": [
        "greenhouse:stripe",
        "lever:ro",
        "ashby:ramp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dev_web_col/ats-job-index").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 = {
    "searchKeyword": "backend engineer",
    "postedSince": 7,
    "companyTokens": [
        "greenhouse:stripe",
        "lever:ro",
        "ashby:ramp",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("dev_web_col/ats-job-index").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 '{
  "searchKeyword": "backend engineer",
  "postedSince": 7,
  "companyTokens": [
    "greenhouse:stripe",
    "lever:ro",
    "ashby:ramp"
  ]
}' |
apify call dev_web_col/ats-job-index --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/ARUdrOW2LMBfpLdXE/builds/bdukyAYPg7ljOxF43/openapi.json