# Ashby Jobs: Job Boards, Salaries & Equity (`deepmine/ashby-jobs`) Actor

Ashby jobs scraper: every open job from any company's Ashby job board (OpenAI, Ramp, Notion...) with every published pay tier, equity, remote countries, team, full description as text or Markdown and apply link. Board URLs, names or a directory. No login.

- **URL**: https://apify.com/deepmine/ashby-jobs.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.29 / 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/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 Jobs: Job Boards, Salaries & Equity

Paste Ashby job boards (`https://jobs.ashbyhq.com/ramp`) or just company names, and get **every open job** as one clean row each: title, location, remote or hybrid, department and team, posting time, **every published pay tier, equity, bonus and commission** (or the pay range written in the description when none is published), the countries a remote job is open to, the company website, the full description as text **and Markdown**, and the apply link.

| 💼 Title | 🏢 Company | 📍 Location | 🏠 Workplace | 💰 Salary | 💵 Pay Summary | 📅 Posted |
|---|---|---|---|---|---|---|
| Chief Compliance Officer, Ramp Advisory LLC | Ramp | New York, NY (HQ) | Hybrid | USD 170,000 - 300,000 per year | $170K – $300K • Offers Equity • Multiple Ranges | 2026-10-16 |
| Lead Counsel, Employment | Ramp | San Francisco, CA | Hybrid | USD 228,000 - 313,000 per year | $228K – $313K • Offers Equity | 2026-10-16 |
| Solutions Consultant, Commercial, Benelux | Notion | Dublin, Ireland | – | EUR 144,000 - 156,000 per year | – | 2026-10-19 |

<sub>Collected 2026-10-19 with Notion and Ramp, 50 newest jobs each: all 50 Ramp jobs published pay (46 with equity); Notion publishes none, but 40 of its 50 descriptions state the range, so 90 of 100 rows have a salary.</sub>

**$0.39 per 1,000 jobs** on the Starter plan ($0.46 Free, $0.35 Scale, $0.29 Business). The prefilled run (100 jobs: 50 from each of 2 companies) costs about $0.04.

It reads Ashby's public job board API, the one each company's careers page uses, live on every run. No browser and no login. Markdown, every pay field and the directory are included at the same price.

### What you can do with it

- **Every pay tier as published:** `salaryRanges` lists each range of each tier (e.g. "SF/NY" and "Nationwide"), `offersEquity`, `offersBonus`, `offersCommission`, and `compensation` keeps Ashby's raw pay data verbatim. `salaryMin`/`salaryMax`/`salaryCurrency`/`salaryPeriod` are ready to sort and chart. When a job publishes no pay but its description states a range ("the estimated base salary range for this role is $238,000 - $250,000 per year"), the salary comes from there and `salarySource` says `description`.
- **Feed LLMs and AI agents:** `descriptionMarkdown` keeps headings, lists, bold and links; `description` is plain text.
- **Build remote job feeds:** `remoteCountryCodes` says which countries a remote job is open to, the way its job page states it.
- **Find companies hiring on Ashby:** turn on **📚 Add boards from the directory** to read boards from our directory of 3,177 Ashby boards with open jobs (checked live 2026-10-19), filtered by a word in the company name, biggest first.
- **Monitor hiring** at target accounts: schedule a daily run with **📅 Posted within** 1; Ashby gives the exact publish time.
- **Filter before you pay:** title words, department or team, job type, locations (whole words or country codes), remote only, posted in the last N days. Jobs your filters drop cost nothing.

### What to paste

- **An Ashby board URL**, e.g. `https://jobs.ashbyhq.com/notion`, or a job URL from it.
- **The board name or the company name**, e.g. `ramp` or `OpenAI`. A name is tried on Ashby, Greenhouse, Lever and SmartRecruiters.
- **The company's own careers page**, e.g. `https://www.notion.com/careers`: the page is checked for a link to its job board.
- Greenhouse, Lever, SmartRecruiters and Workday boards work in the same run, with the same columns (Ashby-only fields are empty there).

### Input

```json
{
  "companies": ["https://jobs.ashbyhq.com/notion", "ramp", "OpenAI"],
  "titleKeywords": ["engineer"],
  "departments": ["Engineering"],
  "employmentTypes": ["Full-time"],
  "locations": ["US"],
  "remoteOnly": false,
  "postedWithinDays": 30,
  "maxJobsPerCompany": 100,
  "maxResults": 1000,
  "includeMarkdown": true,
  "includeAllFields": true
}
```

| Field | What it does |
|---|---|
| `companies` | Ashby board URLs, board names or company names, one per line. Other job board URLs and careers pages work too. |
| `maxJobsPerCompany` | Each company's newest jobs, up to this many (default 100), so one big company can't take all of `maxResults`. 0 = every job. You pay per job, so this caps the cost per company. |
| `maxResults` | Stop after this many jobs in total, which caps the run's cost. |
| `includeDescription` | Full description as plain text (on by default), and as Markdown with `includeMarkdown`. |
| `titleKeywords` | Keep jobs whose title contains any of these (not case-sensitive). |
| `departments` | Keep jobs whose department or team contains any of these (not case-sensitive). |
| `employmentTypes` | Keep only these job types: `Full-time`, `Part-time`, `Contract`, `Internship`, `Temporary`. |
| `locations` | Keep jobs whose location contains any of these as whole words (`India` doesn't match Indiana). Two letters are a country code and match only the job's countries: `US`, `GB` (or `UK`), `DE`, `CA` (Canada, not California). |
| `remoteOnly` | Keep only jobs marked remote. |
| `postedWithinDays` | Keep only jobs published in the last N days (0 = any date). |
| `useDirectory` | Also read boards from the bundled directory (3,177 Ashby boards with open jobs, checked live 2026-10-19), biggest first. |
| `directoryQuery` | Only directory companies whose name or board name contains this, e.g. `ai` or `health`. Up to 3 letters must be a whole word: `ai` finds OpenAI and Mistral AI, not Airwallex. |
| `maxCompanies` | How many directory boards to read at most (default 25). |
| `includeMarkdown` | Adds `descriptionMarkdown` (on by default). |
| `includeHtml` | Adds `descriptionHtml`, the company's own formatting. |
| `includeAllFields` | Adds every pay tier, equity, bonus and commission flags, the raw pay data, team, addresses, remote countries and the company website, and takes the salary from the description when no pay is published (on by default). |
| `includeApplicationDetails` | Adds `applicationDeadline` and the full team path (`teams`) from each job page: one more small request per job. |

### Output

One row per job. Rows come in the order of your companies list (directory boards after them), each company's jobs newest first.

Two datasets, both with the same rows:

- **💼 All Jobs** (default dataset). Views: **📊 Overview** (🖼️ Logo, 💼 Title, 🏢 Company, 📍 Location, 🏠 Workplace, 🗂️ Department, 💰 Salary, 📈 Equity, 📅 Posted, 🔗 Job Page), **📝 Details** (💼 Title, 🏢 Company, 🕒 Job Type, 🗂️ Department, 👥 Team, 🗺️ All Locations, 🌐 Remote Countries, 🌐 Company Website, 📋 Job Board, 🆔 Job ID, 🔗 Job Page) and **💰 Pay** (🖼️ Logo, 💼 Title, 🏢 Company, 📍 Location, 💵 Pay Summary, 💰 Salary Min, 💰 Salary Max, 💱 Currency, ⏱️ Pay Period, 🔎 Pay Source, 📈 Equity, 🤝 Commission, 🔗 Job Page).
- **💰 With Salary**: the delivered jobs with a pay range, in the same order, at no extra charge.

#### Output fields

In row order:

- `companyLogo`: the company logo from its Ashby job board. A stable image link.
- `title`: job title.
- `company`: company name as its job board shows it.
- `location`: the job's main location as the company wrote it.
- `workplaceType`: `Remote`, `Hybrid` or `On-site` from the company's own field, or `Remote` when the location says so.
- `employmentType`: `Full-time`, `Part-time`, `Contract`, `Internship`, `Temporary` or `Other`.
- `department`: the department the company files the job under.
- `salary`: the pay, e.g. `USD 170,000 - 300,000 per year`: the published pay, else the range the description states (with `includeAllFields`).
- `salaryMin`: the lowest salary, as a number.
- `salaryMax`: the highest salary, as a number.
- `salaryCurrency`: ISO currency code, e.g. `USD`.
- `salaryPeriod`: `year`, `month`, `week`, `day` or `hour`.
- `postedAt`: when the job was published, in UTC (`2026-10-16T21:05:12Z`).
- `jobUrl`: the job's page on the Ashby board.
- `applyUrl`: the job's application page.
- `locations`: every place the job is offered, as a list.
- `countryCode`: ISO code of the main location's country.
- `compensationSummary`: the pay line the job page shows, e.g. `$170K – $300K • Offers Equity • Multiple Ranges`.
- `salaryRanges`: every salary or hourly range of every pay tier: `tier`, `min`, `max`, `currency`, `period`, `summary`.
- `salarySource`: where the salary comes from: `compensation` (the pay the company publishes) or `description` (a range written in the job description, when no pay is published).
- `offersEquity`: the company offers equity (options, RSUs or a percentage). Empty when the job publishes no pay.
- `offersBonus`: the published pay includes a bonus.
- `offersCommission`: the published pay includes commission.
- `compensationShown`: the company shows the pay on the job page (Ashby's own setting).
- `team`: the team the company files the job under.
- `isRemote`: Ashby's own remote flag; true also on hybrid jobs open to remote applicants.
- `remoteCountryCodes`: for a remote job, the countries applicants may live in (ISO codes).
- `countryCodes`: the countries of every location of the job.
- `address`: the main location's postal address as published.
- `secondaryLocations`: the job's other locations, each with its postal address.
- `companyWebsite`: the company's website, from its job board.
- `directApply`: you apply on the company's own Ashby form (`applyUrl`).
- `applicationDeadline`: the last day to apply, when the company sets one. Only with `includeApplicationDetails`.
- `teams`: the full team path, top level first. Only with `includeApplicationDetails`.
- `description`: the full job description as plain text. Only with `includeDescription` (on by default).
- `descriptionHtml`: the description with the company's formatting. Only with `includeHtml`.
- `descriptionMarkdown`: the description as Markdown. Only with `includeMarkdown` (on by default).
- `compensation`: Ashby's compensation object, verbatim: every tier and component.
- `ats`: `Ashby` (or the other job board's name).
- `boardUrl`: the job board the job was read from.
- `jobId`: the job's id on Ashby.
- `companyInput`: the entry of your `companies` list (or the directory board) that led to this job.
- `scrapedAt`: when this run read the job (UTC).

Example row (descriptions and raw pay data shortened):

```json
{
  "companyLogo": "https://app.ashbyhq.com/api/images/org-theme-logo/7a158cac-9866-4881-95a8-bc946d3dca79/c68257b4-5a2d-4ecc-93a6-fe3c6766ce8b/55852d64-3584-498c-8afb-0679e5c9dede.png",
  "title": "Chief Compliance Officer, Ramp Advisory LLC",
  "company": "Ramp",
  "location": "New York, NY (HQ)",
  "workplaceType": "Hybrid",
  "employmentType": "Full-time",
  "department": "Compliance",
  "salary": "USD 170,000 - 300,000 per year",
  "salaryMin": 170000,
  "salaryMax": 300000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "postedAt": "2026-10-16T21:05:12Z",
  "jobUrl": "https://jobs.ashbyhq.com/ramp/abd1360f-bd9d-4649-ac02-9af2a437ff98",
  "applyUrl": "https://jobs.ashbyhq.com/ramp/abd1360f-bd9d-4649-ac02-9af2a437ff98/application",
  "locations": ["New York, NY (HQ)", "Remote (US or Canada)", "San Francisco, CA", "Miami, FL"],
  "countryCode": "US",
  "compensationSummary": "$170K – $300K • Offers Equity • Multiple Ranges",
  "salaryRanges": [
    {"tier": "SF/NY", "min": 185000, "max": 300000, "currency": "USD", "period": "year", "summary": "Target Base Salary $185K – $300K"},
    {"tier": "Nationwide", "min": 170000, "max": 250000, "currency": "USD", "period": "year", "summary": "Target Base Salary $170K – $250K"}
  ],
  "salarySource": "compensation",
  "offersEquity": true,
  "offersBonus": false,
  "offersCommission": false,
  "compensationShown": true,
  "team": "Compliance",
  "isRemote": true,
  "remoteCountryCodes": ["US", "CA"],
  "countryCodes": ["US", "CA"],
  "address": {"addressRegion": "NY", "addressCountry": "USA", "addressLocality": "New York City"},
  "secondaryLocations": [{"location": "Remote (US or Canada)", "address": null}, {"location": "San Francisco, CA", "address": {"addressRegion": "California", "addressCountry": "USA", "addressLocality": "San Fransisco"}}],
  "companyWebsite": "https://ramp.com",
  "directApply": true,
  "description": "ABOUT RAMP\n\nRamp is building the smart infrastructure for finance teams...",
  "descriptionMarkdown": "# About Ramp\n\nRamp is building the smart infrastructure for finance teams...",
  "compensation": {"compensationTierSummary": "$170K – $300K • Offers Equity • Multiple Ranges", "compensationTiers": ["..."]},
  "ats": "Ashby",
  "boardUrl": "https://jobs.ashbyhq.com/ramp",
  "jobId": "abd1360f-bd9d-4649-ac02-9af2a437ff98",
  "companyInput": "https://jobs.ashbyhq.com/ramp",
  "scrapedAt": "2026-10-19T16:38:20Z"
}
```

The run's **🧾 Run summary** (the OUTPUT record in the key-value store) shows, per company, which job board was found and how, how many jobs it lists, how many matched your filters and how many were delivered, plus any error.

### When something goes wrong

- A company that isn't found (a wrong name, a closed job board) is listed in the run summary and the status message. The run still delivers everything else.
- If a job board can't be read after several retries on fresh IPs, the run ends as **failed** with the reason, so you notice. The jobs that were read are still in the dataset.
- When `maxResults` is reached, the companies after that point get nothing; the run summary marks them as skipped.

### Pricing

You pay per job delivered: $0.46 per 1,000 jobs on the Free plan, $0.39 on Starter, $0.35 on Scale and $0.29 on Business. Descriptions, Markdown, every pay field, application details and the directory are included at the same price. Company lookups, boards that fail, jobs removed by your filters and the 💰 With Salary list cost nothing.

Examples on Starter: the prefilled run (100 jobs) about $0.04; the default `maxResults` of 1,000 jobs $0.39; every job at the 25 biggest directory boards with `maxJobsPerCompany` 0 (about 10,900 jobs on 2026-10-19) about $4.25.

### FAQ

**Why do some jobs have no salary?** The company decides whether to publish pay on Ashby. Ramp publishes it on every job; Notion on none, but most of its descriptions state the range, and the row takes it from there (`salarySource`: `description`). A job with neither has no salary.

**Is the directory every company on Ashby?** No: it is 3,177 Ashby boards with open jobs, found in public web crawl data and checked live on 2026-10-19. Each run reads the boards live, so a board that closed since shows up in the run summary.

**Do I need a proxy?** The default Apify datacenter proxy is all Ashby's API needs.

**How fresh is the data?** Each run reads the job boards live; nothing comes from a cache or a database.

**Can I get new jobs every day?** Yes: save your input as a task, schedule it daily in Apify, and set `postedWithinDays` to 1 so each run brings only the latest postings.

### Feedback

Missing a field or a company it can't find? Open an issue on the Issues tab and we'll look at it. If the data helped you, a short review on this page helps other people find it.

# Actor input Schema

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

Ashby board URLs (https://jobs.ashbyhq.com/notion), board names (ramp) or company names (OpenAI). Greenhouse, Lever and Workday boards work too.

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

Each company's newest jobs, up to this many. You pay per job, so this caps the cost per company. 0 = every job.

## `maxResults` (type: `integer`):

Stop after this many jobs in total, delivered in the order of your inputs. You pay per job, so this caps the run's cost.

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

Adds the full description as plain text (and Markdown, below), at the same price.

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

Keep jobs whose title contains any of these words or phrases, e.g. engineer, sales manager. Not case-sensitive. Empty = every job.

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

Keep jobs whose department or team contains any of these, e.g. Engineering, Sales. Not case-sensitive. Empty = every department.

## `employmentTypes` (type: `array`):

Keep only these job types. Empty = every type.

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

Keep jobs whose location names any of these, e.g. London, Germany. Two letters are a country code: US, GB, DE, CA (Canada). Empty = anywhere.

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

Keep only jobs the company marks as remote, or whose location says Remote.

## `postedWithinDays` (type: `integer`):

Keep jobs posted in the last N days, e.g. 1 for a daily scheduled run. Uses the board's own publish time. 0 = any date.

## `useDirectory` (type: `boolean`):

Also read Ashby boards from our directory of companies hiring on Ashby, each checked live when it was built. Biggest boards first.

## `directoryQuery` (type: `string`):

Only directory companies whose name or board name contains this, e.g. ai, health. Up to 3 letters must be a whole word (ai: OpenAI, not Airwallex). Empty = any company.

## `maxCompanies` (type: `integer`):

How many directory boards to read at most, biggest first.

## `includeMarkdown` (type: `boolean`):

Adds descriptionMarkdown: headings, lists, bold and links kept, ready for LLMs and AI agents. Same price.

## `includeHtml` (type: `boolean`):

Adds descriptionHtml with the company's own formatting. Same price. Needs job descriptions on.

## `includeAllFields` (type: `boolean`):

Adds every pay tier and range, equity, bonus and commission flags, raw pay data, team, addresses, remote countries and the company website. Without published pay, the description's range is used. Same price.

## `includeApplicationDetails` (type: `boolean`):

Adds the application deadline and the full team path from each job page. Same price; one more request per job, so slower.

## `proxyConfiguration` (type: `object`):

Leave as is: Apify datacenter proxies are all these job boards need. Residential and SERP proxies are replaced with datacenter (they cost more and add nothing here); your own proxy URLs work too.

## Actor input object example

```json
{
  "companies": [
    "https://jobs.ashbyhq.com/notion",
    "https://jobs.ashbyhq.com/ramp"
  ],
  "maxJobsPerCompany": 50,
  "maxResults": 1000,
  "includeDescription": true,
  "remoteOnly": false,
  "postedWithinDays": 0,
  "useDirectory": false,
  "maxCompanies": 25,
  "includeMarkdown": true,
  "includeHtml": false,
  "includeAllFields": true,
  "includeApplicationDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `withSalaryUrl` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "companies": [
        "https://jobs.ashbyhq.com/notion",
        "https://jobs.ashbyhq.com/ramp"
    ],
    "maxJobsPerCompany": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/ashby-jobs").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "companies": [
        "https://jobs.ashbyhq.com/notion",
        "https://jobs.ashbyhq.com/ramp",
    ],
    "maxJobsPerCompany": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/ashby-jobs").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 '{
  "companies": [
    "https://jobs.ashbyhq.com/notion",
    "https://jobs.ashbyhq.com/ramp"
  ],
  "maxJobsPerCompany": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call deepmine/ashby-jobs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deepmine/ashby-jobs"
        }
    }
}
```

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/17On4gJrLRpp5454e/builds/5tGetobECTtsc5OXw/openapi.json
