# Unified ATS Job Feed (`your_friendly_developer/unified-ats-job-feed`) Actor

Combines public Greenhouse, Lever, and Ashby job board JSON APIs into a normalized job dataset with first-seen tracking, per-board failure reporting, and run summaries.

- **URL**: https://apify.com/your_friendly_developer/unified-ats-job-feed.md
- **Developed by:** [Jason Ramirez](https://apify.com/your_friendly_developer) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

## Unified ATS Job Feed

Track company job postings across Greenhouse, Lever and Ashby in one feed. Each run returns normalized job rows with first-seen dates and new-posting flags, plus a run summary counting new and closed postings per board, so you can watch hiring changes at the companies you track without checking three board systems by hand.

An Apify Actor for lead gen and recruiting-tools builders who need cross-ATS job rows. It reads public JSON job boards from Greenhouse, Lever, and Ashby and emits one normalized dataset item per job. It does not scrape HTML pages or require source credentials.

### Input

```json
{
  "companies": [
    { "platform": "greenhouse", "board": "example-greenhouse-board" },
    { "platform": "lever", "board": "example-lever-site" },
    { "platform": "ashby", "board": "example-ashby-board" }
  ],
  "maxJobsPerCompany": 500,
  "includeDescription": false
}
```

Replace placeholders with actual public board tokens. Companies is required and nonempty. Exact duplicate platform/board pairs are fetched once; whitespace around board tokens is trimmed. maxJobsPerCompany must be a positive integer and defaults to 500. It caps rows emitted per board, after sorting. Full public API responses still must be downloaded and normalized for accurate closure counts. It is not a network or memory cap.

### Output schema

| Field | Type | Meaning |
| --- | --- | --- |
| platform | string | greenhouse, lever, or ashby |
| company | string | Input board token, not a resolved legal company name |
| jobId | string | Source-native posting ID |
| title | string | Posting title |
| url | string | Absolute apply or job URL |
| location | string | Best available location, empty when missing |
| locationType | string | remote, onsite, hybrid, or unknown |
| department | string or null | First or source department |
| team | string or null | Source team; Greenhouse uses first office |
| employmentType | string or null | Source value when available |
| postedAt | ISO string or null | Source publication/creation date when available |
| updatedAt | ISO string or null | Source update date when available |
| descriptionText | string | Basic HTML-to-text conversion; not a full HTML parser |
| descriptionOmitted | boolean | True when full descriptions were not requested |
| firstSeenAt | ISO string | First observation in the retained snapshot |
| lastSeenAt | ISO string | Current run timestamp |
| isNew | boolean | Posting absent from the previous snapshot |

With includeDescription false, descriptionText is at most 500 JavaScript string characters and descriptionOmitted is true, even for short descriptions. With true, the full converted text is emitted. Missing optional fields do not fail a board. Missing IDs, titles, valid absolute URLs, or expected top-level arrays fail that board to avoid false closures. No closedSinceLastRun field is emitted on job items.

Rows sort by platform, company, postedAt descending (null last), then jobId lexically. Adapter modules expose endpoint(board) and parse(payload); new platforms can map to the same normalized fields without changing the dataset schema. Workable, SmartRecruiters, and Recruitee are not implemented.

### Velocity and honest receipts

The default key-value store retains SNAPSHOT-{platform}-{board}, containing runAt and a jobs map of jobId to firstSeenAt/title. New IDs receive the current timestamp and isNew true; existing IDs retain firstSeenAt. IDs absent from a successfully fetched full board count as closed. A successful empty board closes all previous IDs. Failed boards leave their snapshots untouched and contribute no closures.

The full fetched board is snapshotted even when output is capped. Therefore a previously observed job can first appear in the emitted dataset with isNew false. newJobs counts new emitted rows; closedJobs counts closures across complete successful boards. Reusing the same persistent default store is required for history across runs. A new default store starts fresh history; this is not a global history service.

A single summary per completed run goes to the named run-summary dataset and LAST_RUN_SUMMARY in the default store. Fields: runAt, boardsRequested (unique input boards), boardsSucceeded, boardsFailed (array of platform/company/error), totalJobs (emitted rows), newJobs, closedJobs. A nonexistent board fails that board and appears in the summary. HTTP, JSON, shape, and timeout errors are isolated per board. Each request times out after 30 seconds; there are no retries. Output or persistence failures abort the run and may prevent a final summary. Dataset writes and snapshots are not transactional; retries after partial storage failure may repeat rows.

### Honest limits and publication

Public boards only. Endpoint shapes in BRIEF.md are ASSERTED, not live-verified in this build. Test fixtures are invented realistic payloads, not recordings of requests. Unknown location types become unknown; dates are not inferred from observation time. Descriptions may contain text published by the source; no personal records are requested. Basic entity conversion does not decode every HTML entity. Greenhouse employment type and posted date can be absent.

Intended pricing when published: pay per job row emitted. Store pricing, billing event configuration, and publication are owner gates; this local build does not charge money or configure paid events. No demand or revenue claims are made.

### Local run

Use Node.js >=18. With dependency access available, run `npm install`, then `npm test`. Tests use node:test, local synthetic fixtures, and injected HTTP responses; they require neither Apify installation nor network access. Run `npm start` after installing dependencies and supplying an Apify local INPUT.json in the default key-value store (normally storage/key_value_stores/default/INPUT.json). The Actor uses the Apify SDK v3 and default dataset/store. The Dockerfile uses the Apify Node 22 base image.

The inherited frontend directories and configs are outside this Actor's entrypoint and test command. The inherited package-lock.json was removed because it described a different application. Generate a fresh lockfile after dependency installation. An actual SDK startup, container build, live requests, and billing setup are not verified by the offline tests.

# Actor input Schema

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

Public ATS board tokens.

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

Cap on job rows emitted per company in one run.

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

Whether each job row should include the full posting description text.

## Actor input object example

```json
{
  "companies": [
    {
      "platform": "greenhouse",
      "board": "stripe"
    }
  ],
  "maxJobsPerCompany": 500,
  "includeDescription": false
}
```

# Actor output Schema

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

Dataset containing all normalized job postings

## `keyValueStore` (type: `string`):

Default key-value store holding the LAST_RUN_SUMMARY record

# 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": [
        {
            "platform": "greenhouse",
            "board": "stripe"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("your_friendly_developer/unified-ats-job-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": [{
            "platform": "greenhouse",
            "board": "stripe",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("your_friendly_developer/unified-ats-job-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": [
    {
      "platform": "greenhouse",
      "board": "stripe"
    }
  ]
}' |
apify call your_friendly_developer/unified-ats-job-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,your_friendly_developer/unified-ats-job-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/OKh2hi8gODZ8eCbGK/builds/xz106dLzHp9ZZEyKn/openapi.json
