# Employer Job Feeds: Greenhouse, Lever, Workday, Ashby + 9 more (`withinnoise/career-site-jobs`) Actor

Job openings read live from employers' own hiring platforms, in one clean schema. Name the companies, or search across 20,000+ employers at once. Covers Greenhouse, Lever, Workday, Ashby, SmartRecruiters and 8 more. Filter by title, location, remote and date, or get only new jobs each run.

- **URL**: https://apify.com/withinnoise/career-site-jobs.md
- **Developed by:** [Within Noise LLC](https://apify.com/withinnoise) (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.00 / 1,000 jobs

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

## Employer Job Feeds

Get job openings straight from employers' own hiring platforms, in one clean schema.

Most companies run their careers page on an applicant tracking system such as Greenhouse, Lever, Workday or Ashby. Each of those platforms publishes its open jobs in its own format. This Actor reads those official job feeds and returns every job in the same shape, with dates, locations, remote status, salary ranges and full descriptions. Name the companies you care about, or search across every employer in our directory at once.

Because the data comes from the employer's own system, it is the freshest and most complete source there is: no reposts, no expired listings, no aggregator in between.

### What you can do with it

- **Search every employer at once.** Turn on *Search across all employers*, give it a job title or a location, and get matching openings from tens of thousands of company career sites.
- **Track hiring at target accounts.** Give it your account list and get a feed of who is hiring for what. A new "Head of Data" or ten open SDR roles is a buying signal.
- **Fill a job board.** Pull openings from thousands of employers into one consistent format.
- **Monitor competitors.** See which teams they are growing and what they pay.
- **Get only what is new.** Turn on *Only jobs that are new since my last run*, put the Actor on a schedule, and each run returns just the newly posted jobs.
- **Feed an AI agent or a job-matching model** with structured, current openings.

### Supported platforms

| Platform | Posting date | Salary range | Description |
|---|---|---|---|
| Greenhouse | Yes | When the employer publishes it | Yes |
| Lever | Yes | When the employer publishes it | Yes |
| Ashby | Yes | When the employer publishes it | Yes |
| Workday | Yes (day-level) | No | Yes |
| Workable | Yes | No | Yes |
| SmartRecruiters | Yes | No | Yes |
| Recruitee | Yes | When the employer publishes it | Yes |
| BambooHR | Yes | Text, when published | Yes |
| Rippling | Yes | No | Yes |
| Teamtailor | Yes | When the employer publishes it | Yes |
| Personio | Yes | No | Yes |
| Pinpoint | No | When the employer publishes it | Yes |
| Breezy HR | Yes | Text, when published | No |

Salary fields are filled only from the structured pay range an employer published. They are never guessed from the description text.

### Two ways to use it

**1. Name the companies.** Give a list of companies and get their openings, filtered however you like.

**2. Search across all employers.** Turn on *Search across all employers* and set at least one title or location keyword. We keep an index of the open jobs at every employer in our directory, refreshed regularly. The index is used only to find which employers have matching jobs; each of those boards is then read live, so every job you get back is open at the moment of your run. A search stops at 1,000 jobs unless you set a different maximum.

You can combine the two: companies you name are always read first.

### Input

Each company entry can be any of these:

| You enter | Example |
|---|---|
| A job board URL (most reliable) | `https://boards.greenhouse.io/figma` |
| The company's own careers page | `https://www.notion.com/careers` |
| A `platform:slug` shorthand | `lever:palantir` |
| A Workday shorthand | `workday:nvidia.wd5/NVIDIAExternalCareerSite` |
| A company name | `duolingo` |

For a careers page, the Actor looks for the job board that page links to or embeds. For a bare company name, it tries the name on each platform and uses the first board that has open jobs; the run log tells you which board it picked, so check it the first time.

```json
{
    "companies": [
        "https://boards.greenhouse.io/figma",
        "https://jobs.ashbyhq.com/ramp",
        "lever:palantir",
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
    ],
    "titleKeywords": ["engineer", "data scientist"],
    "titleExcludeKeywords": ["intern"],
    "locationKeywords": ["United States", "Remote"],
    "postedWithinDays": 7,
    "onlyNewJobs": false,
    "includeDescription": true
}
```

A search across all employers looks like this:

```json
{
    "searchAllCompanies": true,
    "titleKeywords": ["data engineer", "analytics engineer"],
    "locationKeywords": ["United States", "Remote"],
    "postedWithinDays": 7,
    "maxResults": 500
}
```

When you name companies, all filters are optional. Title and location keywords match whole words, so `AI` does not match "Maintainer" and `US` does not match "Australia".

### Output

One item per job:

```json
{
    "id": "ashby:ramp:34413f8d-26bf-4bbc-8ade-eb309a0e2245",
    "ats": "ashby",
    "companySlug": "ramp",
    "companyName": "Ramp",
    "title": "Security Engineer, Cloud",
    "department": "Engineering",
    "team": "Backend",
    "location": "New York, NY (HQ)",
    "locations": ["New York, NY (HQ)", "Remote (Canada)", "Remote (US)", "Miami, FL"],
    "country": "USA",
    "workplaceType": "hybrid",
    "remote": false,
    "employmentType": "Full-time",
    "postedAt": "2026-04-07T17:12:35.753Z",
    "updatedAt": null,
    "url": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245",
    "applyUrl": "https://jobs.ashbyhq.com/ramp/34413f8d-26bf-4bbc-8ade-eb309a0e2245/application",
    "salaryMin": 211400,
    "salaryMax": 290600,
    "salaryCurrency": "USD",
    "salaryInterval": "year",
    "salaryText": "$211.4K – $290.6K • Offers Equity",
    "descriptionText": "ABOUT RAMP\n\nRamp is building the smart infrastructure for finance teams...",
    "scrapedAt": "2026-11-10T15:02:11.000Z"
}
```

`workplaceType` is `remote`, `hybrid`, `onsite`, or `null` when the employer gave no signal. `remote` is `null` in that same case rather than a guessed `false`.

A run summary is saved to the key-value store under `OUTPUT`: for each company, which board was read, how many jobs were open, how many matched your filters, and any error. For a search across all employers it also says how many employers had matches and when the index was last built.

### Pricing

You pay per job returned. Companies that fail to resolve, jobs removed by your filters, and jobs skipped by *Only new jobs* cost nothing. See the Pricing tab for the current rate. Set a maximum charge per run to cap your spend; the Actor stops cleanly when it reaches the cap.

### Things to know

- **Search coverage.** The directory holds the job boards we have found and verified on the 13 supported platforms. An employer that opened its board very recently may not be in it yet; name that company directly and it will be read all the same.
- **Large employers work.** Workday shows at most 2,000 jobs per query; for bigger boards the Actor reads the board category by category and merges the result.
- **Speed.** Most platforms return a whole company in one request. Workday, SmartRecruiters, BambooHR and Rippling need one extra request per job for the description, so turn off *Include the job description* when you only need titles and links.
- **Workday dates** come from "Posted 3 Days Ago" in the listing and are exact to the day. Jobs shown as "Posted 30+ Days Ago" get their exact date when descriptions are included.
- **Remote detection** uses the employer's own remote flag where the platform has one, and otherwise the word "remote" or "hybrid" in the title or location.
- **Company names.** Lever, Ashby, Workday and a few others do not name the employer in their feed, so `companyName` is derived from the board address there (for example `acme-robotics` becomes "Acme Robotics").

### Is this allowed?

The Actor reads the public job feeds that hiring platforms publish so that openings can be shown on career pages and shared with job boards. It does not log in anywhere, does not bypass any access control, and collects no personal data: only job postings that employers published in order to be found.

### Feedback

Missing a platform, or a company that does not resolve? Open an issue on the Issues tab with the careers page URL.

# Actor input Schema

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

One entry per company. Any of these work: a job board URL (https://boards.greenhouse.io/stripe), the company's own careers page (https://www.notion.com/careers), a platform:slug shorthand (lever:palantir, workday:nvidia.wd5/NVIDIAExternalCareerSite), or just a company name (duolingo). A job board URL is the most reliable. Leave empty if you only want to search across all employers.

## `searchAllCompanies` (type: `boolean`):

Search the job boards of every employer in our directory (tens of thousands of companies) instead of naming them. Needs at least one title keyword or location keyword below. Matching employers are found through a daily index, then each one's board is read live, so every job returned is open right now. Stops at 1,000 jobs unless you set a different maximum.

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

Keep a job only when its title contains at least one of these words or phrases. Whole words only, so "AI" does not match "Maintainer". Leave empty to keep every title.

## `titleExcludeKeywords` (type: `array`):

Drop a job when its title contains any of these words or phrases, for example intern, manager, director.

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

Keep a job only when one of its locations contains at least one of these, for example "United States", "New York", "London", "Remote". Checked against every location the employer listed for the job.

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

Keep only jobs the employer marked as remote, or that say remote in the title or location. Jobs with no remote signal are dropped.

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

Keep only jobs posted in the last N days. Jobs whose platform publishes no posting date are dropped when this is set. Leave empty for no date filter.

## `onlyNewJobs` (type: `boolean`):

Remembers which jobs it has already returned to you and skips them next time. Turn this on for a scheduled run and you get a feed of newly posted jobs and pay only for those.

## `stateName` (type: `string`):

Only used with "Only jobs that are new". Runs that share a memory name share one memory of jobs already returned. Use different names for independent feeds.

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

Return the full job description as plain text. Turning this off makes runs faster on Workday, SmartRecruiters, BambooHR and Rippling, where the description needs one extra request per job.

## `includeHtml` (type: `boolean`):

Adds descriptionHtml with the employer's original formatting. Off by default to keep results small.

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

Stop after this many jobs for each company. Leave empty or 0 for no limit.

## `maxResults` (type: `integer`):

Stop the whole run after this many jobs. Leave empty or 0 for no limit.

## Actor input object example

```json
{
  "companies": [
    "https://boards.greenhouse.io/figma",
    "https://jobs.ashbyhq.com/ramp",
    "lever:palantir"
  ],
  "searchAllCompanies": false,
  "remoteOnly": false,
  "onlyNewJobs": false,
  "stateName": "default",
  "includeDescription": true,
  "includeHtml": false,
  "maxJobsPerCompany": 0,
  "maxResults": 0
}
```

# Actor output Schema

## `jobs` (type: `string`):

One item per job opening, all platforms in the same schema.

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

Per company: which job board was read, how many jobs were open, how many matched the filters, and any error.

# 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": [
        "https://boards.greenhouse.io/figma",
        "https://jobs.ashbyhq.com/ramp",
        "lever:palantir"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("withinnoise/career-site-jobs").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": [
        "https://boards.greenhouse.io/figma",
        "https://jobs.ashbyhq.com/ramp",
        "lever:palantir",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("withinnoise/career-site-jobs").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": [
    "https://boards.greenhouse.io/figma",
    "https://jobs.ashbyhq.com/ramp",
    "lever:palantir"
  ]
}' |
apify call withinnoise/career-site-jobs --silent --output-dataset

```

## MCP server setup

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

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/7iJe6EICaWdcVWV73/builds/ocfDUUuQ2fwYzVlmS/openapi.json