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

Scrape public job listings from any company's Ashby job board via the official Posting API. Structured jobs — title, department, team, location, remote type, employment type, compensation range, full description, and apply URL. Bulk multi-company. For job boards and recruiting.

- **URL**: https://apify.com/ratio\_tech/ashby-scraper.md
- **Developed by:** [Marius Matulevicius](https://apify.com/ratio_tech) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Ashby Jobs Scraper — with salary data

**Turn any company's [Ashby](https://www.ashbyhq.com/) careers page into clean JSON — every open role, with the compensation range attached.** No login, no API key, no HTML parsing. One request returns a company's entire board.

Most job scrapers give you titles and locations. This one gives you **salary/compensation ranges** too — pulled straight from the official Ashby Posting API, the same endpoint that powers the company's public career page.

```json
{
  "title": "Engineering Manager, EU",
  "department": "Engineering",
  "location": "Remote - European Union",
  "isRemote": true,
  "employmentType": "FullTime",
  "compensation": "€76K – €185K • Offers Equity • Offers Bonus",
  "jobUrl": "https://jobs.ashbyhq.com/Ashby/7458d4e9-...",
  "applyUrl": "https://jobs.ashbyhq.com/Ashby/7458d4e9-.../application"
}
```

👉 **Try it now:** hit **Run** with the default input. It scrapes Ashby's own board and returns real jobs — with compensation — in seconds. Then swap in any company from the [list below](#companies-that-use-ashby).

***

### Who this is for

- **Recruiters & sourcers** — pull a target company's entire req list, salary bands included, into a sheet. Benchmark comp, spot new openings, find hiring-signal accounts.
- **Sales & lead-gen teams** — "who's hiring for X role" is a buying signal. Monitor a list of Ashby companies and get a fresh feed of new postings every run.
- **Job boards & aggregators** — ingest structured postings (HTML + plain text description, apply URL, comp) from any Ashby company without building a parser per site.
- **Labor-market & comp researchers** — Ashby publishes compensation more often than most ATSs. Build a real salary dataset across companies.
- **AI agents & data pipelines** — one tool call → structured job data. See the [agent note](#for-ai-agents) below.

***

### Why this one

| | This Actor | Typical job scraper |
|---|---|---|
| **Compensation range** | ✅ when the company publishes it | ❌ rarely |
| **Source** | Official public Ashby API | HTML scraping (breaks often) |
| **Speed** | One request = whole board | Page-by-page crawl |
| **Full description** | HTML **and** plain text | Often HTML only |
| **Failed rows billed?** | ❌ never (unbilled errors dataset) | usually yes |
| **Login / API key** | Not needed | varies |

Because it rides the documented public API instead of scraping markup, it's **fast and low-maintenance** — it doesn't break when Ashby restyles a page.

***

### What you get, per job

`title` · `department` · `team` · `location` (+ secondary locations) · `isRemote` · `workplaceType` (Remote/Hybrid/Onsite) · `employmentType` · **`compensation`** · `descriptionHtml` · `descriptionText` · `publishedAt` · `jobUrl` · `applyUrl`

Full field reference is in the [Output](#output) section.

***

### Quick start

1. Find a company that uses Ashby — its careers URL looks like `jobs.ashbyhq.com/CompanyName`.
2. Put `CompanyName` (case-sensitive) into `boards`. You can also paste the full URL.
3. Run. Add more companies to `boards` to scrape several in one run.

```json
{
  "boards": ["Ramp", "Notion", "Linear"],
  "includeCompensation": true,
  "maxJobsPerBoard": 500
}
```

#### Companies that use Ashby

Ashby is popular with high-growth startups. Names to try: `Ramp`, `Notion`, `Linear`, `Vanta`, `Deel`, `Ashby`. If a company's careers link is `jobs.ashbyhq.com/…`, it works here.

***

### Example runs

Three common jobs-to-be-done — copy the input, paste it into the Actor, and run.

**1. Compensation benchmark across companies**
Pull every open role + salary band from a set of competitors into one dataset, then filter on `compensation` in a sheet.

```json
{
  "boards": ["Ramp", "Deel", "Notion"],
  "includeCompensation": true,
  "maxJobsPerBoard": 1000
}
```

**2. "Who's hiring engineers" lead feed**
Scrape a company's whole board, then filter the dataset on `department = "Engineering"`. Schedule it and dedupe on `jobId` between runs for a rolling feed of new reqs.

```json
{
  "boards": ["Linear"],
  "includeCompensation": true,
  "maxJobsPerBoard": 500
}
```

**3. Remote-only job aggregation**
Ingest full postings (HTML + text description, apply URL) from several boards, then keep only `isRemote = true` rows for a remote job board.

```json
{
  "boards": ["Vanta", "Ashby", "Ramp"],
  "includeCompensation": true,
  "maxJobsPerBoard": 1000
}
```

***

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `boards` | `string[]` | `["Ashby"]` | Ashby board names or `jobs.ashbyhq.com` URLs |
| `includeCompensation` | `boolean` | `true` | Include compensation summaries when published |
| `maxJobsPerBoard` | `integer` | `1000` | Max jobs per board (1–10000) |
| `proxyConfiguration` | `object` | Apify datacenter | Proxy settings |

**How to find a board name:** open a company's Ashby careers page. If the URL is `jobs.ashbyhq.com/CompanyName`, then `CompanyName` is the board (case-sensitive). You can also paste the full URL.

***

### Output

Each run pushes one record per job to the default dataset:

```json
{
    "type": "job",
    "board": "Ashby",
    "title": "Engineering Manager, EU",
    "jobId": "7458d4e9-da2e-47bd-98cb-adfda43d42b2",
    "department": "Engineering",
    "team": "EMEA Engineering",
    "employmentType": "FullTime",
    "location": "Remote - European Union",
    "secondaryLocations": ["Spain"],
    "isRemote": true,
    "workplaceType": "Remote",
    "publishedAt": "2024-03-04T14:29:08.532+00:00",
    "compensation": "€76K – €185K • Offers Equity • Offers Bonus",
    "descriptionHtml": "<p>...</p>",
    "descriptionText": "About the role...",
    "jobUrl": "https://jobs.ashbyhq.com/Ashby/7458d4e9-da2e-47bd-98cb-adfda43d42b2",
    "applyUrl": "https://jobs.ashbyhq.com/Ashby/7458d4e9-da2e-47bd-98cb-adfda43d42b2/application",
    "scrapedAt": "2026-07-11T10:00:00.000Z"
}
```

`compensation` is `null` when the company doesn't publish a range. Export the dataset as **JSON, CSV, Excel, or via API**.

***

### Pricing

**Pay per result** — you're billed only for jobs successfully written to the dataset. Malformed inputs, unknown boards, and failed fetches go to a separate **errors** dataset that is **not billed**. No monthly fee, no minimum.

***

### For AI agents

Call this tool when you need a company's open job postings and it uses Ashby. Input is the company's Ashby board name (e.g. `Ashby`, `Ramp`) or its `jobs.ashbyhq.com` URL. Returns one structured record per job — title, department, team, location, remote/workplace type, employment type, **compensation range when published**, full description (HTML + text), and apply URL. Public data, no login. Not for applicant data.

***

### Proxy

The Ashby Posting API is a public, documented endpoint with minimal anti-bot measures. **Datacenter proxies are sufficient.** Residential is not required.

***

### FAQ

**How do I scrape Ashby jobs without an API key?**
You don't need one. Pass a company's Ashby board name (the `CompanyName` in `jobs.ashbyhq.com/CompanyName`) into `boards` and run — the Actor uses Ashby's official public Job Posting API.

**Does it include salary / compensation ranges?**
Yes, when the company publishes them. Each job includes a `compensation` summary (e.g. `€76K – €185K • Offers Equity`) — rare among job scrapers. It's `null` when the company doesn't publish a range.

**Can I scrape multiple Ashby boards in one run?**
Yes. Pass several board names in `boards` and the Actor scrapes them all, one dataset record per job.

**How do I find a company's Ashby board name?**
Open the company's Ashby careers page. If the URL is `jobs.ashbyhq.com/CompanyName`, then `CompanyName` is the board (case-sensitive). You can also paste the full URL.

**Can I get only new jobs since my last run?**
Every record has `publishedAt` and `jobId` — dedupe or filter on those between runs to get just the new postings. Schedule the Actor to build a rolling feed.

**What does it cost?**
Pay per result — billed only for jobs successfully written to the dataset. Unknown boards and failed fetches go to a separate, unbilled errors dataset.

**Is scraping Ashby job boards legal?**
This Actor uses Ashby's official public API — no login, no candidate data. You are responsible for complying with each company's Terms and your local laws. See the notice below.

***

### Legal & compliance notice

This Actor uses the **official, public, documented Ashby Job Posting API** — the same endpoint that powers companies' public career pages. No login is used. Job-posting content (titles, descriptions, compensation) is **company data, not personal data about candidates**.

**The user (buyer) bears sole responsibility** for how they use the data collected, including compliance with:

- Ashby's and each company's Terms of Service
- Applicable data protection and employment laws in their jurisdiction

This tool is intended for legitimate use cases such as job aggregation, labor-market research, compensation benchmarking, and recruiting intelligence. Misuse is the responsibility of the operator.

***

### Related Actors by Ratio Tech

Scraping jobs from other ATS platforms? We maintain a matching set — same output shape, same pay-per-result pricing:

- [Workday Jobs Scraper](https://apify.com/ratio_tech/workday-scraper) — public jobs from any Workday career site
- [SmartRecruiters Jobs Scraper](https://apify.com/ratio_tech/smartrecruiters-scraper) — public jobs from any SmartRecruiters career site
- [Recruitee Jobs Scraper](https://apify.com/ratio_tech/recruitee-scraper) — public jobs from any Recruitee career site

# Actor input Schema

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

Ashby job-board names (case-sensitive), such as 'Ashby' or 'Ramp'. You can also paste a full board URL like 'https://jobs.ashbyhq.com/Ramp' — the board name is parsed out. Find it as the path segment in a company's jobs.ashbyhq.com career URL.

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

Include the compensation summary (e.g. '€76K – €185K • Offers Equity') when the company publishes it.

## `maxJobsPerBoard` (type: `integer`):

Maximum number of jobs to return for each board.

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

Apify Proxy settings. Datacenter proxies are sufficient — the Ashby Posting API is a public, documented endpoint with minimal anti-bot measures.

## Actor input object example

```json
{
  "boards": [
    "Ashby"
  ],
  "includeCompensation": true,
  "maxJobsPerBoard": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `errors` (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 = {
    "boards": [
        "Ashby"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ratio_tech/ashby-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": ["Ashby"] }

# Run the Actor and wait for it to finish
run = client.actor("ratio_tech/ashby-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": [
    "Ashby"
  ]
}' |
apify call ratio_tech/ashby-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/0fym0s6xHfefFSPOP/builds/LYv4ipyLVLXusvwZC/openapi.json