# Ashby Jobs Scraper \[Only $0.8/1K💰] | Startup Jobs | Remote (`ahmed_jasarevic/jobs-ashbyhq-scraper`) Actor

Scrape job postings from any Ashby-hosted startup board — Ramp, Notion, Linear, Perplexity, RunPod and thousands more — via Ashby's public posting API: title, company, location and remote flag, department/team, employment type, salary/equity tiers, job and apply URLs. No browser. $0.0008 per job.

- **URL**: https://apify.com/ahmed_jasarevic/jobs-ashbyhq-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

**Scrape job postings from any Ashby-hosted startup job board — Ramp, Notion, Linear, Perplexity, RunPod, OpenAI and thousands more — through Ashby's own public posting API, with salary and equity tiers, remote flags, full descriptions and company metadata, at $0.0008 per job.** One request returns an entire board, so a handful of slugs already yields thousands of jobs, with no browser and no anti-bot costs.

Built for recruiting agencies, talent researchers, job-board aggregators, VC analysts and hiring-trend researchers.

### Main Use Cases

- **Startup job boards dataset** — build a clean, deduplicated database of every open role across hundreds of Ashby-hosted boards in a single run
- **Startup salary and equity data** — `includeCompensation` pulls the exact compensation tiers (currency, min/max, interval) companies actually list, not scraped estimates
- **Remote startup jobs** — filter or flag by `isRemote` / `workplaceType` (Remote, Hybrid, OnSite) and match `location` on "Remote", "Berlin", "NYC", etc.
- **Hiring analytics** — track open roles, departments and teams over time: which companies are hiring, for what, where
- **Recruiting agency lead generation** — identify scaling startups (Notion, Linear, RunPod…) and the exact roles they are trying to fill
- **Talent market research** — job title distribution, employment types (Full-time/Internship/Contract) and compensation ranges by company or sector

### How It Works — The Posting API, No Browser

Every Ashby customer board at `jobs.ashbyhq.com/{slug}` publishes its full job list as JSON at:

```
https://api.ashbyhq.com/posting-api/job-board/{slug}?includeCompensation=true
```

The actor calls that endpoint once per board (Ramp = 158 jobs, Notion = 128, OpenAI ≈ 1,000 in a single response), then optionally fetches the board's HTML once more to read the embedded `window.__appData` blob — that adds `companyName`, `organizationId`, `companyWebsite` and the team hierarchy. There is nothing to render: Ashby serves the whole board server-side to a plain HTTP client with no login, no CAPTCHA and no rate limiting worth worrying about at normal volumes.

### Build a Startup Jobs Database Without a Browser

Ashby is one of the few ATS vendors whose public job boards are **entirely API-accessible**: the posting API is the same JSON the `jobs.ashbyhq.com` page renders, so a browser actor adds 100x the compute for zero extra fields. Browser-based competitors on the Store charge $0.001485–$0.002 per job; this actor reads the API at **$0.0008 per job** — the cheapest per job of the Ashby-focused options — and is the only one that combines compensation tiers, descriptions, board metadata and filters (`search`, `department`, `team`, `location`) in one actor. Cheap enough to run daily: tracking 10 boards (≈ 1,500 open roles) costs under **$1.30 a run** plus compute.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `boardSlugs` | array | Yes\* | `["ashby","notion","linear","perplexity","runpod"]` | Board slug = path segment of the public job page (`/ramp` → `ramp`); full board URLs accepted too. \*Omitted only if `startUrls` is used |
| `startUrls` | array | No | `[]` | Extra board URLs or slugs scraped in addition to `boardSlugs` |
| `includeCompensation` | boolean | No | `true` | Adds each job's salary/equity/bonus tiers (currency, min/max, interval); `false` makes responses ~40% smaller |
| `includeDescriptions` | boolean | No | `true` | Emits `descriptionHtml` + `descriptionPlain`; disable to shrink the dataset |
| `includeUnlisted` | boolean | No | `false` | Also output jobs unlisted from the public board (`isListed=false`) |
| `fetchBoardMetadata` | boolean | No | `true` | One extra request per board for `companyName`, `organizationId`, `companyWebsite`, team hierarchy; `false` halves the request count |
| `search` | string | No | `""` | Case-insensitive filter on title/department/team/location, e.g. `engineer`, `remote` |
| `department` | string | No | `""` | Exact case-insensitive department, e.g. `Engineering` |
| `team` | string | No | `""` | Exact case-insensitive team, e.g. `Platform` |
| `location` | string | No | `""` | Case-insensitive substring on primary location + workplace type + secondary locations |
| `maxBoards` | integer | No | `20` | Max boards taken from the slug list |
| `maxJobsPerBoard` | integer | No | `500` | Max jobs pushed per board |
| `maxItems` | integer | No | `5000` | Max jobs pushed across all boards |
| `proxy` | object | No | `useApifyProxy: false` | Not needed to get unblocked; for IP rotation/geo only |

### Output — Startup Job Records for Talent Research

**`default` dataset** (one row per job; the `overview` view is preconfigured and expands `compensation`):

| Field | Description |
|---|---|
| `title`, `jobUrl`, `applyUrl` | Job title, canonical posting URL, direct apply link |
| `companyName`, `boardSlug`, `organizationId`, `companyWebsite` | Company identity (metadata requires `fetchBoardMetadata: true`) |
| `location`, `isRemote`, `workplaceType` | Primary location, remote flag, Remote/Hybrid/OnSite |
| `department`, `team`, `employmentType` | Org structure + Full-time/Internship/Contract/Part-time |
| `compensationTierSummary` | Human-readable compensation line (e.g. `$150k – $200k`, `0.10% – 0.15% equity`) |
| `compensation` | Expanded tier objects: currency, interval, minValue/maxValue per component (salary, equity, bonus) |
| `descriptionHtml`, `descriptionPlain` | Full posting text (when `includeDescriptions: true`) |
| `publishedAt` | When the role went live |

Additional raw fields on each item: `secondaryLocation`, `address`, `salaryRange`, `employmentType`, `seniority`, `isListed`, `externalUrl`, `rawTitle`.

### Example Input

```json
{
  "boardSlugs": ["ramp", "notion", "linear", "perplexity", "runpod"],
  "includeCompensation": true,
  "location": "Remote",
  "search": "engineer",
  "maxItems": 1000
}
```

Board URLs work too: `"boardSlugs": ["https://jobs.ashbyhq.com/openai"]`.

### Example Output — Job Record (trimmed)

```json
{
  "title": "Senior Product Engineer",
  "companyName": "Linear",
  "boardSlug": "linear",
  "location": "Remote (Canada, US)",
  "isRemote": true,
  "workplaceType": "Remote",
  "department": "Engineering",
  "team": "Product",
  "employmentType": "Full-time",
  "compensationTierSummary": "$180,000 - $210,000 · 0.05% - 0.10% equity · CAD or USD",
  "compensation": [
    { "tier": "salary", "currency": "USD", "interval": "yearly", "minValue": 180000, "maxValue": 210000 },
    { "tier": "equity", "currency": "USD", "interval": "yearly", "minValue": 0.05, "maxValue": 0.1 }
  ],
  "publishedAt": "2026-09-20T16:33:00.000Z",
  "jobUrl": "https://jobs.ashbyhq.com/linear/senior-product-engineer",
  "applyUrl": "https://jobs.ashbyhq.com/linear/senior-product-engineer/apply"
}
```

### Startup Jobs Data at $0.0008 Per Job

**$0.0008 per job** (`apify-default-dataset-item`) plus the standard **$0.00005 actor start** — no browser minutes, no per-page fees, no anti-bot surcharges. Billing is strictly per emitted job row; boards that return nothing cost nothing but the start event. The default 1,024 MB container and 5,000-job cap keep large board sweeps to a couple of compute units. Free accounts get a preview run; paid plans run to your caps.

### Integrations & Automation

- **API** — run and fetch via the Apify REST API, or call it from AI agents through the Apify MCP server
- **Scheduling** — daily/weekly runs to track new roles, closed roles and compensation changes per company
- **Webhooks** — push new matching jobs (by location, department or search word) to your app, Slack or Sheets
- **Export** — JSON, CSV, Excel, HTML

**Recommended schedule:** daily for new-role alerts and agency pipelines; weekly for hiring-trend and salary datasets.

### Related Actors

- [Greenhouse / Lever / Ashby Job Scraper](https://apify.com/bovi/greenhouse-lever-ashby-job-scraper) — `bovi/greenhouse-lever-ashby-job-scraper` — the most-used multi-ATS job scraper (447 users, 4.9★), $0.001485/job
- [Ashby Jobs API](https://apify.com/fantastic-jobs/ashby-jobs-api) — `fantastic-jobs/ashby-jobs-api` — Ashby posting-API wrapper (449 users, 5.0★)
- [Ashby Jobs Scraper API](https://apify.com/jobo.world/ashby-jobs-scraper-api) — `jobo.world/ashby-jobs-scraper-api` — per-job billing, $0.00099/job
- [Ashby Job Scraper](https://apify.com/dalleyne/ashby-job-scraper) — `dalleyne/ashby-job-scraper` — $0.002/result
- [Ashby Jobs Scraper](https://apify.com/memo23/ashby-jobs-scraper) — `memo23/ashby-jobs-scraper` — $0.04 start + $0.0009/result

This actor is the **cheapest per job** ($0.0008, no start premium) and the only Ashby-focused option combining compensation tiers, full descriptions, board metadata and server-side filters in one actor.

### FAQ

#### Why use this actor instead of the official Ashby API?

There is no auth-gated partner API for job boards — **the posting API is the official public surface**: `https://api.ashbyhq.com/posting-api/job-board/{slug}?includeCompensation=true` returns the whole board as JSON to anyone. This actor wraps it, adds compensation expansion, company metadata from `window.__appData`, filters and per-job billing, and keeps the data in a queryable Apify dataset.

#### What are alternatives to this actor for startup jobs data?

On the Store: [bovi/greenhouse-lever-ashby-job-scraper](https://apify.com/bovi/greenhouse-lever-ashby-job-scraper) (multi-ATS, $0.001485/job), [fantastic-jobs/ashby-jobs-api](https://apify.com/fantastic-jobs/ashby-jobs-api) (449 users, 5.0★), [jobo.world/ashby-jobs-scraper-api](https://apify.com/jobo.world/ashby-jobs-scraper-api) ($0.00099/job), [dalleyne/ashby-job-scraper](https://apify.com/dalleyne/ashby-job-scraper) ($0.002/result), [memo23/ashby-jobs-scraper](https://apify.com/memo23/ashby-jobs-scraper). Ours is the cheapest per job and the only one with compensation tiers + descriptions + filters combined.

#### How do I find a company's board slug?

It's the path segment of its public job page: `jobs.ashbyhq.com/ramp` → `ramp`. Most companies link it as "Careers" on their site. Full URLs like `https://jobs.ashbyhq.com/openai` are accepted as well.

#### Why are some jobs missing compensation?

Compensation is only present when the company publishes it (Ashby returns it under `includeCompensation`); roles without published tiers simply have `null` in `compensationTierSummary` and an empty `compensation` array. This is a data-availability fact, not a scraping limitation.

#### Can I get unlisted jobs?

Yes — set `includeUnlisted: true` to also emit postings the company has unlisted from its public board (`isListed=false`). These still appear on the posting API. Use this flag with care: it reflects roles the company chose to hide publicly.

#### Is a browser or proxy needed?

No. The posting API serves JSON to a plain HTTP client; boards are fetched without JavaScript. The proxy input exists for IP rotation/geo-targeting only and is off by default. No anti-bot costs exist, which is why per-job pricing stays at $0.0008.

### For AI Agents & LLM Apps

- **Purpose**: given Ashby board slugs/URLs, returns one row per open job — title, company, location, remote flag, workplace type, department, team, employment type, compensation tiers (salary/equity/bonus with currency, min/max, interval), full description, job and apply URLs — via Ashby's official posting API.
- **Minimal working input**:

```json
{ "boardSlugs": ["notion", "linear"], "maxItems": 500 }
```

- **Variant inputs** — with pay data + remote filter: `{ "boardSlugs": ["ramp"], "includeCompensation": true, "location": "Remote" }`; keyword-filtered sweep: `{ "boardSlugs": ["ashby", "notion", "linear", "perplexity", "runpod"], "search": "engineer", "maxItems": 1000 }`; descriptions off to slim the dataset: `"includeDescriptions": false`; unlisted roles: `"includeUnlisted": true`.
- **Output fields**: `title, companyName, boardSlug, organizationId, companyWebsite, location, secondaryLocation, address, isRemote, workplaceType, department, team, employmentType, seniority, compensation, compensationTierSummary, salaryRange, descriptionHtml, descriptionPlain, publishedAt, isListed, jobUrl, applyUrl, externalUrl, rawTitle`.
- **Behaviors an agent should know**: one request returns an entire board — there is no pagination to walk. `companyName` etc. come from `fetchBoardMetadata` (default on; one extra HTML request per board — disable to halve requests, at the cost of empty company fields). `includeCompensation` (default on) costs nothing but a larger payload; mistaken heavy runs are bounded by `maxItems` (default 5,000) and `maxJobsPerBoard`/`maxBoards`. Filters (`search`, `department`, `team`, `location`) are applied server-side in the actor — use them instead of post-filtering to keep the dataset small. `compensation` is an array of tier objects (per component); a job with no published pay has `compensationTierSummary: null`. Do not treat `isRemote=false` as "onsite" — check `workplaceType` (Remote/Hybrid/OnSite). Failed boards produce no rows and are not billed per job.
- **Billing**: pay-per-result — $0.0008 per job + standard $0.00005 actor start; no proxy charges unless you enable proxy yourself.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Ashby, Inc. or any company whose job board it reads**. It consumes only the public posting API and publicly visible board pages that Ashby serves to anonymous visitors — no login, no bypass of access controls, no personal data beyond what companies publish on their own job pages (and none of it is used for unsolicited outreach). Users are responsible for their own compliance with [Ashby's Terms of Service](https://www.ashbyhq.com/legal) and each board's terms; the data is intended for legitimate purposes such as talent research, hiring analytics and job aggregation. Respect each company's preferences: unlisted jobs (`isListed=false`) are surfaced only when explicitly requested.

### SEO Keywords

ashby jobs scraper, ashbyhq jobs api, jobs.ashbyhq.com data, startup job boards, scrape startup jobs, startup salary data, equity compensation data, remote startup jobs, hiring analytics, job posting database, ashby api alternative, tech company jobs api, ai startup careers, notion jobs data, linear jobs data, ramp jobs data, perplexity jobs data, runpod jobs data, recruiting agency lead generation, talent market research

# Actor input Schema

## `boardSlugs` (type: `array`):

Board slugs of Ashby-hosted job boards. A board slug is the path segment of its public job page, e.g. https://jobs.ashbyhq.com/ramp -> `ramp`. Full board URLs are accepted too. One API request returns the whole board, so a handful of slugs already yields thousands of jobs.

## `startUrls` (type: `array`):

Optional list of jobs.ashbyhq.com board URLs (or bare slugs) to scrape in addition to `boardSlugs`.

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

Fetch the posting API with includeCompensation=true so every job carries its salary/equity/bonus tiers (currency, min/max values, interval). Disabling it makes responses ~40% smaller and faster when you do not need pay data.

## `includeDescriptions` (type: `boolean`):

Include the full job description as `descriptionHtml` and `descriptionPlain`. Disable to keep the dataset small.

## `includeUnlisted` (type: `boolean`):

Also output job postings that the company has unlisted from its public board (isListed=false).

## `fetchBoardMetadata` (type: `boolean`):

Fetch each board's HTML once to read the embedded `window.__appData` blob, which adds companyName, organizationId, companyWebsite and the team hierarchy. Disable to halve the number of requests.

## `search` (type: `string`):

Case-insensitive keyword filter. Keeps jobs whose title, department, team or location contains this text (e.g. "engineer", "remote").

## `department` (type: `string`):

Exact (case-insensitive) department match, e.g. "Engineering".

## `team` (type: `string`):

Exact (case-insensitive) team match, e.g. "Platform".

## `location` (type: `string`):

Case-insensitive substring match against the primary location, workplace type and secondary locations, e.g. "Remote" or "Berlin".

## `maxBoards` (type: `integer`):

Maximum number of boards to scrape from the slug list.

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

Maximum number of jobs pushed per board.

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

Maximum number of jobs pushed in total across all boards.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "boardSlugs": [
    "ashby",
    "notion",
    "linear",
    "perplexity",
    "runpod"
  ],
  "includeCompensation": true,
  "includeDescriptions": true,
  "includeUnlisted": false,
  "fetchBoardMetadata": true,
  "search": "",
  "maxBoards": 20,
  "maxJobsPerBoard": 500,
  "maxItems": 5000,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "search": "",
    "maxBoards": 20,
    "maxJobsPerBoard": 500,
    "maxItems": 5000,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/jobs-ashbyhq-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 = {
    "search": "",
    "maxBoards": 20,
    "maxJobsPerBoard": 500,
    "maxItems": 5000,
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/jobs-ashbyhq-scraper").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 '{
  "search": "",
  "maxBoards": 20,
  "maxJobsPerBoard": 500,
  "maxItems": 5000,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/jobs-ashbyhq-scraper --silent --output-dataset

```

## MCP server setup

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

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/GueLyBJwaCaXCf1nV/builds/JqmE2Ik0Q20sGH7iJ/openapi.json