# Ashby Job Board Compensation & Openings Scraper (`nimbryxo-studio/ashby-job-board-compensation-and-openings-scraper`) Actor

Scrape public Ashby job boards for any company hiring on jobs.ashbyhq.com. Get every open role with title, department, team, location, remote status, salary/compensation ranges, apply links, and full job descriptions. No login, no API key.

- **URL**: https://apify.com/nimbryxo-studio/ashby-job-board-compensation-and-openings-scraper.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Ashby Job Board Compensation & Openings Scraper

Scrape public **Ashby job boards** for any company hiring on `jobs.ashbyhq.com`. Get every open role with its department, team, structured location, remote or hybrid type, the employer's own salary range, full description, and apply link. Filter by keyword, workplace type, employment type, publish date, or pay. **No login, no API key, no proxy.**

Ashby powers the careers pages of thousands of modern companies. This actor reads the same public job-board data those pages use, so every run reflects the employer's current postings rather than an old index.

### What this actor does

- **Three modes:** `byOrg` lists jobs across companies, `jobDetail` fetches specific postings by URL or ID, and `boardSummary` returns one company-level overview.
- **Accepts what you have:** board slugs (`Ramp`), company names (`Neko Health`), board URLs, or full job URLs.
- **Structured pay:** numeric salary minimum and maximum, currency, pay period, annualized values, equity percentage, and bonus/commission flags, plus the original human-readable summaries.
- **Precise remote data:** separates fully remote from hybrid, keeps secondary locations with their city/region/country, and can add remote-eligible countries.
- **Useful filters:** keyword, department/team, location, workplace type, employment type, publish date or relative window (`24h`, `7d`, `2w`), annual salary range, salary currency, and salary-only.
- **Company and job detail:** optional company name/logo/timezone, all team names, confidentiality flag, compensation philosophy, and direct-apply flag.
- **Clean output:** empty fields are omitted; there are no `null`, blank, or placeholder values.

### Modes

| Mode | What it returns | Typical use |
|---|---|---|
| `byOrg` | One record per job across the companies you name | Job feeds, recruiting intelligence, compensation research |
| `jobDetail` | The exact postings you point at, by public URL or ID | Refresh a saved job, verify a posting, build a watchlist |
| `boardSummary` | One record per company with job counts and department, team, location, workplace, and pay breakdowns | Compare hiring across companies without downloading every description |

### Output per job

- `id` — Ashby posting UUID
- `title`
- `department`, `team`
- `employmentType` — `FullTime`, `PartTime`, `Contract`, `Intern`, or `Temporary`
- `location` — primary location label
- `locationCity`, `locationRegion`, `locationCountry` — structured primary address when published
- `isRemote` — the employer's remote flag; true for both Remote and Hybrid
- `workplaceType` — `Remote`, `Hybrid`, or `OnSite`
- `secondaryLocations[]` — additional location labels
- `secondaryLocationDetails[]` — each secondary location with its city, region, and country
- `isListed` — false for direct-link-only postings
- `publishedAt` — ISO timestamp
- `jobUrl`, `applyUrl`, `sourceUrl`
- `compensationSummary` — the employer's own pay summary, e.g. `$147K – $262K • Offers Equity`
- `salarySummary` — the employer's salary-only summary, e.g. `$147K – $262K`
- `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryInterval` — numeric salary range as published
- `annualSalaryMin`, `annualSalaryMax` — the same range annualized (hourly, weekly, monthly, yearly)
- `hasSalary`, `hasEquity`, `hasBonus`, `hasCommission` — pay-component flags
- `equityPercentMin`, `equityPercentMax` — equity percentage range when published
- `compensationTiers[]` — every published tier with its title, summary, notes, and components
- `compensationComponents[]` — the flattened salary/equity/bonus/commission components
- `descriptionPlain` — full plain-text description
- `descriptionHtml` — full HTML description when enabled
- `organization` — the company's Ashby board slug
- `organizationName`, `organizationLogoUrl`, `organizationTimezone` — optional company metadata
- `teamNames[]` — all team names when job-page details are enabled
- `isConfidential`, `compensationPhilosophyHtml`, `remoteEligibleCountries[]`, `directApply` — optional job-page details
- `recordType: "job"`, `scrapedAt`

### Output per company summary

`boardSummary` mode returns one record per company:

- `organization`, `organizationName`, `organizationLogoUrl`, `organizationTimezone`, `sourceUrl`
- `jobsOnBoard` — public jobs on the board before filters
- `jobsMatched` — jobs after the filters you set
- `departments[]`, `teams[]`, `locations[]` — up to 50 values each, with counts
- `workplaceTypes`, `employmentTypes` — counts by value, including `Unknown` where the board omits it
- `jobsWithCompensation`, `jobsWithSalary` — pay coverage
- `salaryCurrencies[]`
- `publishedAtMin`, `publishedAtMax`
- `recordType: "boardSummary"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byOrg` | `byOrg` / `jobDetail` / `boardSummary` |
| `orgSlugs` | array | `["Ramp"]` | Slugs, company names, or board URLs (mode=byOrg, boardSummary) |
| `jobUrls` | array | `[]` | Public job URLs (mode=jobDetail) |
| `orgSlug` | string | – | Company slug for `orgSlug` + `jobId` lookups (mode=jobDetail) |
| `jobId` | string | – | Posting UUID or full job URL (mode=jobDetail) |
| `searchQuery` | string | – | Text match over title, department, team, location, description (descriptions are searched even when their output is off and in `boardSummary`) |
| `department` | string | – | Text match over department and team |
| `location` | string | – | Text match over primary/secondary location and address |
| `workplaceType` | string | `any` | `any` / `Remote` / `Hybrid` / `OnSite` |
| `employmentType` | string | `any` | `any` / `FullTime` / `PartTime` / `Contract` / `Intern` / `Temporary` |
| `isRemoteOnly` | bool | `false` | Remote-friendly jobs (Remote and Hybrid) |
| `publishedAfter` | string | – | ISO date/datetime or `24h` / `7d` / `2w` |
| `publishedBefore` | string | – | ISO date/datetime or relative window |
| `minAnnualSalary` | int | – | Minimum annualized salary (0–10,000,000) |
| `maxAnnualSalary` | int | – | Maximum annualized salary (0–10,000,000) |
| `salaryCurrency` | string | `any` | Compare salaries in one currency |
| `hasSalaryOnly` | bool | `false` | Drop jobs without a published salary |
| `sortBy` | string | `default` | `default` / `newest` / `oldest` / `title` |
| `includeUnlisted` | bool | `false` | Include direct-link-only jobs in every mode; `jobDetail` returns `job_not_listed` unless enabled |
| `includeCompanyInfo` | bool | `true` | Add company name, logo, timezone |
| `includeDetails` | bool | `false` | Add all team names, confidentiality, compensation philosophy, remote-eligible countries, direct-apply |
| `includeDescriptionPlain` | bool | `true` | Include the plain-text description |
| `includeDescriptionHtml` | bool | `false` | Include the HTML description |
| `maxItemsPerOrg` | int | `0` | Per-company cap after filters (0 = no cap) |
| `maxItems` | int | `100` | Cap on job/summary records (1–5000); error diagnostics are extra |

#### Example: every open role at one company

```json
{
  "mode": "byOrg",
  "orgSlugs": ["Ramp"],
  "maxItems": 500
}
```

#### Example: engineering roles across several companies

```json
{
  "mode": "byOrg",
  "orgSlugs": ["Ramp", "Notion", "Linear"],
  "department": "Engineering",
  "includeCompanyInfo": true,
  "maxItems": 200
}
```

#### Example: fully remote roles published in the last two weeks

```json
{
  "mode": "byOrg",
  "orgSlugs": ["Notion", "Linear", "Supabase"],
  "workplaceType": "Remote",
  "publishedAfter": "2w",
  "hasSalaryOnly": true,
  "maxItems": 100
}
```

#### Example: well-paid product roles in US dollars

```json
{
  "mode": "byOrg",
  "orgSlugs": ["Ramp", "Plaid", "Cohere"],
  "searchQuery": "product",
  "minAnnualSalary": 150000,
  "salaryCurrency": "USD",
  "sortBy": "newest",
  "maxItems": 50
}
```

#### Example: specific postings by URL

```json
{
  "mode": "jobDetail",
  "jobUrls": [
    "https://jobs.ashbyhq.com/Ramp/09a9381c-677b-40a5-9ff1-027bd4302c13",
    "https://jobs.ashbyhq.com/Linear/453f1ba0-a35e-4ed2-8215-1514e0a30b92"
  ],
  "includeDetails": true
}
```

#### Example: compare hiring across companies

```json
{
  "mode": "boardSummary",
  "orgSlugs": ["Ramp", "Notion", "Linear", "Harvey"]
}
```

### Use cases

- **Job boards and aggregators** — keep a live feed of openings from every Ashby-powered company you track.
- **Recruiting and sourcing** — find engineering, design, sales, or operations roles by team, location, and workplace type.
- **Compensation benchmarking** — collect the employer's own salary ranges as numbers, with currency and pay period.
- **Remote-work feeds** — build a daily feed of fully remote roles with remote-eligible countries.
- **Hiring intelligence** — compare departments, teams, locations, and pay coverage across competitors.
- **Market research** — track which companies are hiring and where over time.

### FAQ

**What is Ashby?** Ashby is an applicant-tracking and recruiting platform. Many companies host their public careers page at `jobs.ashbyhq.com/{company}`. This actor reads the public job-board data behind those pages.

**How do I find a company's slug?** It is the path segment in the board URL. For `https://jobs.ashbyhq.com/Ramp`, the slug is `Ramp`. You can also paste the board URL or the company name, and the actor matches it to the closest live board.

**Do I need an API key, login, or proxy?** No. The Ashby job-board endpoint is public. No credentials, cookies, or proxy setup are needed.

**Why is `isRemote` true for a hybrid job?** Ashby's remote flag means "remote-friendly", not "fully remote". Use `workplaceType: "Remote"` for fully remote roles and `workplaceType: "Hybrid"` for hybrid roles.

**Why do some jobs have no salary?** Companies choose whether to publish compensation. When they do not, the salary fields are omitted. This actor never guesses or fabricates a range.

**What do `salaryMin` and `salaryMax` mean when a job has several pay tiers?** They are the lowest and highest values across every published salary component, so a multi-location or multi-level posting reports its full range. `compensationTiers` keeps the individual tiers.

**What is the difference between `salaryMin` and `annualSalaryMin`?** `salaryMin` is the number exactly as published, with `salaryInterval` telling you whether it is yearly, monthly, weekly, or hourly. `annualSalaryMin` converts it to a yearly figure so you can compare roles with different pay periods.

**Why are unlisted jobs missing?** Ashby can return jobs marked `isListed:false`, which are reachable by direct link but are not shown on the public board. They are excluded by default in `byOrg`, `boardSummary`, and `jobDetail`. Set `includeUnlisted: true` to include them; a `jobDetail` lookup for an unlisted job otherwise emits a `job_not_listed` error with the fix in its message.

**Can I get only new postings?** Yes. Set `publishedAfter` to `24h`, `7d`, `2w`, or an ISO date. No saved state is needed between runs.

**Why does the run finish with fewer records than the board has?** `maxItems` is a hard cap and filters run first. Ashby returns a company's whole board at once, so a large board is downloaded even when you save fewer records. Raise `maxItems` or narrow the filters to control the result size.

**Are company websites included?** No. Company names, logos, and timezones are included, but website links are omitted because some employers block automated access to them.

**Is this affiliated with Ashby?** No. This is a third-party actor that reads Ashby's public job-board data.

### Limitations

- Ashby does not publish a directory of every company on its platform. You need a board slug, board URL, job URL, or a company name that resolves to a live board.
- Salary ranges are shown only when the employer publishes them; equity and bonus details follow the same rule.
- Currencies are not converted. Use `salaryCurrency` to compare one currency at a time.
- A board larger than 5,000 jobs would be truncated by the `maxItems` ceiling.
- Markdown descriptions, seniority scores, and LinkedIn or AI enrichment are not produced. Descriptions are available as plain text and HTML.

# Actor input Schema

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

What to collect. `byOrg` lists jobs from one or more companies; `jobDetail` fetches specific postings by URL or ID; `boardSummary` returns one departments/locations/compensation summary per company. The legacy values are kept so saved tasks continue to run.

## `orgSlugs` (type: `array`):

Ashby board slugs, company names, or board URLs. Examples: `Ramp`, `Neko Health`, `https://jobs.ashbyhq.com/Ramp`. Names are matched to the closest live board automatically.

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

Public Ashby job posting URLs, e.g. `https://jobs.ashbyhq.com/Ramp/<job-id>`. The `/application` suffix and query strings are accepted.

## `orgSlug` (type: `string`):

Used with `jobId` when you do not have a full job URL. Example: `Ramp`.

## `jobId` (type: `string`):

The Ashby posting UUID or a full job URL. Used alone or with `orgSlug`.

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

Case-insensitive text match over title, department, team, location, and description. Descriptions are searched even when `includeDescriptionPlain` is off and in `boardSummary` mode. Examples: `engineer`, `payments`, `München`.

## `department` (type: `string`):

Case-insensitive text match over department and team. Examples: `Engineering`, `Sales`, `Design`.

## `location` (type: `string`):

Case-insensitive text match over the primary location, secondary locations, city, region, and country. Examples: `New York`, `Remote`, `London`.

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

Keep only fully remote, hybrid, or on-site jobs. Unlike `isRemoteOnly`, this separates Remote from Hybrid. Jobs with no workplace type are excluded when a specific value is chosen.

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

Keep only one employment type.

## `isRemoteOnly` (type: `boolean`):

Keep jobs the board marks as remote. Ashby sets this for both Remote and Hybrid roles; use `workplaceType=Remote` for fully remote jobs.

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

Only jobs published on or after this date. Accepts `YYYY-MM-DD`, an ISO datetime, or a relative window such as `24h`, `7d`, or `2w`.

## `publishedBefore` (type: `string`):

Only jobs published on or before this date. Accepts `YYYY-MM-DD`, an ISO datetime, or a relative window.

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

Keep jobs whose published annual salary range overlaps this minimum. Hourly, monthly, and weekly ranges are annualized. Jobs with no published salary are kept unless `hasSalaryOnly` is on.

## `maxAnnualSalary` (type: `integer`):

Keep jobs whose published annual salary range overlaps this maximum. Use with `minAnnualSalary` for a range.

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

Only compare salaries in this currency. `any` compares the numeric range as published (currencies are not converted).

## `hasSalaryOnly` (type: `boolean`):

Drop jobs where the employer did not publish a salary range.

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

Order of the returned job records. `default` keeps the board's own order.

## `includeUnlisted` (type: `boolean`):

Include jobs marked `isListed:false` (direct-link-only postings that are not shown on the public board). Applies to every mode: `jobDetail` returns a `job_not_listed` error for an unlisted job unless this is on. Off by default.

## `includeCompanyInfo` (type: `boolean`):

Fetch each company's public board page once for its display name, logo, and timezone. Adds one request per company. Off in the daily test prefill.

## `includeDetails` (type: `boolean`):

Fetch each returned job's public page for all team names, confidentiality, compensation philosophy, direct-apply flag, and remote-eligible countries. Adds one request per job; slower on large runs.

## `includeDescriptionPlain` (type: `boolean`):

Add `descriptionPlain` to each job. On by default; turn it off for compact metadata-only rows.

## `includeDescriptionHtml` (type: `boolean`):

Add the original `descriptionHtml` to each job. Increases dataset size.

## `maxItemsPerOrg` (type: `integer`):

Cap the number of job records from each company after filters. `0` means no per-company cap.

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

Hard cap on the number of job records (or company summaries) pushed to the dataset. Error records for invalid inputs are additional diagnostics and do not count.

## Actor input object example

```json
{
  "mode": "byOrg",
  "orgSlugs": [
    "Ramp"
  ],
  "jobUrls": [],
  "workplaceType": "any",
  "employmentType": "any",
  "isRemoteOnly": false,
  "salaryCurrency": "any",
  "hasSalaryOnly": false,
  "sortBy": "default",
  "includeUnlisted": false,
  "includeCompanyInfo": false,
  "includeDetails": false,
  "includeDescriptionPlain": false,
  "includeDescriptionHtml": false,
  "maxItemsPerOrg": 0,
  "maxItems": 1
}
```

# Actor output Schema

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

Dataset containing scraped Ashby job postings in byOrg and jobDetail modes.

## `boardSummaries` (type: `string`):

Dataset containing one departments/locations/compensation summary per company in boardSummary mode.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "byOrg",
    "orgSlugs": [
        "Ramp"
    ],
    "jobUrls": [],
    "workplaceType": "any",
    "employmentType": "any",
    "isRemoteOnly": false,
    "salaryCurrency": "any",
    "hasSalaryOnly": false,
    "sortBy": "default",
    "includeUnlisted": false,
    "includeCompanyInfo": false,
    "includeDetails": false,
    "includeDescriptionPlain": false,
    "includeDescriptionHtml": false,
    "maxItemsPerOrg": 0,
    "maxItems": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/ashby-job-board-compensation-and-openings-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 = {
    "mode": "byOrg",
    "orgSlugs": ["Ramp"],
    "jobUrls": [],
    "workplaceType": "any",
    "employmentType": "any",
    "isRemoteOnly": False,
    "salaryCurrency": "any",
    "hasSalaryOnly": False,
    "sortBy": "default",
    "includeUnlisted": False,
    "includeCompanyInfo": False,
    "includeDetails": False,
    "includeDescriptionPlain": False,
    "includeDescriptionHtml": False,
    "maxItemsPerOrg": 0,
    "maxItems": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/ashby-job-board-compensation-and-openings-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "byOrg",
  "orgSlugs": [
    "Ramp"
  ],
  "jobUrls": [],
  "workplaceType": "any",
  "employmentType": "any",
  "isRemoteOnly": false,
  "salaryCurrency": "any",
  "hasSalaryOnly": false,
  "sortBy": "default",
  "includeUnlisted": false,
  "includeCompanyInfo": false,
  "includeDetails": false,
  "includeDescriptionPlain": false,
  "includeDescriptionHtml": false,
  "maxItemsPerOrg": 0,
  "maxItems": 1
}' |
apify call nimbryxo-studio/ashby-job-board-compensation-and-openings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/ashby-job-board-compensation-and-openings-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/uLc5okVRk3hoaiEtP/builds/yzfUD4dKeKLHXPa89/openapi.json