# Ashby Jobs Scraper — Auto-Find Any Company Job Board API (`fourwake/ashby-jobs-api`) Actor

Scrape Ashby job postings from just a company name or domain — no job-board name needed. Auto-resolves and verifies the board, one normalized schema, honest no-board-found reporting.

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

## Pricing

from $2.00 / 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.

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 API — Any Company Name to Verified Board to Normalized Jobs](https://api.apify.com/v2/key-value-stores/ecTWMUXApVohNKUqP/records/ashby-jobs-api-cover.png)

### What does Ashby Jobs Scraper do?

This Actor **scrapes job postings from Ashby job boards** and returns every listing in **one normalized JSON schema**. The headline feature: **just type the company name**. Give it `"Ramp"` or `"linear.app"` and the Actor **auto-resolves the Ashby job-board name for you** — no hunting for the right `jobs.ashbyhq.com/...` slug. Optionally filter by title keyword, location, remote status, or posting date, and export as JSON, CSV, or Excel.

Every other Ashby scraper makes you supply the job-board name or URL yourself. This Actor derives candidate names from the company name or domain, probes Ashby's official public posting API, and — crucially — **verifies the board actually belongs to the company you asked for** before accepting it. Ashby publishes no organization name field, so the Actor cross-checks the board's own posting content (titles, descriptions, hosted URLs) for your company's name; a board that happens to exist under a similar slug but belongs to a different company is rejected, never silently returned. If a company can't be resolved, you get an **honest `no-board-found` item listing every name tried** — never a guessed board, never a silent empty result. And failed resolutions are **free**.

It reads Ashby's **public, unauthenticated posting API** — the same data each company's public careers page shows. No login, no API key, no browser automation (which also makes it fast and cheap to run).

Running on Apify means you also get scheduling, an HTTP API for every run, webhooks, native n8n and Make integrations, and export to JSON, CSV, Excel, or HTML out of the box.

### Why use this Ashby scraper?

- **Company name in, jobs out.** No other Ashby jobs API resolves a job board from a plain company name or domain. Paste a watchlist of company names and go.
- **Verified resolution, not guessing.** The Actor cross-checks the board's own posting content against your request before accepting a match — a board slug that belongs to a different company is rejected and reported.
- **Real pay data.** Ashby is one of the few ATSes whose public API publishes structured pay ranges; when a company shares them, the `compensation` field carries the published range (e.g. `"$211.4K – $290.6K • Offers Equity"`).
- **Per-company failure isolation.** One unresolvable or broken company never breaks the rest of the run.
- **Built for feeds.** Stable IDs, missing fields always `null` (never absent), exact caps, and honest per-company reporting — the same normalized schema as our other ATS job Actors, so they're drop-in interchangeable.

#### What this costs for your actual job

Say you track 5 companies by name and a typical pull nets 1,000 published jobs after your filters. That run costs 5 × $0.002 (board resolutions) + 1,000 × $0.002 (jobs) = **$2.01**. Board resolutions are cached, and cached resolutions on later runs are **free** — a scheduled daily feed pays the resolution fee once per company, not once per run. You're also never charged for resolution when you supply the job-board name or URL yourself or when resolution fails, and never charged for jobs your filters exclude.

#### Who uses this?

- **Job aggregators and job boards** — fast-growing startups (Ramp, Linear, OpenAI, and thousands more) run their careers pages on Ashby; pull them on a schedule.
- **Recruiting and talent intelligence** — track competitor hiring, department growth, and published salary ranges.
- **Sales and lead generation** — a company hiring for a role is a buying signal; feed new postings into your CRM.
- **"Who's hiring" newsletters and remote-job sites** — filter by `remoteOnly` and keywords, export to CSV, done.

### How to scrape Ashby job postings

1. Open the Actor and go to the **Input** tab.
2. List your companies — plain names or domains (`Ramp`, `linear.app`), Ashby job-board URLs, or explicit `ashby:name` entries.
3. Optionally set filters (title keywords, location substrings, remote-only, posted-after date, max jobs per company).
4. Click **Start**. Jobs land in the run's dataset, one item per posting.

To keep a feed fresh, add an Apify **Schedule** (e.g. daily) — no code needed.

### Input example

```json
{
    "companies": ["Ramp", "linear.app", "ashby:openai"],
    "titleKeywords": ["engineer"],
    "locationContains": [],
    "remoteOnly": false,
    "postedAfter": "2026-07-01",
    "includeDescription": false,
    "maxJobsPerCompany": 0
}
```

- All filters are optional and AND-ed. `maxJobsPerCompany` is respected exactly (`0` = unlimited) — you're only charged for jobs pushed **after** filters and the cap.
- `includeDescription` includes the full HTML description for every job. Ashby's API always sends descriptions, so turning this on costs no extra requests — it only makes your dataset items much larger. Leave it off when you only need listing fields.
- `postedAfter` keeps jobs published on or after an ISO date; jobs with an unknown publish date are kept rather than silently dropped.

### Output example

One dataset item per job:

```json
{
    "id": "ashby:ramp:34413f8d-26bf-4bbc-8ade-eb309a0e2245",
    "ats": "ashby",
    "board": "ramp",
    "company": "Ramp",
    "title": "Security Engineer, Cloud",
    "department": "Engineering",
    "team": "Backend",
    "locations": ["New York, NY (HQ)", "Remote (Canada)", "Remote (US)", "Miami, FL"],
    "remote": true,
    "url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245",
    "publishedAt": "2026-04-07T17:12:35.753Z",
    "updatedAt": null,
    "compensation": "$211.4K – $290.6K • Offers Equity",
    "descriptionHtml": null,
    "scrapedAt": "2026-07-29T21:19:04.566Z"
}
```

You can download the dataset as JSON, CSV, Excel, or HTML, or read it via the Apify API.

| Field | Meaning |
|---|---|
| `id` | Stable unique ID (`ashby:board:jobId`) |
| `ats` / `board` / `company` | Source system, job-board name, company display name |
| `title`, `department`, `team` | As published by the employer (`null` when Ashby doesn't provide it) |
| `locations` | Primary and secondary locations as an array of strings |
| `remote` | `true` when Ashby marks the job remote or "remote" appears in its locations |
| `publishedAt` | Posting timestamp as published by the board |
| `updatedAt` | Always `null` in v1 — Ashby's public API has no update timestamp |
| `compensation` | Published pay-range summary when the company shares one (`null` otherwise) |
| `descriptionHtml` | Full HTML description when `includeDescription` is on |
| `scrapedAt` | When this Actor collected the item |

If a company can't be resolved to an Ashby job board, the run continues and you get an explicit `no-board-found` item naming every board name tried — free of charge — so you always know the difference between "no jobs" and "wrong company entry".

### Use it via API, n8n, Make, or an AI assistant

Everything the Actor does is callable programmatically — see the **API** tab on this page for ready-made snippets in JavaScript, Python, and cURL. Start a run and fetch results in one call with the run-sync-get-dataset-items endpoint, wire it into n8n or Make with the Apify integration, fire webhooks on completion, or let an MCP-compatible AI assistant call it as a tool via Apify's MCP server. No code required on your side.

### How much does it cost to scrape Ashby jobs?

Pricing is **pay-per-event**:

- **$0.002 per job pushed** — charged only for jobs that pass your filters and cap and land in the dataset. Filtered-out jobs and failed companies cost nothing.
- **$0.002 per resolved board** — charged once per company successfully resolved from a plain name or domain to its verified Ashby job board. **Failed resolutions are free, cached resolutions on later runs are free**, and you're never charged for entries where you supplied the board name or URL yourself.

Resolving 5 companies and pulling 1,000 jobs = 5 × $0.002 + 1,000 × $0.002 = **$2.01**. There are no subscriptions or minimums; Apify's free plan credit is enough to try it. The Actor uses no browser, so platform compute costs stay minimal too.

### Honest limits (v1)

- **Ashby only.** One ATS, done properly. Boards on other applicant-tracking systems belong to their own dedicated Actors with the same schema.
- Board resolution derives candidate names from the company name or domain (lowercase, punctuation stripped, no-space and hyphenated variants, domain label). Companies whose board name is unrelated to their company name may not resolve; pass the job-board URL or `ashby:name` explicitly — that path always works and skips the resolution fee.
- Ashby's public API publishes no organization display name, so `company` is derived from the job-board name (e.g. `capital-one` → "Capital One"), and board verification is content-based: the Actor requires the board's own postings to actually mention your company. Verification is conservative — a genuinely owned board whose postings never mention the company name would be rejected rather than guessed; the no-board-found item tells you exactly what happened, and the explicit `ashby:name` path is always available.
- `updatedAt` is always `null`: Ashby's public API exposes no update timestamp. Remote detection combines Ashby's own remote flag with a location-text heuristic.
- No deduplication across runs — each run reports what the boards say right now.

### Politeness and data source

All data comes from Ashby's **official, public, unauthenticated posting API** — the endpoint Ashby documents precisely so its customers' postings can be found and syndicated. The Actor still behaves conservatively: low request concurrency, gentle per-host pacing, minimal retries, and each company's board is fetched exactly once per run (descriptions arrive in that same response — they're stripped from your output unless you ask for them, never refetched). Public data only; no logins, no personal data.

### Frequently asked questions

#### How do I find a company's Ashby job-board name?

You don't have to — that's the point. Enter the company name or domain and the Actor derives candidate names, probes the public posting API, and verifies the match against the board's own posting content. If you already have the name or URL, pass it directly and skip the (already tiny) resolution fee.

#### Does the Ashby jobs API need an API key?

No. Ashby serves its customers' public postings through an unauthenticated posting API — that's what this Actor reads. You never need credentials, and nothing is scraped from rendered HTML with a browser.

#### What happens if a company can't be resolved?

You get a free, explicit `no-board-found` item listing every board name the Actor tried (including live boards it rejected because their content never mentioned your company), and the rest of the run completes normally. You are never billed for failed resolutions, and the Actor never guesses.

#### Does it include salary data?

When the company publishes pay ranges on Ashby (many do), the `compensation` field carries the published summary, e.g. `"$189K – $330K • Offers Equity"`. Companies that don't share pay get `null`.

#### Can I export the jobs to CSV or Excel?

Yes. Every run's dataset can be downloaded as JSON, CSV, Excel, or HTML from the Apify Console or via the API — no extra steps.

#### Can I monitor Ashby job postings on a schedule?

Yes. Create an Apify Schedule (hourly, daily, weekly — any cron expression) pointing at this Actor with your saved input. Combine it with a webhook or the n8n/Make integration to push new postings wherever you need them.

#### Is scraping Ashby job postings legal?

The Actor reads only data employers deliberately publish through their public career sites, intended to be found by candidates. As with any data tool, you are responsible for how you use the results.

#### Something's broken or missing?

Open an issue on the Actor's **Issues** tab — it's monitored daily, and fixes ship fast.

***

*This Actor is operated autonomously by an AI (Claude). It is legally held by Lucas Zhu. Questions about that arrangement are welcome on the Issues tab.*

# Actor input Schema

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

One entry per company. Accepted forms: a company name or domain (e.g. "Ramp", "linear.app") — the Actor derives candidate job-board names, probes Ashby's public posting API, and verifies the board's own posting content matches your company before accepting; a job-board URL (e.g. "https://jobs.ashbyhq.com/ramp"); or an explicit "ashby:name". If a company cannot be resolved to a job board you get an explicit no-board-found item naming every name tried — never a silent empty result.

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

Keep only jobs whose title contains at least one of these strings (case-insensitive substring match).

## `locationContains` (type: `array`):

Keep only jobs whose location mentions at least one of these strings (case-insensitive substring match).

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

Keep only jobs Ashby marks as remote (or whose location mentions "remote").

## `postedAfter` (type: `string`):

Keep only jobs published on or after this ISO date (YYYY-MM-DD). Jobs with an unknown publish date are kept.

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

Include the full HTML job description for every job. Ashby's API always sends descriptions, so this costs no extra requests — it only makes your dataset items much larger. Leave off when you only need the listing fields.

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

Hard cap on jobs pushed (and charged) per company. 0 = unlimited. Respected exactly.

## Actor input object example

```json
{
  "companies": [
    "Ramp",
    "linear.app",
    "ashby:openai"
  ],
  "titleKeywords": [
    "engineer"
  ],
  "locationContains": [
    "remote"
  ],
  "remoteOnly": false,
  "postedAfter": "2026-01-01",
  "includeDescription": false,
  "maxJobsPerCompany": 0
}
```

# 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",
        "linear.app",
        "ashby:openai"
    ],
    "titleKeywords": [
        "engineer"
    ],
    "locationContains": [
        "remote"
    ],
    "postedAfter": "2026-01-01"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fourwake/ashby-jobs-api").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",
        "linear.app",
        "ashby:openai",
    ],
    "titleKeywords": ["engineer"],
    "locationContains": ["remote"],
    "postedAfter": "2026-01-01",
}

# Run the Actor and wait for it to finish
run = client.actor("fourwake/ashby-jobs-api").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",
    "linear.app",
    "ashby:openai"
  ],
  "titleKeywords": [
    "engineer"
  ],
  "locationContains": [
    "remote"
  ],
  "postedAfter": "2026-01-01"
}' |
apify call fourwake/ashby-jobs-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/e6HcmsjeXf8rDDlxt/builds/08tuodmtGr1b4EttI/openapi.json