# Greenhouse ATS Job Board Lookup by Company (`dataspryva/greenhouse-ats-job-board-lookup-by-company`) Actor

Pull every open role from one or more Greenhouse company boards, or look up specific postings by job ID, with location, department, employment type, salary, and apply link for each.

- **URL**: https://apify.com/dataspryva/greenhouse-ats-job-board-lookup-by-company.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 ATS Job Board Lookup by Company

Pull every open role from any company hiring on Greenhouse, or look up specific postings by URL. Start from a board token, a careers link, a company name or a domain; get clean job records with structured pay ranges, locations, departments, application questions, published dates and direct apply links. Greenhouse's public job board data is read directly, with no login, API key, cookie or proxy.

### What this actor does

- **Three modes:** scrape company boards, fetch specific job URLs, or resolve company boards from names and domains.
- **Flexible company input:** board tokens, `boards.greenhouse.io` / `job-boards.greenhouse.io` links, embed links, single-job links, company names and domains.
- **Structured pay:** every disclosed pay band is preserved with min/max, currency, period and base/OTE labelling.
- **Useful filters:** title, location, department, workplace type, employment type, published/updated date, salary and currency.
- **Descriptions and questions:** full HTML, plain text or Markdown, plus the application questions each posting asks.
- **Complete context:** published and updated dates, offices, department hierarchy, metadata, language, requisition ID and apply URL.
- **Empty fields are omitted** — not set to `null`, `""` or a placeholder.

### Output per job

- `id` — Greenhouse job post ID
- `internalJobId` — Greenhouse's internal job ID
- `requisitionId` — employer requisition number, when published
- `title` — job title
- `companySlug` — Greenhouse board token
- `companyName` — employer name
- `location` — primary location object with `name`, `city`, `state`, `country`
- `locations[]` — every location when a posting covers several
- `isRemote` — `true` when the posting is remote
- `workplaceType` — `remote`, `hybrid` or `onsite` when stated
- `departments[]` — department names
- `departmentsDetailed[]` — department `id`, `name` and `parentId`
- `offices[]` — office names
- `officesDetailed[]` — office `id`, `name`, `location` and `parentId`
- `employmentType` — full-time, part-time, contract, internship or temporary, when stated
- `educationLevel` — Greenhouse education requirement code, when published
- `salary` — primary pay object with `min`, `max`, `currency`, `period`, `range` and `source`
- `salaryBands[]` — every disclosed band with `label`, `min`, `max`, `currency`, `period`, `kind` and `source`
- `publishedAt` — first published timestamp
- `updatedAt` — last updated timestamp
- `applicationDeadline` — application deadline, when set
- `language` — posting language code
- `metadata[]` — custom fields with `name`, `value` and `valueType`
- `team` — team name from metadata, when present
- `seniority` — seniority from metadata, when present
- `content` — full description HTML, when descriptions are enabled
- `contentText` — plain-text description, when requested
- `contentMarkdown` — Markdown description, when requested
- `questions[]` — application questions with `label`, `required` and `fields`
- `applyUrl` — direct apply link
- `absoluteUrl` — Greenhouse-hosted posting URL
- `boardUrl` — company's Greenhouse board URL
- `sourceUrl` — stable Greenhouse posting URL
- `region` — `us` or `eu`
- `recordType` — `job`
- `scrapedAt` — UTC timestamp of the scrape

### Output per company (mode = `companySearch`)

- `companySlug`, `companyName`, `companyDescription` (when published)
- `boardUrl`, `region`, `openJobs` (open jobs when `verifyCompanies` is true)
- `status` — `found`, `empty`, `not_found` or `ambiguous`
- `sourceUrl`, `recordType: "company"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `companyJobs` | `companyJobs`, `jobDetails` or `companySearch` (legacy `getJobs`/`getJob` aliases are accepted) |
| `companies` | array | – | Tokens, board URLs, job URLs, company names or domains |
| `jobUrls` | array | – | Full job URLs for `jobDetails` |
| `searchQuery` | string | – | Directory search text for `companySearch` |
| `titleKeywords` | array | – | Keep titles containing any of these words |
| `excludeTitleKeywords` | array | – | Drop titles containing any of these words |
| `locations` | array | – | Keep locations or offices containing any of these words |
| `departments` | array | – | Keep departments containing any of these words |
| `workplaceType` | string | `any` | `any`, `remote`, `hybrid` or `onsite` |
| `employmentType` | string | `any` | `any`, `full-time`, `part-time`, `contract`, `internship` or `temporary` |
| `publishedAfter` | string | – | First-published cutoff (`YYYY-MM-DD`) |
| `updatedAfter` | string | – | Last-updated cutoff (`YYYY-MM-DD`) |
| `onlyWithSalary` | boolean | `false` | Keep only jobs with a stated pay range |
| `minAnnualSalary` | integer | – | Minimum annualized base pay |
| `salaryCurrency` | string | `any` | Only jobs with pay in this currency |
| `sortBy` | string | `board` | `board`, `publishedNewest`, `publishedOldest`, `updatedNewest` or `titleAZ` |
| `content` | boolean | `false` | Include full job descriptions |
| `descriptionFormat` | string | `html` | `html`, `text`, `markdown` or `all` |
| `includeQuestions` | boolean | `false` | Fetch application questions (one extra request per emitted job) |
| `maxItems` | integer | `500` | Maximum records to emit (1–10,000) |
| `maxJobsPerCompany` | integer | `0` | Per-company cap after filters; `0` means no cap |
| `verifyCompanies` | boolean | `true` | Live-check companies in `companySearch` and report open jobs |

#### Example: all engineering roles at three companies

```json
{
  "mode": "companyJobs",
  "companies": ["stripe", "figma", "https://job-boards.greenhouse.io/airbnb"],
  "titleKeywords": ["engineer", "developer"],
  "workplaceType": "remote",
  "content": false,
  "maxItems": 200
}
```

#### Example: company names and domains

```json
{
  "mode": "companyJobs",
  "companies": ["Anthropic", "jobs.elastic.co", "HubSpot"],
  "onlyWithSalary": true,
  "minAnnualSalary": 120000,
  "salaryCurrency": "USD",
  "sortBy": "publishedNewest",
  "maxItems": 100
}
```

#### Example: specific jobs with descriptions, Markdown and questions

```json
{
  "mode": "jobDetails",
  "jobUrls": [
    "https://job-boards.greenhouse.io/gitlab/jobs/8860302002",
    "https://boards.greenhouse.io/figma/jobs/5426468004"
  ],
  "content": true,
  "descriptionFormat": "all",
  "includeQuestions": true
}
```

#### Example: resolve a company list

```json
{
  "mode": "companySearch",
  "companies": ["Airbnb", "stripe.com", "HubSpot", "not-a-real-board"],
  "verifyCompanies": true,
  "maxItems": 10
}
```

### Use cases

- **Job boards and aggregators** — build live company career pages from the source, with stable IDs and apply links.
- **Recruiting and sourcing** — monitor target companies by department, location and seniority.
- **Compensation research** — collect disclosed pay bands with currency and period labels.
- **Sales and hiring signals** — see which teams and locations are expanding.
- **AI agents and enrichment** — feed clean job text, questions and structured pay into matching or RAG pipelines.
- **Applicant tooling** — list the exact questions a Greenhouse application will ask before a candidate starts.

### FAQ

**Do I need a Greenhouse account, API key or proxy?**
No. The actor reads publicly published job boards. There is nothing to configure and no login, cookie or proxy needed.

**How do I find a company's board token?**
Paste the company's Greenhouse board link, embed link or a single job link. If you only have a company name or domain, the actor tries the built-in verified directory, then common board-name variants. Name/domain lookup is best-effort; a board URL or token is always exact.

**Does this work for companies on the EU Greenhouse host?**
Yes. EU boards return the same public data and are marked `region: "eu"`.

**Why is salary missing from some jobs?**
Pay disclosure is a company choice. Many employers publish no range at all; the field is included only when a real range is available. The actor never invents a number.

**What is the difference between `salary` and `salaryBands`?**
`salary` is the primary base-pay summary. `salaryBands` keeps every disclosed band, including location zones and OTE ranges, because one posting can publish several. OTE and commission bands stay in `salaryBands` but are excluded from the `salary` envelope.

**Why is employment type missing?**
Greenhouse no longer exposes a dedicated employment-type field. The actor reads it from employer metadata when present and omits it otherwise.

**Can I get the full job description and questions?**
Yes. Turn on descriptions and choose HTML, text, Markdown or all three. Questions are optional because they require one additional request per job.

**How many jobs can I get per company?**
A company's whole board is returned in one response, so there is no page limit. Use `maxItems` and `maxJobsPerCompany` to control run size.

**Does this work for private or unlisted boards?**
No. Only publicly published Greenhouse boards are readable.

**Is this affiliated with Greenhouse?**
No. This is an independent third-party actor that reads publicly published job board data and is not operated by or affiliated with Greenhouse Software, Inc.

### Limitations

- Pay, employment type and some metadata are employer-optional; missing values are real, not parsing failures.
- Company name/domain resolution is best-effort. Use a board URL or token for an exact match.
- Application questions are only available per job and add one request per record.
- A posting can publish multiple pay bands; the actor preserves all of them instead of picking one.

# Actor input Schema

## `mode` (type: `string`):

What to fetch: jobs from company boards, specific job URLs, or company board lookup.

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

Board tokens, board URLs, embed URLs, job URLs, company names or domains. Examples: "stripe", "https://job-boards.greenhouse.io/figma", "Airbnb", "jobs.elastic.co".

## `jobUrls` (type: `array`):

Full Greenhouse job URLs to fetch one by one. A company board URL alone is not enough; include /jobs/<id>.

## `searchQuery` (type: `string`):

Name or token text to match against the built-in company directory. Leave empty to resolve the Companies list instead.

## `titleKeywords` (type: `array`):

Keep jobs whose title contains any of these words (case-insensitive).

## `excludeTitleKeywords` (type: `array`):

Drop jobs whose title contains any of these words (case-insensitive).

## `locations` (type: `array`):

Keep jobs whose location or office contains any of these words, e.g. Remote, London, New York.

## `departments` (type: `array`):

Keep jobs in departments that contain any of these words, e.g. Engineering, Sales.

## `workplaceType` (type: `string`):

Keep remote, hybrid or on-site roles. Jobs without a stated arrangement are dropped when this is not Any.

## `employmentType` (type: `string`):

Keep full-time, part-time, contract, internship or temporary roles when the employer states it.

## `publishedAfter` (type: `string`):

Keep jobs first published on or after this date (YYYY-MM-DD).

## `updatedAfter` (type: `string`):

Keep jobs last updated on or after this date (YYYY-MM-DD).

## `onlyWithSalary` (type: `boolean`):

Keep only jobs with a published or clearly stated pay range.

## `minAnnualSalary` (type: `integer`):

Keep jobs whose base pay reaches at least this yearly amount. Hourly, monthly and weekly ranges are annualized.

## `salaryCurrency` (type: `string`):

Only keep jobs with pay in this currency. Use Any to ignore currency.

## `sortBy` (type: `string`):

Result order after filtering.

## `content` (type: `boolean`):

Include the full job description. Departments and offices are always included (fetched separately when descriptions are off).

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

Format used when Include job descriptions is on. HTML is always the content field; text/markdown add contentText/contentMarkdown.

## `includeQuestions` (type: `boolean`):

Fetch each job's application form questions. Adds one request per emitted job.

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

Maximum number of job or company records to emit.

## `maxJobsPerCompany` (type: `integer`):

Cap jobs per company after filters (mode=companyJobs). 0 means no per-company cap.

## `verifyCompanies` (type: `boolean`):

Check each company against the live board and report its open-job count.

## Actor input object example

```json
{
  "mode": "companyJobs",
  "companies": [
    "airbnb"
  ],
  "workplaceType": "any",
  "employmentType": "any",
  "onlyWithSalary": false,
  "salaryCurrency": "any",
  "sortBy": "board",
  "content": false,
  "descriptionFormat": "html",
  "includeQuestions": false,
  "maxItems": 1,
  "maxJobsPerCompany": 0,
  "verifyCompanies": true
}
```

# Actor output Schema

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

Dataset containing Greenhouse job records, plus company rows when mode=companySearch.

# 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 = {
    "mode": "companyJobs",
    "companies": [
        "airbnb"
    ],
    "workplaceType": "any",
    "employmentType": "any",
    "onlyWithSalary": false,
    "salaryCurrency": "any",
    "sortBy": "board",
    "content": false,
    "descriptionFormat": "html",
    "includeQuestions": false,
    "maxItems": 1,
    "maxJobsPerCompany": 0,
    "verifyCompanies": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/greenhouse-ats-job-board-lookup-by-company").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 = {
    "mode": "companyJobs",
    "companies": ["airbnb"],
    "workplaceType": "any",
    "employmentType": "any",
    "onlyWithSalary": False,
    "salaryCurrency": "any",
    "sortBy": "board",
    "content": False,
    "descriptionFormat": "html",
    "includeQuestions": False,
    "maxItems": 1,
    "maxJobsPerCompany": 0,
    "verifyCompanies": True,
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/greenhouse-ats-job-board-lookup-by-company").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 '{
  "mode": "companyJobs",
  "companies": [
    "airbnb"
  ],
  "workplaceType": "any",
  "employmentType": "any",
  "onlyWithSalary": false,
  "salaryCurrency": "any",
  "sortBy": "board",
  "content": false,
  "descriptionFormat": "html",
  "includeQuestions": false,
  "maxItems": 1,
  "maxJobsPerCompany": 0,
  "verifyCompanies": true
}' |
apify call dataspryva/greenhouse-ats-job-board-lookup-by-company --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/greenhouse-ats-job-board-lookup-by-company"
        }
    }
}
```

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/iAMfb4Uf2haeImsKk/builds/gRN0mLqin4dVb7ZGK/openapi.json