# Workday Jobs Scraper (`automation-lab/workday-jobs-api-scraper`) Actor

Extract normalized public Workday job listings from one or many employer career sites for search, aggregation, export, and recurring vacancy monitoring.

- **URL**: https://apify.com/automation-lab/workday-jobs-api-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Workday Jobs Scraper

Collect public **Workday jobs** from one employer or many employers in a single run.

Workday Jobs Scraper queries public `myworkdayjobs.com` career sites, follows their native pagination, and returns normalized vacancy records ready for spreadsheets, databases, recruiting research, and recurring monitoring.

Give it career-site URLs rather than a proprietary company directory. This keeps the target explicit and makes scheduled results repeatable.

### What does Workday Jobs Scraper do?

The Actor uses Workday's public career-site JSON endpoints to:

- search one or more employer career sites;
- aggregate vacancies into one default dataset;
- fetch full job details when requested;
- normalize fields across Workday tenants;
- stop at one global result limit;
- preserve stable keys for comparisons between runs;
- export results as JSON, CSV, Excel, XML, or RSS through Apify.

It does not log in, submit applications, or read a candidate's application status.

### Who is this Workday jobs API for?

**Job-board operators** can ingest employer-posted vacancies into a downstream catalog.

**Recruiting intelligence teams** can compare openings across selected employers.

**Analysts** can export role titles, locations, posting age, and descriptions for workforce research.

**Developers** can call one consistent API instead of integrating separately with every Workday tenant.

**Automation teams** can schedule runs and compare `dedupeKey` values to detect additions and removals.

### Why use this Actor?

Workday tenants use different hosts and career-site identifiers, but their public data follows a common CXS response shape.

This Actor handles URL parsing, pagination, retries, normalization, optional detail requests, deduplication, and Apify dataset export.

The implementation is HTTP-only. It does not start a browser or automatically use paid residential proxies.

When one employer fails in a multi-employer run, the Actor continues with other valid employers. If every supplied site fails, the run fails visibly rather than returning a misleading empty success.

### What Workday job data can I extract?

| Field | Meaning |
| --- | --- |
| `source` | Always `workday` |
| `tenant` | Tenant parsed from the Workday hostname |
| `careerSite` | Career-site identifier |
| `careerSiteUrl` | Canonical employer career-site URL |
| `sourceJobId` | Stable identifier derived from the job path |
| `requisitionId` | Employer requisition ID when publicly available |
| `title` | Job title |
| `location` | Primary location text |
| `additionalLocations` | Other advertised locations |
| `postedOn` | Posting date or age text from Workday |
| `timeType` | Full-time, part-time, or another exposed time type |
| `remoteType` | Remote, hybrid, or on-site text when exposed |
| `descriptionHtml` | Full public description when detail fetching is enabled |
| `jobUrl` | Public job page |
| `applyUrl` | Public application URL or job URL fallback |
| `dedupeKey` | Stable tenant/site/path key for recurring comparisons |
| `scrapedAt` | Collection timestamp in ISO 8601 format |

A field can be `null` when the employer does not expose it.

### How to scrape Workday career sites

1. Open an employer's public `myworkdayjobs.com` career site.
2. Copy the board URL, not an individual job URL.
3. Add one or more URLs to `careerSiteUrls`.
4. Optionally enter keywords in `searchText`.
5. Choose a global `maxItems` limit.
6. Keep `includeDetails` enabled for descriptions and requisition fields.
7. Click **Start**.
8. Open the default dataset to preview or download records.

A supported URL looks like:

```text
https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite
```

Localized paths are also supported:

```text
https://tenant.wd3.myworkdayjobs.com/en-US/ExternalCareers
```

### Input parameters

#### `careerSiteUrls`

Required array of 1–50 public Workday career-site URLs.

All URLs must use HTTPS and a hostname shaped like `{tenant}.wd{number}.myworkdayjobs.com`.

#### `searchText`

Optional keyword text sent to each career site's native search endpoint.

Use a short query such as `software`, `data analyst`, or `finance`.

#### `maxItems`

Maximum number of unique records saved across every supplied employer.

The accepted range is 1–10,000. The default is 100.

#### `includeDetails`

When `true`, the Actor requests each job's public detail endpoint.

This adds descriptions, requisition IDs, time types, and additional locations where available.

Set it to `false` for faster list-level scans.

### Example input: search one employer

```json
{
  "careerSiteUrls": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
  ],
  "searchText": "software",
  "maxItems": 20,
  "includeDetails": true
}
```

### Example input: aggregate employers

```json
{
  "careerSiteUrls": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "https://workday.wd5.myworkdayjobs.com/Workday"
  ],
  "searchText": "",
  "maxItems": 50,
  "includeDetails": false
}
```

The limit applies to the combined dataset, not separately to each URL.

### Example output

```json
{
  "source": "workday",
  "tenant": "samplecompany",
  "careerSite": "ExternalCareers",
  "careerSiteUrl": "https://samplecompany.wd5.myworkdayjobs.com/ExternalCareers",
  "sourceJobId": "Software-Engineer_R1001",
  "requisitionId": "REQ-1001",
  "title": "Software Engineer",
  "location": "Austin, Texas, United States",
  "additionalLocations": ["Remote - United States"],
  "postedOn": "Posted Today",
  "timeType": "Full time",
  "remoteType": "Hybrid",
  "descriptionHtml": "<p>Example public job description.</p>",
  "jobUrl": "https://samplecompany.wd5.myworkdayjobs.com/job/Software-Engineer_R1001",
  "applyUrl": "https://samplecompany.wd5.myworkdayjobs.com/job/Software-Engineer_R1001",
  "dedupeKey": "samplecompany:ExternalCareers:/job/Software-Engineer_R1001",
  "scrapedAt": "2025-01-15T12:00:00.000Z"
}
```

The default dataset is compatible with Apify's API, webhooks, integrations, and exports.

### How much does it cost to extract Workday jobs?

The Actor uses pay-per-event pricing:

- one small `start` event is charged after input validation;
- one `job` event is charged for each normalized vacancy saved;
- failed, duplicate, or rejected records are not charged as jobs;
- detail fields do not create a separate event charge.

Your exact per-job tier appears in Apify Console before the run starts. At the BRONZE tier, each run charges the **$0.0005 start event** once and **$0.001196 per saved job**. For example, a 20-job collection records one `start` event and 20 `job` events; a 100-job collection records one `start` event and 100 `job` events.

Larger platform subscription tiers receive lower per-job rates. Failed, duplicate, and rejected jobs add no item charge. Set a low result limit for small tests and a higher limit for production collections.

### Recurring vacancy monitoring

Run the Actor on a schedule to build timestamped snapshots.

For each snapshot:

1. retain `dedupeKey` as the stable record identity;
2. compare current keys with the previous dataset;
3. treat new keys as newly observed vacancies;
4. treat missing keys as removed or closed vacancies;
5. compare selected fields to identify changed locations or descriptions.

The Actor reports the current public state. It does not maintain historical state or send alerts by itself.

Use an Apify schedule, webhook, Make scenario, or Zapier workflow for downstream monitoring.

### Export Workday jobs to a spreadsheet or pipeline

In Apify Console, open the run's dataset and choose JSON, CSV, Excel, XML, or RSS.

For a recurring pipeline, retrieve dataset items through the API after each successful run.

Common destinations include:

- Google Sheets for review;
- a warehouse for workforce analysis;
- a database-backed job board;
- an alerting workflow for selected roles;
- a deduplication or change-detection service.

Description HTML may contain markup. Strip or sanitize it before rendering in another application.

### API usage with cURL

Replace `YOUR_APIFY_TOKEN` with an Apify API token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~workday-jobs-api-scraper/runs?token=YOUR_APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{
    "careerSiteUrls": ["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"],
    "searchText": "software",
    "maxItems": 20,
    "includeDetails": true
  }'
```

Fetch items from the `defaultDatasetId` returned by the run response.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/workday-jobs-api-scraper').call({
  careerSiteUrls: ['https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite'],
  searchText: 'software',
  maxItems: 20,
  includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Pin a client version in production and keep tokens outside source control.

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/workday-jobs-api-scraper").call(run_input={
    "careerSiteUrls": [
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
    ],
    "searchText": "software",
    "maxItems": 20,
    "includeDetails": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["jobUrl"])
```

Use environment variables or a secret manager for the token.

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/workday-jobs-api-scraper"
```

#### Claude Desktop MCP setup

Add this server entry to your Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/workday-jobs-api-scraper"
    }
  }
}
```

#### Cursor MCP setup

Add the same `mcpServers.apify.url` entry in Cursor's MCP settings.

#### VS Code MCP setup

Add the HTTP URL to your VS Code MCP server configuration, then enable the Apify server for your workspace.

Example prompts:

- “Search NVIDIA's Workday career site for software roles and return the first 20.”
- “Collect list-level jobs from these three Workday career-site URLs.”
- “Run this Workday vacancy collection every morning and compare stable dedupe keys.”

MCP clients still use the same Actor input and pricing contract.

### Reliability, retries, and limits

The Actor retries transient network failures, HTTP 429 responses, server errors, and Workday maintenance redirects up to three attempts with backoff.

Deterministic invalid URLs and client errors are not retried blindly.

Detail requests run with bounded concurrency. A failed detail request keeps the useful list-level record rather than discarding the vacancy.

A failed employer does not stop other employers in the same run. The logs identify any failed career site.

The run fails when every supplied career site fails.

Workday can change or temporarily disable its public endpoints without notice.

### Responsible use and legality

This Actor accesses public employer career-site data without logging in.

You are responsible for ensuring that your collection and downstream use comply with applicable laws, the source site's terms, and contractual obligations.

Avoid collecting more frequently than your use case requires.

Do not use output to discriminate unlawfully, misrepresent an employer, spam applicants, or republish personal data without a lawful basis.

Job descriptions can contain employer trademarks and copyrighted text. Preserve attribution and use the data responsibly.

This Actor does not bypass access controls or retrieve candidate accounts, application status, or private recruiting data.

### Troubleshooting

#### Why does my URL fail validation?

Use the career-site board URL, not a company homepage or individual job page.

The host must end in `.myworkdayjobs.com` and include a Workday shard such as `.wd5.`.

#### Why are description fields null?

Enable `includeDetails`. Some employers do not expose every detail field even when detail fetching is enabled.

#### Why did the run return fewer records than `maxItems`?

The native search may have fewer matches, duplicate paths may be removed, or one employer may have failed. Review the log and dataset.

#### Why did the whole run fail?

Every supplied career site failed validation or its public endpoint was unavailable after retries. Check the URLs and try again after a documented Workday maintenance window.

#### Can it check my Workday application status?

No. Application status requires a private candidate account and is outside this Actor's public vacancy scope.

#### Does it need a proxy?

No proxy is configured. The Actor uses direct HTTP and does not expose an automatic paid fallback.

### Related job data Actors

- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) for public LinkedIn job discovery.
- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper) for employer boards hosted on Greenhouse.
- [Multi-ATS Company Jobs Scraper](https://apify.com/automation-lab/multi-ats-jobs-scraper) when you need broader ATS coverage from one workflow.

Use this Actor when your targets are known public Workday career sites and you want native Workday fields with stable source paths.

### FAQ

**Can I supply several employers?**

Yes. Add up to 50 career-site URLs. `maxItems` is shared across the combined run.

**Can I request only remote jobs?**

Use `searchText` if the employer's native search recognizes “remote,” then verify the returned `location` and `remoteType` fields. There is no guaranteed cross-tenant remote facet.

**Can I scrape an individual job URL?**

No. Supply the career-site board URL and use a restrictive search or small result limit.

**Does the Actor remove closed jobs from an old dataset?**

No. Every run gets its own default dataset. Compare scheduled-run datasets to detect removals.

**Are job records charged when a detail request fails?**

Yes, if the useful list-level vacancy is saved. Details do not have a separate charge event.

**Is an empty search an error?**

No. A valid career site with no matching jobs completes with zero job events. An invalid or unavailable endpoint is treated as an error instead.

# Actor input Schema

## `careerSiteUrls` (type: `array`):

One or more public Workday career site URLs, for example https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite. Add multiple employers to create one normalized dataset.

## `searchText` (type: `string`):

Optional text passed to each Workday career-site search, such as software engineer or data analyst.

## `maxItems` (type: `integer`):

Maximum number of unique jobs saved across all supplied career sites.

## `includeDetails` (type: `boolean`):

Fetch each public job detail endpoint to include description HTML, requisition ID, time type, and additional locations. Disable for faster list-level monitoring.

## Actor input object example

```json
{
  "careerSiteUrls": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
  ],
  "searchText": "",
  "maxItems": 20,
  "includeDetails": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing all successfully collected vacancy records.

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

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/workday-jobs-api-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 = {
    "careerSiteUrls": ["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/workday-jobs-api-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 '{
  "careerSiteUrls": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
  ],
  "maxItems": 20
}' |
apify call automation-lab/workday-jobs-api-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/workday-jobs-api-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/q5f0wfbd4q2FbI5Qt/builds/2j715I38aIdTiLWLi/openapi.json