> ## Documentation Index
> Fetch the complete documentation index at: https://rocketyard.dev/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> These Actors run on the Apify platform and charge per result. Call one with POST https://api.apify.com/v2/acts/rocketyard~<actor-id>/run-sync-get-dataset-items and the header Authorization: Bearer <APIFY_TOKEN>, or connect Apify's MCP server at https://mcp.apify.com?tools=rocketyard/<actor-id>.

# Ashby Jobs API & Scraper

> $0.75 per 1,000 jobs, no subscription. Ashby jobs API: every open job (title, company, location, salary when published and more) as JSON or CSV over REST.

Rocketyard's Ashby Jobs API & Scraper exports every open job from Ashby job boards through Ashby's official public job-board API and returns one clean record per job: title, company, location, workplace type, employment type, department and more. It runs on the Apify platform, so you can start it from the Apify Console, the REST API, an AI agent or a no-code tool.

> [card] [Run it on Apify](https://apify.com/rocketyard/ashby-jobs-scraper)
>
> \$0.75 per 1,000 jobs, no subscription. You run it with your own Apify account, and Apify handles billing.

## Who it's for

* Recruiters and staffing agencies tracking which companies are hiring
* Sales teams using new openings as a buying signal
* Developers of job boards, job alerts and salary tools
* Analysts building hiring and compensation datasets

## What you can do with it

* Export every open role from startups that hire with Ashby, with salary ranges and full descriptions
* Track new and closed roles at target companies every day
* Build a startup job or salary dataset from many Ashby boards

## How it works

Ashby publishes every open job of a company through a public job-board API ([documentation](https://developers.ashbyhq.com/docs/public-job-posting-api)), the feed companies use to show openings on their own sites. The Actor reads that API for each board you give it (a board URL such as `https://jobs.ashbyhq.com/ramp` or just the board name `ramp`), without a browser, and applies your keyword, location, department and remote filters before anything is billed. Reading the API instead of scraping HTML means complete records, including pay ranges when the company publishes them, and nothing breaks when a company redesigns its careers page.

## Example output

A real record from a test run on jobs.ashbyhq.com on 2026-11-05. Fields the page didn't publish are left out here; the Actor returns them as `null`.

```json theme={null}
{
  "url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "type": "JobPosting",
  "title": "Security Engineer, Cloud",
  "company": "Ramp",
  "location": "New York, NY (HQ)",
  "workplaceType": "hybrid",
  "employmentType": "FULL_TIME",
  "department": "Engineering",
  "team": "Backend",
  "datePosted": "2026-04-07T17:12:35.753Z",
  "salaryMin": 211400,
  "salaryMax": 290600,
  "salaryCurrency": "USD",
  "salaryUnit": "YEAR",
  "salaryText": "$211.4K - $290.6K",
  "locations": [
    "New York, NY (HQ)",
    "Remote (Canada)",
    "Remote (US)",
    "Miami, FL"
  ],
  "country": "USA",
  "remote": false,
  "description": "ABOUT RAMP\n\nRamp is building the smart infrastructure for finance teams, embedded in the transaction flow of every dollar a business spends. We automate how over $275B in annualized spend flows in and out of 85,000+ companies: authorizing payments, flagging risk, categorizing spend, and closing b…",
  "applyUrl": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245/application",
  "ats": "ashby",
  "board": "ramp",
  "jobId": "34413f8d-26bf-4bbc-8ade-eb309a0e2245",
  "sourceUrl": "https://jobs.ashbyhq.com/ramp",
  "scrapedAt": "2026-11-05T18:09:14.167Z"
}
```

## Fields

| Field | Description | Filled in latest test |
| - | - | - |
| `title` | Job title | 100% |
| `company` | Company name | 100% |
| `location` | Primary location as published | 100% |
| `workplaceType` | `remote`, `hybrid`, `on-site`, or empty when the posting does not say | 100% |
| `employmentType` | schema.org value (`FULL_TIME`, `PART_TIME`, `CONTRACTOR`, `INTERN`, `TEMPORARY`) or the label as published | 100% |
| `department` | Department | 100% |
| `team` | Team | 100% |
| `datePosted` | First published (ISO 8601) | 100% |
| `dateUpdated` | Last updated (ISO 8601), when the API publishes it | 0% |
| `salaryMin` | Lowest salary of the published range | 70% |
| `salaryMax` | Highest salary of the published range | 70% |
| `salaryCurrency` | ISO 4217 currency code | 70% |
| `salaryUnit` | `YEAR`, `MONTH`, `WEEK`, `DAY` or `HOUR` | 70% |
| `salaryText` | The published pay range as text | 70% |
| `locations` | Every location of the job | 100% |
| `country` | Country | 100% |
| `remote` | `true` for remote jobs, `false` for hybrid or on-site, empty when not stated | 100% |
| `description` | Full job description as plain text | 100% |
| `applyUrl` | Application page | 100% |
| `requisitionId` | Requisition ID, when published | 0% |
| `ats` | Applicant tracking system | 100% |
| `board` | Job-board name (the company part of the board URL) | 100% |
| `jobId` | Job ID in the applicant tracking system | 100% |
| `sourceUrl` | Job board the record came from | 100% |
| `url` | the page the record came from | 100% |
| `scrapedAt` | ISO timestamp of the extraction | 100% |

A field is filled when the source publishes it. The Actor never guesses a value: a missing field comes back as `null`. "Filled in latest test" is the share of records from the latest test run (ramp on Ashby) that had the field; other sources publish more or less.

## Pricing

You pay $0.75 per 1,000 jobs, plus a start fee of $0.00005 per run. Jobs removed by your keyword, location, department or remote filters are not charged.

| Jobs | Cost |
| - | - |
| 1,000 | \$0.75 |
| 10,000 | \$7.50 |
| 100,000 | \$75.00 |

Set `maxItems` or the run's **Maximum cost per run** in Apify to cap spending.

## API

Every Apify Actor is also a REST endpoint, so Ashby Jobs API & Scraper works as an Ashby jobs API, an Ashby job board API or an ATS jobs API. Call it from any language with the Apify REST API, or with Apify's JavaScript and Python clients. You need an Apify API token.

### Ashby jobs API request

```bash theme={null}
curl -s -X POST "https://api.apify.com/v2/acts/rocketyard~ashby-jobs-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"startUrls":[{"url":"https://jobs.ashbyhq.com/ramp"}],"maxItems":1000}'
```

```js theme={null}
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('rocketyard/ashby-jobs-scraper').call({"startUrls":[{"url":"https://jobs.ashbyhq.com/ramp"}],"maxItems":1000});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python theme={null}
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("rocketyard/ashby-jobs-scraper").call(run_input={"startUrls":[{"url":"https://jobs.ashbyhq.com/ramp"}],"maxItems":1000})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

The synchronous endpoint returns the records directly. For long crawls, start the run asynchronously and read the dataset when it finishes.

## MCP

Apify's MCP server exposes this Actor as a tool to Claude, Cursor and other MCP clients. [Open this Actor's MCP setup page](https://mcp.apify.com?tools=rocketyard/ashby-jobs-scraper) for setup steps per client, or connect it with this URL:

```text theme={null}
https://mcp.apify.com?tools=rocketyard/ashby-jobs-scraper
```

Claude Code:

```bash theme={null}
claude mcp add --transport http apify "https://mcp.apify.com?tools=rocketyard/ashby-jobs-scraper"
```

Cursor (`.cursor/mcp.json`) and other clients that read an `mcpServers` config:

```json theme={null}
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com?tools=rocketyard/ashby-jobs-scraper" }
  }
}
```

On first use your browser opens so you can sign in to Apify. Then ask the agent, for example: "Export every open role from startups that hire with Ashby, with salary ranges and full descriptions". The tool returns JSON records, and the runs are billed to that Apify account at \$0.75 per 1,000 jobs.

## Automation

n8n, Make and Zapier all connect to Apify. Each example below uses Actor `rocketyard/ashby-jobs-scraper` with this input:

```json theme={null}
{
  "startUrls": [
    {
      "url": "https://jobs.ashbyhq.com/ramp"
    }
  ],
  "maxItems": 1000
}
```

### n8n

Copy this workflow and paste it onto an n8n canvas. It runs the Actor every morning through an HTTP Request node and returns the records as n8n items.

```json theme={null}
{
  "name": "Ashby Jobs API & Scraper daily",
  "nodes": [
    {
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "days",
              "daysInterval": 1,
              "triggerAtHour": 7
            }
          ]
        }
      },
      "id": "c1f6a2d0-4a57-4b5e-9d7a-0a1b2c3d4e01",
      "name": "Every day at 07:00",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1.2,
      "position": [
        0,
        0
      ]
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://api.apify.com/v2/acts/rocketyard~ashby-jobs-scraper/run-sync-get-dataset-items",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpBearerAuth",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "{\n  \"startUrls\": [\n    {\n      \"url\": \"https://jobs.ashbyhq.com/ramp\"\n    }\n  ],\n  \"maxItems\": 1000\n}",
        "options": {
          "timeout": 300000
        }
      },
      "id": "c1f6a2d0-4a57-4b5e-9d7a-0a1b2c3d4e02",
      "name": "Run Ashby Jobs API & Scraper",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        260,
        0
      ],
      "credentials": {
        "httpBearerAuth": {
          "name": "Apify API token"
        }
      }
    }
  ],
  "connections": {
    "Every day at 07:00": {
      "main": [
        [
          {
            "node": "Run Ashby Jobs API & Scraper",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "settings": {}
}
```

Then open the HTTP Request node and create an **HTTP Bearer Auth** credential named `Apify API token`, with your token from [Apify Console](https://console.apify.com/settings/integrations) as the bearer token. The token stays in n8n's credential store; the workflow only names the credential. Change the input in the node's JSON body to your own.

The node waits up to 300 seconds, which is also the limit of Apify's synchronous endpoint. An input that yields nothing comes back as an item with an `error` field, which you can drop with a Filter node. Apify also publishes a community node, `@apify/n8n-nodes-apify`, with a **Run an Actor and get dataset** operation.

### Make

1. Add Apify's **Run an Actor** module and connect your Apify account.
2. Choose `rocketyard/ashby-jobs-scraper`, paste the input above and set **Run synchronously** to **Yes**. Make limits how long a synchronous run can take, depending on your plan. For longer runs, start the scenario from **Watch Actor Runs** instead.
3. Add **Get Dataset Items** with the run's default dataset ID.
4. Send the items wherever you need them, for example with Google Sheets **Add a Row**, mapping `title`, `company`, `location` and `workplaceType`.

### Zapier

1. Add Apify's **Run Actor** action, connect your Apify account, choose `rocketyard/ashby-jobs-scraper` and paste the input above.
2. Zapier stops synchronous runs after 30 seconds. For anything larger than a small run, let the run continue in the background and start a second Zap from the **Finished Actor run** trigger.
3. Add **Fetch dataset items** with the run's dataset ID, then map `title`, `company`, `location` and `workplaceType` into your app.
4. Test with a small input and check that the Zap handles every record before you turn it on.

## Limits

* Only companies whose careers pages are hosted on Ashby, with a public job board.
* Pay ranges appear only when the company publishes one on the posting.
* Jobs that a company has closed are no longer on its board, so each run returns the roles open right now.

## FAQ

### How much does it cost?

$0.75 per 1,000 jobs plus $0.00005 per run, billed by Apify. 10,000 jobs cost \$7.50. There is no subscription, and you can cap any run with **Maximum cost per run**.

Your Apify plan sets your discount tier (Platinum and Diamond are enterprise tiers):

| Tier | Per 1,000 jobs |
| - | - |
| Free | \$0.75 |
| Bronze | \$0.75 |
| Silver | \$0.60 |
| Gold | \$0.49 |
| Platinum | \$0.49 |
| Diamond | \$0.49 |

### How do I call it from the API?

One request starts a run and returns its results, using your [Apify API token](https://console.apify.com/settings/integrations):

```bash theme={null}
curl -X POST "https://api.apify.com/v2/acts/rocketyard~ashby-jobs-scraper/run-sync-get-dataset-items" -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" -d '{"startUrls":[{"url":"https://jobs.ashbyhq.com/ramp"}],"maxItems":1000}'
```

### What happens when a URL fails?

The dataset gets one free error item for it, with a code and the reason, and the other inputs in the run carry on. [Error codes](https://rocketyard.dev/errors.md) explains each code, whether a retry helps and what to do.

### Which companies does it work on?

Any company whose careers page is hosted on Ashby, with URLs like `https://jobs.ashbyhq.com/ramp`. The board name is the part after the domain (`ramp`).

### What happens when a field is missing?

The field comes back as `null`. The Actor reports what the source publishes and never fills in guesses.

### Is it allowed to scrape this data?

The Actor reads only job postings that companies publish for anyone to see, through Ashby's public API, honours robots.txt, and returns no data about applicants or recruiters. You are responsible for how you use the data under the applicable terms and the law (for example GDPR).

### Can I use it from an AI agent?

Yes. Connect Apify's MCP server as shown in [MCP](#mcp), and the agent can call the Actor as a tool.

## Alternatives

See [how it compares with other ashby job scrapers](https://rocketyard.dev/ashby-jobs-scraper-alternatives.md) on price, users and run success, from Apify Store data. Need a field or site behaviour that isn't covered? Open an issue on the [Actor page](https://apify.com/rocketyard/ashby-jobs-scraper).

## Guides

* [Greenhouse vs Lever vs Ashby job board APIs: which fields each returns](https://rocketyard.dev/greenhouse-vs-lever-vs-ashby-job-board-api.md)
* [Find companies by what their job descriptions say, without code](https://rocketyard.dev/hiring-signals-from-job-descriptions.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.