Ashby Jobs Scraper API — Salary Ranges Included

Unofficial — not affiliated with or endorsed by Ashby.

Data note: job descriptions are employer-published public data and may contain recruiter contact info; don't use it for spam.

Version 0.2.6 · live since 2026-07-15 · 373 Ashby boards verified 2026-07-15 · salary included when the company publishes it · $1 per 1,000 jobs, $0 to start.

Live status: https://api.apify.com/v2/key-value-stores/WickFeed~wickfeed-public-status/records/status.json — real self-test results for every wickfeed scraper (pass/fail plus 30-day success rate), updated hourly, no login needed. Opens as raw data (JSON).

Pick the right WickFeed tool for the job:

• Mixed systems, or unsure which a company uses → ATS Job Aggregator
• Greenhouse only → Greenhouse Jobs Scraper
• Ashby only, with published salary ranges → Ashby Jobs Scraper (this page)
• Workable only → Workable Jobs Scraper
• Companies plus their live open-job counts, not job rows → ATS Company Discovery

Download every open job at the Ashby companies you choose — with the published pay range right in the row whenever the company posts one — as a fresh snapshot each run, in a table you can export to CSV, Excel, or JSON. Pick the bundled list or paste a careers URL, then press Start. No token hunting, no HTML scraping, and no Ashby login or API key is needed; you only need an Apify account to run it.

Four steps from first click to exported file:

1. Click Try for free and sign in with your Apify account.
2. Leave the three demo boards unchanged and click Start.
3. When the run finishes, open Dataset to read the rows.
4. Click Export for CSV, Excel, or JSON.

The salary is the point. Most public job feeds don't carry pay at all — our own Greenhouse and Workable readers return an empty salaryRaw because those APIs simply don't expose it. Ashby is the exception: its public posting API can return the compensation range a company chose to publish, and this actor turns that on and passes it straight through as salaryRaw, unchanged — $151K - $231K, €76K - €185K, CA$400K - CA$500K, $40 per hour. Raw text, exactly as written, so currency and cadence survive. When a posting has no pay, the field is an honest null — never a guess.

And it's an API reader, not an HTML scraper — it reads the same JSON the careers page loads — so a page restyle won't quietly break your daily pull.

Demo cost: 3 boards × 50 jobs × $0.001 = $0.15 at most. The form is prefilled with 3 demo boards (ramp, applied, linear). Press Start: that first run is capped near $0.15, and Apify's $5 monthly free credit more than covers it — a first run nets out at $0. Billing counts delivered jobs only; empty, dead, or misspelled boards contribute $0.

Each run re-fetches a fresh, full snapshot of every open role — it isn't a day-over-day diff. For only the new and changed jobs (alerts that charge only for what changed), the ATS Job Aggregator is the diff monitor built for it.

What you get

A few boards produce rows like these (real postings, fetched 2026-07-15):

Company	Title	Location	Remote	Salary	Posted
Ramp	Technical Consultant, Mid-Market	Remote (US)	yes	$151K - $231K	2026-07-07
Applied	Hardware Test Engineer	Sunnyvale	no	$110K - $190K	2026-06-15
Airwallex	Head of Commercial Growth, Canada	CA - Toronto	yes	CA$400K - CA$500K	2026-01-06
Ashby	Engineering Manager - EU	Remote - European Union	yes	€76K - €185K	2024-03-04
Anyone AI	Mathematics Expert (LATAM & Europe)	Argentina - Fully Remote	yes	$40 per hour	2026-06-19

Each row also carries a stable id, department, the public application url, the plain-text description, and a fetch timestamp.

Paste a link, type a name — no token hunting

You don't need to know a company's Ashby "board token." In the Companies box, put whatever you already have — one company per line:

• A careers page address. Copy it straight from the browser: https://jobs.ashbyhq.com/ramp. This is the reliable path here — the board id is right there in the address, so it always works.
• A company name. Type Airwallex. Because Ashby's public data exposes no company display name, typed names are matched against the 373 bundled verified board names (a starter directory, not every Ashby company) — a name in that list resolves, but many well-known names aren't in it, so when in doubt paste the careers page address.
• A bare board token. ramp, exactly as before. Existing setups and saved runs keep working unchanged.

{ "sources": ["Airwallex", "https://jobs.ashbyhq.com/applied", "linear"] }

If an entry can't be read — a blank line, an address for a different hiring system (a Greenhouse or Workable link pasted here is caught and named), or a name that isn't in the bundled list — that one line is skipped with a plain-English note telling you exactly what to paste instead. It never silently runs empty, and the rest of your list still runs.

Quick start

1. Add companies. Just press Start to use the three demo boards already filled in (ramp, applied, linear). Or paste careers-page addresses, type company names, or switch Company list to "All verified" to pull all 373 Ashby boards.
2. (Optional) Narrow it. Add keywords (e.g. engineer, product) or locations (e.g. new york, remote) to keep only matching jobs.
3. Press Start. By default each board delivers up to 50 jobs — the first 50 that match your filters (or just the first 50 it finds, if you set none) — which keeps that first run small and fast (50 × $0.001 = $0.05 per board). Raise Max results per board once the numbers look right.

Calling the API? An empty input {} maps to the three demo boards the form prefills, each capped at 50 jobs — a ceiling of about $0.15 on that first call. It behaves identically to pressing Start, so there's no empty run and no unpriced surprise.

Bundled company list

Choose "All verified" and press Start — no token hunting. The list holds 373 Ashby boards, every one confirmed live against Ashby's own API on 2026-07-15. You can also add your own companies by hand in Companies (paste a jobs.ashbyhq.com/... address, type a name, or enter a bare org slug); the two lists merge and duplicates are removed.

Output schema — including salary

One row per job, the same fields every time:

Field	Meaning
id	Stable id ashby:<token>:<jobId> — deduplicate on this.
ats	Always ashby — the hiring system this row came from (kept so the schema matches the multi-ATS aggregator).
companyToken	The Ashby org slug this row came from (e.g. ramp).
company	Company / board name (best effort) — title-cased from the Ashby org slug, since the posting API carries no verified display name.
title	Job title.
department	Department or team when provided, else null.
location	Location string as Ashby provides it.
remote	true/false from Ashby's explicit isRemote flag; null when unknown.
url	Public application URL.
postedAt	Publish time (ISO-8601), or null.
updatedAt	Last update time (ISO-8601), or null.
salaryRaw	Published pay range as raw text — see below.
descriptionText	Plain text, capped at ~20,000 chars.
fetchedAt	When this run fetched the row.
schemaVersion	The output-record schema version (a number, currently 1). See Output contract below.

Turn on Include raw HTML description to also get descriptionHtml.

Two real records from a run over the ashby board (fetched 2026-07-15) — note salaryRaw carries the published pay range straight through:

[
  {
    "id": "ashby:ashby:7458d4e9-da2e-47bd-98cb-adfda43d42b2",
    "ats": "ashby",
    "companyToken": "ashby",
    "company": "Ashby",
    "title": "Engineering Manager - EU",
    "department": "Engineering",
    "location": "Remote - European Union",
    "remote": true,
    "url": "https://jobs.ashbyhq.com/ashby/7458d4e9-da2e-47bd-98cb-adfda43d42b2",
    "postedAt": "2024-03-04T14:29:08.532Z",
    "updatedAt": null,
    "salaryRaw": "€76K - €185K",
    "descriptionText": "Ashby is building the next generation of recruiting software. As Engineering Manager for our EU team, you'll lead a group of engineers building product that recruiters love …",
    "fetchedAt": "2026-07-15T18:00:00.000Z",
    "schemaVersion": 1
  },
  {
    "id": "ashby:ashby:86a60834-ba64-484d-9658-afa1bc97a957",
    "ats": "ashby",
    "companyToken": "ashby",
    "company": "Ashby",
    "title": "Mid Market Account Executive - EMEA (French Speaking)",
    "department": "Sales",
    "location": "France",
    "remote": true,
    "url": "https://jobs.ashbyhq.com/ashby/86a60834-ba64-484d-9658-afa1bc97a957",
    "postedAt": "2026-05-21T01:03:51.345Z",
    "updatedAt": null,
    "salaryRaw": "€110.5K - €195.5K",
    "descriptionText": "As a Mid Market Account Executive covering EMEA, you'll own the full sales cycle for French-speaking prospects, from first conversation to close …",
    "fetchedAt": "2026-07-15T18:00:00.000Z",
    "schemaVersion": 1
  }
]

salaryRaw is passed through exactly as Ashby published it (raw text, not parsed into numbers); it is null when a posting has no pay. descriptionHtml is added only when Include raw HTML description is on.

Output contract (schema stability)

An update on our side shouldn't break a column your spreadsheet or pipeline reads. Here's the promise, in writing:

• No existing field is renamed or removed within a major version. The columns above — id, title, url, salaryRaw, and the rest — hold their names and their meaning, so you can build on them safely.
• A null is a real value, not a gap. Where a posting carries no pay, or Ashby exposes nothing for a field, that field is still present and set to null — never dropped, so any column you read is always there. (salaryRaw is null precisely when the company published no range.)
• Fields are only ever added, never imposed. We may add a field later; adding one leaves every field you already read untouched, so existing code keeps working.
• Any breaking change ships announced, not silent. Renaming or removing a field would be a major version bump — flagged in the Changelog (and the Issues tab) before it ships, so it never lands unannounced on a scheduled run.
• schemaVersion is a breaking-contract version. Every row carries it (it's in RUN_SUMMARY too). It's not the release number and not an exact-shape fingerprint: adding a new field doesn't bump it — it changes only when an existing field is renamed, removed, or retyped (a breaking change, which also bumps the major version). So while it reads the same, every field you already read keeps its name, type, and meaning; new fields may have been added alongside. It reads 1 today.
• The field list is published for machines too. The actor ships a machine-readable output schema (a JSON Schema of every field above, salary included), so a pipeline or AI agent can discover the exact row shape without parsing this table.

Pricing

Billing is per delivered job and nothing else: $1.00 per 1,000 jobs — $0 to start a run (the job-fetched event fires only on a delivered row). Empty runs, dead boards, and misspelled tokens all bill $0.

In plain numbers: $1 per 1,000 jobs is $0.001 per row — so 500 jobs works out to about $0.50 and 2,000 jobs to about $2.00. Anything that returns nothing — a dead board, a typo'd token, a board with no open roles — is never charged, so the bill only ever reflects jobs actually delivered.

Free to try. That ~$0.15 demo comes out of the monthly usage credit on Apify's free plan, so a first run costs you $0 and still returns the real output.

Where this sits on price. Single-system job actors on the store list roughly $1.15–$4 per 1,000 — multi-system feeds run higher — and most add a start fee to every run. This actor is a flat $1 per 1,000 with no start fee. One Ashby actor we found runs a touch lower per job: jobo.world/ashby-jobs-scraper-api, at $0.00099 per job with no start fee (checked 2026-07-16) — so compare on the current listings, since store prices move. Store prices as listed 2026-07-15; the competitor price was checked 2026-07-16.

If a charge ever looks off, open an issue on the Issues tab with your run ID. We investigate the same day; if the number was too high on our end, we file a credit request with Apify to put that amount back on your account. (Apify settles seller compensation as account credit rather than cash, so that credit is what we can promise and will pursue — not a guarantee of how Apify itself handles it.)

Limitations (read this)

• Public boards only. It reads what a company publishes on its Ashby board — not private ATS data, internal reqs, or candidate information.
• Salary is present only when the company publishes it. Many boards do; some don't. When a posting has no pay data, salaryRaw is null (see FAQ).
• You supply the companies. No API lists every Ashby company, and this actor doesn't crawl. Use the bundled 373-board list, or read a token off a careers URL.
• No server-side search. Each board returns its whole job list; the keyword, location, remote and date filters run over the whole board after fetching, and Max results per board then caps the matching jobs delivered (so a match is never hidden past the cap).
• Politeness. Requests are capped at ~2/second with retries and backoff, so very large runs take proportionally longer.
• Endpoint drift. If Ashby changes its response shape, the reader may need an update; a bad board is isolated and reported, never fatal.

FAQ

I got few or zero jobs back — is it broken?

Almost always a filter or a cap, not a fault. Work through it in order: clear Keywords and Locations, switch off Remote only, and raise Max results per board (the default stops at 50 per board). Then read the run's Status and Logs for a mistyped board or one that returned zero. A null salaryRaw isn't a fault either — it just means that posting published no pay. Still off? Open the Issues tab with your run link and we'll look.

Advanced diagnostics: a per-board tally — fetched, matched, delivered, filtered, and any board errors — is written to the run's key-value store as RUN_SUMMARY; rows that fail validation go to REJECTS. Check RUN_SUMMARY for a typo'd token. When a board has more matching jobs than the cap, its row shows how many matched, so you can raise Max results per board to get the rest.

Does it scrape HTML?

No. It calls Ashby's official public posting API and reads JSON — identical to the request a browser issues on the careers page. No proxy pool, no headless browser.

How does the salary field work?

The actor requests the posting API with includeCompensation=true and passes Ashby's own compensation summary straight through as salaryRaw, unchanged. That's the scrapeableCompensationSalarySummary value — for example $151K - $231K, €76K - €185K, CA$400K - CA$500K, or $40 per hour. It is raw text, not parsed into numbers, so currency and cadence are preserved exactly as the company wrote them. When a posting has no compensation summary, the actor falls back to Ashby's tier summary if present, otherwise salaryRaw is null. Salary appears only because the company chose to publish it on the posting.

Is this allowed?

It reads exactly the public JSON feed your browser loads when it opens an Ashby careers page — no login, no password, no API key, and no HTML scraping. It touches only data a company chose to publish publicly. How you use the results is your call, and your responsibility — for example, don't use it for spam or unsolicited outreach. This is a description of how the tool works, not legal advice.

Can I schedule daily runs?

Yes, through Apify's scheduler. Each run re-fetches from scratch and hands back a fresh full snapshot of every open role — a daily schedule gives you a complete same-day pull, not a day-over-day diff. Picking out only the new and changed jobs (alerts that charge only for what changed) is a different job: the Jobs Scraper API is the diff monitor built for it.

What happens to a dead or misspelled board?

That single board is skipped and flagged; every other board still runs to completion, and a board that returns nothing is never billed.

Use with AI agents (MCP)

This actor is callable as a tool by AI agents — Claude Desktop, Cursor, n8n, LangGraph, CrewAI, or any MCP-compatible client — via Apify's hosted MCP server at mcp.apify.com. Agents discover it with search-actors, read its input schema with fetch-actor-details, and execute it with call-actor. Point your MCP client at Apify's server:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}

That form authenticates with OAuth; to pass a token instead, add "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }. The output is flat, stable JSON built for machine consumption, and agentic pay-per-event billing is on.

Integrations

Export the results as CSV, Excel, or Google Sheets — no code required. Or connect it: through Apify's native integrations it works with n8n, Make, and Zapier, routing the dataset into Slack, a webhook, a Google Sheet, or your own pipeline.

Changelog

• 0.2.6 — 2026-07-16 — Added a public live-status link (real self-test results, no login).
• 0.2.5 — 2026-07-16 — Filters now run over the whole board before the cap, plus honesty fixes. Max results per board used to cap the raw job list before your keyword, location, remote, and date filters ran, so a matching job past the cap could be missed. Now the filters run over the whole board first and the cap limits the matching jobs delivered — a match is never hidden past the cap. No-filter runs are unchanged (still the first N jobs), and every per-board ceiling holds (at most the cap × $0.001 per board; the 3-board demo still tops out around $0.15). An unreadable Posted after date is now rejected with a plain-English message instead of silently switching the date filter off. Added a machine-readable output schema (JSON Schema) for pipelines and agents, replaced the price comparison with a dated, named check of the one lower-priced Ashby actor we found, and corrected the schemaVersion wording to a breaking-contract version (adding a field doesn't bump it). No number or price changed.
• 0.2.4 — 2026-07-16 — Lowercase names resolve correctly, snapshot wording made honest, and the first run is clearer. A company name typed in lowercase now resolves to the same board as its normal-case spelling — previously a lowercase one-word name could be read as a raw board token and miss the bundled listing. The page now states plainly that each run returns a fresh full snapshot (not day-to-day tracking) and points to the ATS Job Aggregator for real new-and-changed alerts; the company field is labelled honestly as a best-effort board name (Ashby's API carries no verified display name); added a four-step click-to-file walkthrough, a WickFeed tool chooser, and a plain "no login/API key needed, but an Apify account is" line. Troubleshooting now leads with the simple checks (filters, Max results, the run's Status and Logs) before the RUN_SUMMARY details. No number, price, or run behavior changed.
• 0.2.3 — 2026-07-16 — Each page now speaks in its own voice. Rewrote the previously shared, templated sections of this README — pricing, the output contract, the FAQ, the AI-agents (MCP) and integrations sections, and the footer — in this scraper's own numbers-forward voice, so it no longer reads identically to the Greenhouse and Workable pages. Every number, price, and promise is identical, and run behavior is unchanged.
• 0.2.2 — 2026-07-16 — Error messages now point you to the right scraper. Paste a careers link for a different hiring system and the message now names the product that reads it — our Greenhouse or Workable Jobs Scraper for those, or our all-in-one Jobs Scraper + Job Monitor that covers all five systems (Greenhouse, Lever, Ashby, Workable, Recruitee) in one run; paste your company's own website and it points you to that aggregator, which can take the company name and look for the board. The typing hint now points to the careers-page address rather than plain name-typing, since Ashby publishes no company names. The Companies box now also states the first-run cost ceiling (about $0.15 for the prefilled 3-board demo). No change to how a valid run behaves.
• 0.2.1 — 2026-07-16 — Paste a link or type a name — no token hunting. The Companies box now accepts a pasted careers-page address (https://jobs.ashbyhq.com/ramp) or a plain company name, alongside the bare org slugs it always took — existing setups and saved runs are unchanged. Because Ashby's public data has no company display names, typed names are matched against the 373 bundled verified board names, so the careers-page address is the most reliable path here. A link for a different hiring system (Greenhouse, Workable, Lever, …), a company homepage, junk, or a name that isn't bundled is caught and reported in plain English with the exact thing to paste instead, never a silent empty run. Also: every output row now carries a schemaVersion field (currently 1) and this README documents the output contract (existing fields are never renamed or removed within a major version; null means honestly-absent, including salaryRaw when no pay is published) — additive, so existing pipelines are unaffected. And a bare {} API call now runs the same three demo boards the form prefills (≈ $0.15) instead of failing, so a first call can't surprise-bill.
• 0.1.0 — Initial release. Reads Ashby's public posting API with includeCompensation=true and passes published salary ranges straight through as salaryRaw; one normalized row per job, 373 verified-live boards bundled, keyword / location / remote / date filters applied after fetch, per-board failure isolation with retries and backoff, schema-validated output, and pay-per-event billing at $1 per 1,000 jobs ($0 to start a run).

Related actors

• Need 5 hiring systems in one feed? The Jobs Scraper API covers Greenhouse, Lever, Ashby, Workable and Recruitee in this same schema (salary included wherever the source exposes it). Start with its starter-500 preset — 500 verified-live boards in one click — and turn on diff mode to track only new and changed jobs on a daily schedule (and pay $0 on a quiet day).
• Just want Workable boards? The Workable Jobs Scraper uses this same clean schema for Workable companies.
• Not sure which companies use Ashby? ATS Company Discovery finds live boards and their current open-job counts across five systems.

Need help? Open an Issue with your run link. If a run misbehaves or a charge looks off, the Issues tab — with your run link attached — is the quickest way to reach us; we fix buyer-facing breakages the same day.