# Ashby Jobs Scraper — Jobs, Salaries & Descriptions (ATS) (`haketa/ashby-jobs-scraper`) Actor

Scrape job postings from any Ashby (ashbyhq.com) career page — no API key. Export title, company, department, location, salary, equity, apply URL & full description to JSON/CSV/Excel. Search jobs by keyword across 50+ Ashby companies, or target your own. Great for ATS aggregation & recruiting.

- **URL**: https://apify.com/haketa/ashby-jobs-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 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 💼 — Jobs, Salaries & Full Descriptions

> The fast, no-login **Ashby scraper** that turns any **Ashby** (`jobs.ashbyhq.com`) careers page into clean, structured job data — with **salary**, **equity**, structured location and the **full job description**. **Scrape Ashby** by keyword across **50+ popular Ashby companies at once**, or target your own. **No API key. No login. No coding.**

Export every job to **JSON, CSV, Excel, or API**.

[![No API key](https://img.shields.io/badge/API%20key-not%20required-brightgreen)](#)
[![Salary data](https://img.shields.io/badge/salary%20%26%20equity-included-blueviolet)](#)
[![Multi-company](https://img.shields.io/badge/search-50%2B%20companies-orange)](#)
[![Output](https://img.shields.io/badge/export-JSON%20%7C%20CSV%20%7C%20Excel-blue)](#)
[![Speed](https://img.shields.io/badge/fast-pure%20HTTP-success)](#)

**Ashby** is the modern applicant-tracking system (ATS) behind the careers pages of many of the fastest-growing tech, AI and startup companies — OpenAI, Ramp, Notion, Perplexity, Cursor, Cohere, Snowflake, ElevenLabs and hundreds more. This **Ashby jobs scraper** reads the public **Ashby API** behind those pages and gives you tidy, flat records: title, company, department, team, location, **salary range**, equity flag, apply link and the complete description — ready for Excel, a database or an AI pipeline.

Type a keyword. Press **Start**. Get every matching job across dozens of companies — no slugs to hunt down.

> **Built for** job seekers and job-board operators, **recruiters and sourcers**, sales/GTM teams tracking hiring signals, compensation and talent-market analysts, and data/AI teams who need thousands of full job descriptions in bulk.

***

### 📑 Table of contents

- [Why scrape Ashby](#-why-scrape-ashby)
- [What this Ashby scraper does](#-what-this-ashby-scraper-does)
- [Use cases](#-use-cases)
- [Input](#-input)
- [Output](#-output)
- [Field reference & fill rates](#-field-reference--fill-rates)
- [Pagination & scale](#-pagination--scale)
- [How to use](#️-how-to-use)
- [Tips](#-tips)
- [FAQ](#-faq)
- [Legal & responsible use](#️-legal--responsible-use)
- [Related scrapers](#-related-scrapers)

***

### 🔎 Why scrape Ashby?

[Ashby](https://www.ashbyhq.com/) powers the careers pages of a who's-who of modern tech: AI labs, developer-tools companies, fintechs and high-growth SaaS. Every one of those boards exposes a clean public job feed, but there's no single place to search across them — and copying roles, salaries and descriptions by hand, company by company, is slow and error-prone.

This **Ashby scraper** solves that. It reads the same public **Ashby API** that `jobs.ashbyhq.com` uses, normalizes every posting into a flat record, and lets you search **across many companies at once** by keyword — or point it at exactly the boards you care about. You get structured salary numbers (where published), a remote flag, structured location parts and the full plain-text description, so the data lands analysis-ready.

Because it's **pure HTTP** (no browser), it's quick and cheap: a single keyword run returned **508 complete job records in about 26 seconds** in our latest verification, with **100% coverage on every core field** and **zero duplicates**.

**Common reasons people scrape Ashby:**

- Aggregate fresh **startup and AI jobs** into a niche job board or newsletter.
- Benchmark **compensation** using the structured salary ranges companies publish.
- Spot **hiring signals** — a spike in open roles is a buying/growth signal for sales teams.
- Monitor **competitor and target-company hiring** day over day.
- Build **talent-market dashboards** across departments, locations and remote trends.
- Export thousands of **full job descriptions** for search, matching or LLM/RAG datasets.
- Power **recruiting and sourcing** workflows with clean, deduplicated role data.

***

### ✨ What this Ashby scraper does

- ✅ **Scrape any Ashby board** — paste a slug (`ramp`, `openai`) or a full `https://jobs.ashbyhq.com/<company>` URL.
- ✅ **Search 50+ companies at once** — don't know the slugs? Leave *Companies* empty and it scans a **built-in list of 50+ popular Ashby companies** (OpenAI, Ramp, Notion, Perplexity, Cursor, Cohere, Snowflake, ElevenLabs, ClickHouse, Vanta, Plaid, and many more).
- ✅ **Salary & equity** — structured `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryInterval`, a human-readable `salarySummary`, and an `offersEquity` flag, pulled straight from the posting's compensation data.
- ✅ **Full job descriptions** — the complete plain-text description of every role by default, plus an optional raw **HTML** version.
- ✅ **Structured location** — `location` text, `isRemote` flag, `workplaceType` (Remote/Hybrid/Onsite), and parsed `locationCountry` / `locationRegion` / `locationCity`, plus `secondaryLocations`.
- ✅ **Powerful filters** — keyword, location contains, department, employment type, **remote-only**, **minimum salary**, and **posted-within-days**, all applied server-side-fast in one pass.
- ✅ **Automatic de-duplication** — company slugs and jobs are de-duplicated so you never pay for the same posting twice.
- ✅ **Fast & cheap** — lightweight pure-HTTP fetches run many company boards in parallel; dozens of boards in seconds.
- ✅ **Clean exports** — flat records ready for **JSON, CSV, Excel, HTML table, RSS**, or the **Apify API**.

> 💡 **The multi-company advantage.** Most Ashby scrapers make you paste one company slug at a time. This one ships with a curated list of **50+ popular Ashby companies**, so a single keyword search returns matching jobs across all of them. Add your own companies anytime.

***

### 🎯 Use cases

- 🧑‍💻 **Job seekers & job boards** — aggregate fresh, high-quality startup/tech/AI roles with keyword, salary and remote filters.
- 📈 **Recruiters & sourcers** — track who's hiring for what, where, and at what level across the ecosystem.
- 🏢 **Sales & GTM teams** — treat hiring as a buying signal; spot accounts that are scaling a team early.
- 📊 **Compensation & talent analysts** — benchmark published salary ranges by role, level and location.
- 🤖 **Data & AI teams** — export thousands of full job descriptions to build search, matching and LLM/RAG datasets.
- 🧭 **Founders & operators** — read competitor open roles to infer what rivals are building next.
- 🗞️ **Newsletters & communities** — curate a daily "new roles at top AI companies" digest on autopilot.

***

### 📥 Input

Everything is optional — press **Start** with no input and the actor searches the built-in list of popular Ashby companies so you instantly see the shape of the data. Mix any of the fields below.

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array | Keep only jobs whose **title, team, department or description** matches any keyword (e.g. `engineer`, `product manager`, `remote`). Empty = keep all. |
| `companies` | array | Ashby boards to scrape — full URLs (`https://jobs.ashbyhq.com/ramp`) or bare slugs (`ramp`, `openai`). Empty = scan the built-in list. |
| `scanDefaultCompanies` | boolean | When you list your own companies, also include the built-in popular list. Default `false`. |
| `remoteOnly` | boolean | Keep only jobs marked remote. Default `false`. |
| `location` | string | Keep only jobs whose location contains this text (e.g. `United States`, `London`, `Europe`). |
| `departments` | array | Keep only these departments (partial match, e.g. `Engineering`, `Sales`, `Design`). |
| `employmentTypes` | array | Keep only these types: `FullTime`, `PartTime`, `Intern`, `Contract`, `Temporary`. |
| `minSalary` | integer | Keep only jobs whose published salary reaches at least this amount (job's currency). Jobs without published pay are excluded when set. `0` = no filter. |
| `postedWithinDays` | integer | Keep only jobs published in the last N days. `0` = no filter. |
| `includeDescription` | boolean | Add the full plain-text description to each record. Default `true`. |
| `includeHtmlDescription` | boolean | Also add the raw HTML description. Default `false`. |
| `maxJobsPerCompany` | integer | Cap jobs kept per company. `0` = no limit. |
| `maxJobs` | integer | Overall cap on jobs saved. Default `5000`. |
| `maxConcurrency` | integer | How many company boards to fetch in parallel (8–15 recommended). Default `8`. |
| `proxyConfiguration` | object | Proxy settings. The default **Apify Proxy** works out of the box. |

**Search remote ML jobs paying $150k+ across all built-in companies:**

```json
{
  "searchQueries": ["machine learning"],
  "remoteOnly": true,
  "minSalary": 150000
}
```

**Scrape every engineering job at specific companies:**

```json
{
  "companies": ["https://jobs.ashbyhq.com/openai", "ramp", "notion"],
  "departments": ["Engineering"]
}
```

**Fresh jobs from the last week — your companies plus the popular list:**

```json
{
  "companies": ["vanta", "clickhouse"],
  "scanDefaultCompanies": true,
  "postedWithinDays": 7
}
```

**Just give me everything from one company:**

```json
{ "companies": ["cohere"] }
```

***

### 📤 Output

Each dataset item is one job posting as a flat, ready-to-use record. Here is a **real record from the latest verification run** (description truncated for display):

```json
{
  "company": "cohere",
  "jobId": "7133d205-5421-4336-a8e2-6037b5f55073",
  "title": "Senior Full-Stack Engineer, Internal Applications",
  "department": "Engineering & Infra",
  "team": "Internal Applications",
  "employmentType": "FullTime",
  "location": "Toronto",
  "isRemote": true,
  "workplaceType": "Remote",
  "locationCountry": "Canada",
  "locationRegion": "Ontario",
  "locationCity": "Toronto",
  "secondaryLocations": ["Canada"],
  "salaryMin": 215000,
  "salaryMax": 295000,
  "salaryCurrency": "CAD",
  "salaryInterval": "1 YEAR",
  "salarySummary": "CA$215K - CA$295K",
  "offersEquity": true,
  "publishedAt": "2026-09-15T18:21:37.401+00:00",
  "jobUrl": "https://jobs.ashbyhq.com/cohere/7133d205-5421-4336-a8e2-6037b5f55073",
  "applyUrl": "https://jobs.ashbyhq.com/cohere/7133d205-5421-4336-a8e2-6037b5f55073/application",
  "descriptionPlain": "WHO ARE WE?  Cohere is the leading security-first enterprise AI company...",
  "scrapedAt": "2026-11-02T00:53:05.816Z"
}
```

Every field comes straight from the **public Ashby job-board API** — the same data served to `jobs.ashbyhq.com` visitors.

***

### 📊 Field reference & fill rates

Fill rates below are measured from a **fresh 508-job verification run** across the built-in company list (no keyword filter).

Legend: 🟢 almost always present · 🟡 present when the company publishes it · ⚪ only when you enable the option

| Field | Fill | Description |
|---|:---:|---|
| `company` | 🟢 100% | Company slug |
| `jobId` | 🟢 100% | Ashby's unique posting ID (natural key, de-duplicated) |
| `title` | 🟢 100% | Job title |
| `department` | 🟢 100% | Department |
| `team` | 🟢 100% | Team within the department |
| `employmentType` | 🟢 100% | `FullTime`, `PartTime`, `Intern`, `Contract`, `Temporary` |
| `location` | 🟢 100% | Primary location text |
| `isRemote` | 🟢 100% | Remote flag (boolean) |
| `workplaceType` | 🟡 82% | `Remote` / `Hybrid` / `Onsite` |
| `locationCountry` | 🟡 93% | Structured country |
| `locationRegion` | 🟡 57% | Structured state/region |
| `locationCity` | 🟡 67% | Structured city |
| `secondaryLocations` | 🟡 37% | Additional office/remote locations (array) |
| `salaryMin` / `salaryMax` | 🟡 37% | Salary range, when the company publishes it |
| `salaryCurrency` | 🟡 37% | ISO currency code (USD, CAD, EUR, GBP…) |
| `salaryInterval` | 🟡 37% | Pay interval (e.g. `1 YEAR`) |
| `salarySummary` | 🟡 37% | Human-readable salary range |
| `offersEquity` | 🟢 100% | Whether equity is offered (boolean) |
| `publishedAt` | 🟢 100% | Publish date (ISO 8601) |
| `jobUrl` | 🟢 100% | Public posting link |
| `applyUrl` | 🟢 100% | Direct application link |
| `descriptionPlain` | ⚪ 100%\* | Full plain-text description (on by default; avg ~5,700 chars) |
| `descriptionHtml` | ⚪ | Raw HTML description — optional |
| `scrapedAt` | 🟢 100% | ISO 8601 timestamp of the scrape |

\* `descriptionPlain` is present on 100% of records when `includeDescription` is left on (the default).

> 💬 **About salary:** many — but not all — companies publish compensation on Ashby (often required by pay-transparency laws). In the latest run, **37% of jobs** carried a structured salary. When published you get clean min/max/currency; when not, those fields are simply empty. Use **Minimum salary** to keep only jobs with published pay.

***

### 🔁 Pagination & scale

Ashby serves a company's **entire job board in a single API response** — there are no result pages to click through, so this **Ashby scraper** fetches every open role for a company in one fast request (a large company can return **150–200+ jobs** at once). To scale across the market, the actor **fans out over many companies in parallel** (tune with **Max concurrent companies**, 8–15 recommended), de-duplicates company slugs, and streams each job straight into your dataset while de-duplicating on `jobId`.

You stay in control of volume with two caps:

- **`maxJobs`** — overall limit on jobs saved (default **5,000**).
- **`maxJobsPerCompany`** — per-company limit (`0` = no limit).

In our latest verification, a single no-keyword run streamed **508 de-duplicated postings in ~26 seconds** before hitting a deliberate `maxJobs: 500` cap — so leaving the default cap in place, a keyword run across the built-in **50+ companies** returns **thousands of de-duplicated job postings** in well under a minute. The run ends cleanly as soon as every company has been scanned or a cap is hit.

***

### ⚙️ How to use

1. Open the actor and go to the **Input** tab.
2. Do any of these (mix freely):
   - Type keywords under **🔎 Search keywords** (e.g. `engineer`, `product manager`).
   - Paste boards under **🏢 Companies** (e.g. `https://jobs.ashbyhq.com/openai` or `ramp`).
   - Add filters — remote only, location, department, employment type, minimum salary, posted-within-days.
3. Press **Start** ▶️ and watch jobs stream into the dataset.
4. **Export** the results as **JSON, CSV, Excel, HTML table or RSS**, or pull them from the **Apify API**.
5. **Automate** it: add a **Schedule** to re-run your watchlist every morning, or trigger it via the Apify API / SDK and push results to **Make, Zapier, Google Sheets, a webhook or your database**.

No input at all? The actor searches across the built-in list of popular Ashby companies so you instantly see the shape of the data.

***

### 💡 Tips

- **Don't know the slug?** Leave *Companies* empty and search by keyword — the built-in list does the work. The slug is the last part of an Ashby URL: `jobs.ashbyhq.com/`**`ramp`**.
- **Want only paid roles?** Set **Minimum salary** above `0`; jobs without a published salary are dropped automatically.
- **Casting a wide net?** Combine your own companies with `scanDefaultCompanies: true` to cover both your watchlist and the popular list in one run.
- **Keep runs lean.** Turn off **Include job description** if you only need titles/salaries — records get much smaller and faster.
- **Tune throughput** with **Max concurrent companies** (8–15 is a good range); higher is faster across many boards.
- **Daily monitoring?** Pair **Posted within (days)** with a **Schedule** to capture only newly posted roles each run.

***

### ❓ FAQ

<details>
<summary><b>Is scraping Ashby legal?</b></summary>

This actor collects **publicly available** job-posting information — the same data any visitor sees on a company's public careers page. It does not log in, access private data, or bypass authentication. You remain responsible for complying with applicable laws and the relevant terms of service; see **Legal & responsible use** below.

</details>

<details>
<summary><b>Do I need an API key or account?</b></summary>

No. The actor reads public Ashby career pages via the public **Ashby API** — nothing to register, no login, no key.

</details>

<details>
<summary><b>How many jobs can it return, and how fast?</b></summary>

A single large company board can return **150–200+ jobs** in one request; a keyword run across the built-in **50+ companies** yields **thousands of de-duplicated postings**. Our latest run collected **508 jobs in ~26 seconds**. Because it's pure HTTP with parallel company fetches, it's fast and cheap. Use **Max jobs** / **Max jobs per company** to cap volume.

</details>

<details>
<summary><b>Do I need proxies?</b></summary>

No special setup — the default **Apify Proxy** is selected out of the box and works for the Ashby API. You can switch proxy groups in **Proxy configuration** if you prefer.

</details>

<details>
<summary><b>How do I find a company's slug?</b></summary>

It's the last part of its Ashby URL: `https://jobs.ashbyhq.com/`**`ramp`**. Paste either the full URL or just the slug — and if you don't know it, leave *Companies* blank and search by keyword.

</details>

<details>
<summary><b>Which companies are in the built-in list?</b></summary>

A curated set of **50+ popular Ashby companies** across AI, developer tools, fintech and SaaS — including OpenAI, Ramp, Notion, Perplexity, Cursor, Cohere, Snowflake, ElevenLabs, ClickHouse, Vanta, Plaid and many more. You can always add your own on top.

</details>

<details>
<summary><b>Why don't all jobs have a salary?</b></summary>

Salary is included only when the company publishes it on the posting (increasingly common under pay-transparency laws). In the latest run, 37% of jobs carried structured pay. When shown, you get `salaryMin` / `salaryMax` / `salaryCurrency`; otherwise those fields are empty. Use **Minimum salary** to keep only jobs with published pay.

</details>

<details>
<summary><b>Can I get the full job description?</b></summary>

Yes — the full plain-text description is included by default (averaging ~5,700 characters), and you can optionally add the raw HTML version too.

</details>

<details>
<summary><b>What export formats are supported?</b></summary>

JSON, CSV, Excel, HTML table and RSS — from the dataset UI or via the Apify API.

</details>

<details>
<summary><b>Is there an Ashby jobs API I can use?</b></summary>

This actor **is** your Ashby jobs API: run it via the Apify API or SDK, pass companies/keywords as JSON input, and read clean job records back from the dataset endpoint in **JSON, CSV or Excel**. Under the hood it reads Ashby's public job-board API, so no key or login is required.

</details>

<details>
<summary><b>How fresh is the data?</b></summary>

Every run scrapes **live** postings directly from each company's current Ashby board, so results reflect what's open right now. Schedule the actor to re-run daily and your dataset stays up to date automatically.

</details>

<details>
<summary><b>Can I filter by remote, department or date?</b></summary>

Yes. Use **Remote jobs only**, **Departments** (partial match), **Employment types**, **Location contains**, **Minimum salary** and **Posted within (days)** — all combinable in a single run.

</details>

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Unlocked 1,000+ jobs batch collection:** Support for large enterprise talent mining with unlimited job aggregation across all company targets.
- **Enhanced input schema normalization:** Added unified `maxItems` and `maxJobs` support with zero artificial per-company capping.
- **Improved salary & equity extraction:** Standardized currency code normalization and multi-tier compensation parsing.
- **Optimized concurrent worker pool:** Faster throughput across 50+ built-in tech startup job boards with automated 429 backoff.

#### v1.1 (2026-08)

- Added built-in curated directory of 50+ leading Ashby-powered startup careers pages.
- Added structured filters for remote jobs, departments, location text matching, and minimum salary thresholds.
- Added plain text and raw HTML job description extraction toggles.

#### v1.0 (2026-07)

- Initial release featuring keyless ATS job scraping, compensation tier parsing, and direct apply link extraction.

***

### 🔗 Related scrapers

Building a cross-platform jobs dataset or recruiting pipeline? Pair this **Ashby scraper** with the other job-board scrapers in the collection:

- [Seek Scraper](https://apify.com/haketa/seek-scraper) — jobs, salaries and company data from Seek (AU/NZ).
- [ZipRecruiter Scraper](https://apify.com/haketa/ziprecruiter-scraper) — US job listings with pay estimates and apply links.
- [Xing Jobs Scraper](https://apify.com/haketa/xing-jobs-scraper) — German-speaking (DACH) job postings from Xing.
- [Naukri Scraper](https://apify.com/haketa/naukri-scraper) — India's largest job board, with salary and experience data.
- [GulfTalent Jobs Scraper](https://apify.com/haketa/gulftalent-jobs-scraper) — Middle East / Gulf region job listings.
- [Workana Scraper](https://apify.com/haketa/workana-scraper) — freelance projects and gigs from Workana.

***

#### 🔎 Also searched as

Ashby scraper · ashbyhq scraper · Ashby jobs API · Ashby job board scraper · scrape Ashby · ATS job scraper · jobs.ashbyhq.com scraper · startup jobs scraper · tech jobs scraper · AI jobs scraper · salary scraper · job postings API · Greenhouse / Lever alternative · hiring signals · recruiting data

***

*Made for job boards, recruiters, analysts and data teams who need clean Ashby job data fast. Want another field or company added? Open an issue on the actor's **Issues** tab.* **▶️ Press Start and get structured Ashby jobs in seconds.**

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/ashby-jobs-scraper/changelog.md

# Actor input Schema

## `searchQueries` (type: `array`):

Keep only jobs whose title, team or description matches any of these keywords (e.g. "engineer", "product manager", "remote"). Leave empty to keep all jobs.

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

Company job boards to scrape. Paste Ashby URLs (https://jobs.ashbyhq.com/ramp) or bare slugs (ramp, openai). Leave empty to search across a built-in list of popular Ashby companies.

## `scanDefaultCompanies` (type: `boolean`):

When companies are listed above, also include the built-in list of popular Ashby companies (OpenAI, Ramp, Notion, Perplexity, and 50+ more).

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

Keep only jobs marked remote.

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

Keep only jobs whose location matches this text (e.g. "United States", "London", "Europe").

## `departments` (type: `array`):

Keep only jobs in these departments (e.g. Engineering, Sales, Design). Matches partial names.

## `employmentTypes` (type: `array`):

Keep only these employment types. Common values: FullTime, PartTime, Intern, Contract, Temporary.

## `minSalary` (type: `integer`):

Keep only jobs whose listed salary reaches at least this amount (in the job's currency). Jobs without a published salary are excluded when set. 0 = no filter.

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

Keep only jobs published in the last N days. 0 = no filter.

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

Add the full plain-text job description to each record.

## `includeHtmlDescription` (type: `boolean`):

Also add the raw HTML version of the description.

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

Cap the number of jobs kept per company. 0 = no limit.

## `maxJobs` (type: `integer`):

Overall cap on the number of jobs saved. Set 0 for no limit.

## `maxConcurrency` (type: `integer`):

How many company boards to fetch in parallel. Recommended: 8–15.

## `proxyConfiguration` (type: `object`):

Proxy settings. The default (Apify Proxy) works out of the box.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer",
    "designer"
  ],
  "companies": [
    "https://jobs.ashbyhq.com/openai",
    "ramp"
  ],
  "scanDefaultCompanies": false,
  "remoteOnly": false,
  "location": "New York",
  "departments": [
    "Engineering",
    "Marketing"
  ],
  "employmentTypes": [
    "FullTime",
    "Intern"
  ],
  "minSalary": 0,
  "postedWithinDays": 0,
  "includeDescription": true,
  "includeHtmlDescription": false,
  "maxJobsPerCompany": 0,
  "maxJobs": 100,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Download every job (JSON, CSV, Excel).

## `runUrl` (type: `string`):

Open this run in the Apify Console.

## `company` (type: `string`):

Company slug

## `title` (type: `string`):

Job title

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

Department

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

Team

## `employmentType` (type: `string`):

FullTime, Intern, etc.

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

Primary location

## `isRemote` (type: `string`):

Whether remote

## `salaryMin` (type: `string`):

Minimum salary

## `salaryMax` (type: `string`):

Maximum salary

## `salaryCurrency` (type: `string`):

Salary currency

## `salarySummary` (type: `string`):

Salary range text

## `offersEquity` (type: `string`):

Offers equity

## `publishedAt` (type: `string`):

Publish date

## `applyUrl` (type: `string`):

Application link

## `jobUrl` (type: `string`):

Job posting link

## `descriptionPlain` (type: `string`):

Full job description

## `scrapedAt` (type: `string`):

ISO 8601 timestamp

# 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 = {
    "searchQueries": [
        "machine learning"
    ],
    "companies": [],
    "departments": [],
    "employmentTypes": [],
    "maxJobs": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/ashby-jobs-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 = {
    "searchQueries": ["machine learning"],
    "companies": [],
    "departments": [],
    "employmentTypes": [],
    "maxJobs": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/ashby-jobs-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 '{
  "searchQueries": [
    "machine learning"
  ],
  "companies": [],
  "departments": [],
  "employmentTypes": [],
  "maxJobs": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/ashby-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/ashby-jobs-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/n4LO99RLwSJCqOjRs/builds/iGP36xB7pacb7vat7/openapi.json