# Ashby Job Listings API – Careers Board Scraper (`deadwood_data_solutions/ashby-jobs-scraper`) Actor

Scrape live job postings from any company's Ashby board, including published salary ranges. Clean JSON per job with dedup, so scheduled runs only return newly-posted roles.

- **URL**: https://apify.com/deadwood\_data\_solutions/ashby-jobs-scraper.md
- **Developed by:** [K O](https://apify.com/deadwood_data_solutions) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 – New Postings & Salary Feed

Scrape live job postings from **any company's Ashby board** and get one clean JSON record per role — title, location, department, team, employment type, **published salary range**, post date and a direct apply URL. Built-in deduplication means a **scheduled run only returns newly-posted jobs**, so you can wire it straight into a hiring-signal feed, a niche job board, or a comp-benchmarking tool.

### Who uses it

Recruiters and sourcers, job-board and ATS aggregators, comp-data and salary-benchmark products, sales teams tracking a target account's hiring, and anyone building a "new roles at companies I follow" alert.

### Why this is worth charging for

Ashby exposes a public job-board API, but you still have to know each company's board name, hit boards one at a time, dig compensation out of a nested object, and diff runs yourself to find what's new. This actor does all of that: pass a list of companies, get a normalized, deduplicated feed — with salary where the employer publishes it — that you can schedule.

### Input

| Field | Description |
|---|---|
| `companies` | One or more Ashby job-board names — the slug in `jobs.ashbyhq.com/<name>` (e.g. `Ramp`). |
| `includeDescription` | Include each posting's plain-text description. Off by default for lean records. |
| `onlyNewSinceLastRun` | Recommended for schedules — skips jobs already returned by a previous run, so you're only charged for genuinely new postings. |
| `maxItems` | Stop after this many normalized records. |

### Output

Each dataset item is one normalized job:

```json
{
  "jobId": "03e2d4e1-73ad-4f09-a058-2eb9ce34c2bc",
  "company": "Ramp",
  "title": "Technical Consultant, Mid-Market",
  "location": "Remote (US)",
  "secondaryLocations": ["Remote (Canada)"],
  "department": "Sales",
  "team": "Solutions Consulting",
  "employmentType": "FullTime",
  "remote": true,
  "postedAt": "2026-07-07T20:47:09.753+00:00",
  "compensationSummary": "$120K – $150K",
  "url": "https://jobs.ashbyhq.com/Ramp/03e2d4e1-73ad-4f09-a058-2eb9ce34c2bc",
  "applyUrl": "https://jobs.ashbyhq.com/Ramp/03e2d4e1-73ad-4f09-a058-2eb9ce34c2bc/application",
  "description": null,
  "source": "Ashby"
}
```

### Pricing (Pay-Per-Event)

- **`query`** — charged once per run for the board poll.
- **`job-record`** — charged per normalized job pushed. This is the primary event.
- `apify-actor-start` (Apify-managed) — covers baseline compute per run.

A daily monitor of a handful of companies returns a few new roles for pennies; a full-board pull of a large employer is a larger one-time run you control with `maxItems`.

### Source & reliability

Data comes from Ashby's public `api.ashbyhq.com/posting-api/job-board` service. No API key, no proxy needed. Run `npm test` for the offline self-test covering the normalizer and its edge cases.

### FAQ

**Where do I find a company's Ashby board name?**

Open the company's Ashby careers page — the name is the slug in the URL, e.g. `jobs.ashbyhq.com/Ramp` → `Ramp`.

**Do all jobs include salary?**

Only where the employer publishes compensation on the posting. When present it's surfaced as `compensationSummary`; otherwise the field is null.

***

*SEO keywords: Ashby jobs scraper, Ashby job board API, job posting scraper, salary data scraper, compensation data API, ATS scraper, new jobs feed, hiring signals, recruiting data*

# Actor input Schema

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

One or more Ashby job-board names — the slug in jobs.ashbyhq.com/<name> (e.g. Ramp).

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

Include each posting's plain-text job description. Larger records.

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

Stop after this many normalized records have been pushed. Leave blank for no limit.

## `onlyNewSinceLastRun` (type: `boolean`):

Recommended for scheduled runs. Uses persisted state to skip postings already returned earlier, so a recurring schedule only charges for genuinely new jobs.

## Actor input object example

```json
{
  "companies": [
    "Ramp"
  ],
  "includeDescription": false,
  "onlyNewSinceLastRun": true
}
```

# Actor output Schema

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

All normalized records from this run as JSON.

## `resultsCsv` (type: `string`):

All normalized records from this run as CSV.

# 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": [
        "Ramp"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

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