Greenhouse Jobs Scraper: Any Company Board → JSON

Give it a Greenhouse board token, a board URL, or a company: get every live job on that company's Greenhouse board as clean, normalized JSON, in seconds, straight from Greenhouse. Not from an index that was built a few hours ago: this Actor reads the employer's own Greenhouse Job Board API at the moment you ask, so what you get back is what a candidate would see on the careers page right now.

• What you put in: one or more Greenhouse boards. The fastest path is the board token: the boards.greenhouse.io/{token} slug, but you can also paste a board URL or a company name and let the Actor resolve it.
• What you get back: one record per live job posting, in a single canonical schema, plus one status record per board telling you exactly what happened: found, no_board, or error.
• Why this one: the indexed alternatives sell you a pre-built corpus with an indexing delay, a six-month window, and a per-run cap. An index cannot answer "what is on this board right now". This can, at roughly $1 per 1,000 jobs.
• Boosted by the Apify platform: full REST API access, scheduling, monitoring, webhooks and integrations, datacenter proxy rotation, and dataset export to JSON, CSV, or Excel.

What is the Greenhouse Jobs Scraper and what can it do?

The Greenhouse Jobs Scraper is a live Greenhouse Job Board API: you name a board and it returns every open role on it as structured JSON. It is the tool you want when you already know whose jobs you care about (a specific company on Greenhouse, the accounts in your CRM, the portfolio companies in your fund) and you want their current openings on demand or on a schedule.

It reads Greenhouse through its official, public, no-authentication JSON API: the most stable class of source that exists for jobs data, and the reason this Actor needs no browser, no residential proxy, and no anti-bot workarounds. It is Greenhouse-focused on purpose: a narrow, testable promise beats a broad, flaky one. If you need Lever, Ashby, or Workable too, or you do not know which system a company uses, the Job Postings API flagship resolves the board for you across all four.

Live vs. indexed: why freshness is the whole point:

What it deliberately does not do: it does not search across companies by keyword, it does not maintain an index or a history, it does not fetch per-posting application questions, and it does not enrich postings with AI-inferred salaries or skills. Inferred fields are exactly where indexed competitors accumulate quiet errors. This Actor's promise is narrower and honest: the live board, correctly normalized.

What data does it extract? (output fields)

Every record is a canonical JobPosting: a stable id, the source (greenhouse) and its native id, the posting URL, raw and normalized titles, company, structured location, department, description in HTML and plain text, and the dates the role was posted and observed.

Two things are worth calling out:

• salary is not a native Greenhouse field, so it is read out of the description when the employer states one, and labelled source: "parsed". If a role's pay cannot be established honestly, the field is absent: it is never guessed. Descriptions are always fetched so this can run even when you switch descriptions off in the output.
• Greenhouse-specific fields that do not fit the canonical schema: requisition_id, internal_job_id, offices, departments, metadata, first_published, data_compliance, are preserved under extras.greenhouse rather than dropped or forced into a field where they do not belong.

Alongside the job records, each input board produces one board-status row:

{ board, company?, jobCount, status }

How to use the Greenhouse Jobs Scraper (tutorial)

1. Click Start with the example input already filled in: one board, no options.
2. Watch the run finish (a single board typically completes in a few seconds).
3. Open the Dataset tab. You will see the job records plus one board-status row.
4. Export as JSON, CSV, or Excel, or call the run from your own code through the Apify API.

To run it on your own boards, replace the boards array. Each entry needs one of token, boardUrl, or company:

• token: the boards.greenhouse.io/{token} slug, e.g. airbnb. This is the fastest, zero-guess path.
• boardUrl: a board URL to parse the token from; boards.greenhouse.io/…, job-boards.greenhouse.io/…, and embed links are all understood.
• company: a company name or slug; the Actor tries it directly as a token, and, when it looks like a domain, reads that company's careers page for a Greenhouse link (with a similarity guard so it never resolves the wrong board).

Boards in a batch are processed one after another, at a deliberately polite request rate to Greenhouse. If you are polling on a schedule, prefer several small runs over one very large one.

How much does it cost to scrape Greenhouse?

Pay-per-event, with two events:

• $0.002 per board processed: charged once per board that reached a definitive answer, whether that answer is "here are the jobs" or "there is no such Greenhouse board". The resolve-and-fetch work has value either way. This is lower than the flagship's fixed fee because there is no cross-ATS detection.
• $0.001 per job posting returned: charged per validated record ($1 per 1,000 jobs).

Failed lookups are free. A board whose status is error is never charged, and neither are the records of a board whose fetch failed part-way through: they are discarded rather than delivered. We charge for answers, not for our own failures.

A worked example: 10 boards averaging 40 open roles each costs 10 × $0.002 + 400 × $0.001 = $0.42. The comparable indexed APIs charge $1.20–$1.50 per 1,000 jobs; this undercuts them on the marginal price while answering a question they cannot. Platform usage costs are absorbed, not passed through.

Input and output examples

Input: the simplest useful run:

{ "boards": [{ "company": "airbnb" }] }

Input: a filtered batch by token and URL:

{
  "boards": [
    { "token": "airbnb" },
    { "boardUrl": "https://job-boards.greenhouse.io/gitlab" }
  ],
  "titleFilter": "engineer",
  "remoteOnly": true,
  "maxJobsPerBoard": 25
}

Output: one job record (trimmed) and its board's status row:

{
  "id": "8f2c…",
  "source": "greenhouse",
  "url": "https://job-boards.greenhouse.io/airbnb/jobs/4001",
  "title": "Senior Backend Engineer",
  "titleNormalized": "Senior Backend Engineer",
  "company": { "name": "Airbnb", "sourceSlug": "airbnb" },
  "location": { "raw": "San Francisco, CA", "city": "San Francisco", "remote": "unknown" },
  "department": "Engineering",
  "postedAt": "2026-06-20T10:00:00Z",
  "extras": { "greenhouse": { "requisition_id": "REQ-1234", "offices": [{ "name": "San Francisco" }] } }
}

{ "type": "board-status", "board": "airbnb", "company": "airbnb", "jobCount": 42, "status": "found" }

titleFilter, departmentFilter, and locationFilter are plain, case-insensitive substring matches, not regular expressions. remoteOnly keeps every role that is not clearly on-site, because Greenhouse locations are free text, a role whose posture cannot be determined is kept rather than silently dropped.

Other Actors you might need

If your list spans several applicant tracking systems, start with the flagship: resolving the board is the part it does for you.

FAQ, legality, and support

How do I find a company's Greenhouse board token?

The token is the slug in the board URL. If a company's careers page links to boards.greenhouse.io/acme or job-boards.greenhouse.io/acme, the token is acme. You can paste that token, paste the whole URL, or just give the company name and let the Actor resolve it.

How is this different from an indexed jobs API?

An indexed API crawls many career sites on its own schedule and serves you a copy. That is the right shape for "show me every Python job posted this week", and the wrong shape for "what is on this board right now": the copy is only as fresh as the last crawl. This Actor holds no index. It reads the board when you ask, which means no indexing delay and no per-run cap on how much of a board you retrieve.

Can I scrape multiple companies' Greenhouse boards at once?

Yes. Put several entries in the boards array: up to 500 per run, mixing tokens, URLs, and company names freely. They are processed one after another at a polite request rate, and each gets its own board-status row.

What if a board does not exist?

You get a board-status row with status: "no_board", and the run still succeeds. "There is no such Greenhouse board" is a genuine, useful answer, and it is priced as one processed board with no job results.

What happens when Greenhouse changes its API?

Every response is shape-checked before it is normalized. A change that breaks the shape fails the affected board loudly instead of emitting silently wrong records, and a scheduled smoke test runs against known-stable boards so we usually find out before you do.

Is this legal to use?

The data is public, employer-published job advertising, retrieved through Greenhouse's own public Job Board API. Job postings are not personal data, attribution and apply URLs are preserved on every record, and DEI demographic questions are never fetched or stored. As always, how you use the data is your responsibility.