# Ashby Jobs Scraper & API: Daily New-Job Feed (`deftcell/ashby-jobs-api`) Actor

Scrape every public job from Ashby job boards (jobs.ashbyhq.com) as clean JSON: locations, remote and hybrid flags, pay ranges the company publishes, teams, dates, apply links, and plain-text descriptions. Give board names, URLs, careers pages, or domains. Incremental mode returns only new jobs.

- **URL**: https://apify.com/deftcell/ashby-jobs-api.md
- **Developed by:** [Ervin Amaya](https://apify.com/deftcell) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 job delivereds

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 Scraper & API: Daily New-Job Feed

**Ashby jobs scraper and API.** Scrape **every public job posting from any Ashby job board** (jobs.ashbyhq.com) into clean, structured JSON: title, department, team, all locations, remote/hybrid/on-site, **pay ranges the company publishes**, employment type, dates, apply link, and a plain-text description. It reads Ashby's public Job Postings API: no login, no API key, no browser.

Give it board names (`ramp`), board URLs, careers pages, or bare domains. Turn on **incremental mode** and each scheduled run returns only jobs you haven't received yet: a ready-made daily Ashby job feed for job boards, recruiting tools, sales signals, market research, and AI agents.

**Built and maintained by an AI agent operated by Elite Tech Global LLC (Deftcell).** Issues are monitored and answered by the same AI-assisted team.

> Need Greenhouse, Lever, or Workable too? [ATS Jobs API](https://apify.com/deftcell/ats-jobs-api) reads all four in one run with the same output schema. This edition is the same engine, focused on Ashby.

### What this Ashby jobs scraper does

- **Reads Ashby's public Job Postings API**, the one companies use to publish openings on their own careers sites. No login, no API key, no browser. Unlisted postings (hidden from the public board on purpose) are skipped.
- **Pay ranges, parsed carefully.** Ashby's structured compensation comes first, and only when the company chose to show pay on its postings. If a posting has none, a salary *range* is taken from the description only when it is clearly stated next to words like "salary", "base", or "pay". Every salary says where it came from (`salarySource`) and the wording it was read from (`salaryText`).
- **Every location.** The primary location and Ashby's secondary locations are both returned.
- **Remote and workplace flags** from Ashby's own workplace and remote fields. `workplaceType` is `remote`, `hybrid`, `onsite`, or `null` when unknown; `isRemote` is `true` for fully remote jobs and jobs with a remote option.
- **Board finder.** Pass `https://example.com/careers` or `example.com` and the Actor finds the company's Ashby board from that one page.
- **Filters:** keywords, locations, remote only, "posted within N days", and a per-company cap. Filtered-out jobs are not charged.
- **Incremental mode** for daily feeds, with one memory per `feedName`.
- **Polite and reliable:** at most 5 requests in flight, robots.txt (including Crawl-delay) honoured, retries with backoff on 429/5xx, timeouts on every request.

### How to scrape Ashby jobs: input examples

**Board names (the simplest input):**

```json
{ "companies": ["ramp", "linear", "notion"] }
```

**URLs, careers pages, and domains:**

```json
{
  "companies": [
    "https://jobs.ashbyhq.com/ramp",
    "https://api.ashbyhq.com/posting-api/job-board/linear",
    "https://www.example.com/careers"
  ],
  "maxJobsPerCompany": 100
}
```

**Remote engineering jobs from the last two weeks:**

```json
{
  "companies": ["ramp", "linear", "notion"],
  "keywords": ["engineer", "developer"],
  "remoteOnly": true,
  "postedWithinDays": 14
}
```

**Daily feed of new jobs only (pair it with an Apify schedule):**

```json
{
  "companies": ["ramp", "linear", "notion"],
  "incremental": true,
  "feedName": "daily-ashby-feed"
}
```

#### Input fields

| Field | Type | Default | Description |
|---|---|---|---|
| `companies` | array (required) | – | Ashby board names, board or API URLs, careers-page URLs, domains, or `{ "ats": "ashby", "token", "companyName" }` objects. Up to 10,000 per run. |
| `keywords` | string\[] | `[]` | Keep jobs whose title, department, or team contains any keyword. Whole words, case-insensitive; `engineer` also matches "Engineering". |
| `keywordsInDescription` | boolean | `false` | Also search the description text. |
| `locations` | string\[] | `[]` | Keep jobs matching any location: city, region, country, or `Remote`. `US`/`USA`/`United States` are treated as the same place. |
| `remoteOnly` | boolean | `false` | Keep only jobs with `isRemote: true`. |
| `postedWithinDays` | integer | none | Keep jobs whose `postedAt` (or `updatedAt`) is within this many days. |
| `maxJobsPerCompany` | integer | none | Deliver at most this many jobs per company, newest first. |
| `includeDescriptionHtml` | boolean | `false` | Add the original description HTML (`descriptionHtml`). Plain text is always included. |
| `incremental` | boolean | `false` | Deliver only jobs not delivered by earlier runs with the same `feedName`. |
| `feedName` | string | `"default"` | Name of the feed whose memory is used. |

### Output: Ashby job data as JSON, CSV, or Excel

One dataset item per job, in the same schema as [ATS Jobs API](https://apify.com/deftcell/ats-jobs-api). A real posting from a test run on 2026-10-07, description shortened:

```json
{
  "id": "08af4af8f366bf678952519a",
  "ats": "ashby",
  "companyToken": "ramp",
  "companyName": null,
  "atsJobId": "b599c5a9-9c9d-4826-b67a-ca5e012faaad",
  "title": "Partner Development Representative | Reseller",
  "department": "Sales",
  "team": "Channel Sales",
  "employmentType": "FULL_TIME",
  "employmentTypeRaw": "FullTime",
  "locations": [
    "New York, NY (HQ)",
    "Remote (US)"
  ],
  "isRemote": true,
  "workplaceType": "hybrid",
  "salaryMin": 110000,
  "salaryMax": 120000,
  "salaryCurrency": "USD",
  "salaryPeriod": "YEAR",
  "salarySource": "ats",
  "salaryText": "$110K - $120K",
  "postedAt": "2026-10-06T19:25:07.450Z",
  "updatedAt": null,
  "applyUrl": "https://jobs.ashbyhq.com/ramp/b599c5a9-9c9d-4826-b67a-ca5e012faaad/application",
  "jobUrl": "https://jobs.ashbyhq.com/ramp/b599c5a9-9c9d-4826-b67a-ca5e012faaad",
  "descriptionText": "About Ramp\n\nRamp is building the smart infrastructure for finance teams, embedded in the transaction flow of every dollar a business spends. We automa …",
  "companyInput": "ramp",
  "scrapedAt": "2026-10-07T14:40:03.235Z"
}
```

- `id` is stable across runs (a hash of ATS + board + job ID), so you can de-duplicate or upsert on it.
- **`companyName` is `null` unless you give it**: Ashby's public API doesn't publish the company's display name. Pass an object such as `{"ats": "ashby", "token": "ramp", "companyName": "Ramp"}` to fill it. `companyToken` always holds the board name.
- In the example the job is hybrid at its primary location and also open to remote candidates in the US, so `workplaceType` is `hybrid` and `isRemote` is `true`.
- `salarySource` is `ats` when the range comes from Ashby's structured compensation and `description` when it was read from the posting text.
- `jobUrl` is the Ashby posting page and `applyUrl` is its application form.
- Personal e-mail addresses in descriptions are replaced with `[email removed]`.

The dataset's **Overview** tab shows company, title, locations, workplace, type, salary, posted date, and job link. Export as JSON, CSV, Excel, or through the API.

Each run also saves `RUN_SUMMARY` in its key-value store: one record per input with its `status` (`ok`, `no_jobs`, `no_matching_jobs`, `no_new_jobs`, `duplicate`, `board_not_found`, `not_detected`, `robots_disallowed`, `unsupported_ats`, `invalid_input`, `error`, and the charge-limit statuses), the board it resolved to, and job counts.

### Daily feed of new Ashby jobs (incremental mode)

1. Set `incremental: true` and pick a `feedName`, such as `"daily-feed"`.
2. Create an [Apify schedule](https://docs.apify.com/platform/schedules) that runs the Actor (or a saved task) every day.
3. The **first run delivers every matching job.** Later runs deliver only jobs no earlier run with the same `feedName` delivered.

Delivered job IDs are stored per board in a named key-value store in your Apify account, `ashby-jobs-api-incremental`. It's separate from ATS Jobs API's store, so a feed's memory doesn't carry over between the two Actors. A job counts as seen only once it is actually delivered. IDs of removed jobs are forgotten after 180 days. Don't run two incremental runs with the same `feedName` at the same time. To start a feed over, use a new `feedName`.

### How much does the Ashby Jobs API cost?

Pay per event: **$1.50 per 1,000 jobs delivered** ($0.0015 per job) on Apify's Free plan, and $1.35, $1.20, or $1.05 per 1,000 on Starter, Scale, or Business-and-higher plans (Apify Store discounts), plus Apify's small automatic start event per run. Final prices are on the Actor's pricing tab. Jobs removed by filters, jobs already delivered in incremental mode, boards on other ATSs, and companies that fail are never charged. Set a **maximum charge per run** to cap spend.

### Ashby Jobs API for AI agents and MCP clients

- **Smallest useful input:** `{"companies": ["ramp"], "maxJobsPerCompany": 20}`.
- **API:** `POST https://api.apify.com/v2/actors/deftcell~ashby-jobs-api/run-sync-get-dataset-items?token=<APIFY_TOKEN>&maxTotalChargeUsd=1` with the input JSON as the body.
- **MCP:** add `https://mcp.apify.com?tools=deftcell/ashby-jobs-api` to your MCP client ([Apify MCP docs](https://docs.apify.com/integrations/mcp)).

### FAQ: Ashby job scraping

**Why did a company return no jobs?** Check `RUN_SUMMARY`. `not_detected`: no Ashby board was found from the page you gave; pass the board name or URL. `board_not_found`: Ashby has no public board with that name. A board can also exist but have 0 open postings (`no_jobs`). `unsupported_ats`: the company uses another ATS; use [ATS Jobs API](https://apify.com/deftcell/ats-jobs-api).

**How do I find a company's board name?** Open one of its job posts. The board name is the part after `jobs.ashbyhq.com/`. Or just pass the careers page.

**Why does a job have no salary when the company pays well?** Ashby lets each company decide whether pay is shown on its postings. If it isn't shown and the description doesn't state a range, the salary fields stay `null`; nothing is guessed.

**Can it scrape LinkedIn, Indeed, or arbitrary sites?** No. It reads only Ashby's public Job Postings API, plus the single careers page you give it for detection.

### Data source and compliance

- Jobs come only from Ashby's **public [Job Postings API](https://developers.ashbyhq.com/docs/public-job-posting-api)**, which companies use to publish openings. No data is taken from behind a login.
- The output contains **job postings, not people.** Recruiter and contact fields are never output, and personal e-mail addresses are removed. Role mailboxes such as `careers@` stay.
- **robots.txt is respected** for every host, including Crawl-delay. Requests are rate-limited and identified by the user agent `DeftcellJobsAPI/1.0 (+https://apify.com/deftcell)`.
- You are responsible for how you use the data, including the hiring companies' terms and applicable privacy law.
- Not affiliated with or endorsed by Ashby. The name only describes where the data comes from.

### Related Deftcell Actors

Same engine and output schema, different ATS. Each Actor keeps its own incremental memory.

- [ATS Jobs Scraper & API](https://apify.com/deftcell/ats-jobs-api): Greenhouse, Lever, Ashby, and Workable in one run, with auto-detection from careers pages.
- [Greenhouse Jobs Scraper & API](https://apify.com/deftcell/greenhouse-jobs-api): Greenhouse job boards.
- [Lever Jobs Scraper & API](https://apify.com/deftcell/lever-jobs-api): Lever job sites, EU-hosted sites included.
- [Workable Jobs Scraper & API](https://apify.com/deftcell/workable-jobs-api): Workable careers pages (apply.workable.com).

### Support

Open an issue on the **Issues** tab with your run ID and what you expected. **Built and maintained by an AI agent operated by Elite Tech Global LLC (Deftcell).**

# Actor input Schema

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

One entry per company. Accepted forms:

- Board name: "ramp" (the part after jobs.ashbyhq.com/)
- Board URL: https://jobs.ashbyhq.com/linear, or an API URL (api.ashbyhq.com/posting-api/job-board/<company>)
- Careers page or domain: https://example.com/careers or example.com (the Actor fetches that one page, respecting robots.txt, and looks for an Ashby link)
- Object: {"ats": "ashby", "token": "notion", "companyName": "Notion"}
  Boards on other ATSs are reported in RUN_SUMMARY and never charged; use deftcell/ats-jobs-api for Greenhouse, Lever, and Workable.

## `keywords` (type: `array`):

Keep jobs whose title, department, or team contains any of these words or phrases (case-insensitive, whole words; "engineer" also matches "Engineering"). Leave empty to keep all jobs.

## `keywordsInDescription` (type: `boolean`):

When on, keywords also match the job description text (useful for skills such as "Kubernetes").

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

Keep jobs whose location matches any entry, for example "London", "United States", "Germany", or "Remote". "US" and "UK" also match their full names, and US jobs listed as "City, ST" count as United States.

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

Keep only jobs the ATS or the posting marks as remote.

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

Keep only jobs first published within this many days (uses the posting date from the ATS). Leave empty for no limit.

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

Deliver at most this many jobs per company, newest first. Leave empty for all jobs.

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

Add the original description HTML in `descriptionHtml`. Plain text (`descriptionText`) is always included.

## `incremental` (type: `boolean`):

When on, each run delivers only jobs that earlier runs with the same feed name have not delivered yet. The first run delivers everything that matches. Ideal for scheduled daily feeds.

## `feedName` (type: `string`):

Name of the feed whose memory to use, such as `daily-design-jobs`. Use a different name for each separate feed or schedule. Leave empty to use the feed named `default`. (Formerly `incrementalKey`, which still works.)

## Actor input object example

```json
{
  "companies": [
    "ramp",
    "https://jobs.ashbyhq.com/linear",
    {
      "ats": "ashby",
      "token": "notion",
      "companyName": "Notion"
    }
  ],
  "keywordsInDescription": false,
  "remoteOnly": false,
  "maxJobsPerCompany": 50,
  "includeDescriptionHtml": false,
  "incremental": false
}
```

# Actor output Schema

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

Normalized job postings (one item per job) in the default dataset.

## `runSummary` (type: `string`):

Per-company status, detection method and job counts (RUN_SUMMARY record).

# 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",
        "https://jobs.ashbyhq.com/linear",
        "notion"
    ],
    "maxJobsPerCompany": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("deftcell/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",
        "https://jobs.ashbyhq.com/linear",
        "notion",
    ],
    "maxJobsPerCompany": 50,
}

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

```

## MCP server setup

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

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/6LQ5AIBQ4lljShgGd/builds/QcLsVbms9At5HjIBq/openapi.json