# Job Search API: Career Site Jobs (`joblessdev/employer-jobs-search`) Actor

Open jobs from employers' own career sites with the employer apply link. Filter by country, city, work mode, seniority and skills, get only jobs new since your last run, or match jobs to a CV with a score and a reason. From $1 per 1,000 jobs.

- **URL**: https://apify.com/joblessdev/employer-jobs-search.md
- **Developed by:** [jobless.dev](https://apify.com/joblessdev) (community)
- **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.

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

### What does Job Search API: Career Site Jobs do?

This Job Search API finds **open jobs straight from employers' own career sites** (the hiring systems companies post to first), not reposts scraped from job boards. Search by keywords or describe the job in plain words, filter by country, city, work mode, seniority and skills, and get clean rows with the **employer's own apply link**. From **$1 per 1,000 jobs**, and jobs you already received are never charged again.

- **Employer-direct jobs** across all kinds of work: healthcare, sales, engineering, operations, trades and more.
- **Only new jobs** on scheduled runs: each job reaches you once, and skipped duplicates cost nothing.
- **Employer apply link** on every job.
- **Match jobs to a CV**: paste a CV and get the best-fitting open jobs, each with a match score, a one-line reason, and the skills it shows or misses.
- Works with **Zapier, Make, n8n**, the Apify API, and AI agents through Apify's MCP server.

### What can you use it for?

- **Daily job alerts**: schedule a search and send only the new jobs to Slack, email or a sheet.
- **Job boards and career apps**: fill a niche board (nursing, remote design, a city) with fresh employer jobs.
- **Recruiting and sales research**: see which companies are hiring for which roles, where.
- **Job seekers and career coaches**: match a CV to open jobs and see why each one fits.
- **AI agents**: give an agent live, structured job data with apply links.

### How to use it

1. Pick a **Search mode**: keyword search, plain-language search, or match to a CV.
2. Add filters: countries (e.g. `US`, `GB`), cities, work mode, seniority, posted within N days.
3. Set **Max jobs**.
4. Optional: tick **Only jobs new since my last run**, then add a **Schedule** (daily) so new jobs arrive every morning.
5. Run, then download the results as JSON, CSV or Excel, or send them to your tools with an integration.

### Input

| Field | What it does | Example |
|---|---|---|
| `mode` | `search`, `ai_search` (plain words) or `cv_match` | `search` |
| `query` | Keywords, or a plain-language description in `ai_search` | `registered nurse` |
| `cv` | CV text, `cv_match` only | |
| `country` | ISO country codes | `["US", "CA"]` |
| `city` | City names | `["Austin"]` |
| `workplace` | `remote`, `hybrid`, `on_site` | `["remote"]` |
| `employmentType` | `FULL_TIME`, `PART_TIME`, `CONTRACT`, `INTERNSHIP` | `["FULL_TIME"]` |
| `seniority` | `entry` to `executive` | `["mid", "senior"]` |
| `skill` | Skills the job lists (keyword search) | `["Python"]` |
| `postedWithinDays` | Only jobs posted in the last N days | `3` |
| `sort` | `relevance` or `newest` | `newest` |
| `maxResults` | Most jobs per run | `100` |
| `onlyNewSinceLastRun` | Skip jobs this search already returned to you | `true` |

Keyword search example:

```json
{
  "mode": "search",
  "query": "registered nurse",
  "country": ["US"],
  "workplace": ["on_site", "hybrid"],
  "postedWithinDays": 3,
  "maxResults": 100,
  "onlyNewSinceLastRun": true
}
```

Match to a CV:

```json
{
  "mode": "cv_match",
  "cv": "Paste the CV text here...",
  "country": ["GB"],
  "maxResults": 10
}
```

### Output

```json
{
  "id": "job_8Fz2kQ1x",
  "title": "Registered Nurse, ICU",
  "company": "Example Health",
  "locationLabel": "Austin, US",
  "workplace": "on_site",
  "employmentType": "FULL_TIME",
  "seniority": "mid",
  "skills": ["Critical Care", "BLS", "ACLS"],
  "salary": "80,000-105,000 USD per year",
  "postedAt": "2026-10-24T09:00:00Z",
  "url": "https://employer-careers.example/jobs/12345",
  "score": 82,
  "band": "strong",
  "reason": "Strong fit: ICU experience and ACLS shown; no gaps in core skills.",
  "skillsMatched": ["Critical Care", "ACLS"],
  "skillsMissing": [],
  "source": "Jobless"
}
```

`score`, `band`, `reason`, `skillsMatched` and `skillsMissing` appear in **Match jobs to a CV** mode only.

### How much does it cost?

You pay per result (pay per event):

| Event | Price |
|---|---|
| Job returned | $1.00 per 1,000 jobs |
| Plain-language search page (up to 48 jobs) | $0.01 |
| CV read and matched (once per run) | $0.05 |
| Job scored against your CV (instead of the job price) | $0.005 |

Examples: 100 new jobs from a daily keyword search cost **$0.10**. Matching a CV to 10 jobs costs **$0.10**, to 25 jobs **$0.175**. Jobs skipped as already seen cost nothing. You can cap the cost of any run with **Max charge per run**.

### FAQ

**Does every job include the employer apply link?**
Yes. `url` is the job's page on the employer's own hiring system, where the candidate applies.

**Do you cover LinkedIn or Indeed jobs?**
No. This actor returns jobs from employers' own career sites. It does not scrape LinkedIn, Indeed or other job boards.

**How fresh are the jobs?**
Career sites are read several times a day and closed jobs are removed. `postedAt` is the date the employer gives; when they give none, the date is estimated and `postedAtEstimated` is `true`.

**Are salaries included?**
When the employer states one. Many postings do not.

**How does "Only jobs new since my last run" work?**
The actor remembers which jobs each saved search already returned to you and skips them. Skipped jobs are not charged. Change any filter and it counts as a new search.

**Is my CV stored?**
The CV text is used for that run's matching and is not kept by the job search afterwards. Only send CVs you have the right to process.

**Can I resell the data?**
Use it for your own job search, product, research or internal tools. Reselling the job data as a dataset or a competing job feed is not allowed.

### Limits and good to know

- Up to 1,000 jobs per run in keyword search, 240 in plain-language search, 25 in CV match.
- Most jobs come from the employer directly. A small share comes through job distribution partners.
- Company names come from the hiring system and can sometimes be a legal entity name.

### Questions or problems?

Open an issue in the **Issues** tab. We answer within one working day.

# Actor input Schema

## `mode` (type: `string`):

`search`: keyword and filter search. `ai_search`: describe the job in plain words. `cv_match`: paste a CV and get the best-fitting jobs, each with a score and a reason.

## `query` (type: `string`):

Job title or keywords for `search` (e.g. registered nurse), or a plain-language description for `ai_search` (e.g. remote product designer jobs in fintech).

## `cv` (type: `string`):

Plain text of the CV to match. Used only in `cv_match` mode. The CV is read for this run and not kept by the job search after it.

## `country` (type: `array`):

ISO 3166-1 alpha-2 codes, e.g. US, GB, DE.

## `city` (type: `array`):

City names, e.g. Berlin, Austin.

## `workplace` (type: `array`):

Any of remote, hybrid, on_site.

## `employmentType` (type: `array`):

Any of FULL_TIME, PART_TIME, CONTRACT, INTERNSHIP. Not used in cv_match mode.

## `seniority` (type: `array`):

Any of entry, mid, senior, staff, manager, director, executive. Not used in cv_match mode.

## `skill` (type: `array`):

Jobs that list these skills (search mode only).

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

Only jobs posted in the last N days. Not used in cv_match mode.

## `sort` (type: `string`):

search mode only.

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

Most jobs to return. Up to 1,000 in search mode (default 50), 240 in ai_search mode (default 50), 25 in cv_match mode (default 10).

## `onlyNewSinceLastRun` (type: `boolean`):

Skip jobs this same search already returned to you. Skipped jobs are not charged.

## Actor input object example

```json
{
  "mode": "search",
  "query": "software engineer",
  "country": [
    "US"
  ],
  "postedWithinDays": 7,
  "sort": "relevance",
  "maxResults": 20,
  "onlyNewSinceLastRun": false
}
```

# Actor output Schema

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

Every job the run returned, one row per job.

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

Jobs returned, jobs skipped as already seen, and why the run stopped.

# 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 = {
    "query": "software engineer",
    "country": [
        "US"
    ],
    "postedWithinDays": 7,
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("joblessdev/employer-jobs-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 = {
    "query": "software engineer",
    "country": ["US"],
    "postedWithinDays": 7,
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("joblessdev/employer-jobs-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 '{
  "query": "software engineer",
  "country": [
    "US"
  ],
  "postedWithinDays": 7,
  "maxResults": 20
}' |
apify call joblessdev/employer-jobs-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,joblessdev/employer-jobs-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/hmuB53eD2PcQR12jS/builds/OrGz8dIGG1CYzpFBH/openapi.json