# ATS Jobs Feed (`henryklimes/ats-jobs-feed`) Actor

Use this when you need one JSON or CSV feed of open jobs from Greenhouse, Lever, Ashby, Workable, SmartRecruiters or Recruitee. Input board or company IDs; output normalized title, location, salary when published, and apply URL. Not for Workday sites (use Workday Jobs Feed). $1.50 per 1,000 jobs.

- **URL**: https://apify.com/henryklimes/ats-jobs-feed.md
- **Developed by:** [Jindrich Klimes](https://apify.com/henryklimes) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 job listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## ATS Jobs Feed

**Find out who's hiring, what they're hiring for, and why it matters to your business.**

Extract structured job postings from the public APIs of major applicant tracking systems (Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee). Perfect for recruiting intelligence, sales targeting, market research, and AI agents that need reliable hiring data.

### What You Get

Every job posting includes:

- **Company & Role**: Company name, job title, department, team
- **Location Details**: Location, remote status
- **Salary Data**: Original string + normalized min/max/currency/period, when the source publishes pay (see [Salary, dates, and company names](#salary-dates-and-company-names))
- **Job Details**: Description, employment type, application URL
- **Timestamps**: Posted date (see notes below), last updated, scraped timestamp

| Company | Title | Location | Remote | Salary | Department | Posted |
|---------|-------|----------|--------|--------|------------|--------|
| Stripe | Senior Software Engineer | San Francisco, CA | No | $150k-$200k/year | Engineering | 2026-10-15 |
| Netflix | Product Designer | Remote | Yes | null | Product | 2026-11-01 |
| Ramp | Account Executive | New York, NY | No | $120k-$180k/year | Sales | 2026-10-20 |

### Quick Start

**Simple string input** - no need for complex configuration:

```json
{
  "companies": [
    "greenhouse:stripe",
    "lever:netflix",
    "https://jobs.ashbyhq.com/ramp"
  ]
}
```

Or use a **preset list** of curated companies (23 YC startups, 17 AI companies, or 21 fintech companies):

```json
{
  "presetList": "yc-top-startups"
}
```

That's it. Hit Run and get structured job data in seconds.

### Use Cases

#### 🎯 Recruiting Intelligence

**Track competitor hiring activity.** Monitor what roles competitors are hiring for, where they're hiring, and how aggressively they're expanding. Identify talent pools, benchmark salaries, and spot market shifts before they become trends.

**Example**: Track all AI companies to see demand for ML engineers vs. research scientists.

#### 💼 Sales & Lead Generation

**Target companies with hiring signals.** Companies hiring "Cloud Infrastructure Engineer" likely need cloud tools. Companies hiring "Security Engineer" need security solutions. Use job postings as intent signals to prioritize outbound sales.

**Example**: Generate leads for your HR software by tracking companies rapidly scaling their headcount.

#### 📊 Market Research

**Analyze hiring trends across industries.** Track skill demand, salary trends, remote work adoption, geographic hiring patterns. Build datasets for compensation benchmarking, talent market analysis, or economic indicators.

**Example**: Build a salary transparency database by aggregating published salary ranges across thousands of companies.

#### 🤖 AI Agent Data Feeds

Provide structured, reliable job data to AI assistants, chatbots, or automated workflows. Agents can query hiring patterns, recommend career paths, or match candidates to opportunities using this clean, normalized data.

#### 🔗 Job Board Aggregation

Build specialized job boards (AI jobs, remote jobs, senior engineering roles) or career platforms with fresh, structured data from hundreds of companies.

**Example**: Create a "crypto jobs" board by tracking fintech companies.

### Integrations

**API**: Fetch data via [Apify REST API](https://docs.apify.com/api/v2)\
**Automation**: Make, n8n, Zapier\
**MCP**: Use via Model Context Protocol for AI agents

Full integration docs: [Apify Platform Integrations](https://docs.apify.com/platform/integrations)

### Input

#### Company Input (Flexible)

The `companies` array accepts four formats:

1. **Shorthand**: `"greenhouse:stripe"` (ATS:identifier)
2. **URL**: `"https://boards.greenhouse.io/stripe"` (auto-detects ATS)
3. **Full object**: `{"company": "Stripe", "ats": "greenhouse", "atsIdentifier": "stripe"}`
4. **Bare domain or company slug**: `"stripe.com"` or `"stripe"` (fetches the homepage, `/careers`, and `/jobs` and looks for Greenhouse, Lever, Ashby, Workable, SmartRecruiters, or Recruitee links)

`companies` is optional if you set `presetList`. You can also combine them; the lists are merged and de-duplicated.

```json
{
  "presetList": "yc-top-startups",
  "companies": ["greenhouse:gitlab"]
}
```

Available presets (counts verified against public ATS APIs on 2026-11-14):

- `yc-top-startups`: 23 Y Combinator and YC-alumni companies
- `ai-companies`: 17 AI/ML companies
- `fintech`: 21 financial technology companies

Invalid or unresolvable entries are skipped and listed in the OUTPUT per-company status with an error message. They do not fail the whole run.

#### Filters (Optional)

```json
{
  "filters": {
    "keyword": "engineer",
    "location": "San Francisco",
    "remoteOnly": false,
    "postedWithinDays": 30
  }
}
```

`postedWithinDays` uses the same date as `posted_at` (see below). On Greenhouse that is `first_published` when present, not the last-updated date.

#### Testing & Limits

- `maxJobs`: Cap total jobs across all companies (100 jobs = ~$0.15)
- `maxJobsPerCompany`: Cap per-company (prevents one large board from dominating)

#### Advanced Options

- `includeDescription`: Include full job descriptions (default: true)
- `stripPersonalData`: Remove emails/phone numbers for GDPR compliance (default: true)
- `incrementalMode`: Only output new jobs since last run (default: false)

### Output

#### Dataset: Job Postings

Each job posting includes:

| Field | Type | Description |
|-------|------|-------------|
| `company` | String | Company name (official board name when the ATS provides one and the input was a shorthand, URL, or slug; otherwise the name you supplied) |
| `ats` | String | ATS platform (greenhouse, lever, ashby, etc.) |
| `job_id` | String | Unique job ID in the ATS |
| `title` | String | Job title |
| `department` | String | Department or functional area |
| `location` | String | Job location (normalized) |
| `is_remote` | Boolean | Whether the job allows remote work |
| `salary` | String | Original salary string, or `null` when the source does not publish pay |
| `salary_min` | Number | Normalized minimum salary |
| `salary_max` | Number | Normalized maximum salary |
| `salary_currency` | String | Currency code (USD, EUR, GBP, etc.) |
| `salary_period` | String | Period (year, month, hour) |
| `description_text` | String | Job description in plain text |
| `apply_url` | String | URL to apply |
| `posted_at` | String | Posting date (ISO 8601). Greenhouse uses `first_published` when present, otherwise `updated_at` |
| `scraped_at` | String | Timestamp when scraped |

#### Key-Value Store: OUTPUT

Summary record with:

- `totalJobs`: Total jobs extracted
- `companies`: Per-company status (jobsFound, jobsOutput, error, skipped)
- `filters`: Filters applied

### Salary, dates, and company names

Not every job includes salary, a first-published date, or a polished company name. The fields below are filled only when the source actually provides the data.

**Salary** (`salary`, `salary_min`, `salary_max`, `salary_currency`, `salary_period`):

- **Ashby**: from the official compensation object (this Actor always requests `includeCompensation=true`). Jobs without a published salary component stay `null`.
- **Greenhouse**: from the pay-transparency / `pay-range` block in the job HTML when the company uses it, otherwise from a clearly labeled salary range in the description. Many boards (and many jobs on boards that do publish pay) still have `null` salary fields.
- **Lever**: from `salaryRange` when the API includes it, otherwise from a clearly labeled salary range in the description.
- **Workable, SmartRecruiters, Recruitee**: only when a clearly labeled salary range appears in the job description. The public endpoints used here do not expose a structured salary field.

Incidental dollar amounts (revenue, market size, benefits stipends) are not treated as salary.

**Posted date** (`posted_at`) and `postedWithinDays`:

- **Greenhouse**: `first_published` when the jobs endpoint returns it. If it is missing, `posted_at` and `postedWithinDays` fall back to `updated_at`.
- **Ashby**: `publishedAt`. **Lever**: `createdAt`. Other supported ATS platforms use their created / released date when one is present.

**Company name**:

- When the input is a shorthand (`greenhouse:gitlab`), a board URL, or a slug, the Actor uses the official board or organization name when the ATS publishes one (Greenhouse board metadata, Ashby organization name on the public board). If that lookup fails, it falls back to a capitalized identifier (`Gitlab`, `Openai`).
- Names you set yourself in an object input, including any display names on preset entries, are kept as given.

### Supported ATS Platforms

- **Greenhouse** (boards.greenhouse.io)
- **Lever** (jobs.lever.co)
- **Ashby** (jobs.ashbyhq.com)
- **Workable** (apply.workable.com)
- **SmartRecruiters** (careers.smartrecruiters.com)
- **Recruitee** (\*.recruitee.com)

### Ready-made example tasks

Open one, check the prefilled input, and run it in one click:

- [Get OpenAI job openings from Ashby](https://apify.com/henryklimes/ats-jobs-feed/examples/openai-jobs-ashby)
- [Track AI startup job openings](https://apify.com/henryklimes/ats-jobs-feed/examples/ai-startup-jobs-tracker)
- [Export a Greenhouse job board to JSON](https://apify.com/henryklimes/ats-jobs-feed/examples/greenhouse-job-board-to-json)
- [Find remote engineering jobs at YC startups](https://apify.com/henryklimes/ats-jobs-feed/examples/remote-engineering-jobs-yc-startups)
- [Get fintech job openings from Stripe, Plaid, Wise and more](https://apify.com/henryklimes/ats-jobs-feed/examples/fintech-job-openings-feed)

### Pricing

**$0.0015 per job saved** ($1.50 per 1,000 jobs)

- **Example**: 500 jobs = $0.75
- **Failed or empty boards are not charged** - Only successful extractions
- **Quick test**: 100 jobs = ~$0.15
- **Real run (16 Nov 2026)**: every open job at 39 AI companies and startups (the `ai-companies` preset plus 22 more Greenhouse/Ashby boards) returned 6,481 jobs in about 4 minutes, which is $9.72 at this price. Use `filters` (keyword, location, remoteOnly, postedWithinDays) or `maxJobs` to pay only for the rows you need.

Monitor usage via the OUTPUT summary record.

### Incremental Mode

Enable `incrementalMode` to only extract new jobs since the last run:

```json
{
  "companies": ["greenhouse:stripe"],
  "incrementalMode": true,
  "incrementalStoreName": "ats-jobs-seen"
}
```

Perfect for daily scheduled runs to detect new postings.

### FAQ

#### Is this legal?

This Actor accesses **public job board APIs** provided by ATS vendors for displaying jobs. These are official, public endpoints - no scraping or circumvention involved. Job postings are public recruitment information. **Users are responsible for their use of this data.** This is not legal advice.

#### Why is salary empty for some jobs?

Salary is only filled when that source publishes it. Ashby often includes a compensation object, Greenhouse often includes a pay-range block, and Lever sometimes includes `salaryRange` or a labeled range in the description. If the company did not publish pay, the salary fields are `null`. See [Salary, dates, and company names](#salary-dates-and-company-names).

#### Why is my company not returning jobs?

- Verify the ATS and identifier are correct
- Check if the company currently has open positions (boards can be empty)
- Some companies temporarily hide boards during hiring freezes
- Try the prefill examples first to ensure the Actor is working

#### Can I get historical job postings?

No. ATS APIs only expose currently open positions. Use `incrementalMode` with scheduled runs to build your own historical dataset over time.

#### What if an ATS changes its API?

We monitor API stability with daily smoke tests. If an ATS breaks, it will be flagged and fixed quickly. Check the Actor's changelog for known issues.

#### Can I request support for additional ATS platforms?

Yes! If there's an ATS with a public API you need supported, open an issue in the Issues tab on this Actor's Store page.

### Related Actors

- [Screenshot & PDF API](https://apify.com/henryklimes/screenshot-pdf) - Capture careers pages for archival or monitoring

### Support

**Issues**: Report bugs or request features via the Issues tab on this Actor's Store page\
**Documentation**: [Apify Actors](https://docs.apify.com/actors)

### License

This Actor is proprietary software operated by Cleanrows. Usage is subject to Apify's Terms of Service.

# Actor input Schema

## `presetList` (type: `string`):

Optional curated company list. Can be used alone or combined with Companies (duplicates are removed). Counts verified against public ATS APIs: yc-top-startups (23), ai-companies (17), fintech (21).

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

Optional. Companies to include. Accepts shorthand ('greenhouse:stripe'), ATS board URLs, full objects, or a bare domain / company slug ('stripe.com' or 'stripe') which is resolved from the homepage, /careers, and /jobs. Can be combined with a preset list; entries are merged and de-duplicated. At least one of Companies or Preset Company List is required.

## `filters` (type: `object`):

Filter jobs by keywords, location, remote status, or posting date

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

Include full job descriptions in output (increases data size)

## `stripPersonalData` (type: `boolean`):

Remove email addresses and phone numbers from job descriptions (recommended)

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

Maximum total jobs across all companies. 100 jobs is a quick test (~$0.15)

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

Maximum number of jobs to extract per company (prevents one large board from starving others)

## `incrementalMode` (type: `boolean`):

Only output new jobs (stores seen job IDs in a named KV store)

## `incrementalStoreName` (type: `string`):

Name of the key-value store for incremental mode

## Actor input object example

```json
{
  "companies": [
    "greenhouse:gitlab",
    "lever:leverdemo",
    "ashby:ramp"
  ],
  "includeDescription": true,
  "stripPersonalData": true,
  "incrementalMode": false,
  "incrementalStoreName": "ats-jobs-seen"
}
```

# Actor output Schema

## `jobPostings` (type: `string`):

All extracted job postings with normalized fields

## `summary` (type: `string`):

Summary of extraction including total jobs count, per-company status, and applied filters

# 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 = {
    "companies": [
        "greenhouse:gitlab",
        "lever:leverdemo",
        "ashby:ramp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("henryklimes/ats-jobs-feed").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 = { "companies": [
        "greenhouse:gitlab",
        "lever:leverdemo",
        "ashby:ramp",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("henryklimes/ats-jobs-feed").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 '{
  "companies": [
    "greenhouse:gitlab",
    "lever:leverdemo",
    "ashby:ramp"
  ]
}' |
apify call henryklimes/ats-jobs-feed --silent --output-dataset

```

## MCP server setup

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

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/fkaM5DV4HQ75OGtXA/builds/bqoJRHbVneYOQ7CzK/openapi.json
