# Greenhouse Jobs Scraper · All Postings From Any Company Board (`reapx/greenhouse-jobs-scraper`) Actor

Greenhouse Jobs Scraper extracts live job postings from any company using Greenhouse ATS (Stripe, Airbnb, Figma, Anthropic, GitLab). Scrape job titles, departments, locations, remote flags, salaries, descriptions, and apply URLs into clean JSON.

- **URL**: https://apify.com/reapx/greenhouse-jobs-scraper.md
- **Developed by:** [Tarek Etman](https://apify.com/reapx) (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

from $2.00 / 1,000 job posting returneds

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

![reapX — public sources in, addressable records out](https://reapx.dev/reapx.gif)

## Greenhouse Jobs Scraper · All Postings From Any Company Board

Greenhouse Jobs Scraper is a fast, HTTP-only Greenhouse jobs scraper and API that collects live job listings from any Greenhouse ATS company career page (Stripe, Anthropic, Figma, Airbnb, GitLab). Scrape job postings, titles, departments, locations, remote flags, seniority levels, salary data, full descriptions, and direct apply URLs for tech hiring market intelligence, job boards, recruitment analytics, and AI agents.

> Maintained by **reapX**. Every row cites the Apify run that produced it — nothing is
> inferred, modelled or filled in, and a field absent from the source is absent from the row.
> The extracted archive for this source is browsable at
> [reapx.dev/data/greenhouse-jobs-scraper/](https://reapx.dev/data/greenhouse-jobs-scraper/) and mirrored as an open dataset on
> [Hugging Face](https://huggingface.co/datasets/reapxdev/greenhouse-jobs-scraper) and
> [Kaggle](https://www.kaggle.com/datasets/reapxdev/greenhouse-jobs-scraper). Questions: reapxdev@proton.me

### Greenhouse Jobs Scraper output data

One row per public job posting, with these fields:

| Field | What it is |
|---|---|
| `title`, `company`, `boardToken` | The role and who is hiring |
| `department`, `departments`, `departmentPath`, `topLevelDepartment` | The team, plus its full parent chain from the board's own department tree |
| `location`, `locations`, `offices` | Location text as written, split into places, and Greenhouse office names |
| `workplaceType`, `isRemote` | Remote, hybrid or onsite |
| `seniorityLevel` | Internship, entry, mid, senior, staff, principal, director or executive |
| `employmentType` | Full time, part time, contract, internship, temporary |
| `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | The advertised pay range, parsed into numbers |
| `postedAt`, `postedDaysAgo`, `updatedAt`, `updatedDaysAgo` | When the posting went live and when it was last edited |
| `jobUrl`, `greenhouseUrl`, `applyUrl`, `boardUrl` | Canonical link, Greenhouse link, direct application link, full board |
| `descriptionText`, `descriptionHtml`, `descriptionChars` | The full job description as text and as HTML |
| `requisitionId`, `internalJobId`, `customFields` | The company's own requisition number and any public metadata fields |

### How to find a Greenhouse board token

The board token is the last part of a company's Greenhouse board URL. In `https://job-boards.greenhouse.io/stripe` the token is `stripe`. You can paste either form into **Greenhouse company boards** - full URLs, `boards.greenhouse.io` links, embedded board links and bare tokens all work.

### Scrape jobs from multiple companies at once

Put up to 200 board tokens in one run and the results arrive in a single dataset, sorted together. This is the fastest way to build a job feed across a cohort - a portfolio, a competitor set, an industry - because Greenhouse hosts the boards of a large share of venture-backed companies.

### Filter Greenhouse jobs by department, location and seniority

Every filter is optional and they combine with AND, while the values inside one filter combine with OR:

- **Job title must contain / must NOT contain** - keyword include and exclude lists
- **Department contains** - matched against the team name *and* every parent department above it, so `engineering` still finds a role a company filed under an internal team code
- **Location contains** - matched against the posting location and the office names
- **Description contains** - full-text search inside the job description, for finding roles that mention a specific technology
- **Seniority level** and **Employment type**
- **Remote jobs only** and **Only jobs with an advertised salary**
- **Posted within the last N days** and **Updated within the last N days**

### Get job postings with salary data

Greenhouse boards do not have a salary field, so pay ranges live inside the description text. This scraper reads them out and parses them into `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod`, keeping deal sizes, sales quotas and product prices out of those columns. Turn on **Only jobs with an advertised salary** to get compensation rows only.

### Track new job postings over time

Set **Posted within the last N days** to `7` and schedule the run weekly to get only what is newly live. `postedAt` and `updatedAt` come from the board itself, so a role that was reposted or edited is visible as such.

### Input configuration

Every field is optional. The prefilled values below are what runs if you press Start without changing anything.

#### Settings

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `boards` | list | one value per line | One entry per company. Paste the board token (the last part of the board URL, e.g. "stripe") or the full board URL, e.g. "https://job-boards.greenhouse.io/stripe". Example: stripe, anthropic, figma. Leave empty to run the three sample boards. Prefilled with `["stripe", "anthropic", "figma"]`. |

#### Filters

Every filter is optional. Filters combine with AND; the values inside one filter combine with OR.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `titleKeywords` | list | one value per line | Case-insensitive. A posting is kept when its title contains at least one of these. Example: engineer, developer. |
| `excludeTitleKeywords` | list | one value per line | Case-insensitive. Drops postings whose title contains any of these. Example: intern, contract. |
| `departmentKeywords` | list | one value per line | Matched against the posting's team name and every parent department above it, so "engineering" still finds a role filed under an internal team code. Example: engineering, data. |
| `locationKeywords` | list | one value per line | Matched against the posting location and office names. Example: San Francisco, New York, London. |
| `descriptionKeywords` | list | one value per line | Full-text search inside the job description. Example: Rust, Kubernetes, Series B. |
| `seniorityLevels` | list | one value per line | Seniority is read from the job title. Titles with no seniority marker count as mid. Example: senior, staff. |
| `employmentTypes` | list | one value per line | Read from the board's own employment-type field when it publishes one, otherwise from the title. Example: fullTime. |
| `remoteOnly` | true/false | checkbox | Keep only postings whose location, title or board field says remote. Example: true. |
| `withSalaryOnly` | true/false | checkbox | Keep only postings that publish a pay range in the description. Example: true. |
| `postedWithinDays` | integer | 1 to 3650 | Uses the date the posting first went live. Example: 7 for the past week. |
| `updatedWithinDays` | integer | 1 to 3650 | Uses the date the posting was last edited on the board. Example: 30. |

#### Output

What each row contains, how the rows are ordered, and how many you get.

| Field | Type | Accepts | What it does |
| --- | --- | --- | --- |
| `includeDescription` | true/false | checkbox | Adds descriptionText to every row. Turn it off for a slim listing feed. Example: true. |
| `includeDescriptionHtml` | true/false | checkbox | Adds descriptionHtml with the original formatting. Example: false. |
| `sortBy` | string | one of 5: `newest`, `oldest`, `company`, `title`, ... | Applied across all boards before the Max jobs cut-off. Example: newest. |
| `maxItems` | integer | 1 to 50000 | Total rows returned across every board. You are charged per row returned. Example: 200. |
| `maxItemsPerBoard` | integer | 1 to 50000 | Stops one very large board from using up the whole budget. Leave empty for no per-board limit. Example: 25. |

### Pricing

Pay per event. The primary event is **Job posting returned** (`job-posting`), charged at **$0.003 per event** on the free plan, falling to $0.0012 on the highest tier.

One public job posting delivered as a complete row: title, company, department path, location, seniority, advertised salary, full description and apply URL. Boards that are unreachable, empty or that match no filter are never charged.

Other charged events: `apify-actor-start` (Actor Start).

Minimum charge cap per run: $0.005.

Tiered discounts apply automatically on every paid Apify plan. Platform usage is absorbed by the Actor, so the per-event price is the whole price.

### Usage examples

#### The prefilled run, which is what Start does with nothing changed

```json
{
  "boards": [
    "stripe",
    "anthropic",
    "figma"
  ],
  "remoteOnly": false,
  "withSalaryOnly": false,
  "includeDescription": true,
  "includeDescriptionHtml": false,
  "sortBy": "newest",
  "maxItems": 200
}
```

#### A larger run, with the record cap as the cost cap

```json
{
  "boards": [
    "stripe",
    "anthropic",
    "figma"
  ],
  "remoteOnly": false,
  "withSalaryOnly": false,
  "includeDescription": true,
  "includeDescriptionHtml": false,
  "sortBy": "newest",
  "maxItems": 5000
}
```

### Output example

One row, exactly as the actor wrote it to the dataset:

```json
{
  "jobId": "7823417003",
  "title": "AI Engineer, Intern",
  "company": "Postman",
  "boardToken": "postman",
  "department": "AI",
  "departments": [
    "AI"
  ],
  "departmentPath": [
    "ALL DEPARTMENTS",
    "ENGINEERING.",
    "AI"
  ],
  "topLevelDepartment": "ALL DEPARTMENTS",
  "location": "Berkeley, California, United States",
  "locations": [
    "Berkeley, California, United States"
  ],
  "offices": [
    "Berkeley, California"
  ],
  "workplaceType": null,
  "isRemote": false,
  "seniorityLevel": "internship",
  "employmentType": "internship",
  "salaryText": null,
  "salaryMin": null,
  "salaryMax": null
}
```

That row carries 34 fields in total; 18 are shown.

#### Fields on every row

| Field | Type | What it is |
| --- | --- | --- |
| `jobId` | string | Greenhouse job posting ID. Unique inside one company board and stable across runs. |
| `title` | string | Job title exactly as the company published it. |
| `company` | string | Hiring company name as it appears on the Greenhouse board. |
| `boardToken` | string | Greenhouse board token the posting came from; the last part of the board URL. |
| `department` | string | First department the company filed the posting under. Null when the board publishes none. |
| `departments` | list | Every department name the company attached to the posting, exactly as filed on the board. |
| `departmentPath` | list | The posting's department resolved to its full root-to-leaf chain from the board's department tree. Companies often file roles under an internal code, and this is what turns that code into a readable org path. |
| `topLevelDepartment` | string | First entry of the department path: the org the role rolls up to. Use this to group postings across companies that name their sub-teams differently. |
| `location` | string | Location text as written on the posting, which may list several places in one string. |
| `locations` | list | The location text split into separate places. |
| `offices` | list | Greenhouse office names attached to the posting, such as a region or a named office. |
| `workplaceType` | string | Remote, hybrid or onsite, read from the board's own field when it has one, otherwise from the location and title. Null when the posting gives no signal. |
| `isRemote` | true/false | True when the posting is remote. |
| `seniorityLevel` | string | Seniority band inferred from the job title. Titles carrying no seniority marker are reported as mid. |
| `employmentType` | string | Employment type from the board's own field when published, otherwise inferred from the title. Null when neither says. |
| `salaryText` | string | The pay range exactly as written in the description. Null when the posting advertises no pay. |
| `salaryMin` | number | Lower bound of the advertised pay range as a number. |
| `salaryMax` | number | Upper bound of the advertised pay range as a number. Null when only one figure is published. |
| `salaryCurrency` | string | ISO currency code of the advertised pay. |
| `salaryPeriod` | string | The period the advertised pay covers. |
| `postedAt` | string | ISO 8601 timestamp of when the posting first went live on the board. |
| `postedDaysAgo` | integer | Whole days between the first publish date and this run. |
| `updatedAt` | string | ISO 8601 timestamp of the last edit the company made to the posting. |
| `updatedDaysAgo` | integer | Whole days between the last edit and this run. |
| `requisitionId` | string | The company's internal requisition number for the role, when it publishes one. |
| `internalJobId` | string | Greenhouse internal job ID. Several postings of the same role share it. |
| `jobUrl` | string | Canonical posting URL, which is the company's own careers page when it hosts the board. |
| `greenhouseUrl` | string | The posting on Greenhouse's own job board host. |
| `applyUrl` | string | Direct link to the application form for this posting. |
| `boardUrl` | string | The company's full Greenhouse job board. |
| `descriptionText` | string | Full job description as plain text. Present when Include the full job description is on. |
| `descriptionHtml` | string | Full job description as HTML. Present when Include the job description as HTML is on. |
| `descriptionChars` | integer | Character count of the plain-text description, useful for spotting thin postings. |
| `customFields` | object | The board's own public metadata fields, name to value. Empty when the company publishes none. |
| `scrapedAt` | string | ISO 8601 timestamp of when this row was collected. |

4 named dataset views ship with it: **Job postings**, **Advertised pay**, **Hiring by team**, **Newest openings**. They drive the Output tab in Console and the Output block on the Actor's `.md` page.

### FAQ

**Do I need a Greenhouse API key or a login?**
No. This uses Greenhouse's public job board API, which needs no authentication. Only postings a company has already published publicly are returned.

**How do I find a company's Greenhouse board token?**
Open the company's careers page and look at the job board URL. If it points at `job-boards.greenhouse.io` or `boards.greenhouse.io`, the path segment after the host is the token. Paste the whole URL if you prefer - it is parsed for you.

**How many companies can I scrape in one run?**
Up to 200 board tokens per run. Each board is a single request, so even a large cohort finishes in well under a minute.

**Can I get the full job description?**
Yes. `descriptionText` carries the complete description as plain text and is on by default; switch on **Include the job description as HTML** for `descriptionHtml` with the original formatting.

**Does it return salary information?**
Where the company advertises it. Pay transparency laws mean a growing share of postings publish a range, and those are parsed into numeric `salaryMin` and `salaryMax` fields.

**Why is `seniorityLevel` set to mid on some jobs?**
Greenhouse publishes no seniority field, so it is inferred from the job title. A title carrying no seniority marker at all is reported as `mid`.

**Can an AI agent call this Actor?**
Yes. The input schema and the dataset schema are fully typed and described, so an agent can pick arguments and read the output without extra instruction.

**What happens if a board token is wrong?**
That board is reported in the run status message as unreadable, is skipped, and is never charged. Every other board in the same run still returns its postings.

***

Unofficial - not affiliated with Greenhouse. Collects public data only. reapx.
Contact reapxdev@proton.me.

### The full published archive

- **[greenhouse jobs scraper archive](https://reapx.dev/data/greenhouse-jobs-scraper/)** — every entity this Actor has observed
- **[All reapx datasets](https://reapx.dev/data/)** — 20 sources, tens of thousands of pages
- **[llms.txt](https://reapx.dev/llms.txt)** · **[feed.json](https://reapx.dev/feed.json)** ·
  **[feed.xml](https://reapx.dev/feed.xml)** — the machine-readable index, for agents

Each archive page carries Dataset JSON-LD, a canonical URL and the identifiers used, so an agent
can resolve an entity without running anything. Nothing on those pages is estimated or modelled.

### 🧪 Example input

A real, runnable configuration — this is an actual input this Actor has run with.

```json
{
  "boards": [
    "amplitude",
    "circleci",
    "cloudflare",
    "cockroachlabs",
    "databricks",
    "datadog",
    "elastic",
    "fastly",
    "gitlab",
    "grafanalabs",
    "jfrog",
    "launchdarkly",
    "mixpanel",
    "mongodb",
    "neo4j",
    "netlify",
    "newrelic",
    "pagerduty",
    "postman",
    "temporaltechnologies",
    "vercel"
  ],
  "descriptionKeywords": [
    "rust",
    "golang",
    "kubernetes",
    "terraform"
  ],
  "titleKeywords": [
    "engineer",
    "engineering",
    "developer",
    "architect",
    "sre",
    "infrastructure"
  ],
  "sortBy": "newest",
  "maxItems": 250,
  "maxItemsPerBoard": 25,
  "remoteOnly": false,
  "withSalaryOnly": false,
  "includeDescription": true,
  "includeDescriptionHtml": false
}
```

### 📄 Sample output

One real row from a real run of this Actor, unedited.

```json
{
  "jobId": "7823417003",
  "title": "AI Engineer, Intern",
  "company": "Postman",
  "boardToken": "postman",
  "department": "AI",
  "departments": [
    "AI"
  ],
  "departmentPath": [
    "ALL DEPARTMENTS",
    "ENGINEERING.",
    "AI"
  ],
  "topLevelDepartment": "ALL DEPARTMENTS",
  "location": "Berkeley, California, United States",
  "locations": [
    "Berkeley, California, United States"
  ],
  "offices": [
    "Berkeley, California"
  ],
  "workplaceType": null,
  "isRemote": false,
  "seniorityLevel": "internship",
  "employmentType": "internship",
  "salaryText": null,
  "salaryMin": null,
  "salaryMax": null,
  "salaryCurrency": null,
  "salaryPeriod": null,
  "postedAt": "2026-08-01T14:52:20.000Z",
  "postedDaysAgo": 1,
  "updatedAt": "2026-08-01T14:52:20.000Z",
  "updatedDaysAgo": 1,
  "requisitionId": "2134",
  "internalJobId": "5803801003",
  "jobUrl": "https://job-boards.greenhouse.io/postman/jobs/7823417003",
  "greenhouseUrl": "https://job-boards.greenhouse.io/postman/jobs/7823417003",
  "applyUrl": "https://job-boards.greenhouse.io/postman/jobs/7823417003#app",
  "boardUrl": "https://job-boards.greenhouse.io/postman",
  "descriptionText": "Who Are We?\n\nPostman is the world’s leading API platform, used by more than 45 million+ developers and 500,000 organizations, including 98% of the Fortune 500. Postman is helping developers and professionals across the globe build the API-first world by simplifying each step of the API lifecycle and streamlining collaboration—enabling users to create better APIs, faster.\n\nThe company is headquartered in San Francisco and has offices in Boston, New York, Austin, Tokyo, London, and Bangalore - where Postman was founded. Postman is privately held, with funding from Battery Ventures, BOND, Coatue, CRV, Insight Partners, and Nexus Venture Partners. Learn more at postman.com or connect with Postman on X via @getpostman.\n\nP.S: We highly recommend reading The \"API-First World\" graphic novel to understand the bigger picture and our vision at Postman.\n\nThe Opportunity\n\nWe're seeking an AI Engineer Intern to work alongside our AI team on large-scale AI and Agentic systems from data pipeline to production deployment. This role is scoped for someone with foundational experience who wants to deepen it: you'll own discrete pieces of real systems under the mentorship of senior engineers, not shadow work or isolated coursework-style projects.\n\nWhat You'll Do\n\nModel Development\n\n- Partner with product managers, designers, and engineers to translate product requirements into scoped AI problem statements.\n\n- Prepare data pipeline and AI store design under senior engineer guidance.\n\n- Build and validate AI models using PyTorch or JAX(Optax/Orbax / TensorStore/Grain) and similar tools.\n\n- Run large-scale experiments, evaluate models against defined metrics, and support ablation studies and error analysis.\n\nProductionization\n\n- Help build inference APIs and batch scoring workflows; integrate AI outputs with backend services.\n\n- Support AIOps practices already in place on the team: model versioning, CI/CD pipelines, monitoring dashboards, and logging.\n\n- Assist with model optim
```

### How it works

1. You set the filters below, or none at all.
2. The Actor calls the source's own public endpoint and pages through the results.
3. Every row is pushed to the dataset **as it is built**, not buffered to the end — so a
   run that hits its time limit still returns everything it collected up to that point.
4. You are charged per row returned, so the maximum-results field is also your cost cap.

### 💬 Your feedback

Found a bug, or need a field this does not return yet? Open an issue on the Actor's **Issues**
tab, or write to **reapxdev@proton.me**. Bugs get fixed and reasonable field requests get
added.

# Actor input Schema

## `boards` (type: `array`):

One entry per company. Paste the board token (the last part of the board URL, e.g. "stripe") or the full board URL, e.g. "https://job-boards.greenhouse.io/stripe". Example: stripe, anthropic, figma. Leave empty to run the three sample boards.

## `titleKeywords` (type: `array`):

Case-insensitive. A posting is kept when its title contains at least one of these. Example: engineer, developer.<br><br>Leave this field empty to include every option.

## `excludeTitleKeywords` (type: `array`):

Case-insensitive. Drops postings whose title contains any of these. Example: intern, contract.<br><br>Leave this field empty to include every option.

## `departmentKeywords` (type: `array`):

Matched against the posting's team name and every parent department above it, so "engineering" still finds a role filed under an internal team code. Example: engineering, data.<br><br>Leave this field empty to include every option.

## `locationKeywords` (type: `array`):

Matched against the posting location and office names. Example: San Francisco, New York, London.<br><br>Leave this field empty to include every option.

## `descriptionKeywords` (type: `array`):

Full-text search inside the job description. Example: Rust, Kubernetes, Series B.<br><br>Leave this field empty to include every option.

## `seniorityLevels` (type: `array`):

Seniority is read from the job title. Titles with no seniority marker count as mid. Example: senior, staff.<br><br>Leave this field empty to include every option.

## `employmentTypes` (type: `array`):

Read from the board's own employment-type field when it publishes one, otherwise from the title. Example: fullTime.<br><br>Leave this field empty to include every option.

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

Keep only postings whose location, title or board field says remote. Example: true.

## `withSalaryOnly` (type: `boolean`):

Keep only postings that publish a pay range in the description. Example: true.

## `postedWithinDays` (type: `integer`):

Uses the date the posting first went live. Example: 7 for the past week.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

## `updatedWithinDays` (type: `integer`):

Uses the date the posting was last edited on the board. Example: 30.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

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

Adds descriptionText to every row. Turn it off for a slim listing feed. Example: true.

## `includeDescriptionHtml` (type: `boolean`):

Adds descriptionHtml with the original formatting. Example: false.

## `sortBy` (type: `string`):

Applied across all boards before the Max jobs cut-off. Example: newest.<br><br>Options: <code>newest</code>, <code>oldest</code>, <code>company</code>, <code>title</code>, <code>salary</code>.

## `maxItems` (type: `integer`):

Total rows returned across every board. You are charged per row returned. Example: 200.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

## `maxItemsPerBoard` (type: `integer`):

Stops one very large board from using up the whole budget. Leave empty for no per-board limit. Example: 25.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

## Actor input object example

```json
{
  "boards": [
    "stripe",
    "anthropic",
    "figma"
  ],
  "remoteOnly": false,
  "withSalaryOnly": false,
  "includeDescription": true,
  "includeDescriptionHtml": false,
  "sortBy": "newest",
  "maxItems": 200
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per public job posting: who is hiring, for what, where, and how to apply.

## `compensation` (type: `string`):

Postings that publish a pay range, with the range parsed into numbers.

## `orgStructure` (type: `string`):

Each opening placed in the company's own department tree, for reading where a company is growing.

## `freshness` (type: `string`):

How recently each role went live and when the company last edited it.

## `results` (type: `string`):

Every record this run produced, with all fields and no view applied. Field-level titles, types, descriptions and examples are declared in the dataset 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 = {
    "boards": [
        "stripe",
        "anthropic",
        "figma"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("reapx/greenhouse-jobs-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 = { "boards": [
        "stripe",
        "anthropic",
        "figma",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("reapx/greenhouse-jobs-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 '{
  "boards": [
    "stripe",
    "anthropic",
    "figma"
  ]
}' |
apify call reapx/greenhouse-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/yoic3orw08XKqdPXd/builds/Qkc6f5vaiW7lphkoD/openapi.json