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

Scrape every active job from any Greenhouse careers board — titles, locations, departments, offices, full descriptions, custom fields, and application form questions. Live from the official API, no cache or AI guesswork. Filter by title, location, department, date, or remote-only at the source.

- **URL**: https://apify.com/schnellscrapers/greenhouse-jobs-scraper.md
- **Developed by:** [Nate Schnell](https://apify.com/schnellscrapers) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### What does Greenhouse Jobs Scraper do?

**Greenhouse Jobs Scraper** pulls every active job from any company's Greenhouse-hosted careers board, live from the official Greenhouse Job Board API. Paste the board token (e.g. `airbnb`, `stripe`) or any Greenhouse URL, get back a clean dataset of every posting — titles, locations, departments, offices, custom hiring metadata, the full HTML description, and optionally the application form's questions. Great for recruiters tracking competitor hiring, lead-gen pipelines targeting hiring companies, job aggregators backfilling postings, and analysts mapping talent demand.

### What data can you extract from Greenhouse?

Each emitted record has 20 fields. The most common ones:

- **Identity** — `id`, `internalJobId`, `requisitionId`, `board` (token), `absoluteUrl`
- **Title & company** — `title`, `companyName`
- **Location** — `location` (string), `offices[]` (with Greenhouse office IDs and city/region)
- **Department** — `departments[]` (with Greenhouse department IDs)
- **Timing** — `firstPublished`, `updatedAt`, `applicationDeadline`
- **Description** — `content` (HTML, entity-decoded), optional `contentText` (plain text)
- **Custom hiring fields** — `metadata[]` carries everything the company configured on the board (workplace type, salary band, employment type, etc.)
- **Application form** — optional `questions` object with custom questions, demographic questions, location questions, and compliance notices

Every Greenhouse-supported field is preserved with the original Greenhouse IDs, so records can be joined back to internal hiring data.

### How to use Greenhouse Jobs Scraper

1. Create a free Apify account.
2. Open **Greenhouse Jobs Scraper** and click **Try for free**.
3. Paste one or more board tokens or URLs into **Greenhouse boards**. The token is the last path segment of a company's careers URL — e.g. `boards.greenhouse.io/airbnb` → `airbnb`.
4. (Optional) Add filters: `Title includes`, `Location excludes`, `Department includes`, `Remote only`, `Only jobs updated after`, etc. Filtering runs at the source, before billing.
5. Click **Save & Start**. Each board returns in 1–10 seconds depending on size.
6. Download results from the **Storage** tab in JSON, CSV, Excel, XML, or HTML.

### How much does it cost?

Greenhouse Jobs Scraper is **pay-per-result**: you're billed one event per emitted job, regardless of how many boards you query.

- **$0.0015 per job** (Free + Bronze plans)
- **$0.001 per job** (Silver, Gold, Platinum, Diamond)
- The Apify Free plan includes $5/month of credit, enough for ~3,300 free jobs.
- **No minimum** — pull 1 job or 50,000.
- Filters (title, location, department, date, remote) are applied at the source, so filtered-out jobs aren't billed.

Cost tip: setting `includeContent: false` doesn't change the per-job price, but it does cut the dataset size by ~95% if you only need titles and links.

### Input

Required: `boards` (array of tokens or URLs). Every other field is optional.

```json
{
  "boards": ["airbnb", "stripe", "https://boards.greenhouse.io/figma"],
  "includeContent": true,
  "parseContent": true,
  "titleFilter": ["engineer", "designer"],
  "locationExcludeFilter": ["india"],
  "departmentFilter": ["engineering"],
  "remoteOnly": false,
  "updatedAfter": "2026-04-01",
  "maxItems": 200
}
````

See the **Input** tab for every field with help text. Common patterns:

- Pull *everything* from one company: `{ "boards": ["airbnb"] }`
- Just titles and links (cheap fast pull): `{ "boards": ["stripe"], "includeContent": false }`
- Remote engineering jobs across several companies: `{ "boards": ["airbnb","stripe","figma"], "remoteOnly": true, "departmentFilter": ["engineering"] }`
- Build an LLM-friendly dataset: `{ "boards": ["airbnb"], "parseContent": true, "includeQuestions": true }`

### Output

One record per active job. Sample:

```json
{
  "id": 7649441,
  "internalJobId": 3369660,
  "requisitionId": "ONE",
  "board": "airbnb",
  "companyName": "Airbnb",
  "title": "Account Executive (12 Month FTC)",
  "absoluteUrl": "https://careers.airbnb.com/positions/7649441?gh_jid=7649441",
  "location": "Paris, France",
  "departments": [{ "id": 57796, "name": "Sales" }],
  "offices": [{ "id": 178, "name": "Paris, France", "location": "Paris, France" }],
  "firstPublished": "2026-02-24T09:04:33-05:00",
  "updatedAt": "2026-02-24T09:25:19-05:00",
  "language": "en",
  "applicationDeadline": null,
  "metadata": [
    { "id": 10216612, "name": "Workplace Type", "value": "Hybrid", "valueType": "single_select" }
  ],
  "content": "<p>Airbnb was born in 2007 ...</p>",
  "contentText": "Airbnb was born in 2007 ...",
  "questions": null,
  "scrapedAt": "2026-05-21T19:16:56Z",
  "source": "https://boards-api.greenhouse.io/v1/boards/airbnb/jobs?content=true"
}
```

Empty boards return zero records (Greenhouse responds 200 with `{"jobs":[]}`). Boards that don't exist or have moved off Greenhouse log a warning and skip — your run isn't billed for them.

### Integrations

Greenhouse Jobs Scraper works with the full Apify integration set: **Make**, **Zapier**, **n8n**, **Slack**, **Google Drive**, **GitHub**, **Airbyte**, scheduled runs, and the Apify API. Trigger runs from your CRM, push fresh jobs into a Sheet or a database, or fan out webhook notifications when new postings appear. See [Apify integrations](https://docs.apify.com/platform/integrations).

### Related actors

- [Indeed Jobs Scraper](https://apify.com/schnellscrapers/indeed-jobs-scraper) — for jobs hosted on Indeed (millions of postings across all employers, not just Greenhouse-using companies).
- For multi-ATS aggregation across Workday + Lever + Ashby + Greenhouse and 50 other systems, the closest fit on the Store is `fantastic-jobs/career-site-job-listing-api` — it's a DB query against a pre-crawled index, not a live scrape.

### FAQ

#### How does Greenhouse Jobs Scraper work?

It hits `https://boards-api.greenhouse.io/v1/boards/{token}/jobs?content=true` — Greenhouse's official public Job Board API — and normalizes the response into the dataset schema. Optional features (plain-text body, application questions) fetch one extra endpoint per job. No login, no proxy, no headless browser.

#### Can I use Greenhouse Jobs Scraper as an API?

Yes. Trigger a run via the Apify REST API:

```
POST https://api.apify.com/v2/acts/schnellscrapers~greenhouse-jobs-scraper/runs?token=<APIFY_TOKEN>
```

The Apify console exposes a `run-sync-get-dataset-items` endpoint that returns the records inline when the run finishes — handy for synchronous integrations.

#### Can I use it in Python or Node.js?

```python
from apify_client import ApifyClient
client = ApifyClient(token="<APIFY_TOKEN>")
run = client.actor("schnellscrapers/greenhouse-jobs-scraper").call(run_input={
    "boards": ["airbnb", "stripe"],
    "titleFilter": ["engineer"],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["companyName"], item["location"])
```

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('schnellscrapers/greenhouse-jobs-scraper').call({
  boards: ['airbnb', 'stripe'],
  titleFilter: ['engineer'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Is it legal to scrape Greenhouse?

Greenhouse job boards are public-facing and the Job Board API is documented for third-party use at [developers.greenhouse.io](https://developers.greenhouse.io/job-board.html). Greenhouse Jobs Scraper hits only the official API and respects `robots.txt`. As with any scraping, the data you collect is what's already publicly available; storing or republishing it must comply with the hiring company's terms and any applicable privacy laws (GDPR, CCPA).

#### Why is my company's board returning a 404?

The board token is the slug in the company's Greenhouse careers URL — `boards.greenhouse.io/<token>`. Some companies have moved off Greenhouse (Linear, Retool, HashiCorp, Coinbase, Snowflake all 404 today) or use a custom-domain alias that maps to a different token. Open the company's careers page and check the URL the listings load from.

#### How fresh is the data?

Live — every run hits Greenhouse's API directly. Compare to DB-aggregator actors (e.g. `fantastic-jobs/career-site-job-listing-api`), which have an indexing lag of up to 30 minutes per their docs.

#### Can I get application form questions?

Yes — set `includeQuestions: true`. This fetches `boards-api.greenhouse.io/v1/boards/{token}/jobs/{id}?questions=true` per job and merges the result into a `questions` field. One extra HTTP request per job, so leave off for large pulls unless you need it.

### Your feedback

Found a bug, missing a field, or want a new filter? Open an issue on the actor's Issues tab or email me. Every report gets read.

# Actor input Schema

## `boards` (type: `array`):

Companies to pull jobs from. Paste the board token (e.g. `airbnb`, `stripe`) or any Greenhouse URL — `https://boards.greenhouse.io/airbnb`, `https://job-boards.greenhouse.io/airbnb`. The token is the last path segment in a company's Greenhouse careers URL.

## `includeContent` (type: `boolean`):

Include the HTML job description in each record. Turn off to shrink results by ~95% when you only need titles, locations, and links.

## `parseContent` (type: `boolean`):

When the HTML description is included, also output a `contentText` field with HTML stripped and entities decoded. Handy for downstream search, embeddings, or LLM ingestion.

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

**Costs one extra HTTP request per job.** For every emitted job, also fetch its application form structure — custom questions, demographic questions, location questions, and compliance notices. Leave off for large boards unless you need it.

## `titleFilter` (type: `array`):

Case-insensitive substring match against the job title. A record is kept if any term matches (e.g. `engineer`, `designer`). Leave empty to keep all titles.

## `titleExcludeFilter` (type: `array`):

Drop jobs whose title contains any of these substrings (e.g. `senior`, `manager`).

## `locationFilter` (type: `array`):

Substring match against the job location string (e.g. `new york`, `berlin`, `remote`). Keep all locations if empty.

## `locationExcludeFilter` (type: `array`):

Drop jobs whose location matches any term (e.g. `india` to exclude India-based postings).

## `departmentFilter` (type: `array`):

Substring match against department names attached to the job (e.g. `engineering`, `design`, `data`).

## `officeFilter` (type: `array`):

Substring match against office names attached to the job (e.g. `san francisco`, `london`).

## `companyFilter` (type: `array`):

Substring match against `companyName`. Useful when one Greenhouse board hosts multiple sub-brands.

## `descriptionContains` (type: `array`):

Substring match against the job description body (e.g. `python`, `kubernetes`, `visa sponsorship`). Auto-enables `includeContent` if disabled.

## `remoteOnly` (type: `boolean`):

Keep only jobs that look remote — matched against the location string, office name, and the common `Workplace Type` custom field. Strict: hybrid jobs are excluded.

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

ISO 8601 date or timestamp (e.g. `2026-05-01` or `2026-05-01T00:00:00Z`). Drops jobs whose `updated_at` is older. Leave blank to keep every active job.

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

Hard cap on total records emitted across all boards. Useful for cost-bounded test runs. Leave at 0 to emit every matching job.

## `maxItemsPerBoard` (type: `integer`):

Per-board cap on emitted records. Leave at 0 to emit every matching job from each board.

## `dryRun` (type: `boolean`):

Fetch and parse the boards but do not write to the dataset. Use to preview without spending credits.

## Actor input object example

```json
{
  "boards": [
    "airbnb",
    "stripe"
  ],
  "includeContent": true,
  "parseContent": false,
  "includeQuestions": false,
  "titleFilter": [],
  "titleExcludeFilter": [],
  "locationFilter": [],
  "locationExcludeFilter": [],
  "departmentFilter": [],
  "officeFilter": [],
  "companyFilter": [],
  "descriptionContains": [],
  "remoteOnly": false,
  "maxItems": 0,
  "maxItemsPerBoard": 0,
  "dryRun": false
}
```

# Actor output Schema

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

Default dataset of job records. Key fields: title, companyName, location, departments, absoluteUrl, content, updatedAt.

# 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 = {
    "boards": [
        "airbnb",
        "stripe"
    ],
    "titleFilter": [],
    "titleExcludeFilter": [],
    "locationFilter": [],
    "locationExcludeFilter": [],
    "departmentFilter": [],
    "officeFilter": [],
    "companyFilter": [],
    "descriptionContains": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("schnellscrapers/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 = {
    "boards": [
        "airbnb",
        "stripe",
    ],
    "titleFilter": [],
    "titleExcludeFilter": [],
    "locationFilter": [],
    "locationExcludeFilter": [],
    "departmentFilter": [],
    "officeFilter": [],
    "companyFilter": [],
    "descriptionContains": [],
}

# Run the Actor and wait for it to finish
run = client.actor("schnellscrapers/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 '{
  "boards": [
    "airbnb",
    "stripe"
  ],
  "titleFilter": [],
  "titleExcludeFilter": [],
  "locationFilter": [],
  "locationExcludeFilter": [],
  "departmentFilter": [],
  "officeFilter": [],
  "companyFilter": [],
  "descriptionContains": []
}' |
apify call schnellscrapers/greenhouse-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Greenhouse Jobs Scraper",
        "description": "Scrape every active job from any Greenhouse careers board — titles, locations, departments, offices, full descriptions, custom fields, and application form questions. Live from the official API, no cache or AI guesswork. Filter by title, location, department, date, or remote-only at the source.",
        "version": "0.1",
        "x-build-id": "T5rvIQXcGyHBzxDE3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/schnellscrapers~greenhouse-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-schnellscrapers-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/schnellscrapers~greenhouse-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-schnellscrapers-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/schnellscrapers~greenhouse-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-schnellscrapers-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": [
                    "boards"
                ],
                "properties": {
                    "boards": {
                        "title": "Greenhouse boards",
                        "type": "array",
                        "description": "Companies to pull jobs from. Paste the board token (e.g. `airbnb`, `stripe`) or any Greenhouse URL — `https://boards.greenhouse.io/airbnb`, `https://job-boards.greenhouse.io/airbnb`. The token is the last path segment in a company's Greenhouse careers URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeContent": {
                        "title": "Include job description (HTML)",
                        "type": "boolean",
                        "description": "Include the HTML job description in each record. Turn off to shrink results by ~95% when you only need titles, locations, and links.",
                        "default": true
                    },
                    "parseContent": {
                        "title": "Also produce plain-text description",
                        "type": "boolean",
                        "description": "When the HTML description is included, also output a `contentText` field with HTML stripped and entities decoded. Handy for downstream search, embeddings, or LLM ingestion.",
                        "default": false
                    },
                    "includeQuestions": {
                        "title": "Include application form",
                        "type": "boolean",
                        "description": "**Costs one extra HTTP request per job.** For every emitted job, also fetch its application form structure — custom questions, demographic questions, location questions, and compliance notices. Leave off for large boards unless you need it.",
                        "default": false
                    },
                    "titleFilter": {
                        "title": "Title includes",
                        "type": "array",
                        "description": "Case-insensitive substring match against the job title. A record is kept if any term matches (e.g. `engineer`, `designer`). Leave empty to keep all titles.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "titleExcludeFilter": {
                        "title": "Title excludes",
                        "type": "array",
                        "description": "Drop jobs whose title contains any of these substrings (e.g. `senior`, `manager`).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationFilter": {
                        "title": "Location includes",
                        "type": "array",
                        "description": "Substring match against the job location string (e.g. `new york`, `berlin`, `remote`). Keep all locations if empty.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationExcludeFilter": {
                        "title": "Location excludes",
                        "type": "array",
                        "description": "Drop jobs whose location matches any term (e.g. `india` to exclude India-based postings).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "departmentFilter": {
                        "title": "Department includes",
                        "type": "array",
                        "description": "Substring match against department names attached to the job (e.g. `engineering`, `design`, `data`).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "officeFilter": {
                        "title": "Office includes",
                        "type": "array",
                        "description": "Substring match against office names attached to the job (e.g. `san francisco`, `london`).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyFilter": {
                        "title": "Company includes",
                        "type": "array",
                        "description": "Substring match against `companyName`. Useful when one Greenhouse board hosts multiple sub-brands.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "descriptionContains": {
                        "title": "Description contains",
                        "type": "array",
                        "description": "Substring match against the job description body (e.g. `python`, `kubernetes`, `visa sponsorship`). Auto-enables `includeContent` if disabled.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Keep only jobs that look remote — matched against the location string, office name, and the common `Workplace Type` custom field. Strict: hybrid jobs are excluded.",
                        "default": false
                    },
                    "updatedAfter": {
                        "title": "Only jobs updated after",
                        "type": "string",
                        "description": "ISO 8601 date or timestamp (e.g. `2026-05-01` or `2026-05-01T00:00:00Z`). Drops jobs whose `updated_at` is older. Leave blank to keep every active job."
                    },
                    "maxItems": {
                        "title": "Maximum records (total)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Hard cap on total records emitted across all boards. Useful for cost-bounded test runs. Leave at 0 to emit every matching job.",
                        "default": 0
                    },
                    "maxItemsPerBoard": {
                        "title": "Maximum records per board",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Per-board cap on emitted records. Leave at 0 to emit every matching job from each board.",
                        "default": 0
                    },
                    "dryRun": {
                        "title": "Dry run",
                        "type": "boolean",
                        "description": "Fetch and parse the boards but do not write to the dataset. Use to preview without spending credits.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```