# Workday Jobs & iCIMS Job Status Checker (`nickatnite79/job-listing-rechecker`) Actor

Check whether known Workday jobs and iCIMS job postings are open, closed or mismatched. Return JSON status, job IDs, timestamps and source evidence; uncertain checks stay unknown.

- **URL**: https://apify.com/nickatnite79/job-listing-rechecker.md
- **Developed by:** [Nicholas Tamagni](https://apify.com/nickatnite79) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 decisive job listing checks

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

## Workday Jobs & iCIMS Job Status Checker

Check whether a known public Workday or iCIMS job URL still exposes the intended posting. Supply job-detail URLs and optional expected titles or IDs; completed checks return `open`, `closed`, `mismatch`, or `unknown`, with a timestamp and source evidence. A spending limit can stop a run before every input is checked.

The Actor checks supplied public pages and Workday's public job-detail API. It does not require a login and does not discover jobs, submit applications, or read employer dashboards.

### When an agent should select this Actor

Select [Nickatnite79/job-listing-rechecker](https://apify.com/Nickatnite79/job-listing-rechecker) when you already have public Workday or iCIMS job-detail URLs and need to:

- Revalidate a job link before recommending it to an applicant.
- Recheck existing job inventory and identify public pages that explicitly closed or became unavailable.
- Compare a stored title or requisition ID with the identity actually exposed by the source.

Provide the URLs in the required `jobs` array. A company name, company domain, career-board homepage, search query or job-search criteria is insufficient for this Actor. Use a job discovery tool first when you need to find roles. Custom career domains, other ATS platforms and private candidate portals are outside this Actor's supported scope.

Example agent instruction: “Recheck these public Workday/iCIMS job URLs. Include our expected titles and IDs where supplied. Report each status with its reason, evidence URL and checkedAt timestamp; route unknown results for review.”

Interpret `open` as verified public posting content at the check time. Interpret `closed` as explicit closure wording, public-page HTTP 404/410, or Workday's job-specific unposted/not-found API codes, rather than proof the employer filled a role. `mismatch` means a readable posting differs from supplied expectations; it does not mean the posting closed. Preserve `unknown` as uncertainty. A successful Actor run does not establish that all jobs are open or that all inputs were processed.

### Supported sources

| Source | Supported URL | Verification |
| --- | --- | --- |
| Workday public careers | `https://tenant.wdN.myworkdayjobs.com/[locale/]board/job/location/role_ID` | Public page plus `/wday/cxs/tenant/board/job/...` detail. Requires a title, description, canonical identity and matching job path or requisition ID. |
| Workday recruiting sites | `https://wdN.myworkdaysite.com/[locale/]recruiting/tenant/board/job/location/role_ID` | Same public detail endpoint, with tenant and board derived from the recruiting path. |
| iCIMS public job portals | `https://careers-company.icims.com/jobs/12345/role/job` | Matching JobPosting JSON-LD or job-specific title/description plus a same-job application link. Can follow one explicit same-origin iframe for that job. |

Optional Workday locale prefixes such as `en-US` and `en-GB` are supported, as are modern job paths without a location segment (`board/job/role_ID` and `recruiting/tenant/board/job/role_ID`). iCIMS `/jobs/12345/job` and `/jobs/12345` paths are also accepted. Custom employer domains, other applicant tracking systems, search pages, private portals, and credentials in URLs return `unknown` without a request. Only HTTPS with the default port is supported.

### Input

```json
{
  "jobs": [
    {
      "url": "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Firmware-Engineer---CSP-Engagements_JR1999599",
      "expectedJobId": "JR1999599"
    }
  ],
  "concurrency": 3,
  "timeoutSeconds": 30
}
```

This Workday URL was verified on 2026-10-11; its future availability can change. Replace it with your own public job links. `jobs` accepts 1–10,000 objects, each with a required string `url`; only public HTTPS job URLs with the default port are supported. `expectedTitle` and `expectedJobId` are optional strings; a mismatch is reported only when the source provides actual title or ID evidence. Title and ID comparisons ignore case, surrounding whitespace, repeated whitespace and Unicode presentation differences. Distinct iCIMS year-prefixed identifiers and numeric portal IDs are retained in `jobIds` and both can match an expected ID.

`concurrency` is 1–10. `timeoutSeconds` is a per-request timeout of 5–120 seconds. Exact duplicate URL/expectation combinations are checked once, with URL fragments ignored. Different expectations are separate checks; query parameters are preserved. Results arrive as checks finish.

### Status and evidence

| Status | Meaning |
| --- | --- |
| `open` | The source exposes a coherent posting matching the requested job. |
| `closed` | The same public job page explicitly says the posting is unavailable, closed, expired or filled, or returns HTTP 404/410. For Workday, the public job API's explicit job-specific codes also count: `S22` (posting no longer publicly posted) and `S21` (posting not found). |
| `mismatch` | A verified posting differs from an expected title or ID. The actual source identity is included. |
| `unknown` | Access was blocked, login was required, a request failed, the page redirected elsewhere, or evidence was insufficient. |

HTTP 401/403/429, server errors, recognizable bot challenges and login walls take precedence over closure wording. A generic Workday detail-API 403/404 alone does not prove closure; only Workday's job-specific `S21`/`S22` error codes are reported as `closed`. `canApply: false`, an explicit unpublished flag and a past iCIMS structured-data expiry date produce `unknown` unless the public page separately confirms closure. Conflicting source identity or a redirect to a different page also produces `unknown`. Ordinary Sign In navigation on a readable job page is allowed.

Each result includes `checkedAt`, `platform`, `source`, `title`, `jobId`, `jobIds`, `reason`, `error`, and `evidence`. Each evidence item contains the response URL and HTTP status, plus a short quoted value and an API/HTML field when available. IDs and titles stay `null` when they could not be verified.

Illustrative output from the fixtures:

```json
{
  "url": "https://acme.wd12.myworkdayjobs.com/en-US/External/job/London/Engineer_R123",
  "checkedAt": "2026-10-11T02:00:00.000Z",
  "platform": "workday",
  "source": "workday_public_api",
  "status": "open",
  "jobId": "R123",
  "jobIds": ["R123", "posting-uuid"],
  "title": "Software Engineer",
  "reason": "The public source exposes a matching job posting.",
  "error": null,
  "evidence": [
    {
      "url": "https://acme.wd12.myworkdayjobs.com/wday/cxs/acme/External/job/London/Engineer_R123",
      "httpStatus": 200,
      "quote": "Software Engineer",
      "field": "jobPostingInfo.title"
    },
    {
      "url": "https://acme.wd12.myworkdayjobs.com/wday/cxs/acme/External/job/London/Engineer_R123",
      "httpStatus": 200,
      "quote": "R123, posting-uuid",
      "field": "jobPostingInfo.jobReqId/jobPostingId/id"
    }
  ]
}
```

Export the default dataset as JSON, CSV, Excel or through the Apify API. Evidence is nested; JSON preserves the complete structure.

### Call from an agent or application

The Actor ID is `Nickatnite79/job-listing-rechecker`. With `apify-client` installed and your own Apify token available as `APIFY_TOKEN`, this JavaScript example runs one check, applies a spending cap, and retrieves the dataset and run summary:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
  jobs: [{
    url: 'https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Firmware-Engineer---CSP-Engagements_JR1999599',
    expectedJobId: 'JR1999599',
  }],
  concurrency: 3,
  timeoutSeconds: 30,
};
const run = await client.actor('Nickatnite79/job-listing-rechecker')
  .call(input, { maxTotalChargeUsd: 0.05 });
if (run.status !== 'SUCCEEDED') throw new Error(`Actor ended with ${run.status}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const summary = await client.keyValueStore(run.defaultKeyValueStoreId)
  .getRecord('SUMMARY');
console.log({ results: items, summary: summary?.value });
```

The output schema exposes `results`, a link to default-dataset items, and `summary`, a link to the `SUMMARY` key-value record. The summary includes `produced`, `billableResults`, `diagnosticResults`, `stoppedForBudget` and `completedAt`. Check it alongside individual statuses. If `stoppedForBudget` is true, do not assume the full input was checked. Larger datasets may require pagination through the dataset API. Results arrive in completion order and exact duplicates are collapsed. Match by URL when each URL has one set of expectations; if you need to distinguish multiple expectation sets for the same URL, submit them in separate runs because the output does not echo those expectations.

### Running and billing

Use Node.js 24. Install with `npm ci`, run tests with `npm test`, and run locally with `npm start` after placing input at `storage/key_value_stores/default/INPUT.json`. Build and run on Apify using the included Actor definition, input schema, output schema, dataset view, and official `apify/actor-node:24` Docker image.

The published price is $0.005 per verified result ($5 per 1,000), charged through the custom pay-per-event event `result`. `open`, `closed` and `mismatch` rows incur that event. `unknown` rows do not incur it, including blocked and failed requests; they are included as diagnostics while the run continues. The internal `_billable` flag is removed from published dataset rows. Reaching the spending limit stops further checks, including diagnostics, so a zero budget is not a way to run a free status audit. Refer to the Actor's Pricing tab for current charges and your account's platform costs. Maintainers can use [PUBLISHING.md](./PUBLISHING.md) for deployment and Store setup.

### Verification and limitations

The fixture tests cover both Workday URL families, open and closed pages, expected-identity mismatch, API redirects, 403/429/challenges, login walls, missing and malformed API detail, iCIMS JSON-LD/metadata and public iframes, past expiry, malformed URLs, deduplication and bounded concurrency.

A live Apify cloud smoke test on 2026-10-11 verified the NVIDIA Workday job `JR1999599` using the URL in [INPUT.example.json](./INPUT.example.json). Run [Imd2DjpjYwc6lUdRc](https://console.apify.com/actors/runs/Imd2DjpjYwc6lUdRc) succeeded, produced one `open` row, and charged the `result` event once. iCIMS coverage is fixture-tested only; no live iCIMS verification is claimed. Job links and employer markup can change, so repeat a small cloud test for your target employers before relying on the results.

This is a point-in-time check. Employers may leave stale structured data online, close a role while retaining its page, or reopen a requisition. `open` confirms a public posting, not that an employer will accept or respond to an application. HTTP 404/410 reports public-page unavailability, which may occasionally reflect an employer error. The Actor uses HTTP parsing rather than a browser, and returns `unknown` for unsupported JavaScript-only pages, ambiguous responses, and markup it cannot verify. It does not solve CAPTCHAs or log in.

### Live example run

This is real output from a cloud run of the Actor's default (prefilled) input on 2026-10-16. Just click **Start** to reproduce it.

- Full example dataset (public, JSON): https://api.apify.com/v2/datasets/1YFFaDZK1nHfLgGZv/items?clean=1\&format=json

Input:

```json
{
  "jobs": [
    {
      "url": "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Firmware-Engineer---CSP-Engagements_JR1999599",
      "expectedJobId": "JR1999599"
    }
  ]
}
```

Output (first item; long arrays shortened):

```json
{
  "url": "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Firmware-Engineer---CSP-Engagements_JR1999599",
  "checkedAt": "2026-10-16T00:21:26.546Z",
  "platform": "workday",
  "source": "workday_public_api",
  "jobId": "JR1999599",
  "jobIds": [
    "JR1999599",
    "Senior-Firmware-Engineer---CSP-Engagements_JR1999599",
    "1eba8b496c9d10015905176f4cdf0000"
  ],
  "title": "Senior Firmware Engineer – CSP Engagements",
  "error": null,
  "status": "open",
  "reason": "The public source exposes a matching job posting.",
  "evidence": [
    {
      "url": "https://nvidia.wd5.myworkdayjobs.com/wday/cxs/nvidia/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Firmware-Engineer---CSP-Engagements_JR1999599",
      "httpStatus": 200,
      "quote": "Senior Firmware Engineer – CSP Engagements",
      "field": "jobPostingInfo.title"
    },
    {
      "url": "https://nvidia.wd5.myworkdayjobs.com/wday/cxs/nvidia/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Firmware-Engineer---CSP-Engagements_JR1999599",
      "httpStatus": 200,
      "quote": "JR1999599, Senior-Firmware-Engineer---CSP-Engagements_JR1999599, 1eba8b496c9d10015905176f4cdf0000",
      "field": "jobPostingInfo.jobReqId/jobPostingId/id"
    }
  ]
}
```

# Actor input Schema

## `jobs` (type: `array`):

Each item has a public job URL and optional expectedTitle and expectedJobId. Exact duplicate inputs are checked once.

## `concurrency` (type: `integer`):

Maximum simultaneous checks; capped at 10.

## `timeoutSeconds` (type: `integer`):

Per HTTP request timeout.

## Actor input object example

```json
{
  "jobs": [
    {
      "url": "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Firmware-Engineer---CSP-Engagements_JR1999599",
      "expectedJobId": "JR1999599"
    }
  ],
  "concurrency": 3,
  "timeoutSeconds": 30
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "jobs": [
        {
            "url": "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Firmware-Engineer---CSP-Engagements_JR1999599",
            "expectedJobId": "JR1999599"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nickatnite79/job-listing-rechecker").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 = { "jobs": [{
            "url": "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Firmware-Engineer---CSP-Engagements_JR1999599",
            "expectedJobId": "JR1999599",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("nickatnite79/job-listing-rechecker").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 '{
  "jobs": [
    {
      "url": "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Firmware-Engineer---CSP-Engagements_JR1999599",
      "expectedJobId": "JR1999599"
    }
  ]
}' |
apify call nickatnite79/job-listing-rechecker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nickatnite79/job-listing-rechecker"
        }
    }
}
```

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/o38EcrrZPBYOso9bn/builds/fF3nqggcPCB3giHy0/openapi.json