# Greenhouse Public Jobs Scraper (`fetchcraft/greenhouse-jobs-scraper`) Actor

Pulls all public job postings for any company using Greenhouse as their ATS. Returns structured data (title, location, department, posted date, apply URL). Pairs with the AI Sales Personalizer for recruiter and B2B outreach to companies actively hiring. Free preview, $0.005 per job after.

- **URL**: https://apify.com/fetchcraft/greenhouse-jobs-scraper.md
- **Developed by:** [Emily Ward](https://apify.com/fetchcraft) (community)
- **Categories:** Lead generation, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 job posting returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Greenhouse Public Jobs Scraper

**Pulls all public job postings for any company using Greenhouse as their applicant tracking system. Hiring at scale is one of the strongest growth signals available, and Greenhouse's public board API exposes it cleanly.**

### What you get back per job

| Field | Description |
| --- | --- |
| `company_token` | The Greenhouse company slug you queried |
| `job_id` | Greenhouse's job ID |
| `title` | Role title |
| `department` | Department names (joined with comma if multiple) |
| `location` | Display location |
| `remote` | Boolean: true if location mentions remote / work-from-home / anywhere |
| `updated_at` | Last update timestamp |
| `apply_url` | Direct apply link on Greenhouse |

### Pricing

- **Preview mode**: $0 (5 jobs total, no charges)
- **Standard**: $0.005 per job returned

A typical hiring company has 20-200 open roles. Scanning 10 companies = ~$1 to $10 total. Recurring weekly monitoring across 20 target accounts = ~$10 to $40/month.

### How to use it

1. Click **Try for free** with `preview_mode` ticked.
2. Enter a list of Greenhouse company slugs in `companies`. Find the slug by visiting any company's careers page powered by Greenhouse: the URL contains `boards.greenhouse.io/SLUG`. Defaults include `vercel`, `anthropic`, `supabase`, `ramp`.
3. (Optional) Filter by `include_departments`: "engineering", "sales", "marketing".
4. (Optional) Filter by `include_locations`: "sydney", "remote", "london".
5. (Optional) `remote_only: true` for distributed roles only.
6. Hit Start.

### Common use cases

**B2B SDRs at devtools / DevOps / AI companies** monitor hiring at target accounts. A target account hiring 5 senior engineers in 90 days is a signal they have engineering budget and are scaling, both of which mean they buy more tools.

**Recruiters** use Greenhouse as a talent-mapping source. Knowing which competitors are hiring which roles, in which locations, with which titles, is leverage in candidate conversations.

**Investors and scouts** use hiring volume + role mix as a growth indicator for portfolio companies and prospect lists.

**Account-based marketers** time outreach to coincide with hiring surges (a company that just posted 10 new sales roles is the right time to sell sales tooling).

### Pipeline: combine with AI Sales Personalizer

1. Run this scraper on your 20 target accounts. Get back 100 to 500 open roles, with company + apply URL.
2. Group by `company_token`, take the company URL (one per company).
3. Feed company URLs through **AI Sales Personalizer** with a context-aware pitch ("We help engineering teams scaling past 50 engineers...").
4. Push to your sequencer for outbound.

Total cost: $5 (scraper, 1000 roles across 20 accounts) + $3 (20 personalizations) = $8 for a full intent-driven outbound list.

### Sister actors

- **AI Sales Personalizer**: turns target accounts into personalized cold openers
- **HN Who Is Hiring Scraper**: complementary aggregated hiring signal across all of HN
- **Show HN Lead Scraper**: complementary product-launch leads
- **ProductHunt Daily Launches Scraper**: complementary product-launch leads
- **GitHub Trending Scraper**: complementary OSS-maintainer leads

The 6-actor portfolio gives complete B2B intelligence coverage for under $50/month.

### What this does NOT do

- It does not work for companies on Lever, Workday, Ashby, or other ATSes. Greenhouse only.
- It does not surface salary data (Greenhouse does not expose it via the public API).
- It does not include compensation_compensation_complete data unless the company has opted in.
- It does not check that companies still have the role open beyond Greenhouse's own freshness.

### Tips

1. **Build a target-account list once, scrape weekly.** A persistent list of 20 to 50 Greenhouse-hosted target accounts is the highest-leverage monitoring setup.
2. **Pair department + location filters.** "Engineering + Sydney" surfaces a much tighter list than either alone.
3. **Watch the `updated_at` field across runs.** New jobs since your last run are the hottest leads.

### How to find more Greenhouse companies

Many YC-backed startups use Greenhouse. Common slugs include: `anthropic`, `vercel`, `supabase`, `ramp`, `airtable`, `gusto`, `figma`, `linear`, `replicate`, `mercury`. Search "boards.greenhouse.io" on Google for many more.

### Tags

`leads` `lead-generation` `greenhouse` `job-board` `recruiting` `tech-recruiting` `b2b` `sales` `sdr` `intent-data`

---

Built by Emily Ward, Sydney. Sixth actor in the B2B intel portfolio.

# Actor input Schema

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

List of Greenhouse company slugs to scrape. Each slug is the path segment in a Greenhouse careers URL (e.g., 'vercel' for boards.greenhouse.io/vercel). Find a company's slug by visiting their careers page and checking the URL.
## `include_departments` (type: `string`):

Filter to roles in these departments. Match is case-insensitive substring. Example: "engineering, sales, marketing". Leave blank for all departments.
## `include_locations` (type: `string`):

Filter to roles in these locations. Match is case-insensitive substring. Example: "sydney, remote, london". Leave blank for all.
## `remote_only` (type: `boolean`):

If true, only return jobs whose location includes Remote, Anywhere, or Work from home.
## `max_per_company` (type: `integer`):

Hard cap per company.
## `preview_mode` (type: `boolean`):

Preview mode (free, 5 jobs total)

## Actor input object example

```json
{
  "companies": [
    "vercel",
    "anthropic",
    "supabase",
    "ramp"
  ],
  "include_departments": "",
  "include_locations": "",
  "remote_only": false,
  "max_per_company": 200,
  "preview_mode": false
}
````

# 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 = {
    "companies": [
        "vercel",
        "anthropic",
        "supabase",
        "ramp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetchcraft/greenhouse-jobs-scraper").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 = { "companies": [
        "vercel",
        "anthropic",
        "supabase",
        "ramp",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fetchcraft/greenhouse-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companies": [
    "vercel",
    "anthropic",
    "supabase",
    "ramp"
  ]
}' |
apify call fetchcraft/greenhouse-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetchcraft/greenhouse-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Greenhouse Public Jobs Scraper",
        "description": "Pulls all public job postings for any company using Greenhouse as their ATS. Returns structured data (title, location, department, posted date, apply URL). Pairs with the AI Sales Personalizer for recruiter and B2B outreach to companies actively hiring. Free preview, $0.005 per job after.",
        "version": "0.1",
        "x-build-id": "AXzfPlScfeg4iC1cX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetchcraft~greenhouse-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetchcraft-greenhouse-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetchcraft~greenhouse-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetchcraft-greenhouse-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetchcraft~greenhouse-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetchcraft-greenhouse-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Greenhouse company tokens",
                        "type": "array",
                        "description": "List of Greenhouse company slugs to scrape. Each slug is the path segment in a Greenhouse careers URL (e.g., 'vercel' for boards.greenhouse.io/vercel). Find a company's slug by visiting their careers page and checking the URL.",
                        "default": [
                            "vercel",
                            "notion-labs",
                            "anthropic"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "include_departments": {
                        "title": "Include departments (comma-separated)",
                        "type": "string",
                        "description": "Filter to roles in these departments. Match is case-insensitive substring. Example: \"engineering, sales, marketing\". Leave blank for all departments.",
                        "default": ""
                    },
                    "include_locations": {
                        "title": "Include locations (comma-separated)",
                        "type": "string",
                        "description": "Filter to roles in these locations. Match is case-insensitive substring. Example: \"sydney, remote, london\". Leave blank for all.",
                        "default": ""
                    },
                    "remote_only": {
                        "title": "Remote roles only",
                        "type": "boolean",
                        "description": "If true, only return jobs whose location includes Remote, Anywhere, or Work from home.",
                        "default": false
                    },
                    "max_per_company": {
                        "title": "Max jobs per company",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap per company.",
                        "default": 200
                    },
                    "preview_mode": {
                        "title": "Preview mode (free, 5 jobs total)",
                        "type": "boolean",
                        "description": "Preview mode (free, 5 jobs total)",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
