# Greenhouse Jobs Scraper & API — 200,000+ Jobs, No Row Cap (`hiraware/greenhouse-jobs`) Actor

Get every open job from 7,500+ companies hiring on Greenhouse, like Airbnb, Stripe and SpaceX, in one run, with no company list and no row cap. Only live listings: closed jobs are removed at every refresh. Filter by title, location, salary, remote work, seniority, benefits and visa sponsorship.

- **URL**: https://apify.com/hiraware/greenhouse-jobs.md
- **Developed by:** [hiraware.com](https://apify.com/hiraware) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 jobs

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

Get **every open job from 7,500+ companies hiring on Greenhouse** in a single run: 200,000+ live
roles at companies like Airbnb, Stripe, SpaceX and Datadog. You don't need a list of companies, and
there's no cap on how many jobs you can pull. To try it, click **Start** with the default input.

### What does Greenhouse Jobs Scraper & API do?

It searches one ready-made index of every public Greenhouse job board and returns the jobs that match
your filters, with clean descriptions and structured fields.

- **No row cap.** Pull 50 jobs or 200,000. You decide with `maxResults` and your spend limit.
- **Only live listings.** When a job closes on the company's board, we remove it at our next refresh.
- **Every open job, however old.** A role that has been open for a year is still hiring, so we keep it.
- **Salaries you can compare.** Every salary also comes in annual US dollars, hourly rates included,
  so a "$100k+" search finds hourly and non-US roles too.
- **Straight from the posting.** Salary, benefits and requirements come from what the employer wrote.
  Anything we infer, like an employment type, sits in its own clearly labelled field.
- **AI-screening disclosure.** See which employers say they use AI to screen applicants. You won't
  find this in any other Greenhouse feed.
- **Job data only.** No personal details are included unless you switch on the US hiring contact.

### How much does it cost to scrape Greenhouse jobs?

You pay per job returned: $2.00 per 1,000 jobs on Apify's Free plan, down to $1.00 per 1,000 on
Business (see the **Pricing** tab for every plan). Each run also has a start fee of $0.00005.

Platform usage and full descriptions are included. A run that finds no jobs costs only the start fee.

### How to scrape Greenhouse jobs

1. Click **Try for free** and sign in to Apify.
2. On the **Input** tab, add what you're looking for, e.g. a job title, countries, or a minimum salary.
   Every field is optional.
3. Click **Start**. Small runs finish in seconds; a run of thousands of jobs with descriptions takes a few minutes.
4. Download the results from the **Output** tab as JSON, CSV or Excel, or connect them to Google
   Sheets, Zapier, Make, a webhook or the Apify API.

### Input

Every field is optional. An empty input returns the newest jobs first.

| Field | What it does |
|---|---|
| `query` | Title search by whole word, so "java" won't match "JavaScript". Use at least 3 letters or digits. |
| `titleExclude` | Skip titles containing any of these words, e.g. `senior`, `intern` |
| `tech` | Jobs that mention any of these technologies. Use this for short names like C++, Go and AI. |
| `companies` | Greenhouse board names, e.g. `stripe` |
| `countries` / `cities` / `regions` | 2-letter country codes; exact city and state names |
| `remoteType`, `seniority`, `jobFunction` | Pick from the lists |
| `employmentType` | As stated by the employer. Tick `includeInferredEmploymentType` to also match our best guess. |
| `minSalaryUsd`, `hasSalary` | Pay filters, in annual USD |
| `benefitTags` | Jobs offering **all** of the benefits you pick, e.g. `parental_leave`, `equity`, `retirement` |
| `visaSponsorship`, `securityClearance`, `aiScreening` | Eligibility and disclosure filters |
| `postedAfter`, `language`, `yearsMax` | How recent, which language, how much experience |
| `includeDescription`, `descriptionFormat` | Readable `text`, clean `html` that's safe to show on your site, or `both` |
| `includeHiringContact` | **Off by default.** For US jobs only: the name and email the employer put in the posting |
| `maxResults` | 5,000 by default. Raise it as far as you like. |

#### Example 1: remote AI operations roles

Senior or lead, US, remote, paying at least $100k a year, offering parental leave and a retirement
plan, at employers who disclose AI screening:

```json
{
  "query": "AI operations",
  "titleExclude": ["intern"],
  "countries": ["US"],
  "remoteType": ["remote"],
  "seniority": ["lead", "senior"],
  "minSalaryUsd": 100000,
  "benefitTags": ["parental_leave", "retirement"],
  "aiScreening": "disclosed",
  "descriptionFormat": "both",
  "maxResults": 50
}
```

#### Example 2: senior cloud engineers who know Kubernetes or Terraform

```json
{
  "query": "software engineer",
  "tech": ["Kubernetes", "Terraform"],
  "countries": ["US"],
  "remoteType": ["remote"],
  "seniority": ["senior"],
  "minSalaryUsd": 140000
}
```

### Output

One row per job. These are real jobs those two inputs returned, shortened. IDs, dates and links are
shown as placeholders.

**From example 1:**

```json
{
  "job_id": "greenhouse:<job id>",
  "title": "Senior AI Operations Lead",
  "company_name": "CodePath",
  "requisition_id": "<employer's reference>",
  "department_raw": "Business Operations",
  "job_function": "operations",
  "seniority": "lead",
  "employment_type": "full-time",
  "employment_type_inferred": null,
  "location_raw": "Remote, United States",
  "location_country": "US",
  "remote_type": "remote",
  "remote_scope": "restricted",
  "salary_min": 110000,
  "salary_max": 150000,
  "salary_currency": "USD",
  "salary_period": "year",
  "salary_min_usd_annual": 110000,
  "salary_max_usd_annual": 150000,
  "benefit_tags": ["health_insurance", "retirement", "paid_time_off", "parental_leave", "learning_budget"],
  "benefits": [
    "Health & Wellness: Medical, dental, and vision insurance (90% employer-covered for employees and dependents)…",
    "Work-Life Balance: Generous PTO, paid holidays, 10 weeks of fully paid parental leave…",
    "Professional Growth: $1,000 annual professional development stipend and home office setup support"
  ],
  "responsibilities": [
    "Embed and audit. Rotate through functions. Audit how the team really works, map the repetitive tasks…",
    "Build the v1 fast. Develop task-specific agents and automations… using Claude, Claude Code, MCP integrations…"
  ],
  "requirements": [
    "5+ years in automation/ops tooling, including recent hands-on LLM/agent work in a professional setting",
    "Hands-on experience building with LLM tools and low-code/no-code automation platforms (e.g. Claude, n8n, Zapier, Make)…"
  ],
  "tech_stack": ["LLM"],
  "ai_screening_disclosed": true,
  "ai_opt_out_url": "https://app7.greenhouse.io/ai_opt_out_request/job_post/<job id>/ai_opt_out",
  "posted_at": "YYYY-MM-DDThh:mm:ssZ",
  "retrieved_at": "YYYY-MM-DDThh:mm:ssZ",
  "apply_url": "https://job-boards.greenhouse.io/codepath/jobs/<job id>",
  "description_text": "CodePath is the largest educator of college computer science students in the country…",
  "description_html": "<p>CodePath is the largest educator of college computer science students in the country…</p>…"
}
```

**From example 2:**

```json
{
  "job_id": "greenhouse:<job id>",
  "title": "Senior Software Engineer - Cloud Platform Engineering",
  "company_name": "MariaDB plc",
  "job_function": "engineering",
  "seniority": "senior",
  "location_raw": "Remote - US",
  "location_country": "US",
  "remote_type": "remote",
  "salary_min": 141000,
  "salary_max": 185000,
  "salary_currency": "USD",
  "salary_period": "year",
  "tech_stack": ["Python", "Java", "C++", "SQL", "MySQL", "Redis", "AWS", "GCP", "Azure", "Kubernetes",
                 "Docker", "Terraform", "Linux", "Serverless", "LLM", "Golang"],
  "years_experience_min": 5,
  "requirements": [
    "5+ years of professional software development experience, with at least 2 years focused on data-intensive applications…",
    "Demonstrated end-to-end ownership of a non-trivial production feature or module…"
  ],
  "nice_to_have": [
    "Experience contributing to or maintaining open-source projects in the database, AI/ML application, or agent-tooling ecosystem.",
    "Hands-on experience developing MCP servers or integrating A2A (Agent2Agent) protocols into production systems."
  ],
  "benefit_tags": ["health_insurance", "retirement", "paid_time_off", "unlimited_pto", "parental_leave"],
  "visa_sponsorship": false,
  "ai_screening_disclosed": true,
  "apply_url": "https://job-boards.eu.greenhouse.io/mariadbplc/jobs/<job id>"
}
```

What to notice:

- **`tech_stack` is read from the whole posting**, so one `tech` filter finds every job that names
  Kubernetes or Terraform, whatever the title says.
- **`visa_sponsorship: false`** because the posting says "MariaDB does not sponsor work visas". We
  only return `true` when a posting actually offers sponsorship, and `null` when it doesn't say.
- **`benefits` is the employer's own list; `benefit_tags` makes it filterable.** Example 1 matched
  `parental_leave` and `retirement` because the posting says so.
- **`ai_screening_disclosed` and `ai_opt_out_url`** come straight from Greenhouse's disclosure fields.
- **`requisition_id`** is the employer's own reference, useful for spotting the same role reposted elsewhere.
- `null` means the posting doesn't say. We never fill a gap with a made-up default.

#### Salaries in one currency

Every salary is also returned per year in US dollars, so one `minSalaryUsd` filter covers them all.
Real examples from the index:

| Job | As published | `salary_*_usd_annual` |
|---|---|---|
| Counselor, Cortica | $48–60 per hour | $99,840–124,800 |
| Head of Women's Apparel UK/EU, Quince | £100,000–165,000 per year | $132,196–218,123 |
| Senior AI Operations Lead, CodePath | $110,000–150,000 per year | $110,000–150,000 |

Hourly pay is annualised at 2,080 hours; other currencies use a fixed reference exchange rate. Treat
the USD figures as estimates.

### How complete is the data?

We publish how often each field is filled, so you know what you're buying. Measured across 8,554
live jobs from 400 companies spread over the whole index:

| Field | Filled |
|---|---|
| title, company, apply link, posted date, description | 100% |
| department | 99.6% |
| requisition ID | 95.7% |
| city / country | 86.5% / 85.0% |
| job function | 69.7% |
| responsibilities / requirements | 61.1% / 46.6% |
| benefit tags | 53.3% |
| years of experience | 41.3% |
| AI-screening disclosed | 32.8% |
| employment type (stated / stated or inferred) | 11.9% / 32.1% |
| salary (also in annual USD) | 31.2% |
| seniority | 29.5% |
| tech stack | 24.6% |
| remote / hybrid / onsite | 15.7% |
| visa sponsorship stated | 2.1% |

When a posting doesn't say, the field is `null`. We never fill a gap with a made-up default.

### FAQ

#### How fresh are the jobs?

Every board is re-checked regularly, and a job that closes is removed at the next refresh. Each row
carries `retrieved_at`, the last time we confirmed it live.

#### Why do some jobs have no salary?

Most employers don't publish one. When they do, we return it, both as written and in annual US dollars.

#### Can I get only the jobs posted since my last run?

Yes. Schedule the Actor and set `postedAfter` to the date of your previous run.

#### Can I search inside job descriptions?

Not yet. Use `query` for titles, `tech` for technologies and `benefitTags` for benefits.

#### Is it legal to scrape Greenhouse jobs?

We collect only job postings that companies publish publicly on their Greenhouse career boards. No
personal data is returned unless you switch on the US hiring contact, which the employer published in
the posting itself. As with any data, check that your use complies with the laws that apply to you.

#### Can I use it from code or with AI agents?

Yes. Call it through the Apify API with the JavaScript or Python client, or through the Apify MCP
server. See the **API** tab for ready-made examples.

### For AI agents

- **Purpose:** search live Greenhouse job postings across 7,500+ companies by filters. No company list needed.
- **Minimal input:** `{"query": "data engineer", "countries": ["US"], "maxResults": 100}`
- **Always set `maxResults`** to what you need. The default is 5,000 and there is no platform cap.
- **Billing:** one `job-returned` event per job delivered, plus a $0.00005 start fee per run. Empty results cost only the start fee.
- **Short tech names** (C++, Go, AI) go in `tech`, not `query`. `query` needs 3+ letters or digits.
- **Output:** one row per job, with `job_id`, `title`, `company_name`, `location_*`, `salary_*`
  (plus `salary_*_usd_annual`), `benefit_tags`, `requirements`, `responsibilities`, `posted_at`,
  `apply_url` and `description_text`. Unknown values are `null`.
- **Run summary:** the `RUN_SUMMARY` record in the key-value store states why the run stopped and when
  the index was last checked.

### Help us grow the index

**Missing a company?** Open an issue with its Greenhouse link and we'll add it to the index.

***

Greenhouse is a trademark of Greenhouse Software, Inc. This Actor is independent, and isn't affiliated
with or endorsed by Greenhouse Software, Inc. It reads only publicly published job boards.

# Actor input Schema

## `query` (type: `string`):

Words that must appear in the job title, matched as whole words, e.g. "data engineer". Use at least 3 letters or digits. For short names like C++, Go or AI, use Technologies below.

## `titleExclude` (type: `array`):

Skip jobs whose title contains any of these words, e.g. senior, staff, intern.

## `tech` (type: `array`):

Jobs that mention any of these technologies, e.g. Python, Kubernetes, C++, Go.

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

Only these companies. Use the name from their Greenhouse link: boards.greenhouse.io/stripe is "stripe".

## `countries` (type: `array`):

2-letter country codes, e.g. US, GB, DE. A job listed in several countries matches any of them.

## `cities` (type: `array`):

City names, e.g. London, New York. Not case-sensitive.

## `regions` (type: `array`):

State or region names, e.g. California, Texas, Ontario.

## `remoteType` (type: `array`):

Only included when the posting says so. Jobs that don't mention it won't match.

## `seniority` (type: `array`):

Taken from the job title, or the employer's own level where they set one. Jobs that don't say won't match.

## `employmentType` (type: `array`):

Full-time, part-time and so on, as the employer states it. Most employers don't, so tick the box below to include our best guess too.

## `includeInferredEmploymentType` (type: `boolean`):

Also match jobs where we worked it out, e.g. a yearly salary usually means full-time. Our guess is in its own field (employment\_type\_inferred), never mixed with what the employer said.

## `jobFunction` (type: `array`):

The part of the business, e.g. engineering or sales, taken from the employer's department first and the title second.

## `yearsMax` (type: `integer`):

Your experience in years. Returns jobs asking for this much or less.

## `minSalaryUsd` (type: `integer`):

Minimum yearly pay in US dollars. Other currencies and hourly rates are converted (hourly × 2,080 hours), so treat it as an estimate. Jobs without a published salary are left out when this is set.

## `hasSalary` (type: `boolean`):

Only jobs where the employer published a salary or pay range.

## `benefitTags` (type: `array`):

Only jobs whose posting mentions ALL of the benefits you pick.

## `visaSponsorship` (type: `boolean`):

Only jobs that say they offer visa sponsorship.

## `securityClearance` (type: `boolean`):

Only jobs that mention a security clearance.

## `aiScreening` (type: `string`):

Whether the employer says it uses AI to screen applications.

## `postedAfter` (type: `string`):

Only jobs posted on or after this date. Leave it empty to include every open job, however old.

## `language` (type: `string`):

2-letter language code of the posting, e.g. en.

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

The full job description, included at no extra cost.

## `descriptionFormat` (type: `string`):

Readable text, clean HTML that's safe to show on your site, or both.

## `includeHiringContact` (type: `boolean`):

Off by default. For US jobs only: the name and email the employer put in the posting. It's read from the description, so it may contain mistakes.

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

The most jobs to return. There's no platform cap, so raise it as far as you like. Your spend limit for the run is always respected.

## Actor input object example

```json
{
  "query": "software engineer",
  "includeInferredEmploymentType": false,
  "hasSalary": false,
  "visaSponsorship": false,
  "securityClearance": false,
  "aiScreening": "any",
  "includeDescription": true,
  "descriptionFormat": "text",
  "includeHiringContact": false,
  "maxResults": 100
}
```

# Actor output Schema

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

No description

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

No description

# 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 = {
    "query": "software engineer",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("hiraware/greenhouse-jobs").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 = {
    "query": "software engineer",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("hiraware/greenhouse-jobs").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 '{
  "query": "software engineer",
  "maxResults": 100
}' |
apify call hiraware/greenhouse-jobs --silent --output-dataset

```

## MCP server setup

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

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/mdQCMUCegmbe89uWn/builds/9Lt9QGbgdkYaxq7Ep/openapi.json