# Ashby Jobs Scraper (`schnellscrapers/ashby-jobs-scraper`) Actor

Scrape every active job from any Ashby-hosted careers board — titles, departments, teams, employment + workplace type, full descriptions, and optional salary bands. Live from the official Ashby Posting API. Filter by title, location, department, date, or remote-only at the source.

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

## Pricing

from $0.75 / 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 Ashby Jobs Scraper do?

**Ashby Jobs Scraper** pulls every active job from any company's Ashby-hosted careers board, live from the official Ashby Posting API. Paste the org slug (e.g. `ramp`, `notion`, `linear`) or any `jobs.ashbyhq.com/<slug>` URL and get back a clean dataset of every posting — titles, departments, teams, locations (primary + secondary), remote/hybrid/on-site flags, full HTML and plain-text descriptions, and optional salary bands. Great for recruiters tracking competitor hiring at startups, lead-gen pipelines targeting hiring companies, job aggregators backfilling postings, and candidates watching a shortlist of employers.

### What data can you extract from Ashby?

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

- **Identity** — `id` (Ashby UUID), `board` (slug), `jobUrl`, `applyUrl`
- **Title & org** — `title`, `department`, `team`
- **Type** — `employmentType` (FullTime / PartTime / Contract / Intern / Temporary), `workplaceType` (Remote / Hybrid / OnSite), `isRemote`
- **Location** — `location` (primary string), `secondaryLocations[]` (each with a postal address), top-level `address`
- **Timing** — `publishedAt`, `isListed`
- **Description** — `descriptionHtml`, `descriptionText` (Ashby's `descriptionPlain`, lightly tidied)
- **Salary** — optional `compensation` block (tier summary, components, currency, interval, equity) plus a flat `compensationSummary` string. Populated when the company publishes pay on their Ashby board — common for US and Canada roles.

Every Ashby-exposed field is preserved so records can be joined back to internal hiring data via the job UUID.

### How to use Ashby Jobs Scraper

1. Create a free Apify account.
2. Open **Ashby Jobs Scraper** and click **Try for free**.
3. Paste one or more org slugs or URLs into **Ashby boards**. The slug is the first path segment after `jobs.ashbyhq.com/` — e.g. `jobs.ashbyhq.com/ramp` → `ramp`.
4. (Optional) Add filters: `Title includes`, `Department includes`, `Workplace type`, `Remote only`, `Only jobs published after`, etc. Filtering runs at the source, before billing.
5. (Optional) Turn on **Include salary / compensation** to add pay bands per job.
6. Click **Save & Start**. Each board returns in 1–10 seconds depending on size.
7. Download results from the **Storage** tab in JSON, CSV, Excel, XML, or HTML.

### How much does it cost?

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

- **$0.00075 per job** ($0.75 per 1,000 jobs) — flat rate across all plans
- The Apify Free plan includes $5/month of credit, enough for ~6,500 free jobs.
- **No minimum** — pull 1 job or 50,000.
- Filters are applied at the source, so filtered-out jobs aren't billed.

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

### Input

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

```json
{
  "boards": ["ramp", "notion", "https://jobs.ashbyhq.com/linear"],
  "includeDescription": true,
  "includeCompensation": true,
  "titleFilter": ["engineer", "designer"],
  "workplaceTypeFilter": ["Remote", "Hybrid"],
  "departmentFilter": ["engineering"],
  "remoteOnly": false,
  "publishedAfter": "2026-04-01",
  "maxItems": 200
}
````

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

- Pull *everything* from one company: `{ "boards": ["ramp"] }`
- Just titles and links (cheap fast pull): `{ "boards": ["ramp"], "includeDescription": false }`
- Remote engineering jobs with salary across several companies: `{ "boards": ["ramp","notion","linear"], "remoteOnly": true, "departmentFilter": ["engineering"], "includeCompensation": true }`
- Build an LLM-friendly dataset: `{ "boards": ["ramp"], "parseDescription": true }` (Ashby ships plain text natively — only enable `parseDescription` for fallback)

### Output

One record per active job. Sample (with `includeCompensation: true`):

```json
{
  "id": "34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "board": "ramp",
  "title": "Security Engineer, Cloud",
  "department": "Engineering",
  "team": "Backend",
  "employmentType": "FullTime",
  "location": "New York, NY (HQ)",
  "secondaryLocations": [
    { "location": "Miami, FL", "address": { "postalAddress": { "addressLocality": "Miami", "addressRegion": "Florida", "addressCountry": "USA" } } },
    { "location": "Remote (US)", "address": { "postalAddress": { "addressLocality": null, "addressRegion": null, "addressCountry": "United States" } } }
  ],
  "isRemote": true,
  "workplaceType": "Hybrid",
  "isListed": true,
  "publishedAt": "2026-04-07T17:12:35.753+00:00",
  "jobUrl": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "applyUrl": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245/application",
  "address": { "postalAddress": { "addressLocality": "New York City", "addressRegion": "NY", "addressCountry": "USA" } },
  "descriptionHtml": "<h1><strong>About Ramp</strong></h1><p>...</p>",
  "descriptionText": "ABOUT RAMP\n\nRamp is building ...",
  "compensation": {
    "compensationTierSummary": "$211.4K – $290.6K • Offers Equity",
    "scrapeableCompensationSalarySummary": "$211.4K - $290.6K",
    "compensationTiers": [/* ... */],
    "summaryComponents": [
      { "compensationType": "Salary", "interval": "1 YEAR", "currencyCode": "USD", "minValue": 211400, "maxValue": 290600 },
      { "compensationType": "EquityPercentage", "interval": "NONE", "currencyCode": null, "minValue": null, "maxValue": null }
    ]
  },
  "compensationSummary": "$211.4K – $290.6K • Offers Equity",
  "scrapedAt": "2026-05-21T20:00:00Z",
  "source": "https://api.ashbyhq.com/posting-api/job-board/ramp?includeCompensation=true"
}
```

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

### Integrations

Ashby 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

- [Greenhouse Jobs Scraper](https://apify.com/schnellscrapers/greenhouse-jobs-scraper) — same shape for companies on Greenhouse (Airbnb, Stripe, Figma, Dropbox, etc.).
- [Indeed Jobs Scraper](https://apify.com/schnellscrapers/indeed-jobs-scraper) — for jobs hosted on Indeed (millions of postings across all employers, not just ATS-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 Ashby Jobs Scraper work?

It hits `https://api.ashbyhq.com/posting-api/job-board/{slug}` — Ashby's official public Posting API — and normalizes the response into the dataset schema. Adding `includeCompensation=true` fetches the same endpoint with salary blocks attached. No login, no proxy, no headless browser.

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

Yes. Trigger a run via the Apify REST API:

```
POST https://api.apify.com/v2/acts/schnellscrapers~ashby-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/ashby-jobs-scraper").call(run_input={
    "boards": ["ramp", "notion"],
    "titleFilter": ["engineer"],
    "includeCompensation": True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["department"], item["compensationSummary"])
```

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

#### Is it legal to scrape Ashby?

Ashby job boards are public-facing and the Posting API is documented for third-party use as the endpoint for embedded career sites. Ashby 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 slug is the first path segment in the company's Ashby careers URL — `jobs.ashbyhq.com/<slug>`. Some companies have moved off Ashby or use a custom-domain alias that maps to a different slug. Open the company's careers page and check the URL the listings load from. Empty boards (the company is still on Ashby but has no published roles) return zero records, not a 404.

#### How fresh is the data?

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

#### Can I get salary data?

Yes — set `includeCompensation: true`. Pay bands appear for jobs where the company has opted to publish salary on their Ashby board (common for US/CA roles, less so elsewhere). Equity callouts, currency, and interval are preserved.

### 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 org slug (e.g. `ramp`, `notion`, `linear`) or any Ashby URL — `https://jobs.ashbyhq.com/ramp`, `https://jobs.ashbyhq.com/ramp/<jobId>`. The slug is the first path segment after `jobs.ashbyhq.com/`.

## `includeDescription` (type: `boolean`):

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

## `parseDescription` (type: `boolean`):

Ashby already ships a `descriptionPlain` field — kept as `descriptionText`. Enable this only if you see boards where `descriptionPlain` is empty but `descriptionHtml` is not.

## `includeCompensation` (type: `boolean`):

Add Ashby's `compensation` block per job (salary bands, equity, currency, interval) plus a flat `compensationSummary` string. Only populated for companies that publish salary on their Ashby board — many do for US/CA roles.

## `onlyListed` (type: `boolean`):

Drop jobs whose `isListed` flag is false — these are draft or unpublished jobs that occasionally slip into the API response. Recommended on.

## `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 primary location string (e.g. `new york`, `berlin`, `remote`). Keep all locations if empty.

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

Drop jobs whose location matches any term.

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

Substring match against the `department` field (e.g. `engineering`, `design`, `data`).

## `teamFilter` (type: `array`):

Substring match against the `team` field — typically a sub-group inside the department (e.g. `backend`, `growth`).

## `employmentTypeFilter` (type: `array`):

Exact-match (case-insensitive) against Ashby's employmentType values. Common values: `FullTime`, `PartTime`, `Contract`, `Intern`, `Temporary`.

## `workplaceTypeFilter` (type: `array`):

Exact-match (case-insensitive) against Ashby's workplaceType values. Common values: `Remote`, `Hybrid`, `OnSite`.

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

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

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

Keep only jobs where `isRemote` is true, `workplaceType` is `Remote`, or the location string contains `remote`. Strict: hybrid jobs are excluded.

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

ISO 8601 date or timestamp (e.g. `2026-05-01` or `2026-05-01T00:00:00Z`). Drops jobs whose `publishedAt` is older.

## `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": [
    "ramp",
    "notion"
  ],
  "includeDescription": true,
  "parseDescription": false,
  "includeCompensation": false,
  "onlyListed": true,
  "titleFilter": [],
  "titleExcludeFilter": [],
  "locationFilter": [],
  "locationExcludeFilter": [],
  "departmentFilter": [],
  "teamFilter": [],
  "employmentTypeFilter": [],
  "workplaceTypeFilter": [],
  "descriptionContains": [],
  "remoteOnly": false,
  "maxItems": 0,
  "maxItemsPerBoard": 0,
  "dryRun": false
}
```

# Actor output Schema

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

Default dataset of job records. Key fields: title, department, location, workplaceType, compensationSummary, jobUrl, descriptionText.

# 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": [
        "ramp",
        "notion"
    ],
    "titleFilter": [],
    "titleExcludeFilter": [],
    "locationFilter": [],
    "locationExcludeFilter": [],
    "departmentFilter": [],
    "teamFilter": [],
    "employmentTypeFilter": [],
    "workplaceTypeFilter": [],
    "descriptionContains": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("schnellscrapers/ashby-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": [
        "ramp",
        "notion",
    ],
    "titleFilter": [],
    "titleExcludeFilter": [],
    "locationFilter": [],
    "locationExcludeFilter": [],
    "departmentFilter": [],
    "teamFilter": [],
    "employmentTypeFilter": [],
    "workplaceTypeFilter": [],
    "descriptionContains": [],
}

# Run the Actor and wait for it to finish
run = client.actor("schnellscrapers/ashby-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": [
    "ramp",
    "notion"
  ],
  "titleFilter": [],
  "titleExcludeFilter": [],
  "locationFilter": [],
  "locationExcludeFilter": [],
  "departmentFilter": [],
  "teamFilter": [],
  "employmentTypeFilter": [],
  "workplaceTypeFilter": [],
  "descriptionContains": []
}' |
apify call schnellscrapers/ashby-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ashby Jobs Scraper",
        "description": "Scrape every active job from any Ashby-hosted careers board — titles, departments, teams, employment + workplace type, full descriptions, and optional salary bands. Live from the official Ashby Posting API. Filter by title, location, department, date, or remote-only at the source.",
        "version": "0.1",
        "x-build-id": "S6BVvEV0MxP64mjZS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/schnellscrapers~ashby-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-schnellscrapers-ashby-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~ashby-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-schnellscrapers-ashby-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~ashby-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-schnellscrapers-ashby-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": "Ashby boards",
                        "type": "array",
                        "description": "Companies to pull jobs from. Paste the org slug (e.g. `ramp`, `notion`, `linear`) or any Ashby URL — `https://jobs.ashbyhq.com/ramp`, `https://jobs.ashbyhq.com/ramp/<jobId>`. The slug is the first path segment after `jobs.ashbyhq.com/`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDescription": {
                        "title": "Include job description",
                        "type": "boolean",
                        "description": "Include the HTML and plain-text job description in each record. Turn off to shrink results by ~90% when you only need titles, locations, and links.",
                        "default": true
                    },
                    "parseDescription": {
                        "title": "Re-derive plain-text description from HTML",
                        "type": "boolean",
                        "description": "Ashby already ships a `descriptionPlain` field — kept as `descriptionText`. Enable this only if you see boards where `descriptionPlain` is empty but `descriptionHtml` is not.",
                        "default": false
                    },
                    "includeCompensation": {
                        "title": "Include salary / compensation",
                        "type": "boolean",
                        "description": "Add Ashby's `compensation` block per job (salary bands, equity, currency, interval) plus a flat `compensationSummary` string. Only populated for companies that publish salary on their Ashby board — many do for US/CA roles.",
                        "default": false
                    },
                    "onlyListed": {
                        "title": "Only include listed jobs",
                        "type": "boolean",
                        "description": "Drop jobs whose `isListed` flag is false — these are draft or unpublished jobs that occasionally slip into the API response. Recommended on.",
                        "default": true
                    },
                    "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 primary 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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "departmentFilter": {
                        "title": "Department includes",
                        "type": "array",
                        "description": "Substring match against the `department` field (e.g. `engineering`, `design`, `data`).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "teamFilter": {
                        "title": "Team includes",
                        "type": "array",
                        "description": "Substring match against the `team` field — typically a sub-group inside the department (e.g. `backend`, `growth`).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "employmentTypeFilter": {
                        "title": "Employment type",
                        "type": "array",
                        "description": "Exact-match (case-insensitive) against Ashby's employmentType values. Common values: `FullTime`, `PartTime`, `Contract`, `Intern`, `Temporary`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "workplaceTypeFilter": {
                        "title": "Workplace type",
                        "type": "array",
                        "description": "Exact-match (case-insensitive) against Ashby's workplaceType values. Common values: `Remote`, `Hybrid`, `OnSite`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "descriptionContains": {
                        "title": "Description contains",
                        "type": "array",
                        "description": "Substring match against the job description text (e.g. `python`, `kubernetes`, `visa sponsorship`). Auto-enables `includeDescription` if disabled.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Keep only jobs where `isRemote` is true, `workplaceType` is `Remote`, or the location string contains `remote`. Strict: hybrid jobs are excluded.",
                        "default": false
                    },
                    "publishedAfter": {
                        "title": "Only jobs published after",
                        "type": "string",
                        "description": "ISO 8601 date or timestamp (e.g. `2026-05-01` or `2026-05-01T00:00:00Z`). Drops jobs whose `publishedAt` is older."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```