Greenhouse APIjob-boards.greenhouse.io ↗
Access job listings, departments, offices, and application form questions from any Greenhouse.io public job board via 6 structured endpoints.
What is the Greenhouse API?
This API exposes 6 endpoints for reading structured data from any public Greenhouse.io job board. list_jobs returns every open position for a given board token, including job ID, title, URL, location, department, and office assignments. get_job goes deeper, returning the full HTML job description and the complete application form question set. search_jobs adds keyword, department, office, and recency filters across any board.
curl -X GET 'https://api.parse.bot/scraper/83293b68-327f-4cd1-bf90-079591d9fd35/get_board_info?board_token=anthropic' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace job-boards-greenhouse-io-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
from parse_apis.greenhouse_job_board_api import Greenhouse, Board, Job, Department, Office, Location
greenhouse = Greenhouse()
# Construct a board and list its jobs
board = greenhouse.board("anthropic")
# List all jobs from the board
for job in board.jobs(content=False, limit=5):
print(job.title, job.absolute_url, job.id)
# Search for jobs matching a keyword in a specific department
for job in board.search(query="engineer", department="Sales", limit=3):
print(job.title, job.location.name)
# List departments on the board
for dept in board.departments(limit=5):
print(dept.name, dept.id, dept.parent_id)
# List offices on the board
for office in board.offices(limit=3):
print(office.name, office.location, office.id)
# Get full details for a specific job
for job in board.jobs(limit=1):
detailed = job.refresh(board_token="anthropic", questions=True)
print(detailed.title, detailed.content, detailed.absolute_url)
Retrieve basic info about a company's Greenhouse job board, including the company name and any board-level content. One round-trip per board.
| Param | Type | Description |
|---|---|---|
| board_tokenrequired | string | The company's Greenhouse board token (e.g. 'anthropic', 'spacex', 'stripe'). |
{
"type": "object",
"fields": {
"name": "string, the company/board display name",
"content": "string, board content or notes (may be empty)"
},
"sample": {
"data": {
"name": "Anthropic",
"content": ""
},
"status": "success"
}
}About the Greenhouse API
Board and Job Data
Every endpoint is scoped to a specific company board via the board_token parameter — for example, anthropic, stripe, or spacex. get_board_info returns the company display name and any board-level content. list_jobs returns an array of job objects, each carrying id, title, absolute_url, location, departments, and offices. Pass content=true to include the full HTML job description and metadata in each job object.
Job Detail and Application Forms
get_job retrieves a single posting by job_id and returns all fields from the list view plus the full content HTML and, when questions=true, an array of application form question objects. Each question object includes label, required, and a fields array describing input type — useful for building application pre-fill tools or ATS integrations that need to mirror a company's exact form structure.
Department and Office Browsing
list_departments returns every department on the board with id, name, parent_id, child_ids, and a nested jobs array. list_offices follows the same pattern, nesting departments (and their jobs) inside each office object — so you can traverse the full org hierarchy of open roles in one call. Both endpoints are useful for building filtered job discovery interfaces or monitoring headcount changes by team or location.
Search and Filtering
search_jobs accepts a free-text query matched against job titles and descriptions, plus department and office filters (exact match, case-insensitive). The is_new boolean limits results to jobs published within the last 7 days, making it straightforward to build a job-alert feed without storing state beyond the last poll time.
The Greenhouse API is a managed, monitored endpoint for job-boards.greenhouse.io — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when job-boards.greenhouse.io changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official job-boards.greenhouse.io API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Monitor new engineering roles at a target company using
search_jobswithis_new=trueand a department filter. - Pre-fill a job application UI by fetching the exact question structure from
get_jobwithquestions=true. - Build a cross-company job aggregator by iterating
list_jobsacross multiple board tokens. - Track headcount growth by department over time using repeated calls to
list_departments. - Map office expansion by polling
list_officesand diffing the returned location and job counts. - Power a recruiter research tool that surfaces all open roles at a company with direct application URLs from the
absolute_urlfield. - Alert on keyword-matching roles (e.g. 'machine learning', 'staff engineer') across multiple boards using the
queryparameter insearch_jobs.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Greenhouse have an official developer API?+
What does `search_jobs` return and how does the `is_new` filter work?+
search_jobs returns a filtered subset of all jobs on the board, along with a total count. The is_new filter compares each job's publish date against a 7-day window and returns only postings added within that period. Combined with the query, department, and office parameters, you can narrow results to, for example, new roles in a specific office without client-side post-processing.Does the API return private or internal job postings?+
board_token.Can the API submit job applications on behalf of a user?+
Does the API support paginating through large job lists?+
list_jobs and search_jobs return all matching jobs in a single response along with a total count — there is no page or offset parameter. For boards with a very large number of postings, the full result set is returned at once. If you need incremental delivery, you can fork this API on Parse and revise it to add pagination logic.