# Career Site Job Search API: Workday, Greenhouse, Lever & More (`makerio/career-site-job-search`) Actor

Search open jobs by title across 17,000+ company career sites on Workday, Greenhouse, Lever, Ashby, SmartRecruiters, Workable, BambooHR, Personio, Teamtailor, Rippling and Recruitee. Live data read at run time, with location, remote, date and salary filters, full descriptions and new-job monitoring.

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

## Pricing

from $5.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.

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

Type a job title and get the newest matching jobs from **17,000+ company career sites** at once: every employer in our directory that hires through Workday, Greenhouse, Lever, Ashby, SmartRecruiters, BambooHR, Personio, Teamtailor, Rippling or Recruitee, plus every employer on Workable. The data is **live**: every run reads the career sites at that moment, through the same public job APIs the sites use themselves. No stale database, no login, no proxies.

**Try it in about a minute.** Click **Try for free** and run the example as it is. It searches "data engineer" for 30 seconds and returns the 10 newest matches it finds. A run on November 16, 2026 returned jobs like these, all posted that day:

| Company | Job title | Location | Salary |
|---|---|---|---|
| Defense Unicorns | Data Engineer - Agentic AI | Springfield, VA | $148,750 – $201,250 per year |
| FanDuel | Data Engineer | Edinburgh, United Kingdom | |
| Insight Investment | Principal Data Engineer - Contract | London, United Kingdom | |

Each job also has the full description, posting date, every location, remote type, employment type, seniority and the apply link. Then type your own job title, add `locations` ("US", "Germany", "Remote") or `postedWithinDays`, and raise the search time to 300 seconds to read every site.

### What you can do with it

- **Find jobs before they spread to job boards.** Companies post on their own career site first. Search all of them in one run.
- **Build a niche job board or alert.** Schedule the Actor daily with "Only jobs not returned before" and get just the new postings.
- **Track hiring for a role or skill.** See which companies are hiring "Kubernetes" engineers or "clinical research" staff this week.
- **Feed a recruiting or sales pipeline.** Hiring is a buying signal. Export jobs with company, location, salary and link.

### How it works

1. You enter a job title or keyword. It must appear in the job title, so "data engineer" finds "Senior Data Engineer" and "Data Engineering Manager", not every job that mentions data.
2. The Actor reads the job lists of every career site in the directory (Workable through its own job search across all its employers), keeps the matching titles and applies your filters. A search takes about 2 minutes.
3. Matches are ranked newest first, duplicates are removed (many employers post one job on several sites), and each company is capped so a few big employers do not fill the result.
4. Full details are loaded only for the jobs you get back: description, exact posting date, all locations, salary when published, and the apply link.

### Input

| Field | What it does |
|---|---|
| `searchText` | Job title or keyword. Required. Whole words, any letter case, common endings included. |
| `locations` | Cities, regions, countries, two-letter country codes or `Remote`. Checked against every location of a job. |
| `remoteOnly` | Keep only remote jobs. |
| `postedWithinDays` | Keep only jobs published in the last N days. |
| `maxJobs` | Stop after this many jobs. Also caps the cost. |
| `maxJobsPerCompany` | At most this many jobs from one company. |
| `ats` | Search only some platforms. |
| `companies` | Search only these companies (names or career site URLs). |
| `excludeTitleKeywords` | Drop titles with these words, for example `intern`. |
| `descriptionKeywords` | Keep jobs whose description mentions any of these terms. |
| `employmentTypes` | `full_time`, `part_time`, `contract`, `temporary`, `internship`. |
| `requireSalary` | Keep only jobs with a published pay range. |
| `descriptionFormat` | `text` (default), `html`, `both` or `none`. |
| `onlyNewJobs`, `stateKey` | Return only jobs not returned by earlier runs of the same monitor. |
| `maxSearchSeconds` | Stop reading new career sites after this many seconds (default 90). Sites are read biggest first, so the default finds about 90% of the matches; set 300 to read every site. |

Example: remote data engineer jobs in the US from the last week.

```json
{
    "searchText": "data engineer",
    "locations": ["US", "United States", "Remote"],
    "remoteOnly": true,
    "postedWithinDays": 7,
    "maxJobs": 100,
    "maxJobsPerCompany": 3
}
```

More examples:

Registered nurse jobs from hospital career sites, posted in the last 3 days, without travel or per diem roles (124 jobs in our test run).

```json
{
    "searchText": "registered nurse",
    "postedWithinDays": 3,
    "excludeTitleKeywords": ["travel", "per diem"],
    "maxJobs": 200,
    "maxJobsPerCompany": 10
}
```

Ready-made versions of these searches are on the **Example tasks** tab: remote software engineers, new data engineer jobs, registered nurses, product managers with salary, AI engineers, a daily machine learning job alert, software engineers in London, companies hiring SDRs, accountants in the US and cybersecurity jobs.

Product manager jobs that publish a salary, from Greenhouse, Lever and Ashby only (mostly tech companies and startups).

```json
{
    "searchText": "product manager",
    "ats": ["greenhouse", "lever", "ashby"],
    "requireSalary": true,
    "maxJobs": 100
}
```

Python developer jobs that mention Django or FastAPI in the description, as plain text.

```json
{
    "searchText": "python developer",
    "descriptionKeywords": ["Django", "FastAPI"],
    "descriptionFormat": "text"
}
```

A daily alert: schedule this input once a day and each run returns only the jobs that earlier runs did not return. Runs with the same `stateKey` share their memory.

```json
{
    "searchText": "machine learning engineer",
    "locations": ["Remote"],
    "onlyNewJobs": true,
    "stateKey": "ml-remote",
    "maxJobs": 100
}
```

### Output

Every job has the same fields, whatever platform it came from. A field is `null` when the company did not publish it.

A job from a "data engineer" search, shortened:

```json
{
    "id": "ashby:first-resonance:326cdc16-c3ee-46ee-a759-a65524f37db2",
    "ats": "ashby",
    "companyName": "First Resonance",
    "title": "Data Engineer",
    "department": "Engineering",
    "location": "Los Angeles",
    "locations": ["Los Angeles"],
    "workplaceType": "onsite",
    "isRemote": false,
    "employmentType": "full_time",
    "seniority": null,
    "salaryMin": 140000,
    "salaryMax": 180000,
    "salaryCurrency": "USD",
    "salaryInterval": "year",
    "salaryText": "$140K – $180K • Offers Commission",
    "postedAt": "2026-11-16T00:00:00.000Z",
    "url": "https://jobs.ashbyhq.com/first-resonance/326cdc16-c3ee-46ee-a759-a65524f37db2",
    "applyUrl": "https://jobs.ashbyhq.com/first-resonance/326cdc16-c3ee-46ee-a759-a65524f37db2/application",
    "descriptionText": "We're looking for a full-time Data Engineer to build the data platform behind ..."
}
```

That search returned jobs from Greenhouse, Ashby, Workday, Workable, SmartRecruiters and Lever in one list, from companies such as Illumina, Caterpillar, Roblox, AECOM, Wise and Bristol-Myers Squibb.

A run summary is saved as `SUMMARY` in the key-value store: how many boards were searched, how many jobs matched, how many were returned per platform.

### Use it from your code

Call the Actor through the [Apify API](https://docs.apify.com/api/v2) with your API token (Console > Settings > API & Integrations). The simplest way is one request that runs a search and returns the jobs as JSON:

```bash
curl -X POST "https://api.apify.com/v2/acts/makerio~career-site-job-search/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchText": "data engineer", "remoteOnly": true, "postedWithinDays": 7, "maxJobs": 50}'
```

Python, with `pip install apify-client`:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("makerio/career-site-job-search").call(run_input={
    "searchText": "data engineer",
    "remoteOnly": True,
    "postedWithinDays": 7,
    "maxJobs": 50,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["postedAt"][:10], job["companyName"], "|", job["title"], "|", job["url"])
```

JavaScript, with `npm install apify-client`:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('makerio/career-site-job-search').call({
    searchText: 'data engineer',
    remoteOnly: true,
    postedWithinDays: 7,
    maxJobs: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const job of items) console.log(job.companyName, '|', job.title, '|', job.url);
```

To get new jobs every day without code, open the Actor in Apify Console, save the input as a task, add a schedule, and connect the result to Google Sheets, Slack, email or a webhook under **Integrations**.

### Coverage

| Platform | Career sites | Open jobs |
|---|---|---|
| Workday | 3,370 sites of 2,099 employers | 754,000 |
| SmartRecruiters | 667 companies | 201,000 |
| Greenhouse | 4,032 boards | 167,000 |
| Ashby | 2,214 boards | 52,000 |
| Lever | 271 boards | 26,000 |
| BambooHR | 3,568 career sites | 28,000 |
| Personio | 1,399 career sites | 15,000 |
| Teamtailor | 548 career sites | 9,000 |
| Rippling | 1,105 career sites | 13,000 |
| Recruitee | 127 career sites | 3,000 |
| Workable | every employer on Workable, through its job search | |

Together about 1.3 million open jobs, plus Workable's. The directory is built from public web crawls and grows over time. A company that is missing can still be searched: put its career site URL into `companies`. That also works for SAP SuccessFactors career sites on a company's own domain, such as `careers.ey.com` or `jobs.bayer.com`; they have no public list, so they are searched only when you name them.

### Pricing

Pay per event, no subscription:

- **$0.03 per search.** One search reads every career site in the directory, however many jobs it finds.
- **$5 per 1,000 jobs returned** ($0.005 per job). Filters run before you are charged, so you pay only for jobs you get.

A search that returns 50 jobs costs $0.28. Set `maxJobs` or a maximum cost per run and the Actor stops exactly there. Searching only the companies you list in `companies` costs just the jobs.

### FAQ

**How is this different from a job board API?**
Job boards resell postings that companies first publish on their own career sites, often days later and with missing fields. This Actor reads the career sites directly, at run time.

**Why must the keyword be in the title?**
Searching descriptions returns every job that mentions a word in passing. Title matching gives precise results. Use `descriptionKeywords` to narrow further by skills.

**Can I get every job of one company?**
Use [Career Site Jobs Scraper](https://apify.com/makerio/career-site-jobs) for full company job lists, or [Workday Jobs Scraper](https://apify.com/makerio/workday-jobs) for Workday sites.

**Is it legal?**
The Actor reads only public job postings that companies publish for anyone to see, without logging in. It collects no personal data. Check the terms that apply to your use case.

### Support

Missing a company or a field? Open an issue on the **Issues** tab.

# Actor input Schema

## `searchText` (type: `string`):

Required. One job title or keyword that must appear in the job title, for example "data engineer", "registered nurse" or "product designer". Not case sensitive; whole words with common endings ("engineer" also finds "Engineering"). The description is not searched here (use descriptionKeywords). To search several titles, start one run per title.

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

Optional. Keep jobs in any of these places, checked against every location of the job. Use a city, region or country name ("Berlin", "California", "United States"), a two-letter country code ("US") or "Remote". Leave empty for jobs worldwide. Jobs whose location is only a site name without a city or country (for example "Katy Hospital") are left out when this is set.

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

Keep only jobs the company marks as remote, or with "remote" in the location.

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

Optional. Keep only jobs published in the last N days, for example 1 for today and yesterday or 7 for the past week. Leave empty for any age; results are always sorted newest first.

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

Stop after this many jobs (default 50; the example uses 10). Each returned job costs $0.005, so this also caps the cost of the run: 50 jobs cost $0.03 + $0.25.

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

Return at most this many jobs from one company, so a few big employers do not fill the whole result.

## `ats` (type: `array`):

Search only these platforms. Leave empty to search all of them.

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

Optional. Search only these companies instead of every known career site: company names, careers page URLs or job board URLs from any of the supported platforms, including SAP SuccessFactors career sites on a company's own domain such as careers.ey.com.

## `excludeTitleKeywords` (type: `array`):

Drop jobs whose title contains any of these words or phrases, for example "intern" or "director".

## `descriptionKeywords` (type: `array`):

Keep jobs that mention at least one of these terms in the title or the full description, for example "Kubernetes" or "SAP".

## `employmentTypes` (type: `array`):

Keep only these employment types.

## `requireSalary` (type: `boolean`):

Keep only jobs that state a pay range, in the job data or in the description.

## `descriptionFormat` (type: `string`):

How to return the full job description. Choose "No description" for the fastest run.

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

Remember returned jobs between runs and output only postings that are new since the last run. Ideal for a daily schedule that feeds job alerts.

## `stateKey` (type: `string`):

Optional. Runs with the same monitor name share their memory of returned jobs. Use different names to track different searches separately.

## `maxSearchSeconds` (type: `integer`):

Stop reading new career sites after this many seconds and return what was found. Sites are read biggest first, so the limit leaves out only the smallest ones; the run summary says how many. The example uses 30 seconds (about a minute per run); the default of 90 seconds finds about 90% of the matches in about 2 minutes. Set 300 to read every site.

## Actor input object example

```json
{
  "searchText": "data engineer",
  "remoteOnly": false,
  "maxJobs": 10,
  "maxJobsPerCompany": 5,
  "requireSalary": false,
  "descriptionFormat": "text",
  "onlyNewJobs": false,
  "maxSearchSeconds": 30
}
```

# Actor output Schema

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

One item per open job posting: title, company, all locations, country, remote type, employment type, seniority, posting date, requisition ID, job link and description.

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

JSON record with the search text, how many career sites were searched per platform, how many jobs matched and were returned, failed or skipped sites, and rate limits met during the run.

# 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 = {
    "searchText": "data engineer",
    "maxJobs": 10,
    "maxJobsPerCompany": 5,
    "maxSearchSeconds": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("makerio/career-site-job-search").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 = {
    "searchText": "data engineer",
    "maxJobs": 10,
    "maxJobsPerCompany": 5,
    "maxSearchSeconds": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("makerio/career-site-job-search").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 '{
  "searchText": "data engineer",
  "maxJobs": 10,
  "maxJobsPerCompany": 5,
  "maxSearchSeconds": 30
}' |
apify call makerio/career-site-job-search --silent --output-dataset

```

## MCP server setup

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

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/DhAf6alke3CsoT0WD/builds/IfOAMfj96cG1GBOjK/openapi.json
