# Workday Public Careers Monitor (`accountable_eel/workday-public-careers-monitor`) Actor

Workday careers monitor: get new jobs from a myworkdayjobs career site since the last run, a new job postings alert for any public Workday careers site. One row per job: title, location, posted on and link. Reads the first 40 postings a site lists per run. New Workday jobs to Google Sheets or n8n.

- **URL**: https://apify.com/accountable_eel/workday-public-careers-monitor.md
- **Developed by:** [Adriana Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Jobs, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 job posting returneds

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

## Workday Public Careers Monitor: New Openings on Large Employers' Workday Sites

Large employers publish their openings on Workday-hosted career sites, and those sites list thousands of roles. This actor reads the JSON that the Workday site itself loads, remembers the requisition ids it has already returned, and gives you only the openings that are new since the last run.

### Who it's for

**A competitive-intelligence analyst at a market-research firm.** Your client sells into five large manufacturers and wants a monthly note on where each one is adding headcount. Counting the whole board each time is useless at that scale; the new requisitions per employer per month are the story.

**A university career-services office.** Local employers on Workday post graduate-scheme and internship roles throughout the year. Students want a short list of what appeared this week, not a dump of everything the site holds.

**A staffing-agency account manager.** One enterprise client is the account. A new requisition in a function you can fill is a reason to call before the client's own recruiters have finished their first screen.

All three track a handful of big sites over time and care about arrivals. If you only need a one-off count of a single site, the lookup actor in the related list is a cheaper fit.

### Why this one

- **No browser.** It posts directly to the site's `wday/cxs` JSON endpoint and pages through the results 20 at a time, so a run is fast and light.
- **A stable id per opening.** The requisition id Workday shows on each posting, such as `JR2027031`, is the key the stored record uses.
- **Only arrivals are billed.** Billing is per posting returned. A site with nothing new returns nothing.
- **Failed sites cost nothing.** A bad address becomes a visible `found: false` row, never a charge.

### What you get

| Field | Meaning |
| --- | --- |
| `job_id` | The requisition id Workday shows in the posting's bullet fields. |
| `title` | The job title. |
| `location` | Workday's location text, for example "Israel, Yokneam". |
| `posted_on` | Workday's relative wording, such as "Posted Today" or "Posted 2 Days Ago". It is a label, not a date. |
| `external_path` | The path of the posting on the site. |
| `url` | The full link to the posting. |
| `company_board_id` | `tenant/site` for the row. |
| `first_seen_timestamp` | When this monitor first recorded the opening. This is the date to sort and alert on. |

Because `posted_on` is relative, use `first_seen_timestamp` for anything that needs a real date.

### Finding the right Workday address

Workday addresses have three parts that matter, and getting one wrong is the most common reason a site returns nothing.

- **Tenant.** The first label of the host. In `nvidia.wd5.myworkdayjobs.com` the tenant is `nvidia`.
- **Data centre.** The `wd1`, `wd3`, `wd5` part. It differs between employers and is part of the real address.
- **Site.** The first path segment that is not a language code. For `.../en-US/NVIDIAExternalCareerSite` the site is `NVIDIAExternalCareerSite`.

**Paste the full careers URL.** With the whole address, the actor takes the host as given and every part is right. On 2026-10-08 `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite` and the same address with `/en-US/` in it both answered with a site size of 2,000 postings.

**The `tenant/site` shorthand has a limit.** It always assumes the `wd1` data centre. We tested `nvidia/NVIDIAExternalCareerSite` on 2026-10-08 and Workday answered HTTP 422, because NVIDIA is on `wd5`. The row comes back as `ERROR` and is not billed. Use the shorthand only for employers you know are on `wd1`; otherwise paste the URL.

### Pricing

- **Job posting returned**: $1 per 1,000 job postings

Plus a $0.001 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

Size matters here more than on smaller platforms, so a big site is never read in full unless you ask for it. Each site is read newest first, up to `maxPostingsPerBoard` postings: 200 by default, 2,000 at most. At the listed price, a first run on a large site costs at most about $0.20 with the default, and about $2.00 if you raise the cap to 2,000. Seed with `skipFirstRun` and the backlog costs nothing.

**How the actor learns a site's size.** Workday states the number of postings only in the answer to its very first request and sends `total: 0` with every page after that. On 2026-10-08 we saw exactly this on the NVIDIA, Salesforce, Adobe and Pfizer sites. The actor therefore keeps the figure from that first answer and asks for the next 20 postings, one request at a time with a 150 ms pause, until it holds `maxPostingsPerBoard` postings or the site has none left. On the NVIDIA site the pages ran from "Posted Today" at the start down to "Posted 29 Days Ago" by offset 1000, so the postings that make the cut are the most recent ones. Workday itself answers an offset of 2,000 with the first page again, which is why the cap stops there. If Workday replies 429 or a 5xx error after the first page, the run stops and delivers what it has read so far; only delivered postings are recorded, so the rest are still new next time.

**Keywords and the cap.** `includeKeywords` and `excludeKeywords` are applied after the read, to the postings that were fetched. With `includeKeywords` set you get the matches among the newest `maxPostingsPerBoard` postings of each site, not among every posting it holds, and an older matching role is not found. Raise the cap if the filter has to reach further back.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `company_board_id` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~workday-public-careers-monitor/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"company_board_id":["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

### Input

```json
{
  "company_board_id": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
  ]
}
```

Full Workday career site URL (e.g. "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"). The short tenant/site form only works for sites on the wd1 data centre. Charged per job posting returned. Boards with no result are free. Accepted formats: https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite, nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite.

Other settings: `maxPostingsPerBoard` (how many of a site's newest postings to read, 200 by default), `includeKeywords` and `excludeKeywords` (matched case-insensitively against title and location), `maxResults`, `testRun` (first five sites), `onlyFound`, `deltaMode` (on by default), `deltaName` and `skipFirstRun`.

### Sample output

| query | found | status | job_id | title | location | posted_on | external_path | url | company_board_id | first_seen_timestamp | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite | true | OK | <job id> | <title> | <location> | <posted on> | <external path> | <apply url> | <board id> | <first seen timestamp> | 1970-01-01T00:00:00.000Z |

A site whose endpoint returns 404 is reported as `NOT_FOUND`; any other failure, including the 422 above, as `ERROR`. Neither is billed.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~workday-public-careers-monitor/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"company_board_id":["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~workday-public-careers-monitor/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"company_board_id":["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~workday-public-careers-monitor/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"company_board_id":["{{job posting}}"]}`, mapping the row's job posting into the `company_board_id` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Workday Public Careers Monitor | Apify" — the agent will find and run this actor.

### Tips

- **Seed first, then monitor.** For Workday sites, `skipFirstRun` is almost always right. The first run records every requisition that passes your keyword filter among the newest `maxPostingsPerBoard` postings and bills none.
- **Narrow with keywords.** A filter such as `engineer` keeps the dataset readable. The filter runs before the stored record is touched, so a posting it hides stays unrecorded and shows up as new if you loosen the filter later. Requisitions cut by `maxResults`, or not delivered because the run hit its spending limit, are likewise left out of the record and arrive on the next run. A site that posts more than `maxPostingsPerBoard` roles between two runs pushes its oldest arrivals out of the window, so schedule more often or raise the cap for very busy sites.
- **Reset one site, not all.** The record sits in the key-value store `workday-delta-store`, or in the store you name in `deltaName`. The key is `baseline-<tenant>-<site>`; delete only that key to start one site over.
- **Keep sites in separate stores when audiences differ.** Different `deltaName` values keep their baselines apart.
- **Expect no description text.** The list response carries title, location and a path. If you need the full job description, follow `url`.

### vs. alternatives

| | What it costs | What you get | Trade-off |
| --- | --- | --- | --- |
| **This actor** (`workday-public-careers-monitor`) | $0.001 per posting returned, $0.001 per run, nothing when no posting is new | New openings only, keyed on requisition id, with a first-seen date | Workday only, a relative posted label, and a first run that bills up to `maxPostingsPerBoard` postings (200 by default) unless seeded |
| **Workday Jobs Lookup** (`workday-jobs-lookup`) | Billed per company, listed at $0.004 per site found | A snapshot of the site with remote-only and keyword filters and its own new-jobs mode | Cheaper for one-off pulls and for sites that add four or more postings between runs. Choose it if you want a remote-only filter. |
| **Workday's own JSON endpoint** | Free | The same list | You write the paging, the seen-list and the scheduling |

The sibling's price is the figure on its page at the time of writing; check it before relying on the comparison.

### FAQ

#### Why do I get nothing for an employer I know uses Workday?

Most often the address is wrong. Open the careers page in a browser, copy the full URL, and paste that instead of a shorthand.

#### What will a first run on a huge site cost?

At most about $0.20 with the default of 200 postings, because only the newest 200 are read. Setting `maxPostingsPerBoard` to its ceiling of 2,000 can bring that to about $2.00. Seed with `skipFirstRun` to pay nothing for the backlog.

#### Why did a keyword search miss a role I can see on the site?

The keyword filter only looks at the newest `maxPostingsPerBoard` postings. A matching role older than that window is outside the read; raise the cap to reach it.

#### What does "Posted 30+ Days Ago" mean?

It is Workday's own wording for older postings. This monitor passes it through unchanged and does not convert it to a date.

#### Can I watch one location only?

Add the place name to `includeKeywords`; it is matched against the location text. Postings the filter hides are not recorded, so removing the place name later brings them back as new.

### Related actors

- [Workday Jobs Lookup](https://apify.com/accountable_eel/workday-jobs-lookup) is the per-site snapshot with remote-only filtering.
- [ATS Jobs Unified Lookup](https://apify.com/accountable_eel/ats-jobs-unified-lookup) shows which applicant-tracking system a company uses.

# Actor input Schema

## `company_board_id` (type: `array`):

Full Workday career site URL (e.g. "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"). The short tenant/site form only works for sites on the wd1 data centre. Charged per job posting returned. Boards with no result are free. Accepted formats: https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite, nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `deltaMode` (type: `boolean`):

When true, compare active jobs against stored baseline and only emit new jobs.

## `deltaName` (type: `string`):

Optional Key-Value store name for persisting seen job IDs baseline.

## `skipFirstRun` (type: `boolean`):

If true and state store is empty, populates baseline without emitting rows.

## `maxPostingsPerBoard` (type: `integer`):

One Workday site can hold thousands of postings. Only the newest this many are read from each site (1 to 2,000, default 200), and every posting returned is billed. Keyword filters are applied to those postings only.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "company_board_id": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "deltaMode": true,
  "deltaName": "",
  "skipFirstRun": false,
  "maxPostingsPerBoard": 200,
  "columns": [
    "job_id",
    "title",
    "location",
    "posted_on",
    "external_path",
    "url",
    "company_board_id",
    "first_seen_timestamp"
  ],
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "company_board_id": [
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/workday-public-careers-monitor").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 = {
    "company_board_id": ["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/workday-public-careers-monitor").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 '{
  "company_board_id": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/workday-public-careers-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/workday-public-careers-monitor"
        }
    }
}
```

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/tLuVKYEHgdAbA5KTU/builds/bFsO3avsEnmyPN6cv/openapi.json