# Career Site Jobs Scraper (`letsfindwork/career-site-jobs-scraper`) Actor

Fresh job postings from 1M+ open jobs on employers' own career sites (Greenhouse, Lever, Workday, Ashby and 40+ more). Filter by keyword, country, city, remote or hybrid, job type, occupation, company, industry and size. Each job has the apply link.

- **URL**: https://apify.com/letsfindwork/career-site-jobs-scraper.md
- **Developed by:** [LetsFindWork](https://apify.com/letsfindwork) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 job 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

### What does Career Site Jobs Scraper do?

**Career Site Jobs Scraper** returns open jobs that employers post on **their own career sites**: the job boards of over 40 applicant tracking systems, such as Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Personio and Teamtailor. Every board is read about once a day, so the jobs are fresh, and a job the employer takes down leaves the results.

Filter by **keywords, country, city, occupation, workplace (remote, hybrid, onsite), employment type, company industry and company size**. Each job comes with clean facts (places as ISO codes, pay as numbers, an ISCO-08 occupation), a short snippet and the **employer's own apply link**.

Use it for:

- job boards and job alerts
- market and salary research
- lead lists of companies that hire for a role
- AI agents that search jobs for a person

### How to use it

1. Set the filters you need. All are optional; leave them empty for every open job.
2. Set **Max jobs**: the run stops there.
3. Run it. Download the dataset as JSON, CSV or Excel, or read it with the Apify API.
4. Want only new jobs each day? Use **New Job Postings Feed** instead, on a schedule.

### Input example

```json
{
  "q": "data engineer",
  "country": ["DE", "NL"],
  "workplaceType": ["remote", "hybrid"],
  "employmentType": ["full-time"],
  "companySize": ["51-200", "201-500"],
  "postedAfter": "2026-11-01",
  "maxJobs": 500
}
```

- **Countries**: ISO codes such as `DE` or `US`.
- **Occupations**: ISCO-08 codes or prefixes; `25` is ICT professionals.
- **Company industries**: as Wikidata names them, such as `software industry`.
- **Company sizes**: `1-10`, `11-50`, `51-200`, `201-500`, `501-1000`, `1001-5000`, `5001-10000`, `10001+`.

### Output

One dataset item per job. The main fields:

| Field | What it is |
| --- | --- |
| `id` | Job id |
| `title`, `company`, `department` | As the employer wrote them |
| `location` | The place as written; `countries`, `regionCodes`, `cities`, `timezones` as clean values |
| `workplaceType` | `remote`, `hybrid` or `onsite` |
| `employmentType` | Full time, part time, contract and so on |
| `salary` | The pay as written; `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` as numbers; `salaryYearEur` to compare |
| `occupation` | ISCO-08 code |
| `agency` | Posted by a staffing or recruiting firm |
| `duplicateGroupId`, `canonical` | The same opening on several boards, and which one to keep |
| `postedAt`, `firstSeenAt` | The employer's date and the day we first saw the job |
| `snippet` | One or two sentences of the job text, without contact data |
| `ai` | Skills, experience, education, benefits, visa sponsorship and remote regions, read from the text by a language model (can be wrong) |
| `ats`, `url`, `applyUrl` | The tracking system, the job page and the employer's application form |

```json
{
  "id": 1843201,
  "title": "Senior Data Engineer",
  "company": "Example Analytics",
  "location": "Berlin, Germany",
  "workplaceType": "hybrid",
  "employmentType": "full-time",
  "countries": ["DE"],
  "cities": ["Berlin"],
  "salaryMin": 70000,
  "salaryMax": 85000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "year",
  "occupation": "2521",
  "postedAt": "2026-11-12T09:30:00.000Z",
  "snippet": "You will build and run the data pipelines behind our product analytics.",
  "ats": "greenhouse",
  "url": "https://job-boards.greenhouse.io/example/jobs/123",
  "applyUrl": "https://job-boards.greenhouse.io/example/jobs/123"
}
```

The full job text is not included: each job has the snippet and the employer's links.

### How much does it cost?

**USD 4 per 1,000 jobs** (USD 0.004 per job in the dataset), plus Apify's small start fee per run. You pay per result only, not for platform usage. Max jobs and your run's cost limit keep each run within your budget.

### FAQ

**Where do the jobs come from?** From employers' public job boards on their applicant tracking systems. No LinkedIn, no aggregator sites, no logins.

**Which jobs are in it?** Any field and any country: remote, hybrid and onsite.

**Why is a field empty?** Values are left empty when the employer's own data does not give them with confidence.

# Actor input Schema

## `q` (type: `string`):

Words in the title, company or department

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

ISO country codes, e.g. DE, US

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

City names

## `occupation` (type: `array`):

ISCO-08 codes or prefixes, e.g. 25 for ICT professionals

## `workplaceType` (type: `array`):

remote, hybrid, onsite

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

full-time, part-time, contract, temporary, internship

## `industry` (type: `array`):

As Wikidata names them, e.g. software industry

## `companySize` (type: `array`):

1-10, 11-50, 51-200, 201-500, 501-1000, 1001-5000, 5001-10000, 10001+

## `company` (type: `array`):

Company names

## `postedAfter` (type: `string`):

Only jobs posted on or after this date

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

Stop after this many jobs

## Actor input object example

```json
{
  "maxJobs": 100
}
```

# Actor output Schema

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

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("letsfindwork/career-site-jobs-scraper").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("letsfindwork/career-site-jobs-scraper").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 '{}' |
apify call letsfindwork/career-site-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

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/JRcZ21nc15mPGY3f8/builds/v7f0rNfFIj3e3MgN9/openapi.json
