How to Scrape Greenhouse Job Boards in 2026

Most job scraping is a brawl with anti-bot systems. Greenhouse is the rare exception — and understanding why changes how you should approach it. Greenhouse is an applicant tracking system (ATS) that thousands of companies use to host their careers pages, and it deliberately exposes a public job board REST API so that those careers pages (and aggregators) can read the data. No login, no captcha, no headless browser. The challenge isn’t getting in; it’s knowing the endpoints, modeling the output, and batching across boards. This guide covers all three.

The ATS reality: it’s an API, not a scrape

When a company hosts hiring on Greenhouse, their jobs live behind a board token (usually the company name, like stripe or airbnb). Greenhouse serves that board’s data over public HTTP GET endpoints that return JSON. That means:

• No authentication. No OAuth, no API key, no per-customer integration.
• No anti-bot. No fingerprinting, no proxy requirement, no challenge pages.
• No pagination. A board returns its full job list in one response — you filter client-side.
• Sub-second per board. Plain GETs against a fast public API.

The actor wraps these endpoints, adds bounded parallel fetches across many boards, retries with linear backoff, and normalizes everything into clean JSON records. Companies on Greenhouse include Airbnb, Stripe, Anthropic, Mistral AI, Doctolib, Datadog, Notion — and thousands of other tech companies.

The modes

The actor operates in several modes that map to the board’s endpoint structure:

• List jobs across one or many boards — the inventory.
• Job detail — full HTML job description (decoded), with optional plain-text content, structured custom fields, pay-range arrays, and the application/EEOC/demographic question arrays.
• Company board profile — board-level metadata.
• Departments — the hierarchical department tree.
• Offices — the office/geographic hierarchy.

Because boards have no pagination, listing is fast and complete: you get every open role on a board in a single fetch, then filter by city, department, or salary band client-side.

▶ Run the Greenhouse Job Board API scraper — jobs, full descriptions, departments, offices and pay ranges from any Greenhouse board. Pure HTTP, no auth, parallel batch across thousands of companies.

What a job record looks like

{
  "company_board": "stripe",
  "job_id": 5712340,
  "title": "Staff Software Engineer, Payments",
  "absolute_url": "https://boards.greenhouse.io/stripe/jobs/5712340",
  "location": "Dublin, Ireland",
  "departments": ["Engineering", "Payments"],
  "offices": ["Dublin"],
  "pay_range": { "min": 140000, "max": 195000, "currency": "EUR" },
  "content_html": "<p>About the role...</p>",
  "content_text": "About the role...",
  "updated_at": "2026-05-31T08:12:44Z"
}

Two fields make this especially useful: content_html (decoded — Greenhouse returns it HTML-entity-escaped, which the actor handles) and the optional pay_range, which is the foundation of any compensation-benchmarking product. The application question arrays and EEOC/demographic/GDPR metadata are there too if your use case touches compliance or application automation.

Typical use cases

• HR tech and job aggregators — build a near-real-time tech-job inventory across every Greenhouse-hosted company, no per-company integration.
• Sales intelligence and lead gen — hiring signals are buying signals. An engineering-hiring spike means budget and growth; surface it for prospecting.
• Recruitment agencies — track open roles by company, city, department, and salary band.
• VC / scouting — measure hiring velocity across a portfolio as a leading growth indicator.
• Compensation intelligence — collect published pay ranges and titles by location for benchmarking.
• ATS / HRIS integrations — ingest Greenhouse-hosted jobs without negotiating per-customer OAuth.
• AI agents — feed structured job descriptions (HTML + text) into career-coaching and company-research assistants.
• Career sites and newsletters — populate niche boards and curated digests with fresh listings.

The hiring-signal angle is the underrated one. Because there’s no friction, you can poll thousands of boards cheaply and detect the moment a company opens its first ML role or doubles its sales headcount — a leading indicator you can sell.

Cost math — and a notable detail

Here’s the standout: per the actor’s pricing, the per-result charge is zero — you pay only a tiny per-run start fee. That means a run that lists every open role across hundreds of boards costs effectively the start fee plus compute, with no per-row tax. For high-volume aggregation — the exact use case Greenhouse data is best for — this is about as cheap as managed scraping gets. Polling a few thousand boards daily to maintain a live tech-job inventory costs a trivial amount per month.

The DIY version is genuinely simple for one board (it’s a public API, after all). The work the actor saves you is at scale: bounded parallelism so you don’t hammer the endpoints, retry/backoff for the boards that occasionally 5xx, HTML decoding, normalization across boards whose fields vary, and the department/office tree exports.

Pitfalls to plan for

• Board tokens aren’t always the company name. Some are abbreviated or legacy. You need the correct token per company; a wrong token returns nothing.
• Pay ranges are optional and uneven. Many boards omit them, and where present they vary by jurisdiction (US pay-transparency laws drive most of them). Treat pay_range as frequently-null.
• HTML needs decoding. Greenhouse returns descriptions entity-escaped. If you parse the raw API yourself, decode before rendering or indexing.
• Not every company is on Greenhouse. It’s huge in tech but won’t cover non-tech or companies on Lever/Workday/Ashby. Don’t assume full market coverage.
• “Open” can lag. A role can linger after it’s effectively filled. Use updated_at and diff across runs to infer real activity.
• Respect the endpoints. No auth doesn’t mean infinite throughput — keep parallelism bounded (the actor does) to stay a good citizen.

FAQ

Is there a Greenhouse jobs API? Yes — Greenhouse exposes a public job board API at boards-api.greenhouse.io/v1/boards/{token}/jobs (and /jobs/{id} for detail). It’s unauthenticated, has no anti-bot, and returns each board’s full job list in one response. The board token is usually the company name (e.g. stripe).

Do I need an API key to scrape Greenhouse job boards? No. The job board endpoints are public and keyless. A key/OAuth is only needed for the private Harvest/Onboarding APIs (a company’s own ATS data) — not for reading public job boards.

How do I find a company’s Greenhouse board token? It’s the slug in their careers URL (boards.greenhouse.io/{token} or job-boards.greenhouse.io/{token}). Some are abbreviated or legacy, so a wrong token returns nothing — verify per company.

Wrapping up

Greenhouse is the easy case in job scraping precisely because it’s an open ATS API — but turning that into a clean, batched, normalized, department-aware dataset across thousands of boards is still real work. A managed actor gives you list/detail/department/office modes, decoded descriptions, and pay ranges with a per-result cost of zero, which makes large-scale hiring-signal and job-inventory products genuinely cheap to run.

▶ Open the Greenhouse Job Board API on Apify — full jobs, descriptions, departments, offices, pay ranges. No auth, parallel batch, per-result cost of zero. Start with Apify’s free monthly credit.