# Greenhouse Jobs API & Scraper (`rocketyard/greenhouse-jobs-scraper`) Actor

Greenhouse jobs API and scraper: get every open job from any company's Greenhouse job board (title, company, location, salary when published, department and more) over REST, from Greenhouse's official API. Filter by keyword or location. JSON, CSV or Excel. $1.00 per 1,000 jobs, no subscription.

- **URL**: https://apify.com/rocketyard/greenhouse-jobs-scraper.md
- **Developed by:** [Rocketyard](https://apify.com/rocketyard) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.65 / 1,000 results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Greenhouse Jobs API & Scraper

**Greenhouse Jobs API & Scraper** is a REST API on the Apify platform: one request returns every open job from a company's Greenhouse job board, with the same fields as the other job board Actors, as JSON, CSV or Excel. You can also run it from a form in the Apify Console, without code.

### What is Greenhouse Jobs API & Scraper?

Greenhouse Jobs API & Scraper exports **every open job** from companies that hire with Greenhouse. It reads Greenhouse's [official public job board API](https://developers.greenhouse.io/job-board.html) and returns one clean record per job: title, location, workplace type, employment type, department, salary range when the company publishes one, the full description and the apply link. Give it Greenhouse job board URLs or just the board names. You don't need a Greenhouse account, an API key or a browser, so it is a Greenhouse jobs scraper that doesn't break when a careers page changes.

### Use cases

- **Pull every open role from many Greenhouse-hosted career pages into one dataset**
- **Monitor which companies are hiring for which roles, and where**
- **Salary benchmarking from published pay ranges**
- **Feed fresh job data into job boards, CRMs and AI pipelines**

### Why use Greenhouse Jobs API & Scraper?

- Reads Greenhouse's official public job-board API: complete and current data, no HTML parsing, no browser
- Every open role of a company in one request: title, location, department, salary range when published, full description
- Many companies per run: paste board URLs or just the board names
- Keyword, location, department and remote filters run before billing: you pay only for the jobs you keep
- Clean JSON with the same fields for Greenhouse, Lever and Ashby boards
- Pay only per result: no monthly rental, no minimums

### What data can you get from Greenhouse job boards?

Each job comes back with 27 fields, listed under [Output fields](#output-fields) with how often each one is filled. Companies choose what they publish, and salary varies most. On 2026-11-05, 48.6% of 4,322 jobs across 12 Greenhouse boards had a published salary range, from 0% at Stripe to 100% at Discord.

### Can I use the free Greenhouse Job Board API instead?

Yes, and for one board you read once, you may not need this Actor. The Greenhouse Job Board API is free and needs no key:

```bash
curl -s "https://boards-api.greenhouse.io/v1/boards/discord/jobs?content=true&pay_transparency=true"
```

Here is what Greenhouse Jobs API & Scraper adds on top of it:

- **Salary parsing**: pay ranges arrive under `pay_input_ranges` in cents, and only with `pay_transparency=true`. The Actor returns `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryUnit` and `salaryText`.
- **Plain-text descriptions**: `content` is escaped HTML. The Actor returns readable text with its paragraphs and lists.
- **Workplace type**: Greenhouse has no such field. The Actor sets `workplaceType` when the location says Remote or Hybrid.
- **One format across platforms**: Greenhouse, Lever and Ashby jobs share the same fields, so they fit one table without per-platform mapping.
- **Many boards in one run**: filters run before billing, and a board that fails gets a free error item while the others carry on.
- **No code to run**: start it from a form, export JSON, CSV or Excel, and use Apify's schedules, webhooks and integrations.

### How it compares

| Greenhouse jobs scraper | Users (last 30 days) | Successful runs (last 30 days) | Price per 1,000 results |
| --- | --- | --- | --- |
| Greenhouse Jobs API | 156 | 99.9% | $2.00 |
| Greenhouse Job Scraper | 70 | 46.3% | $2.00 |
| Greenhouse Jobs Scraper | 35 | 98.4% | $2.00 |
| **This Actor** | new | every release is tested on live pages first | **$1.00** |

Apify Store data from 2026-11-03, free-plan prices. Prices and stats change; check each listing before you compare.

### Greenhouse jobs API

Every Apify Actor is also a REST endpoint, so Greenhouse Jobs API & Scraper works as a Greenhouse jobs API, a Greenhouse job board API or an ATS jobs API, without a server of your own. One `POST` starts a run, waits for it and returns the results:

```text
POST https://api.apify.com/v2/acts/rocketyard~greenhouse-jobs-scraper/run-sync-get-dataset-items
```

Send your [Apify API token](https://console.apify.com/settings/integrations) in the `Authorization` header and the [input](#input-example) as the JSON body. Add `?format=csv` or `?format=xlsx` to get CSV or Excel instead of JSON. The request waits up to 300 seconds; for a longer run, start it with `POST /v2/acts/rocketyard~greenhouse-jobs-scraper/runs` and read the dataset when it finishes. The Greenhouse, Lever and Ashby Actors share one output format, so together they give you one ATS jobs API across the three platforms.

### How to scrape Greenhouse jobs

1. Click **Try for free**.
2. Add job boards to **Job board URLs** (for example `https://job-boards.greenhouse.io/discord`), or board names to **Job board names** (for example `discord`).
3. Optionally keep only the jobs you need with **Keyword in job title**, **Location**, **Department** or **Remote jobs only**. Filters run before billing.
4. Click **Start**, then download results as JSON, CSV or Excel, or read them through the API.

#### How do I find a company's Greenhouse board name?

Open the company's careers page and click a job. If the address starts with `job-boards.greenhouse.io/<name>` or `boards.greenhouse.io/<name>`, `<name>` is the board name. If the careers page stays on the company's own domain, look for `gh_jid=` in the job's address, or for `boards.greenhouse.io/embed/job_board?for=<name>` in the page source.

### Input

| Field | JSON key | What it does |
|---|---|---|
| Job board URLs | `startUrls` | Greenhouse job boards to export, one per company, e.g. https://job-boards.greenhouse.io/discord. A job page or an API URL of a board also works: the whole board is read. Leave empty if you fill in Job board names. |
| Job board names | `companies` | Board names as they appear in the job board URL, e.g. "discord" for https://job-boards.greenhouse.io/discord. Use instead of, or together with, Job board URLs. A name without a public board returns a free error item. |
| Keyword in job title | `keyword` | Keep only jobs whose title contains this text, in any letter case. Separate alternatives with commas, e.g. engineer, designer. Jobs filtered out are not charged. |
| Location | `location` | Keep only jobs whose location contains this text, in any letter case, e.g. London. Separate alternatives with commas, e.g. London, Remote. |
| Department | `department` | Keep only jobs whose department or team contains this text, in any letter case, e.g. Engineering. Separate alternatives with commas. |
| Remote jobs only | `remoteOnly` | Keep only jobs the company marks as remote. Jobs that do not state a workplace type are left out, so this can miss remote jobs on boards that rarely state it. |
| Max results | `maxItems` | Stop after this many jobs in total, across all job boards. This also caps what the run can charge for results. |
| Max results per job board | `maxItemsPerBoard` | Optional: keep at most this many jobs from each job board, for example to sample many companies. Empty means no limit. |
| Max concurrency | `maxConcurrency` | Job boards fetched in parallel. A polite delay between requests to the same host always applies. |
| Proxy configuration | `proxyConfiguration` | Optional. Greenhouse's public job-board API needs no proxy, so leave this empty unless your runs are blocked. |

### Input example

```json
{
  "startUrls": [
    {
      "url": "https://job-boards.greenhouse.io/discord"
    }
  ],
  "companies": [
    "figma"
  ],
  "keyword": "engineer",
  "maxItems": 1000
}
```

### Output example

A real record from the latest test run (job-boards.greenhouse.io) on 2026-11-05. Fields the page didn't publish are left out here; the Actor returns them as `null`.

```json
{
  "url": "https://job-boards.greenhouse.io/discord/jobs/8917177002",
  "type": "JobPosting",
  "title": "Associate Commercial Counsel",
  "company": "Discord",
  "location": "San Francisco Bay Area or Remote (U.S.)",
  "workplaceType": "remote",
  "department": "Legal",
  "datePosted": "2026-11-03T16:27:16.000Z",
  "dateUpdated": "2026-11-03T16:31:51.000Z",
  "salaryMin": 200000,
  "salaryMax": 225000,
  "salaryCurrency": "USD",
  "salaryUnit": "YEAR",
  "salaryText": "USD 200,000 - 225,000 per year",
  "locations": [
    "San Francisco Bay Area or Remote (U.S.)",
    "San Francisco, California, United States"
  ],
  "country": "United States",
  "remote": true,
  "description": "Discord has a highly engaged community of millions of daily active users who use the platform for many different reasons, but there’s one thing that nearly everyone does: play video games. Discord plays a uniquely important role in the future of gaming, and we are focused on making it easier and…",
  "applyUrl": "https://job-boards.greenhouse.io/discord/jobs/8917177002",
  "requisitionId": "R-107469",
  "ats": "greenhouse",
  "board": "discord",
  "jobId": "8917177002",
  "sourceUrl": "https://job-boards.greenhouse.io/discord",
  "scrapedAt": "2026-11-05T18:08:59.131Z"
}
```

#### Output fields

| Field | Description | Filled |
|---|---|---|
| `url` | Job posting page | 100% |
| `type` | Always `JobPosting` | always |
| `title` | Job title | 100% |
| `company` | Company name | 100% |
| `location` | Primary location as published | 100% |
| `workplaceType` | `remote`, `hybrid`, `on-site`, or empty when the posting does not say | 30.2% |
| `employmentType` | schema.org value (`FULL_TIME`, `PART_TIME`, `CONTRACTOR`, `INTERN`, `TEMPORARY`) or the label as published | 13.4% |
| `department` | Department | 100% |
| `team` | Team | not in this API |
| `datePosted` | First published (ISO 8601) | 100% |
| `dateUpdated` | Last updated (ISO 8601), when the API publishes it | 100% |
| `salaryMin` | Lowest salary of the published range | 48.6% |
| `salaryMax` | Highest salary of the published range | 48.6% |
| `salaryCurrency` | ISO 4217 currency code | 48.6% |
| `salaryUnit` | `YEAR`, `MONTH`, `WEEK`, `DAY` or `HOUR` | 45.5% |
| `salaryText` | The published pay range as text | 48.6% |
| `locations` | Every location of the job | 100% |
| `country` | Country | 49.7% |
| `remote` | `true` for remote jobs, `false` for hybrid or on-site, empty when not stated | 30.2% |
| `description` | Full job description as plain text | 100% |
| `applyUrl` | Application page | 100% |
| `requisitionId` | Requisition ID, when published | 93.2% |
| `ats` | Applicant tracking system | always |
| `board` | Job-board name (the company part of the board URL) | always |
| `jobId` | Job ID in the applicant tracking system | always |
| `sourceUrl` | Job board the record came from | always |
| `scrapedAt` | ISO timestamp of the extraction | always |

"Filled" is the share of jobs with a value, measured through this Actor's mapping on 12 Greenhouse boards on 2026-11-05 (4,322 open jobs). Companies decide what they publish, so your boards can differ. A field without a value comes back as `null`, never guessed.

### Limits

- Only companies whose careers pages are hosted on Greenhouse, with a public job board. The Actor reads the boards you name; it doesn't discover companies.
- Each run returns the roles open right now. Closed jobs leave the board, so the Actor keeps no history: to track changes, schedule it and compare runs by `jobId`.
- The keyword filter reads the job title, not the description.

### Error items

When an input produces no data, the dataset gets one **error item** for it, so nothing is skipped silently. Error items are **free**: only result records are charged.

```json
{
  "url": "https://job-boards.greenhouse.io/no-such-board",
  "input": "https://job-boards.greenhouse.io/no-such-board",
  "error": {
    "type": "https://rocketyard.dev/errors#not-found",
    "title": "Not found",
    "status": 404,
    "detail": "HTTP 404 (no public Greenhouse job board named \"no-such-board\")",
    "instance": "https://job-boards.greenhouse.io/no-such-board",
    "code": "NOT_FOUND"
  }
}
```

The `error` object follows [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457) (Problem Details). Its `type` links to the [explanation of the code](https://rocketyard.dev/errors), and `status` is the site's HTTP status when there was one. Filter on `error.code` to separate failures from data; it has its own column in CSV and Excel exports.

| Code | Meaning | Retry? |
|---|---|---|
| [`ROBOTS_DISALLOWED`](https://rocketyard.dev/errors#robots-disallowed) | The site's robots.txt does not allow automated access to this URL (or to the page it redirects to), so it was not fetched. | no |
| [`ROBOTS_UNREACHABLE`](https://rocketyard.dev/errors#robots-unreachable) | The site's robots.txt could not be loaded because of a server or network error. Under RFC 9309, the page is then not fetched. | yes |
| [`PRIVATE_ADDRESS`](https://rocketyard.dev/errors#private-address) | The URL, or a redirect from it, points to a private or local network address. Only public websites are fetched. | no |
| [`NOT_FOUND`](https://rocketyard.dev/errors#not-found) | The page or source does not exist (HTTP 404 or 410). | no |
| [`BLOCKED`](https://rocketyard.dev/errors#blocked) | The site refused access (HTTP 401, 403 or 429) or answered with a bot-check or consent page instead of the content. | sometimes |
| [`HTTP_ERROR`](https://rocketyard.dev/errors#http-error) | The site answered with another HTTP error: a server error (5xx) that persisted after retries, or an unexpected 4xx status. | sometimes |
| [`TIMEOUT`](https://rocketyard.dev/errors#timeout) | The site did not answer in time, even after retries. | yes |
| [`NETWORK_ERROR`](https://rocketyard.dev/errors#network-error) | The connection failed (DNS, TLS or a reset connection), even after retries. | yes |
| [`WRONG_CONTENT_TYPE`](https://rocketyard.dev/errors#wrong-content-type) | The URL returned something the Actor doesn't read, such as a PDF or image instead of an HTML page, or a web page where an API response was expected. | no |
| [`TOO_LARGE`](https://rocketyard.dev/errors#too-large) | The response exceeded the size limit (10 MiB for web pages, 48 MiB for API responses). | no |
| [`PARSE_ERROR`](https://rocketyard.dev/errors#parse-error) | The response could not be read (malformed HTML or JSON). | sometimes |
| [`EMPTY`](https://rocketyard.dev/errors#empty) | The source has nothing to return right now: a list with no open items, a store or collection with no products, a search with no results, or a web page whose HTML has no readable text (often a page built only by JavaScript in the browser). | no |
| [`NO_MATCHES`](https://rocketyard.dev/errors#no-matches) | The source has items, but none of them matched your filters. | no |

### Pricing

Pay per result: **$1.00 per 1,000 jobs**, plus a tiny per-run start fee. Jobs removed by your filters are free. There is no monthly rental, and you can cap spend per run with **Max results** or **Maximum cost per run**. At that price, exporting every job from the boards we measured costs from $0.03 (Discord, 27 jobs) to $0.93 (Databricks, 926 jobs).

### Integrations and API

- **Schedule**: an [Apify schedule](https://docs.apify.com/platform/schedules) runs it daily or weekly. Each run returns every open role, so compare runs by `jobId` to see new and closed ones.
- **Webhooks**: an [Apify webhook](https://docs.apify.com/platform/integrations/webhooks) calls your URL when a run finishes, with the run's dataset ID in the payload.
- **Make**: the Apify app's **Run an Actor** and **Get Dataset Items** modules, then any Make app, such as Google Sheets. [Steps](https://rocketyard.dev/greenhouse-jobs-scraper#make).
- **Zapier**: the **Finished Actor run** trigger and the **Fetch dataset items** search. Zapier stops synchronous runs after 30 seconds, so use the trigger for anything larger than a small run. [Steps](https://rocketyard.dev/greenhouse-jobs-scraper#zapier).
- **n8n**: Apify's community node (`@apify/n8n-nodes-apify`) or an HTTP Request node. [Workflow to copy](https://rocketyard.dev/greenhouse-jobs-scraper#n8n).
- **Code**: the [Apify API](https://docs.apify.com/api/v2) and the JavaScript and Python clients. [Examples](https://rocketyard.dev/greenhouse-jobs-scraper#api).
- **AI agents**: Apify's MCP server exposes it as a tool to any MCP client. [Setup](https://rocketyard.dev/greenhouse-jobs-scraper#mcp).

### FAQ

**How much does it cost?** You pay per result: $1.00 per 1,000 jobs, plus a start fee of $0.00005 per run, with no subscription. Cap any run with **Maximum cost per run**.

Your Apify plan sets your discount tier (Platinum and Diamond are enterprise tiers):

| Tier | Per 1,000 jobs |
|---|---|
| Free | $1.00 |
| Bronze | $1.00 |
| Silver | $0.80 |
| Gold | $0.65 |
| Platinum | $0.65 |
| Diamond | $0.65 |

**How do I call it from the API?** One request starts a run and returns its results, using your [Apify API token](https://console.apify.com/settings/integrations):

```bash
curl -X POST "https://api.apify.com/v2/acts/rocketyard~greenhouse-jobs-scraper/run-sync-get-dataset-items" -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" -d '{"startUrls":[{"url":"https://job-boards.greenhouse.io/discord"}],"maxItems":100}'
```

**How do I use it with AI agents?** Connect Apify's MCP server at `https://mcp.apify.com?tools=rocketyard/greenhouse-jobs-scraper`, and the agent can call this Actor as a tool.

**Which companies does it work on?** Any company whose careers page is hosted on Greenhouse, with URLs like `https://job-boards.greenhouse.io/discord`. The board name is the part after the domain (`discord`). Job page and API URLs of a board work too.

**Where does the data come from?** From Greenhouse's official public job-board API ([documentation](https://developers.greenhouse.io/job-board.html)), the same feed companies use to show their openings on their own websites. No login, no browser, and robots.txt is respected.

**Does it include salaries?** Yes, when the company publishes a pay range on the posting: `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryUnit` and `salaryText`. Postings without a published range have these fields empty.

**Is it legal to scrape Greenhouse jobs?** The Actor reads only job postings that companies publish for anyone to see, through Greenhouse's public API, honours robots.txt, and returns no data about applicants or recruiters. You are responsible for complying with applicable laws and terms (for example GDPR) for how you use the data.

**What happens when a board fails?** If a board can't be read, doesn't exist, has no open jobs or has none matching your filters, the dataset gets one [error item](#error-items) for it with a code and the reason, and you are not charged for it. The other boards in the run carry on.

**How fresh is the data?** Every run reads the live job board, so you get the roles that are open right now.

**I need another applicant tracking system or a field.** Open an issue on the Actor's Issues tab. Requests are reviewed regularly and drive new features.

### You might also like

- [Ashby Jobs API & Scraper](https://apify.com/rocketyard/ashby-jobs-scraper): every open job from Ashby job boards, with the same output fields
- [Job Postings API - Any Career Site](https://apify.com/rocketyard/jobposting-schema-scraper): job posting data from any website with schema.org markup
- [Lever Jobs API & Scraper](https://apify.com/rocketyard/lever-jobs-scraper): every open job from Lever job boards, with the same output fields
- [Events Scraper - Any Event Site to Structured Data](https://apify.com/rocketyard/event-schema-scraper): event data from any website with schema.org markup
- [Hotel Details Scraper - Address, Stars & Amenities](https://apify.com/rocketyard/hotel-schema-scraper): hotel data from any website with schema.org markup

### Your feedback

Found a bug, a site that doesn't work or a missing field? Open an issue on the [Issues tab](https://apify.com/rocketyard/greenhouse-jobs-scraper/issues): issues are public, so the answer helps the next person too. If the Actor did the job, a review on this page helps other people find it.

### Made by Rocketyard

[Rocketyard](https://rocketyard.dev) builds pay-per-result scrapers for public web data, and every release is tested on live pages before it ships. Guides for this Actor: [overview](https://rocketyard.dev/greenhouse-jobs-scraper), [REST API](https://rocketyard.dev/greenhouse-jobs-scraper#api), [MCP for AI agents](https://rocketyard.dev/greenhouse-jobs-scraper#mcp) and [n8n, Make and Zapier](https://rocketyard.dev/greenhouse-jobs-scraper#automation).

How-to guides:

- [Export all open jobs from a Greenhouse board to CSV or JSON](https://rocketyard.dev/export-greenhouse-jobs-csv-json)
- [Greenhouse vs Lever vs Ashby job board APIs: which fields each returns](https://rocketyard.dev/greenhouse-vs-lever-vs-ashby-job-board-api)
- [Track new roles at target companies daily with a schedule and a webhook](https://rocketyard.dev/track-new-jobs-daily)
- [Find companies by what their job descriptions say, without code](https://rocketyard.dev/hiring-signals-from-job-descriptions)

# Actor input Schema

## `startUrls` (type: `array`):

Greenhouse job boards to export, one per company, e.g. https://job-boards.greenhouse.io/discord. A job page or an API URL of a board also works: the whole board is read. Leave empty if you fill in Job board names.

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

Board names as they appear in the job board URL, e.g. "discord" for https://job-boards.greenhouse.io/discord. Use instead of, or together with, Job board URLs. A name without a public board returns a free error item.

## `keyword` (type: `string`):

Keep only jobs whose title contains this text, in any letter case. Separate alternatives with commas, e.g. engineer, designer. Jobs filtered out are not charged.

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

Keep only jobs whose location contains this text, in any letter case, e.g. London. Separate alternatives with commas, e.g. London, Remote.

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

Keep only jobs whose department or team contains this text, in any letter case, e.g. Engineering. Separate alternatives with commas.

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

Keep only jobs the company marks as remote. Jobs that do not state a workplace type are left out, so this can miss remote jobs on boards that rarely state it.

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

Stop after this many jobs in total, across all job boards. This also caps what the run can charge for results.

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

Optional: keep at most this many jobs from each job board, for example to sample many companies. Empty means no limit.

## `maxConcurrency` (type: `integer`):

Job boards fetched in parallel. A polite delay between requests to the same host always applies.

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

Optional. Greenhouse's public job-board API needs no proxy, so leave this empty unless your runs are blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://job-boards.greenhouse.io/discord"
    }
  ],
  "remoteOnly": false,
  "maxItems": 1000,
  "maxConcurrency": 3
}
```

# Actor output Schema

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

One record per Greenhouse job, as JSON, CSV or Excel, plus a free error item for each job board that produced none.

## `runSummary` (type: `string`):

Job boards fetched, jobs stored, boards skipped and errors.

# 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 = {
    "startUrls": [
        {
            "url": "https://job-boards.greenhouse.io/discord"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("rocketyard/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 = { "startUrls": [{ "url": "https://job-boards.greenhouse.io/discord" }] }

# Run the Actor and wait for it to finish
run = client.actor("rocketyard/greenhouse-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://job-boards.greenhouse.io/discord"
    }
  ]
}' |
apify call rocketyard/greenhouse-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rocketyard/greenhouse-jobs-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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