# Career Site Jobs Scraper — Workday, Greenhouse, Lever & 6 more (`pampadata/career-site-jobs-scraper`) Actor

Every open job of the companies you list, live from their own ATS boards (Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, Workable, Personio, Rippling). Links, websites or names. Workday past its 2,000-job stop, salary as numbers, an 'ATS says N, delivered N' check, only-new mode.

- **URL**: https://apify.com/pampadata/career-site-jobs-scraper.md
- **Developed by:** [Cowboi Bebot](https://apify.com/pampadata) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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

Every open job of the companies you list, read **live** from their own job boards: **Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, Workable, Personio and Rippling**. Give a link, a website or just a name. All nine come out in one row shape, with **salary as numbers**, and each company ends with a plain check: **how many jobs its board says it has, and how many you received.**

*Versión en español más abajo.*

### Quick facts

- **What it does:** Every open job of the companies you list, read live from their own job boards on 9 ATS (Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, Workable, Personio, Rippling), in one row shape, salary as numbers, Workday past its 2,000-job stop.
- **Use it for:** tracking the jobs of a list of target companies; hiring signals; job feeds without a database lag; monitoring only new jobs.
- **Not for:** job boards that aggregate many employers (Indeed, LinkedIn); BambooHR, Teamtailor, Breezy, iCIMS, Oracle or SuccessFactors boards (not in this version); finding a Workday site by name alone.
- **Input:** `companies` (required): job-board or careers links, `ats:slug` (e.g. `greenhouse:stripe`), a website or a plain name; Workday needs its link. Optional filters (applied before charging): `titleKeywords`, `excludeTitleKeywords`, `locations`, `workplaceTypes`, `departments`, `postedWithinDays`; `maxJobsPerCompany` (0 = all); `onlyNewJobs` + `stateName`; `includeDescription` (default on).
- **Output:** one dataset row per job, and one `SUMMARY` record with "ATS says N, delivered N" per company. Every field with its type is under *Output reference* below.
- **Charged events (pay per event):** `job` USD 0.0015 per job delivered (USD 1.50 per 1,000), full description included; plus Apify's standard start event `apify-actor-start`.
- **Never charged:** companies as such (there is no fee per company), a company whose board is not found, jobs your filters drop, jobs whose page could not be read, jobs already delivered in monitoring mode, the SUMMARY record.
- **Limits:** stops at `maxJobsPerCompany` or at your maximum charge per run (SUMMARY `stoppedBy`); a board found by name says so (`detectedBy`): check the company column; do not run two monitors with the same `stateName` at once.
- **Run it from:** Apify Console, the Apify API or an AI agent through the Apify MCP server (Actor `pampadata/career-site-jobs-scraper`), with schedules and integrations.

#### Minimal input

A small input that works, taken from this Actor's own tests; every other field is optional:

```json
{
  "companies": [
    "greenhouse:datadog"
  ],
  "titleKeywords": [
    "engineer"
  ],
  "excludeTitleKeywords": [
    "manager"
  ],
  "locations": [
    "New York"
  ],
  "postedWithinDays": 60
}
```

### Why this one

- **Live, not a database.** Each run reads the company's board at that moment: a job posted ten minutes ago is there, a closed one is gone. No 6-month window, no "company not in our index".
- **Workday past its 2,000-job stop.** Workday never lists more than 2,000 jobs per search (later pages repeat the first ones). This Actor splits the search by Workday's own facets (job family, time type, location...) and merges the parts. Tests on 2026-10-08:

| Workday site | Workday's own count | One plain search | This Actor |
|---|---|---|---|
| NVIDIA | 2,000 (facets: 2,680) | 2,000 | 2,680 |
| PwC (experienced) | 3,855 | 2,000 | 3,855 |
| Target | 2,000 (facets: 14,149) | 2,000 | 14,130 |

Another Workday Actor in the Store, run on NVIDIA the same day, returned 2,000 jobs and reported 2,000 jobs on the site.

- **The check per company.** The SUMMARY record says, for every line you gave: which board it matched and how, how many jobs the board says, how many were listed, filtered out and delivered, and why a company is not complete if it is not.
- **Salary as numbers** (minimum, maximum, currency, period) from the ATS's own salary field where it has one (Ashby, Lever, Recruitee, Rippling, SmartRecruiters) and otherwise from the pay-range sentence in the ad (US/EU pay-transparency text: `"Pay Range $102,000 — $120,000 USD"`, `"148,000 USD - 235,750 USD"`). In tests: Datadog 217 of 432 jobs with a salary, OpenAI 651 of 812 (from Ashby's field), NVIDIA about half (from the text).
- **Only new jobs** for monitoring: run it daily on the same list and you get (and pay for) only the jobs you have not received before, plus a count of jobs closed since the last run.

### What you can give it (one per line)

| You type | What happens |
|---|---|
| `https://job-boards.greenhouse.io/stripe`, `jobs.lever.co/spotify`, `jobs.ashbyhq.com/openai`, `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`, `jobs.smartrecruiters.com/ServiceNow`, `bunq.recruitee.com`, `apply.workable.com/huggingface`, `acme.jobs.personio.de`, `ats.rippling.com/rippling/jobs` | That board, directly. A link to one job or to the API works too. |
| `greenhouse:stripe`, `lever-eu:mistral` | That board, directly. |
| `figma.com` | The Actor looks for a job-board link on the site (home, /careers, /jobs); if there is none, it tries the domain's name on each ATS. |
| `Datadog` | The name is tried as a board name on the 8 ATS that use one (Workday needs its link). The board with the most jobs wins; the others are listed in SUMMARY as `alsoFoundOn`. |

A board found by name says so in SUMMARY (`detectedBy`), with a warning to check the company column: two companies can share a name. In a test of 20 well-known companies, 17 were found by name alone; the other 3 use Workday or their own system and need a link.

### Filters (you pay only for jobs that pass)

Title contains any of / does not contain (whole words: "data" matches *Data Engineer*, not *Database*), location contains (or country code: `US`, `DE`), workplace type (remote, hybrid, on-site), department or team, posted in the last N days, maximum jobs per company.

### What you get for each job

`company`, `ats`, `board`, `jobId`, `title`, `url`, `applyUrl`, `department`, `team`, `location`, `locations` (all of them), `countryCode`, `workplaceType` (REMOTE / HYBRID / ON_SITE), `employmentType` (FULL_TIME, PART_TIME, CONTRACT, TEMPORARY, INTERN) and the ATS's own words, `postedAt`, `updatedAt`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryText`, `salarySource` (`ats` or `description`), `requisitionId`, `descriptionText`, `descriptionHtml`, `contactsRemoved`, `input` (your line). Fields an ATS does not publish stay empty; nothing is guessed.

#### Example (trimmed)

```json
{
  "company": "openai",
  "ats": "ashby",
  "board": "openai",
  "jobId": "fc5bbc77-a30c-4e7a-9acc-8a2e748545b4",
  "title": "Data Engineer",
  "url": "https://jobs.ashbyhq.com/openai/fc5bbc77-a30c-4e7a-9acc-8a2e748545b4",
  "applyUrl": "https://jobs.ashbyhq.com/openai/fc5bbc77-a30c-4e7a-9acc-8a2e748545b4/application",
  "department": "Applied AI",
  "team": "Applied AI Engineering",
  "location": "San Francisco",
  "locations": [
    "San Francisco",
    "Mountain View"
  ],
  "countryCode": "US",
  "workplaceType": "HYBRID",
  "employmentType": "FULL_TIME",
  "employmentTypeRaw": "FullTime",
  "postedAt": "2023-09-26T22:34:48Z",
  "updatedAt": null,
  "salaryMin": 235000,
  "salaryMax": 385000,
  "salaryCurrency": "USD",
  "salaryPeriod": "YEAR",
  "salaryText": "$235K – $385K",
  "salarySource": "ats",
  "requisitionId": null,
  "descriptionText": "ABOUT THE TEAM\n\nThe Applied team works across research, engineering, product, and design to bring OpenAI’s technology to consumers and businesses.\n\nWe seek to l…",
  "contactsRemoved": 0,
  "input": "openai",
  "descriptionHtml": "<p>…</p>"
}
```

### The SUMMARY record

In the run's key-value store, one entry per line you gave: `ats`, `board`, `boardUrl`, `detectedBy`, `alsoFoundOn`, `atsSays`, `listed`, `filteredOut`, `alreadyDelivered` (only-new mode), `closedSinceLastRun`, `delivered`, `complete`, `stoppedBy`, `warnings`, `errors`. It is saved as the run goes, so a run stopped by its timeout still says what it got. The same board given twice (a name and a link) is delivered and billed once.

### Only new jobs (monitoring)

Turn on **Only new jobs** and give a **State name** (one per monitor). The first run delivers every matching job; later runs with the same state name deliver only jobs not delivered before. The memory is a named key-value store, `career-site-jobs-state`, in your own Apify account (delete it to start over, or use another state name). A job that was filtered out or cut by your limits is not remembered, so it comes when it matches. Each delivered batch is remembered at once, so a run that stops halfway does not bill those jobs again. Do not run two monitors with the same state name at the same time: both would see the same jobs as new.

### Pricing

You pay only for jobs delivered: **USD 1.50 per 1,000 jobs** (USD 0.0015 each), full description included. Nothing per company, nothing for a company whose board is not found, nothing for jobs your filters drop, nothing for a job whose page could not be read. Apify also bills its standard tiny start event (USD 0.00005 per run, per GB of memory).

The Actor stops cleanly at your *maximum cost per run*, and the SUMMARY record says where it stopped.

### Good to know

- **Workday** needs the career-site link (`https://<company>.wd<N>.myworkdayjobs.com/<site>`): the site name cannot be guessed. Open the company's careers page, click a job, and copy the address up to the site name.
- Workday, SmartRecruiters and Rippling publish the full text, exact date and salary only on each job's own page, so the Actor opens it (one request per job). Turning off *Include the full description* skips those requests (much faster on big Workday boards; those three then give only title, place and an approximate date), unless a filter needs what only the job page has: then the pages are still opened and only the text is left out.
- Workday's own count stops at 2,000; for bigger boards `atsSays` is the total of Workday's facet counts.
- If an ATS does not give a publish date and you set *Posted in the last N days*, that job is left out (it cannot be checked).
- Leave the proxy setting as it is: the ATS boards are public. If one ever blocks Apify's datacenter IPs, the run moves to residential IPs by itself.

### Personal data

The rows are about jobs and companies. The Actor **removes personal e-mail addresses and phone numbers from the ad text** (`[email removed]`, `[phone removed]`); a department's address such as careers@ or accommodations@ stays. Names that appear in an ad text stay; if you store them, data-protection law may apply to you. This Actor is not affiliated with, endorsed by or sponsored by any of the ATS vendors or companies named here; their names are trademarks of their owners.

### Questions or a missing ATS?

Open an issue in the **Issues** tab. Answers come in writing.

### Output reference

#### Dataset: one row per job

| Field | Type | What it is |
|---|---|---|
| `company` | string | Company name as the board gives it (never the name you typed). |
| `ats` | string | greenhouse, lever, ashby, workday, smartrecruiters, recruitee, workable, personio or rippling. |
| `board` | string | The board's slug or site on that ATS. |
| `jobId` | string | The ATS's job ID. |
| `title` | string | Job title. |
| `url` | string | Link to the job. |
| `applyUrl` | string | Link to apply. |
| `department` | string or null | Department, when the ATS gives one. |
| `team` | string or null | Team, when the ATS gives one. |
| `location` | string | Main location. |
| `locations` | array of string | All locations of the job. |
| `countryCode` | string | ISO country code of the location. |
| `workplaceType` | string | REMOTE, HYBRID or ON_SITE. |
| `employmentType` | string or null | FULL_TIME, PART_TIME, CONTRACT, TEMPORARY or INTERN. |
| `employmentTypeRaw` | string or null | The ATS's own words for the employment type. |
| `postedAt` | string | First published (ISO 8601). |
| `updatedAt` | string or null | Last updated, when the ATS gives it. |
| `salaryMin` | integer or null | Salary minimum as a number. |
| `salaryMax` | integer or null | Salary maximum as a number. |
| `salaryCurrency` | string or null | ISO currency code. |
| `salaryPeriod` | string or null | e.g. YEAR, MONTH, HOUR. |
| `salaryText` | string or null | Salary as written. |
| `salarySource` | string or null | "ats" (the ATS's salary field) or "description" (the pay-range sentence of the ad). |
| `requisitionId` | string or null | Requisition ID, when the ATS gives one. |
| `descriptionText` | string | Full description as text (personal e-mails and phone numbers removed); empty with includeDescription off. |
| `descriptionHtml` | string | Full description as HTML (same removal). |
| `contactsRemoved` | integer | Personal e-mails and phone numbers removed from the text. |
| `input` | string | Your input line this job came from. |

#### SUMMARY record (run's key-value store, never charged)

| Field | Type | What it is |
|---|---|---|
| `companies` | array of object | One item per input line (fields below). |
| `jobsDelivered` | integer | Jobs delivered in the run. |
| `onlyNewJobs` | boolean | Monitoring mode on or off. |
| `stateName` | string or null | State name used in monitoring mode. |
| `requests` | object | Request counters of the run (requests, retries, refusals or blocks, failures; whether the run moved to residential IPs). |
| `proxy` | string | Proxy mode of the run. |

Each item of `companies`:
| Field | Type | What it is |
|---|---|---|
| `input` | string | Your input line. |
| `ats`, `board`, `boardUrl` | string or null | The board it matched. |
| `detectedBy` | string or null | How the board was found (link, ats:name, link on the website, name tried on each ATS). |
| `alsoFoundOn` | array of string | Other boards found for the same name. |
| `atsSays` | integer or null | The board's own job count (for Workday over 2,000: the total of its facet counts). |
| `listed` | integer | Jobs listed on the board. |
| `filteredOut` | integer | Jobs your filters dropped (not charged). |
| `alreadyDelivered` | integer | Monitoring: jobs delivered by an earlier run (not charged). |
| `closedSinceLastRun` | integer or null | Monitoring: jobs closed since the last run. |
| `delivered` | integer | Jobs delivered (and charged). |
| `complete` | boolean | true only when the whole board was read and nothing stopped it. |
| `missing` | integer or null | Gap between the board's count and what was listed. |
| `stoppedBy` | string or null | Why it stopped early (maxJobsPerCompany, your maximum charge…). |
| `splits`, `incompleteParts` | integer, array | Workday: smaller searches it took, and parts it could not finish. |
| `detailsFailed`, `detailsFailedJobs` | integer, array | Job pages that could not be read (not charged). |
| `warnings`, `errors` | array of string | Warnings (e.g. found by name: check the company) and errors. |

### More Actors by this developer

- [Google Ads Transparency Scraper](https://apify.com/pampadata/google-ads-transparency-scraper)
- [SEEK Jobs Scraper (Seek, JobStreet, Jobsdb)](https://apify.com/pampadata/seek-jobs-scraper)
- [AliExpress Search Scraper](https://apify.com/pampadata/aliexpress-search-scraper)
- [Google News Scraper](https://apify.com/pampadata/google-news-scraper)
- [Sports Odds vs Prediction Markets (Kalshi, Polymarket)](https://apify.com/pampadata/sports-odds-vs-prediction-markets)
- [Google Trends Scraper](https://apify.com/pampadata/google-trends-scraper)
- [YouTube Transcripts in Bulk (whole channels, playlists)](https://apify.com/pampadata/youtube-transcripts-bulk)

***

### Versión en español

Todos los avisos abiertos de las empresas que le pases, leídos **en vivo** de sus propias bolsas de empleo: **Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, Workable, Personio y Rippling**. Le podés dar un enlace, una web o solo el nombre. Los nueve salen con la misma forma, con **el sueldo como números**, y cada empresa termina con un control: **cuántos avisos dice su bolsa que tiene y cuántos recibiste.**

#### De un vistazo

- **Qué hace:** Todos los avisos abiertos de las empresas que le pases, leídos en vivo de sus propias bolsas en 9 sistemas (Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, Workable, Personio, Rippling), con la misma forma de fila, sueldo como números y Workday más allá de su tope de 2.000.

- **Sirve para:** seguir los avisos de una lista de empresas; señales de contratación; feeds sin el atraso de una base de datos; monitorear solo avisos nuevos.

- **No sirve para:** portales que juntan muchas empresas (Indeed, LinkedIn); BambooHR, Teamtailor, Breezy, iCIMS, Oracle o SuccessFactors (no están en esta versión); encontrar un Workday solo por nombre.

- **Entrada:** `companies` (obligatorio): enlaces de bolsa, `ats:nombre`, la web o el nombre; Workday necesita su enlace. Filtros opcionales (antes de cobrar), `maxJobsPerCompany`, `onlyNewJobs` + `stateName`, `includeDescription`. Ejemplo mínimo en JSON: sección *Minimal input* de la parte en inglés.

- **Salida:** una fila por aviso y un registro `SUMMARY` con "la bolsa dice N, entregados N" por empresa.

- **Eventos que se cobran:** `job` USD 0,0015 por aviso entregado (USD 1,50 cada 1.000), con el texto completo; más `apify-actor-start`.

- **Nunca se cobra:** las empresas en sí (no hay cargo por empresa), una bolsa que no se encuentra, avisos que tus filtros descartan, avisos ilegibles, avisos ya entregados en modo monitoreo, el SUMMARY.

- **Límites:** se detiene en `maxJobsPerCompany` o en tu costo máximo por corrida (`stoppedBy`); si la bolsa se encontró por nombre, SUMMARY lo dice (`detectedBy`).

- **En vivo, no una base de datos:** lo publicado hace diez minutos está; lo cerrado, no.

- **Workday pasando su tope de 2.000:** Workday nunca lista más de 2.000 avisos por búsqueda; el programa divide la búsqueda por los filtros del propio Workday y junta las partes. NVIDIA: 2.680 de 2.680 (otro programa de la tienda, el mismo día: 2.000); Target: 14.130 de 14.149.

- **Sueldo como números** (mínimo, máximo, moneda, período), del campo de sueldo del sistema o, si no tiene, de la frase del rango salarial del aviso.

- **Solo avisos nuevos:** corriéndolo cada día con la misma lista, recibís (y pagás) solo lo que no recibiste antes, más cuántos avisos se cerraron.

**Qué le das:** enlaces de las bolsas (o de un aviso), `ats:nombre` (`greenhouse:stripe`), la web de la empresa (`figma.com`) o el nombre (`Datadog`). Si se encontró por nombre, el resumen lo dice y pide revisar que sea la empresa correcta. Workday necesita su enlace.

**Filtros** (pagás solo por lo que pasa): palabras del puesto (incluir/excluir), lugar o país, modalidad, área, publicados en los últimos N días, máximo por empresa.

El registro **SUMMARY** dice, por cada línea: qué bolsa se usó y cómo se encontró, cuántos avisos dice la bolsa, cuántos se listaron, filtraron y entregaron, y por qué no está completa si no lo está.

**Precio:** USD 1,50 cada 1.000 avisos entregados, con el texto completo. Nada por empresa, nada si no se encuentra la bolsa, nada por los avisos que tus filtros descartan. Más el evento de inicio estándar de Apify (USD 0,00005 por corrida, por GB de memoria). Se detiene en tu costo máximo por corrida y lo informa en SUMMARY.

**Datos personales:** se borran los correos y teléfonos personales del texto del aviso (los de un área, como careers@, quedan). Este programa no está afiliado a ninguno de los sistemas ni empresas nombrados.

¿Dudas o falta un sistema? Abrí un *issue* en la pestaña **Issues**; se responde por escrito.

# Actor input Schema

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

One per line. Any of: a job-board or careers link (boards.greenhouse.io/stripe, jobs.lever.co/spotify, jobs.ashbyhq.com/openai, nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite, jobs.smartrecruiters.com/ServiceNow, bunq.recruitee.com, apply.workable.com/huggingface, acme.jobs.personio.de, ats.rippling.com/rippling); a company website (figma.com); a company name (Datadog); or ats:board (greenhouse:stripe, lever-eu:mistral). Workday needs its link. The SUMMARY record says which board each line was matched to and how.

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

Keep only jobs whose title contains one of these words or phrases (whole words, any case: 'data' matches 'Data Engineer', not 'Database'). Empty = all jobs.

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

Drop jobs whose title contains one of these words (e.g. intern, senior).

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

Keep jobs whose location contains one of these texts, or whose country code is one of them (US, GB, DE...). Example: Berlin, Remote, US.

## `workplaceTypes` (type: `array`):

Keep only these. Jobs whose ATS says nothing about it are dropped when this is set.

## `departments` (type: `array`):

Keep jobs whose department or team contains one of these texts.

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

Keep jobs first published in the last N days. Jobs whose ATS gives no publish date are dropped when this is set.

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

Deliver (and charge) only jobs not delivered by an earlier run with the same 'State name'. The first run delivers everything that matches. SUMMARY also counts jobs closed since the last run. The memory is a named key-value store 'career-site-jobs-state' in your own Apify account.

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

Keeps separate memories for different monitors (e.g. 'sales-targets', 'eng-jobs'). Letters, digits, dot, dash, underscore.

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

Description as text and HTML (personal e-mails and phone numbers removed). Off = smaller rows; Workday, SmartRecruiters and Rippling then skip one request per job, so they also lose the exact publish date, employment type and salary that only the job page has.

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

0 = all. The SUMMARY says when a company stopped at this limit.

## `proxyConfiguration` (type: `object`):

Default: Apify datacenter proxy, moving to residential IPs only if an ATS keeps blocking. The ATS gates are public; in tests no proxy change was needed.

## Actor input object example

```json
{
  "companies": [
    "https://job-boards.greenhouse.io/datadog",
    "openai",
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
  ],
  "onlyNewJobs": false,
  "stateName": "default",
  "includeDescription": true,
  "maxJobsPerCompany": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset items: one row per job delivered, same shape for all 9 ATS (company, ats, board, jobId, title, url, applyUrl, department, team, location(s), countryCode, workplaceType, employmentType, postedAt, salary as numbers with salarySource, descriptionText/Html, input). Charged per row: event `job`.

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

Key-value record SUMMARY: per company line, which board matched and how (detectedBy), atsSays vs listed vs filteredOut vs delivered, complete, stoppedBy, monitoring counts; run totals. Not charged.

# 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://job-boards.greenhouse.io/datadog",
        "openai",
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
    ],
    "maxJobsPerCompany": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("pampadata/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 = {
    "companies": [
        "https://job-boards.greenhouse.io/datadog",
        "openai",
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    ],
    "maxJobsPerCompany": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("pampadata/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 '{
  "companies": [
    "https://job-boards.greenhouse.io/datadog",
    "openai",
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
  ],
  "maxJobsPerCompany": 50
}' |
apify call pampadata/career-site-jobs-scraper --silent --output-dataset

```

## MCP server setup

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