# Greenhouse, Lever, Ashby & Workable Job Postings (`scaleturn/career-site-job-feed`) Actor

Job postings API and scraper for Greenhouse, Lever, Ashby and Workable career sites. Enter company names, careers pages or board links; it finds the ATS and returns all open jobs in one schema, with salary where published. Only-new-jobs monitor. No login. $1.40-2/1,000 jobs, $1/1,000 boards.

- **URL**: https://apify.com/scaleturn/career-site-job-feed.md
- **Developed by:** [Sanjaya Maharjan](https://apify.com/scaleturn) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 job returneds

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

This Actor is a job postings API and scraper for company career sites on **Greenhouse, Lever, Ashby and Workable**, such as Discord, Spotify, Linear or Hugging Face. Give it a list of companies, careers-page URLs or board links. It works out which applicant tracking system (ATS) each company uses, reads that ATS's public job-board API and returns every open job as one row in one consistent format. No login, API key or browser is needed.

Turn on **incremental mode** and schedule the Actor to get a job feed: each run then returns only the jobs that are new since the last run, plus a free notice for each job that has closed.

- **What you get:** one row per open job with title, company, location, remote flag, department, employment type, salary where the employer publishes it, posting date, full description, job link and apply link.
- **From:** Greenhouse, Lever (US and EU accounts), Ashby and Workable job boards.
- **Input:** company names, careers-page URLs, ATS board links or `ats:token` pairs, one per line.
- **Price:** USD 2.00 per 1,000 jobs on Apify's Free plan, down to USD 1.40 per 1,000 on Gold and higher plans, plus USD 1.00 per 1,000 company boards checked and Apify's small start fee (see Pricing).

A real Linear posting on Ashby, recorded on 2026-11-07 and shown as the Actor outputs it for the input `https://jobs.ashbyhq.com/linear` (description shortened; Ashby publishes no company name, so `company` is the board token):

```json
{
    "id": "ashby:linear:12f8f208-0b9c-4569-bb3d-41c8a197029e",
    "ats": "ashby",
    "boardToken": "linear",
    "company": "linear",
    "title": "Senior / Staff Product Engineer",
    "location": "North America",
    "remote": true,
    "department": "Product",
    "employmentType": "Full-time",
    "salary": "$240K - $320K",
    "postedAt": "2026-03-04T02:08:44.483Z",
    "updatedAt": null,
    "jobUrl": "https://jobs.ashbyhq.com/linear/12f8f208-0b9c-4569-bb3d-41c8a197029e",
    "applyUrl": "https://jobs.ashbyhq.com/linear/12f8f208-0b9c-4569-bb3d-41c8a197029e/application",
    "description": "At Linear, we're building the product development system for teams and agents. AI is funda ..."
}
```

*Not affiliated with or endorsed by Greenhouse, Lever, Ashby or Workable; the Actor uses the public job-board endpoints they publish.*

### How to scrape Greenhouse, Lever, Ashby and Workable jobs

1. In **Companies, careers-page URLs or board tokens**, enter one company per line: an ATS board link (`https://jobs.lever.co/metabase`), an `ats:token` pair (`greenhouse:discord`), a careers-page URL or just a company name.
2. Optionally narrow the jobs with **Job title contains**, **Location contains**, **Remote jobs only** or **Posted within the last N days**.
3. Click **Start**. The jobs appear in the **Output** tab. Export them as JSON, CSV or Excel, or read them with the API (see below).
4. To get only new jobs every day, turn on **Only new jobs (incremental mode)** and schedule the Actor (see "Incremental mode and scheduling").

### What it does

- **Four ATSs in one Actor.** Greenhouse, Lever (US and EU), Ashby and Workable.
- **Detects the ATS for you.** Paste an ATS board link, a company's own careers page, an `ats:token` pair or just a company name.
- **One schema for every ATS.** Title, company, location, remote flag, department, employment type, salary (where published), posted date, job and apply links, plain-text description and a stable job id.
- **Filters.** Keep only jobs whose title or location contains your keywords, remote jobs, or jobs posted in the last N days. Only jobs that match are output.
- **Only new jobs, on a schedule.** Incremental mode remembers which jobs it has already returned for each board, and reports jobs that have closed since the last run, free of charge.
- **Failures stay contained.** If one board fails (for example a wrong token), the run carries on with the others and reports the failure in a per-board run report. You are not charged for failed boards.
- **Uses public job-board APIs only.** No login, no browser, no proxies. These are the job-board APIs each ATS vendor publishes so that its customers' open jobs can be shown on careers sites.

### Use cases

- **Job boards and aggregators.** Fill a niche job board with the open roles of a list of target companies. A daily incremental run adds the new jobs and tells you which ones to take down.
- **Recruiting and sales tools.** Watch which companies are hiring, for which roles and where. New postings are a buying signal.
- **Market research.** Track hiring by company, department, location or remote share over time.

### Supported ATSs and accepted input

| ATS | Board URL forms recognised | Explicit form |
|---|---|---|
| Greenhouse | `boards.greenhouse.io/{token}`, `job-boards.greenhouse.io/{token}`, embed script `boards.greenhouse.io/embed/job_board/js?for={token}` | `greenhouse:{token}` |
| Lever | `jobs.lever.co/{site}`, EU accounts `jobs.eu.lever.co/{site}` | `lever:{site}` (US accounts) |
| Ashby | `jobs.ashbyhq.com/{name}` (also the embed script) | `ashby:{name}` |
| Workable | `apply.workable.com/{account}`, `{account}.workable.com` | `workable:{account}` |

Each line of the **companies** input can be:

1. **An ATS board URL**, for example `https://jobs.lever.co/palantir`. No detection requests are needed.
2. **An explicit `ats:token`**, for example `greenhouse:stripe`. The fastest and most precise form.
3. **A company's own careers page**, for example `https://www.figma.com/careers/`. The Actor loads that one page and looks for a link to, or an embed of, one of the four ATSs. It also follows a redirect from that page to an ATS board.
4. **A bare company name or token**, for example `Hugging Face`. The Actor tries the name (as given when it has no spaces, squashed to `huggingface` and hyphenated to `hugging-face`) on all four ATS APIs and keeps the board with the most open jobs. This is a guess, so the run report marks the row with `"resolvedBy": "name-probe"` and the company name the ATS publishes, and the log shows a warning.

Forms 1 and 2 are the most reliable. Use 3 and 4 when you do not know the board.

Greenhouse and Ashby ignore letter case in board names, so `ashby:PineCone` and `jobs.ashbyhq.com/pinecone` are the same board: it is read and charged once, and its job ids are always lower case. Lever and Workable board names are case-sensitive and are used as given.

### Input example

```json
{
    "companies": [
        "greenhouse:discord",
        "https://jobs.ashbyhq.com/linear",
        "https://jobs.lever.co/metabase",
        "https://apply.workable.com/huggingface/",
        "https://www.figma.com/careers/",
        "Duolingo"
    ],
    "titleKeywords": ["engineer", "product manager"],
    "remoteOnly": false,
    "includeDescription": true,
    "incremental": false
}
```

| Field | Default | What it does |
|---|---|---|
| `companies` | required | One entry per company, in any of the forms above. |
| `titleKeywords` | empty | Keep only jobs whose title contains at least one of these words or phrases (not case-sensitive). |
| `locationKeywords` | empty | Keep only jobs whose location contains at least one of these words (not case-sensitive). |
| `remoteOnly` | `false` | Keep only jobs marked remote. |
| `postedWithinDays` | empty | Keep only jobs posted in the last N days. Jobs without a posting date are left out when this is set. |
| `includeDescription` | `true` | Adds the plain-text job description. Turn it off for smaller, faster output. |
| `incremental` | `false` | Return only jobs not returned by earlier runs, plus closed-job notices (see below). |
| `stateStoreName` | `career-site-job-feed-state` | Name of the key-value store that keeps incremental state. Use one name per independent monitor. |

A job must pass every filter you set. Only jobs that pass are output and charged.

### Output

One dataset item per job. Two real postings as the Actor outputs them (descriptions shortened). A Lever job with a published salary, from a recorded posting, as the input `lever:matchgroup` returns it:

```json
{
    "id": "lever:matchgroup:69396299-e587-4063-aef6-0ce2fd66e9ee",
    "ats": "lever",
    "boardToken": "matchgroup",
    "company": "matchgroup",
    "title": "AI Product Engineer",
    "location": "Vancouver, British Columbia",
    "remote": false,
    "department": "Match Group",
    "employmentType": "Internship",
    "salary": "CAD 35-38 per-hour-wage",
    "postedAt": "2026-09-18T16:14:22.697Z",
    "updatedAt": null,
    "jobUrl": "https://jobs.lever.co/matchgroup/69396299-e587-4063-aef6-0ce2fd66e9ee",
    "applyUrl": "https://jobs.lever.co/matchgroup/69396299-e587-4063-aef6-0ce2fd66e9ee/apply",
    "description": "Know where you belong!\n\nMatch Group is a leading provider of dating products across the gl ..."
}
```

A Greenhouse job from a test run (Greenhouse publishes no employment type or salary field):

```json
{
    "id": "greenhouse:discord:8917177002",
    "ats": "greenhouse",
    "boardToken": "discord",
    "company": "Discord",
    "title": "Associate Commercial Counsel",
    "location": "San Francisco Bay Area or Remote (U.S.)",
    "remote": true,
    "department": "Legal",
    "employmentType": null,
    "salary": null,
    "postedAt": "2026-11-03T16:27:16.000Z",
    "updatedAt": "2026-11-03T16:31:51.000Z",
    "jobUrl": "https://job-boards.greenhouse.io/discord/jobs/8917177002",
    "applyUrl": "https://job-boards.greenhouse.io/discord/jobs/8917177002",
    "description": "Discord has a highly engaged community of millions of daily active users ..."
}
```

| Field | Notes |
|---|---|
| `id` | Stable id, `ats:boardToken:atsJobId`. The same job keeps the same id from run to run. |
| `ats`, `boardToken` | Where the job came from. |
| `company` | Company name as published by the ATS. Lever and Ashby do not publish one, so for them it is the name you entered, or the board token. |
| `title`, `location` | As published. Several locations are joined with `; ` (Workable lists a job once per location; the Actor merges them into one job). |
| `remote` | `true` for remote jobs. Lever, Ashby and Workable publish a workplace or remote field; for Ashby and Lever, hybrid counts as not remote, and Lever falls back to the location text when the workplace type is unspecified. Greenhouse has no such field, so it is `true` when the location text contains the word "remote". |
| `department` | Greenhouse departments, Lever department or team, Ashby department or team, Workable department. |
| `employmentType` | For example `Full-time`. Greenhouse does not publish it, so it is always `null` there. |
| `salary` | Lever: the published salary range, for example `CAD 35-38 per-hour-wage`. Ashby: the published compensation summary, for example `$240K - $320K`. `null` when not published and for the other ATSs. |
| `postedAt` | Posting date in ISO 8601: Greenhouse first published, Lever created, Ashby published, Workable published (a date only). |
| `updatedAt` | Last update in ISO 8601, Greenhouse only. |
| `jobUrl`, `applyUrl` | Job page and application page. |
| `description` | Plain text with line breaks and `- ` bullets, as written by the employer: for Lever, the intro, the lists (such as requirements and benefits) and the closing text. `null` when descriptions are off. |
| `changeType` | Incremental mode only. `"closed"` on a free notice for a job that has closed since the last run; such an item has only `id`, `ats`, `boardToken`, `company` and `changeType`. Not present on job items. |

The Actor does not output recruiter or hiring-manager names, emails or phone numbers.

#### Run report

Each run also writes an `OUTPUT` record to the run's key-value store (the **Run report** output) with one row per input entry:

```json
{
    "boards": [
        { "input": "greenhouse:discord", "ats": "greenhouse", "boardToken": "discord", "status": "ok",
          "jobsFound": 27, "jobsNew": 27, "jobsPushed": 27, "jobsClosed": 0 },
        { "input": "Duolingo", "ats": "greenhouse", "boardToken": "duolingo", "status": "ok",
          "jobsFound": 59, "jobsNew": 59, "jobsPushed": 59, "jobsClosed": 0,
          "resolvedBy": "name-probe", "atsCompanyName": "Duolingo" },
        { "input": "lever:nosuchboard12345", "ats": "lever", "boardToken": "nosuchboard12345", "status": "failed",
          "jobsFound": 0, "jobsNew": 0, "jobsPushed": 0, "jobsClosed": 0,
          "error": "HTTP 404 for https://api.lever.co/v0/postings/nosuchboard12345?mode=json" }
    ],
    "boardsOk": 2,
    "boardsFailed": 1,
    "jobsPushed": 86,
    "chargeLimitReached": false
}
```

- `status` is `ok`, `failed` (the board could not be found or loaded; nothing was charged), `skipped` (a duplicate of an earlier entry, or the run's spending limit was already reached) or `limited` (the spending limit was reached while this board's jobs were being output).
- `jobsFound` counts the board's open jobs that pass your filters, `jobsNew` those not returned before (all of them without incremental mode), `jobsPushed` those in the dataset, and `jobsClosed` the closed-job notices.
- `resolvedBy: "name-probe"` marks a board found by trying a bare name. `atsCompanyName` is the company name Greenhouse or Workable publishes for that board (`null` for Lever and Ashby, which publish none). Check it: a generic name such as `Remote` can match another company's board.

### Incremental mode and scheduling

With **incremental** on, the Actor keeps, for each board, the ids of the jobs it has returned. They live in a named key-value store in your account (`stateStoreName`), so they survive between runs.

- The **first run** returns every open job and saves the ids.
- **Later runs** return only jobs whose id has not been returned before. If nothing is new, you pay nothing for jobs.
- A job that has **closed** since the last run (or no longer matches your filters) comes back once as `{ "id": ..., "changeType": "closed" }`, free of charge, and is then forgotten. A job that the employer re-posts under a new id counts as new.
- Jobs that were not delivered because the spending limit was reached are not marked as seen, so a later run delivers them.
- If Apify restarts a run (for example when it moves the run to another server), jobs already in the run's dataset are not output or charged again.

To set up a monitor:

1. Create a **task** for this Actor with your company list and **incremental** on.
2. Give it its own **state store name**, for example `jobs-monitor-fintech`. Two tasks that share a name share their memory of seen jobs, so one would hide new jobs from the other.
3. Add a **schedule** to the task, for example once a day.
4. Read each run's dataset, or connect an integration or webhook to receive the new jobs and closed notices.

To start over and get every job again, use a new state store name or delete the store.

### Pricing

The Actor is priced **per event**. The run's Apify platform usage is included in these prices:

- **Jobs returned:** the price per job depends on your Apify plan.

  | Apify plan | Per 1,000 jobs | Per job |
  |---|---|---|
  | Free | USD 2.00 | USD 0.002 |
  | Bronze | USD 1.80 | USD 0.0018 |
  | Silver | USD 1.60 | USD 0.0016 |
  | Gold and higher | USD 1.40 | USD 0.0014 |

- **USD 1.00 per 1,000 company boards checked** (USD 0.001 per board per run) on every plan, including runs that find no new jobs.

- Apify's Actor start fee of **USD 0.00005 per GB of memory per run** (one start event per GB, minimum one), which is USD 0.05 per 1,000 runs at 1 GB.

Each run lists the events it charged. Example: a daily monitor of 30 companies costs USD 0.03 a day for the checks, plus USD 0.0014 to 0.002 for each new job it finds, depending on your plan.

- You pay for jobs written to the dataset. Closed-job notices are free.
- Boards that fail cost nothing.
- With filters, only matching jobs are charged.
- In incremental mode, jobs already returned by earlier runs are not returned again, so they are not charged again.
- You can set a maximum total charge for a run (Apify's minimum for this Actor is USD 0.005). When it is reached, the Actor stops outputting jobs and Apify then stops the run. Jobs already output are recorded as delivered, so incremental runs do not charge them again. If Apify stops the run before it ends, the run report may be missing; the dataset holds every job you paid for.

On the Free plan, Apify's USD 5 of free monthly usage covers roughly 2,000 jobs from this Actor (fewer if you check many boards or start many runs).

### Use via API

Run the Actor and get its jobs in one call (replace `YOUR_API_TOKEN`):

```bash
curl -X POST "https://api.apify.com/v2/acts/scaleturn~career-site-job-feed/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["greenhouse:discord", "https://jobs.lever.co/metabase"], "includeDescription": false}'
```

For long lists, start a run asynchronously and read the dataset when it finishes. You can also use the Apify JavaScript or Python client, webhooks, schedules and integrations (for example Make, Zapier, n8n, Google Sheets or Slack) to send new jobs where you need them. AI agents can find and run the Actor as a tool through the [Apify MCP server](https://docs.apify.com/mcp).

### Speed

Measured on 2026-11-07 from a single machine (your speed on the platform will differ): 33 boards with 3,204 jobs, descriptions on, took 14 to 35 seconds in three runs. An incremental run over the same boards with nothing new took 39 seconds, because every board is still read in full.

### Limits

- **Only these four ATSs.** SmartRecruiters, Workday, iCIMS, Taleo, SuccessFactors, Teamtailor and other systems are not supported. Neither are LinkedIn, Indeed or other job sites.
- **Careers-page detection reads one page as plain HTML.** If the page loads its job list with JavaScript from a source other than these ATSs, or only shows job links after interaction, nothing is found and the entry is reported as failed. Use the ATS board URL or `ats:token` instead.
- **Bare names are a best guess.** A name is tried on all four ATSs and the board with the most jobs wins. A different company that uses the same token on another ATS could be picked; the run report flags such rows. Use an explicit form when it matters.
- **Lever EU accounts** are reached only through a `jobs.eu.lever.co` URL (tested with Lever's own EU demo board); `lever:token` and name probing use the US API.
- **Greenhouse** is read from its public job-board API host only; Greenhouse boards hosted in its EU region are not covered.
- **Ashby** postings marked as unlisted (reachable by direct link only) are left out, matching the public board.
- **Filters work on the published fields.** The remote filter uses the `remote` field described above; the date filter uses `postedAt`.
- **Data is as published.** Fields the employer leaves empty are `null`. Descriptions are passed through as written and may include contact details the employer chose to publish.
- **The ATS APIs can change.** If a vendor changes or withdraws its public API, the affected boards will fail until the Actor is updated.

### FAQ

**How is this different from a LinkedIn or Indeed jobs scraper?** It reads each employer's own job board, the original posting rather than a job site's copy of it. Jobs appear as soon as the employer posts them, closed jobs disappear in the same run, there are no reposts or promoted duplicates, and nothing needs a login, cookies or proxies. It covers only the companies you list (or that it can find from a name or careers page) and only these four ATSs; it does not search all jobs on the web by keyword.

**Can I search jobs by keyword instead of listing companies?** Not with this Actor: it reads the boards of the companies you give it. To search open jobs by keyword across many companies' career sites without listing them first, use our [ATS Jobs Search](https://apify.com/scaleturn/ats-jobs-search) Actor.

**Is it legal to use this data?** The Actor reads only public job-board endpoints that the ATS vendors publish for showing open jobs: Greenhouse documents its Job Board API as public with no authentication for reading, Lever's Postings API documentation says published jobs "may be scraped by third parties", and Ashby and Workable document their public job-board endpoints for their customers' careers pages. It reads job postings only and outputs no personal data about recruiters or hiring managers. How you use the data is your responsibility; if in doubt about your use case, ask a lawyer. This is not legal advice.

**Is it affiliated with the ATS vendors?** No. It is not affiliated with or endorsed by Greenhouse, Lever, Ashby or Workable.

**Why is a company missing?** Either it uses an ATS this Actor does not support, or its careers page does not link to its board in plain HTML. Find the board link (it usually appears when you open a job) and enter that instead.

**Can I get the data into my own system?** Yes: through the API call above, a webhook when a run finishes, or an Apify integration.

### How it is tested

- Unit tests with recorded responses from each of the four ATS APIs, plus tests for detection, letter case, incremental state and closed notices, filters, spending-limit handling, restarts, retries and per-host request limits. End-to-end tests run the Actor with the Apify SDK's pay-per-event simulation.
- Lever sometimes publishes a posting's plain-text intro and closing as empty while the formatted (HTML) version is full. The Actor then converts the formatted version to text, so the description is complete. A test with real postings recorded on 2026-11-16 covers this.
- On 2026-11-07 the Actor was run on 33 real company boards (10 Greenhouse, 8 Lever, 9 Ashby, 6 Workable), entered in all four input forms. For every board, the number of jobs it returned matched the number of postings in the ATS's own public API, and every job id in the output was unique.
- Incremental mode was checked live on the same boards: the first run returned all 3,204 jobs, an immediate second run returned none, and after one job was removed from the saved state and one closed job added, a third run returned exactly that job and one closed notice.

### Politeness

The Actor sends at most 4 requests at a time to each ATS host, uses timeouts, and retries rate-limited (HTTP 429) or failed (HTTP 5xx) requests with growing, randomised pauses. It identifies itself with a generic `career-site-job-feed/1.0` user agent.

# Actor input Schema

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

One entry per line. Accepted forms: an ATS board URL (boards.greenhouse.io/stripe, job-boards.greenhouse.io/reddit, jobs.lever.co/palantir, jobs.eu.lever.co/name, jobs.ashbyhq.com/notion, apply.workable.com/huggingface or name.workable.com); a company's own careers-page URL, which is scanned for an ATS link or embed; an explicit 'ats:token' such as greenhouse:stripe, lever:palantir, ashby:notion or workable:huggingface; or a bare company name or token, which is tried on all four ATS APIs.

## `titleKeywords` (type: `array`):

Output only jobs whose title contains at least one of these words or phrases (not case-sensitive), for example 'engineer' or 'product manager'. Leave empty for all titles. Only jobs that are output are charged.

## `locationKeywords` (type: `array`):

Output only jobs whose location contains at least one of these words (not case-sensitive), for example 'Berlin' or 'United Kingdom'. Leave empty for all locations.

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

Output only jobs marked remote.

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

Output only jobs posted in the last N days. Jobs without a posting date are left out when this is set. Leave empty for any date.

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

Adds the plain-text job description to each job. Turn off for smaller, faster output.

## `incremental` (type: `boolean`):

Remembers the job ids returned for each board in a named key-value store and returns only jobs not returned before. Jobs that have closed since the last run come back once as a free notice with changeType 'closed'. The first run returns every open job. Use with a schedule to monitor boards.

## `stateStoreName` (type: `string`):

Name of the key-value store that holds the seen job ids. Use a different name for each independent monitor (for example one per schedule), so they do not share state.

## Actor input object example

```json
{
  "companies": [
    "greenhouse:discord",
    "https://jobs.ashbyhq.com/linear",
    "https://jobs.lever.co/metabase"
  ],
  "remoteOnly": false,
  "includeDescription": true,
  "incremental": false,
  "stateStoreName": "career-site-job-feed-state"
}
```

# Actor output Schema

## `results` (type: `string`):

One item per open job, plus free closed-job notices in incremental mode.

## `runReport` (type: `string`):

One row per input entry: board, status (ok, failed, skipped, limited) and job counts.

# 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:discord",
        "https://jobs.ashbyhq.com/linear",
        "https://jobs.lever.co/metabase"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scaleturn/career-site-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": [
        "greenhouse:discord",
        "https://jobs.ashbyhq.com/linear",
        "https://jobs.lever.co/metabase",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scaleturn/career-site-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": [
    "greenhouse:discord",
    "https://jobs.ashbyhq.com/linear",
    "https://jobs.lever.co/metabase"
  ]
}' |
apify call scaleturn/career-site-job-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scaleturn/career-site-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/7W9n5lHdacur4ZlWd/builds/KfRJdl9VMSq0AGu6L/openapi.json
