# ATS Job Board Scraper (Greenhouse, Lever, Ashby) (`sheshinmcfly/ats-job-board-scraper`) Actor

Extract open job postings from any companys Greenhouse, Lever, or Ashby career page in one unified format: title, department, location, remote status, and clean plain-text description (no raw HTML). No login or API key needed, ideal for sourcing and AI agents.

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

## Pricing

from $0.80 / 1,000 job postings

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

## ATS Job Board Scraper (Greenhouse, Lever, Ashby)

Extract every open job posting from any company's **Greenhouse**, **Lever**, or **Ashby** career page — in one unified schema, with clean plain-text descriptions instead of raw HTML. No login, no API key, no subscription required.

### What data do you get?

| Field | Type | Example |
|---|---|---|
| source, company | string | `greenhouse`, `stripe` |
| jobId, title | string | unique job ID + title |
| department, team | string | e.g. `Sales`, `Engineering` |
| location, allLocations | string, array | office(s) the role is based in |
| remote, employmentType | boolean, string | remote-eligible, full-time/contract |
| **descriptionText** | string | clean plain text — HTML tags and entities already stripped |
| postedAt, updatedAt | string | posting timeline |
| jobUrl, applyUrl | string | link to apply |

14 fields per job posting, unified across all three ATS platforms.

### How to use

1. Open the actor and enter one or more `{ "ats": "...", "company": "..." }` pairs — the company slug is the part of the career-page URL after `/boards.greenhouse.io/`, `/jobs.lever.co/`, or `/jobs.ashbyhq.com/`
2. Click **Start**
3. Download results as JSON, CSV, or Excel

### Use cases

- **Sourcing & recruiting**: monitor which companies are hiring for specific roles
- **Market research**: track headcount growth and hiring trends by department across competitors
- **Job board aggregation**: build a niche job board by pulling listings from multiple companies into one feed
- **Sales intelligence**: hiring signals (e.g. "hiring their first AE") as a prospecting trigger
- **Compensation research**: extract salary ranges mentioned in job descriptions at scale

### Input parameters

```json
{
  "companies": [
    { "ats": "greenhouse", "company": "stripe" },
    { "ats": "lever", "company": "ro" },
    { "ats": "ashby", "company": "ramp" }
  ]
}
````

| Parameter | Type | Required | Description |
|---|---|---|---|
| `companies` | array of objects | Yes | `{ "ats": "greenhouse"\|"lever"\|"ashby", "company": "slug" }` pairs. |
| `proxyConfiguration` | object | No | Optional — the actor works reliably without a proxy in most cases. |

### Example output (JSON)

```json
{
  "source": "greenhouse",
  "company": "stripe",
  "jobId": "7954688",
  "title": "Account Executive, AI Sales",
  "department": "AI GTM Strategy & Solutions",
  "location": "San Francisco, CA",
  "allLocations": ["US"],
  "remote": null,
  "employmentType": null,
  "descriptionText": "Who we are\n\nAbout Stripe\n\nStripe is a financial infrastructure platform...",
  "postedAt": "2026-06-02T08:58:57-04:00",
  "jobUrl": "https://stripe.com/jobs/search?gh_jid=7954688",
  "applyUrl": "https://stripe.com/jobs/search?gh_jid=7954688",
  "extractedAt": "2026-07-09T22:00:00.000Z"
}
```

### Performance

Returns results in a few seconds per company — each platform is queried via its own public job-board API, no browser required.

### Pricing

Pay-per-event: **$0.80 per 1,000 results** ($0.0008 per job posting). Every Apify account gets $5 in free usage per month, enough to try this actor at no cost.

### Related actors

- **[Congressional Stock Trades Scraper](https://apify.com/sheshinmcfly/congress-stock-trades-scraper)** — every House member stock trade disclosed under the STOCK Act.
- **[FMCSA Carrier Intelligence](https://apify.com/sheshinmcfly/fmcsa-carrier-intelligence)** — verify US trucking carriers by DOT number.

### FAQ

**Which ATS platforms are supported?**
Greenhouse, Lever, and Ashby — the three most common modern applicant tracking systems with public job-board APIs.

**How do I find a company's slug?**
It's the part of the career-page URL right after the platform domain — e.g. `stripe` in `boards.greenhouse.io/stripe`, `ro` in `jobs.lever.co/ro`, `ramp` in `jobs.ashbyhq.com/ramp`.

**What if a company doesn't use any of these platforms (e.g. Workday)?**
It won't return results — only Greenhouse, Lever, and Ashby career pages are supported in this version.

**How current is the data?**
Each run queries the company's live job board directly, so results reflect whatever is posted at run time.

### Keywords

job board scraper, greenhouse api, lever api, ashby api, ATS scraper, job postings, recruiting data, hiring signals, sourcing tool, applicant tracking system

### Legal Disclaimer

This actor extracts publicly available job posting data from company career pages. Users are solely responsible for ensuring their use of this data complies with applicable laws and each platform's terms of service.

### Changelog

- **v1.0 (2026-07-09)** — Initial release: Greenhouse, Lever, and Ashby support, unified schema, clean plain-text descriptions, no login required.

# Actor input Schema

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

List of {ats, company} pairs. "ats" is one of greenhouse, lever, ashby. "company" is the career-page slug (e.g. the "stripe" in boards.greenhouse.io/stripe).

## `proxyConfiguration` (type: `object`):

Optional — the actor works reliably without a proxy in most cases.

## Actor input object example

```json
{
  "companies": [
    {
      "ats": "greenhouse",
      "company": "stripe"
    },
    {
      "ats": "lever",
      "company": "ro"
    },
    {
      "ats": "ashby",
      "company": "ramp"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

All extracted job postings stored in the default dataset.

# 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": [
        {
            "ats": "greenhouse",
            "company": "stripe"
        },
        {
            "ats": "lever",
            "company": "ro"
        },
        {
            "ats": "ashby",
            "company": "ramp"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sheshinmcfly/ats-job-board-scraper").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": [
        {
            "ats": "greenhouse",
            "company": "stripe",
        },
        {
            "ats": "lever",
            "company": "ro",
        },
        {
            "ats": "ashby",
            "company": "ramp",
        },
    ] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ATS Job Board Scraper (Greenhouse, Lever, Ashby)",
        "description": "Extract open job postings from any companys Greenhouse, Lever, or Ashby career page in one unified format: title, department, location, remote status, and clean plain-text description (no raw HTML). No login or API key needed, ideal for sourcing and AI agents.",
        "version": "0.1",
        "x-build-id": "u1WpRDLeafHZy7FiE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sheshinmcfly~ats-job-board-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sheshinmcfly-ats-job-board-scraper",
                "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/sheshinmcfly~ats-job-board-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sheshinmcfly-ats-job-board-scraper",
                "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/sheshinmcfly~ats-job-board-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sheshinmcfly-ats-job-board-scraper",
                "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": "List of {ats, company} pairs. \"ats\" is one of greenhouse, lever, ashby. \"company\" is the career-page slug (e.g. the \"stripe\" in boards.greenhouse.io/stripe)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional — the actor works reliably without a proxy in most cases.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
