# Ashby Jobs Scraper & API (`codingfrontend/ashby-jobs-scraper-api`) Actor

Scrape jobs directly from Ashby ATS via one fast API. Pull live roles from high-growth startups like Notion, Plaid & Ramp. Zero ghost jobs, verified daily — built for job boards, AI agents & startup hiring research.

- **URL**: https://apify.com/codingfrontend/ashby-jobs-scraper-api.md
- **Developed by:** [Coding Frontned](https://apify.com/codingfrontend) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Find current public openings on Ashby company job boards and review the details for each role. Search the built-in company boards, narrow results with filters, or provide a public Ashby board name.

### What you can search

With no company filter, the Actor checks public boards for OpenAI, Notion, Cursor, Replit, ElevenLabs, Ramp, Supabase, Linear, and Perplexity. Add `companies_include` to search a different company board hosted by Ashby. Names and domains are converted to a board name; a private or non-Ashby company index is not used.

Use the filters to find roles by title or description, location, work model, employment type, experience wording, skills, publication date, or disclosed annual USD base pay. `queries` values are combined as OR choices; prefix a value with `-` to exclude it. Page number and page size apply to one combined, de-duplicated result list.

### Run the Actor

1. Open **Input** in the Apify Console.
2. Leave **Company boards** empty to search the nine built-in boards, or enter public Ashby board names.
3. Add only the filters you need. The default is page 1 with 50 jobs; page size can be set from 1 to 100.
4. Start the run and open **Dataset** to review the jobs. If some boards are unavailable but jobs were saved, the platform run succeeds and the summary marks the result `PARTIAL`. A run with no useful jobs is marked failed, with the reason and counts in the run summary.

The request timeout defaults to 30 seconds, retries to 2, and the maximum response size to 20 MB per request. These settings are under **Request options**. Retries are bounded; an Ashby `Retry-After` instruction is followed, and a request is not repeated after access is denied.

For example, this searches roles mentioning either phrase while excluding internships:

```json
{
  "queries": ["software engineer", "data engineer", "-intern"],
  "locations": ["Remote", "San Francisco"],
  "work_models": ["remote", "hybrid"],
  "employment_types": ["full-time"],
  "page_size": 25
}
```

### What the dataset contains

Each job row includes the public job ID and title, company board name, department and team where provided, location and secondary locations, employment details, publication date, the full public job description, and compensation Ashby marks as visible. Workplace type comes from the structured feed or a clear work-model statement in the posting. Compensation keeps its published currency, period, range, and tier details. An experience-level label appears only when the job title uses a clear seniority term. The role page and application link are separate when Ashby publishes separate links.

The **Include company details** option adds a public board logo when one is available. The board name and board link are always included. Missing source details are left out instead of being guessed. Request counts, source errors, result counts, and run status stay in `OUTPUT_SUMMARY`, not in job rows. `OUTPUT` contains the same summary for compatibility. A company match report is saved when you provide `companies_include`.

#### Example result

The `description` value below is a **documentation-only excerpt** from the public OpenAI posting. It shows 14 words; actual dataset rows contain the complete publisher text without this example limit.

```json
{
  "id": "8fb1615c-34bf-47c4-a1d1-b7b2f836bbd3",
  "title": "Technical Program Manager, Compute Infrastructure",
  "company": {
    "id": "ashby:openai",
    "name": "OpenAI",
    "board_url": "https://jobs.ashbyhq.com/openai"
  },
  "department": "Technical Program Management",
  "team": "Technical Program Management",
  "locations": [
    {
      "location": "San Francisco",
      "city": "San Francisco",
      "region": "California",
      "country": "United States",
      "address": {
        "postalAddress": {
          "addressLocality": "San Francisco",
          "addressRegion": "California",
          "addressCountry": "United States"
        }
      }
    }
  ],
  "location": "San Francisco",
  "employment_type": "Full-time",
  "workplace_type": "Hybrid",
  "compensation": {
    "summary": "$257K – $335K • Offers Equity",
    "salary_summary": "$257K - $335K",
    "tiers": [
      {
        "components": [
          {
            "summary": "$257K – $335K",
            "compensation_type": "Salary",
            "interval": "1 YEAR",
            "currency": "USD",
            "minimum": 257000,
            "maximum": 335000
          },
          {
            "summary": "Offers Equity",
            "compensation_type": "EquityCashValue",
            "interval": "1 YEAR",
            "currency": "USD"
          }
        ]
      }
    ]
  },
  "listing_url": "https://jobs.ashbyhq.com/openai/8fb1615c-34bf-47c4-a1d1-b7b2f836bbd3",
  "apply_url": "https://jobs.ashbyhq.com/openai/8fb1615c-34bf-47c4-a1d1-b7b2f836bbd3/application",
  "source_board": "openai",
  "date_posted": "2026-03-12T16:38:15.322Z",
  "description": "The compute infrastructure team runs the GPU fleet and large-scale compute clusters that serve"
}
```

The excerpt is from the native Ashby job feed and public role page. It shows the output shape; it does not limit the Actor's dataset text.

### Pricing and source limits

The current Actor price is $0.00399 for each saved dataset result, plus a $0.001 start charge and applicable platform usage. Check the **Pricing** panel before starting a run because prices can change.

This Actor reads public Ashby job-board feeds and public company-board pages. It does not use a private Jobo index, submit applications, or access private boards. A supplied company name only works when its corresponding public Ashby board is available. Public postings can change or be removed at any time; results reflect what the source returned during the run.

### Help and responsible use

Follow Ashby and employer terms, source limits, and applicable law. The Actor returns public hiring information; do not use it to contact applicants or infer private personal details. This Actor is independent and is not affiliated with Ashby or employers whose boards it reads. For a problem, use the Actor's **Issues** tab and include the run ID and the relevant run-summary message.

# Actor input Schema

## `queries` (type: `array`):

Up to five job titles or keywords; values are OR-ed. Prefix a value with - to exclude it.

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

Cities, regions, or countries.

## `work_models` (type: `array`):

Where work is performed; leave empty for all.

## `employment_types` (type: `array`):

Employment type filters.

## `experience_levels` (type: `array`):

Seniority filters.

## `skills_include` (type: `array`):

Return jobs whose public posting text contains any listed skill.

## `skills_exclude` (type: `array`):

Exclude jobs whose public posting text contains any listed skill.

## `companies_include` (type: `array`):

Whole company names, domains, or Ashby board slugs.

## `companies_exclude` (type: `array`):

Companies to exclude by name, domain, or board slug.

## `min_salary_usd` (type: `integer`):

Annual USD lower bound. A job must disclose public USD annual base salary in the Ashby feed to match.

## `max_salary_usd` (type: `integer`):

Annual USD upper bound. A job must disclose public USD annual base salary in the Ashby feed to match.

## `posted_after` (type: `string`):

ISO date or a relative value such as 7 days ago.

## `posted_before` (type: `string`):

ISO date or a relative value such as 1 month ago.

## `page` (type: `integer`):

Result page.

## `page_size` (type: `integer`):

Results per page.

## `include_company_details` (type: `boolean`):

Add the company board logo when the public board page provides one. Company name, board link, and job details are returned independently of this option.

## `timeoutMs` (type: `integer`):

Per-request timeout covering headers and body reads.

## `maxRetries` (type: `integer`):

Retries for transient public-source failures such as 429 and 5xx responses.

## `maxResponseBytes` (type: `integer`):

Maximum response size accepted from a public Ashby endpoint.

## `userAgent` (type: `string`):

Optional descriptive user-agent for public requests.

## Actor input object example

```json
{
  "page": 1,
  "page_size": 50,
  "include_company_details": false,
  "timeoutMs": 30000,
  "maxRetries": 2,
  "maxResponseBytes": 20000000
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `runSummary` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("codingfrontend/ashby-jobs-scraper-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("codingfrontend/ashby-jobs-scraper-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 '{}' |
apify call codingfrontend/ashby-jobs-scraper-api --silent --output-dataset

```

## MCP server setup

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