# Workday Jobs Scraper — Any Career Site, Filters & Details (`fabrikit/workday-jobs-scraper`) Actor

Workday jobs scraper for any myworkdayjobs.com or myworkdaysite.com career site: title, locations, remote and time type, posting date, requisition ID and job URL, plus optional full description. Keyword and facet filters; splits big sites past Workday's 2,000-result cap. From US$1.40 per 1,000 jobs.

- **URL**: https://apify.com/fabrikit/workday-jobs-scraper.md
- **Developed by:** [Fabrikit](https://apify.com/fabrikit) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 job scrapeds

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 Scraper

**Workday Jobs Scraper extracts open job postings from any company career site hosted on Workday** (`*.myworkdayjobs.com` and `*.myworkdaysite.com`): title, locations, remote and time type, posting date, requisition ID and the job link, plus an optional add-on with the full description. Paste the career-site address you land on after clicking "Careers" on a company website, add a keyword or filters if you like, and get clean JSON, CSV or Excel. No login, no browser, no API key.

Thousands of large employers (NVIDIA, Salesforce, Intel, Mastercard, Capital One, Wells Fargo, Red Hat, Workday itself...) publish their vacancies on Workday. Each career site has its own address and its own filter panel; this Actor reads them all through the same public JSON endpoints the career sites use in your browser, and returns one consistent schema.

It belongs to the same family as our [ATS Jobs Scraper](https://apify.com/fabrikit/ats-jobs-api) (Greenhouse, Lever, Ashby and SmartRecruiters boards) and the [Career Page Jobs Scraper](https://apify.com/fabrikit/career-page-jobs-scraper) (finds which of 13 ATS a company uses). Workday works differently from those systems (one tenant per company, facet IDs, a 2,000-result ceiling per search), so it gets its own Actor.

### What you get

- **Job basics on every record**: job ID, requisition number (when the site shows it in the list), title, company tenant, career site, location (or the number of locations), remote type (Remote, Hybrid, Flex... when the employer publishes it), time type on sites that list it, the "Posted N Days Ago" label, days since posting, a posting date, extra list lines such as "Posting End Date", and the public job URL with the Apply button.
- **Details add-on** (`includeDetails`): full description as plain text and as HTML, every location, the exact posting date, the apply-by date, "days left to apply", country and ISO country code, requisition location, the hiring legal entity and whether the posting accepts applications.
- **Keyword search** in each site's own search box.
- **Facet filters by name**: type `United States`, `Remote`, `Engineering`, `Full time` or `Job Category: Sales`; the Actor finds the matching values in each site's filter panel, whatever internal names the site uses.
- **Posted within N days** (1 to 30), with an early stop so recent-job runs stay cheap.
- **Past the 2,000-result ceiling**: Workday never returns more than 2,000 results for one search. When you ask for more, the search is split by a facet (for NVIDIA: job category) and the parts are merged without duplicates.
- **Careers-page discovery**: give a company careers page that links to Workday (for example `https://www.redhat.com/en/jobs`) and the Actor follows the link.
- E-mail addresses and phone numbers in descriptions are removed.

### Use cases

- **Job boards and aggregators**: keep a feed of jobs from the employers you cover, with links back to the original posting.
- **Hiring signals for sales**: see which companies are hiring for which teams and locations right now.
- **Labor-market research**: track job counts by category, country or remote type for a list of large employers.
- **Job seekers and recruiters**: monitor a few target companies daily with `postedWithinDays: 1`.
- **AI agents and RAG**: give an assistant structured, current openings from specific employers.

### How to use

1. Open the company's career site in your browser and copy the address (for example `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`). Keep the `wd1`/`wd5`/`wd12` part: it tells which Workday data center hosts the company.
2. Paste one or more addresses into **Workday career-site URLs**. A filtered search address from the site also works: its keyword (`q`) and facet parameters are applied.
3. Optionally set a keyword, filters, a posting-age limit and the details add-on, then press **Start**.

Example input:

```json
{
    "careerSiteUrls": [
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
        "https://wd1.myworkdaysite.com/recruiting/wf/WellsFargoJobs",
        "https://www.redhat.com/en/jobs"
    ],
    "searchText": "",
    "filters": ["Remote", "Engineering"],
    "postedWithinDays": 7,
    "includeDetails": true,
    "maxItems": 200,
    "maxItemsPerSite": 100
}
```

A single job URL (`.../job/<location>/<title>_<id>`) returns just that job. A site where one of your filters matches nothing is skipped, and the run SUMMARY says why.

### Output example

One real record (NVIDIA, details add-on on; description shortened):

```json
{
    "jobId": "Senior-HPC-Storage-Engineer_JR2014997",
    "requisitionId": "JR2014997",
    "title": "Senior HPC Storage Engineer - EDA Infrastructure",
    "company": "nvidia",
    "careerSite": "NVIDIAExternalCareerSite",
    "location": "US, CA, Santa Clara",
    "locationsCount": 2,
    "remoteType": null,
    "timeType": "Full time",
    "postedOn": "Posted Today",
    "postedDaysAgo": 0,
    "postedDate": "2026-10-20",
    "postedDateSource": "details",
    "listFields": [],
    "url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-HPC-Storage-Engineer_JR2014997",
    "careerSiteUrl": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "input": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "detailsFetched": true,
    "description": "As a member of the HW Infrastructure Storage Strategy team, you will be the bridge between storage infrastructure and the chip design ...",
    "descriptionHtml": "<p>As a member of the HW Infrastructure Storage Strategy team, ...</p>",
    "locations": ["US, CA, Santa Clara", "US, Remote"],
    "country": "United States of America",
    "countryCode": "US",
    "requisitionLocation": "US, CA, Santa Clara",
    "endDate": null,
    "timeLeftToApply": null,
    "hiringEntity": "2100 NVIDIA USA",
    "canApply": true,
    "workdayJobId": "e197b3ffb77f102fc60f579474340000",
    "scrapedAt": "2026-10-21T01:20:47.727Z"
}
```

Without the add-on, the detail fields are left out, multi-location jobs have `location: null` with `locationsCount`, and `postedDate` is estimated from the "Posted N Days Ago" label (`postedDateSource: "estimated"`, possibly one day off; null for "30+ days"). A `SUMMARY` record in the key-value store lists, per career site, how many jobs it reports, which filters matched, whether the search was split and any error.

### Pricing

Pay per event, no subscription:

| Event | Price |
|---|---|
| `job-result` — each unique job saved | US$1.40 per 1,000 jobs |
| `job-details` — add-on, each job enriched with its job page | US$0.40 per 1,000 jobs |

Examples: 1,000 jobs = **US$1.40**; 1,000 jobs with full details = **US$1.80**; a daily check of 20 companies returning 300 new jobs with details ≈ US$0.54 per day. Duplicates are never charged, `maxItems` is exact, and the run stops at the spending limit you set.

### How it compares

- **Workday job databases and APIs** search across many employers at once from a pre-built index. Good for broad discovery; this Actor instead reads the live career sites you choose, so new postings appear as soon as the employer publishes them and you control which companies are covered.
- **Browser-based scrapers** render every page in Chrome. Here every request is a small JSON call: 20 jobs per request, about 0.5 KB per job, so runs are fast and cheap.
- **Our other job Actors**: for Greenhouse, Lever, Ashby or SmartRecruiters boards use the [ATS Jobs Scraper](https://apify.com/fabrikit/ats-jobs-api); if you only know company names and not their ATS, try the [Career Page Jobs Scraper](https://apify.com/fabrikit/career-page-jobs-scraper).
- Limits, honestly: salary is only present when the employer writes it in the description (Workday has no salary field in the public answer); the list view does not say which locations a multi-location job has (the details add-on does); company names come as Workday tenant names (`nvidia`, `wf`) plus the legal entity in the details.

### Integrations

Use the results through the Apify API (JSON, CSV, Excel, XML), schedule runs in Apify, send them to Google Sheets, Slack or a webhook, or connect the Actor to **n8n**, **Make**, **Zapier** and other tools with the Apify integrations. AI agents can call it through the **Apify MCP server**.

### FAQ

**Is it legal?** The Actor reads job postings that employers publish openly on their career sites, without logging in and at a polite pace. Job ads are business information; contact details of individual people are removed from descriptions. Check the terms of the sites and the laws that apply to how you reuse the data. This Actor is not affiliated with Workday, Inc.

**Do I need a proxy?** Usually not; the default Apify proxy setting is enough. Workday career sites are behind Cloudflare: if requests start getting blocked, the Actor switches to Apify residential proxies automatically for the rest of the run.

**Why does my URL fail with HTTP 422 or 404?** 422 means the company name or the `wdN` part of the address does not match where the company is hosted; 404 means the career-site name is wrong or the site was retired. Open the career site in a browser and copy its current address.

**How many jobs can I get?** All open jobs of a site. Searches above 2,000 results are split automatically (turn off `splitLargeSites` to stop at 2,000).

**Can I get jobs from a company that does not use Workday?** No; use our [Career Page Jobs Scraper](https://apify.com/fabrikit/career-page-jobs-scraper) for other applicant tracking systems.

### Changelog

- **0.1** (October 2026): first release. Career-site, filtered-search and job URLs; careers-page discovery; keyword, facet filters by name, posted-within-days; details add-on; automatic split past 2,000 results; residential fallback.

### En español

**Workday Jobs Scraper** extrae los empleos abiertos de cualquier sitio de carreras alojado en Workday (`myworkdayjobs.com` y `myworkdaysite.com`): título, ubicaciones, modalidad remota y jornada, fecha de publicación, número de requisición y enlace al aviso; con el complemento de detalles suma la descripción completa (sin correos ni teléfonos de personas), todas las ubicaciones, fecha exacta, fecha límite para postular, país y entidad contratante. Pegas la dirección del sitio de carreras de la empresa, opcionalmente una palabra clave, filtros por nombre (`United States`, `Remote`, `Engineering`) y antigüedad máxima, y obtienes JSON, CSV o Excel. Supera el tope de 2.000 resultados por búsqueda de Workday dividiendo la búsqueda por facetas. Cuesta **US$1,40 por cada 1.000 empleos** y US$0,40 por cada 1.000 con detalles. Para Greenhouse, Lever, Ashby o SmartRecruiters usa nuestro [ATS Jobs Scraper](https://apify.com/fabrikit/ats-jobs-api).

# Actor input Schema

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

One URL per line. Accepted: a career site (`https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`, `https://wd1.myworkdaysite.com/recruiting/wf/WellsFargoJobs`, with or without a language part such as `/en-US/`), a filtered search copied from the site (its `q` keyword and facet parameters are kept), a single job URL (`.../job/<location>/<title>_<id>`), or a company careers page that links to its Workday site (`https://www.redhat.com/en/jobs`).

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

Optional. Sent to each site's own search box, e.g. `data engineer` or `python`. Leave empty to list every open job (newest first). A `q` parameter inside a pasted URL takes precedence for that URL.

## `filters` (type: `array`):

Optional. Names of values from the site's own filter panel, one per line: a country (`United States`), a city or site (`Santa Clara`), a job category (`Engineering`), a work type (`Remote`, `Hybrid`), `Full time`... Each word is matched against the facets of every site (exact name first, then partial). Use `Facet: Value` to pick a facet, e.g. `Job Category: Sales`. Values of the same facet are combined with OR, different facets with AND. A site where a filter matches nothing is skipped (and listed in the SUMMARY).

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

Keep only jobs posted in the last N days (1-30), using the site's "Posted N Days Ago" label. 0 = any date. Workday only says "30+ days" for older jobs, so 30 is the longest window.

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

One extra request per job for the full description (plain text and HTML, e-mail addresses and phone numbers removed), every location, the exact posting date, the application end date, country and ISO code, requisition ID and the hiring legal entity. Charged as the job-details event on top of job-result.

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

Stop after this many jobs in total across all sites (exact; duplicates are never saved or charged).

## `maxItemsPerSite` (type: `integer`):

Keep at most this many jobs from each career site, so one large employer does not use up the whole run. 0 = no per-site limit.

## `splitLargeSites` (type: `boolean`):

Workday never returns more than 2,000 results for one search. When you ask for more than that from a bigger site, the search is split by one of the site's facets (job category, location type, country...) and the parts are combined without duplicates. Turn off to read only the first 2,000.

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

Workday career sites answer the JSON endpoints used here without login. If Cloudflare in front of a site starts blocking (HTTP 403/429 or a challenge page), the Actor retries through Apify RESIDENTIAL proxies automatically.

## Actor input object example

```json
{
  "careerSiteUrls": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "https://wd1.myworkdaysite.com/recruiting/wf/WellsFargoJobs"
  ],
  "filters": [],
  "postedWithinDays": 0,
  "includeDetails": false,
  "maxItems": 20,
  "maxItemsPerSite": 10,
  "splitLargeSites": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All jobs saved during the run (overview view)

## `jobsWithDetails` (type: `string`):

Same jobs with description, locations, country and dates (filled when the details add-on is on)

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

Per career site: jobs listed, filters matched, splits used, errors; requests and proxy rung

# 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",
        "https://wd1.myworkdaysite.com/recruiting/wf/WellsFargoJobs"
    ],
    "filters": [],
    "maxItems": 20,
    "maxItemsPerSite": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/workday-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 = {
    "careerSiteUrls": [
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
        "https://wd1.myworkdaysite.com/recruiting/wf/WellsFargoJobs",
    ],
    "filters": [],
    "maxItems": 20,
    "maxItemsPerSite": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/workday-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 '{
  "careerSiteUrls": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "https://wd1.myworkdaysite.com/recruiting/wf/WellsFargoJobs"
  ],
  "filters": [],
  "maxItems": 20,
  "maxItemsPerSite": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/workday-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fabrikit/workday-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/6xutUXgl4iXds4wcT/builds/3M7fET9goehgvFvkQ/openapi.json