# Workday Jobs API — Every Posting on a Workday Career Site (`insight.solutions/workday-jobs-api`) Actor

Every open posting on any Workday career site (\*.myworkdayjobs.com) as clean rows: title, requisition id, locations, posted date, time and remote type, country and the full description. Workday's own facets and search, any number of sites. No key, no login, no browser.

- **URL**: https://apify.com/insight.solutions/workday-jobs-api.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** Jobs, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 job postings

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 Jobs API — Every Posting on a Workday Career Site

Paste any **Workday** career-site address — anything on `*.myworkdayjobs.com`,
such as `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`, a link
to one posting, or just `boeing.wd1.myworkdayjobs.com/EXTERNAL_CAREERS` — and get
**one clean row per open posting**: title, requisition id, locations, posted
date, time type, remote type, country and the full description as text,
Markdown or HTML. Filter with Workday's own facets (job category, country,
location, time type…) and search box, or with title, location, remote and
posted-within-days filters of your own. Any number of sites in one run.

It reads exactly what the career site itself loads in a visitor's browser:
Workday's public career-site JSON. **No API key, no login, no cookie, no
browser.** A tenant that only shows its jobs to signed-in users is reported, not
worked around.

### At a glance

**Input** — this is the Store prefill; paste it and run:

```json
{ "sites": ["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"], "searchText": "", "facets": {},
  "listFacets": false, "includeDescription": true, "descriptionFormat": "text", "titleFilter": [],
  "titleExclude": [], "locationFilter": [], "remoteOnly": false, "maxJobsPerSite": 20, "maxJobsTotal": 1000,
  "maxDetailFetches": 1000, "maxConcurrency": 3, "maxRunSecs": 240, "proxyConfiguration": { "useApifyProxy": true } }
```

NVIDIA's 20 newest postings with their descriptions — 1 list page and 20
detail documents, about 21 requests.

**Output** — one `job-posting` row per posting; the fields you will use most are
`title`, `jobId`, `locations`, `countryCode`, `postedAt`, `timeType`,
`isRemote`, `descriptionText` and `url`. Then one free `site` row per site with
the total Workday reports. Anything that could not be read — a site id that
does not exist, a tenant that refuses anonymous visitors, a facet the site does
not have — comes back as a free diagnostic row (`ok: false`, `errorType`,
`error`) instead of a charge.

**Price** — **$1 per 1,000 postings** (+ $0.001 per run) on the FREE tier, with
or without descriptions; site rows, facet rows, diagnostics, filtered-out
postings and empty runs free; limited permissions, works over the Apify MCP
server (`mcp.apify.com`) and with x402 agentic payments.

**From code** —
`client.actor("insight.solutions/workday-jobs-api").call(run_input={…})` with
`apify-client`, or `POST
https://api.apify.com/v2/acts/insight.solutions~workday-jobs-api/run-sync-get-dataset-items`.

Need other ATS platforms too — Greenhouse, Lever, Ashby and the rest? See
**Career Site Jobs API**
([insight.solutions/ats-jobs-api](https://apify.com/insight.solutions/ats-jobs-api)),
which reads 13 of them, Workday included, in one schema.
This Actor does one platform, all the way down: every facet, any number of
sites, and descriptions for every posting.

***

### What you get

A **job posting** as the list page gives it (the prefill's first row, with
`includeDescription: false`; empty columns left out):

```json
{
  "ok": true,
  "rowType": "job-posting",
  "input": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
  "scrapedAt": "2026-10-05T12:00:00.000Z",
  "source": "nvidia.wd5.myworkdayjobs.com",
  "sourceUrl": "https://nvidia.wd5.myworkdayjobs.com/wday/cxs/nvidia/NVIDIAExternalCareerSite/jobs",
  "jobId": "JR2026139",
  "title": "Senior Technical Program Manager",
  "url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Technical-Program-Manager_JR2026139",
  "company": "Nvidia",
  "siteName": "NVIDIAExternalCareerSite",
  "locationsText": "US, CA, Santa Clara",
  "locations": ["US, CA, Santa Clara"],
  "city": "Santa Clara",
  "region": "CA",
  "countryCode": "US",
  "postedOn": "Posted Today",
  "postedAt": "2026-10-05",
  "postedAtPrecision": "derived",
  "rank": 1
}
```

With `includeDescription` on (the default), each posting's detail document adds
— shown here for an NVIDIA posting in the test fixtures:

```json
{
  "applyUrl": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Deep-Learning-Performance-Engineer_JR1998001/apply",
  "locations": ["US, CA, Santa Clara", "US, TX, Austin"],
  "remoteType": "Hybrid Remote",
  "isRemote": false,
  "timeType": "Full time",
  "postedAt": "2026-09-01",
  "postedAtPrecision": "exact",
  "descriptionText": "Optimise deep learning kernels across the NVIDIA stack.\n\n- CUDA\n- Profiling",
  "sourceUrl": "https://nvidia.wd5.myworkdayjobs.com/wday/cxs/nvidia/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Deep-Learning-Performance-Engineer_JR1998001"
}
```

A **site** row (free, one per site read):

```json
{
  "ok": true,
  "rowType": "site",
  "company": "Nvidia",
  "siteName": "NVIDIAExternalCareerSite",
  "url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
  "totalPostings": 2000,
  "returned": 20,
  "filteredOut": 0,
  "facetNames": ["jobFamilyGroup", "workerSubType", "timeType", "locationHierarchy2", "locationHierarchy1", "locations"]
}
```

A **facet** row (free, with `listFacets: true`) — one per value, so you can
filter by it:

```json
{ "ok": true, "rowType": "facet", "company": "Boeing", "siteName": "EXTERNAL_CAREERS",
  "facetParameter": "jobFamilyGroup", "facetLabel": "Job Category",
  "valueLabel": "Software Engineering (6J)", "valueId": "8b618a30e00f01c7277572e8143f8b25", "count": 94 }
```

Every row carries every column — null where it does not apply — so the dataset
exports as one table.

***

### Quick start

1. Open the career site you want in a browser and copy the address bar — any page
   of it.
2. Paste it into **Workday career sites**. Add as many as you like.
3. Run. Each posting arrives as a row; each site adds one free `site` row with
   the total Workday reports.

To filter with Workday's own categories, run once with **List facets** on and
**Max postings per site** at 1. The free `facet` rows list every category,
country and location the site offers, with its id and count. Put the names you
want into **Facets** and run again.

***

### Any Workday address works

| You paste | It reads |
|---|---|
| `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite` | the site |
| `https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite` | the same site (the locale is skipped) |
| `https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Senior-Technical-Program-Manager_JR2026139` | the whole site that posting is on |
| `nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite` | the same site |
| `workday:nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite` | the same site (Career Site Jobs API's spelling) |
| `https://nvidia.wd5.myworkdayjobs.com/wday/cxs/nvidia/NVIDIAExternalCareerSite/jobs` | the same site (the API address itself) |

The same site given twice is read once. A query string (`?q=…`) is ignored —
search and filters come from the inputs, so a run means the same thing for every
site in it. Anything that is not a Workday career site — another ATS, a company
homepage, a host with no site id — comes back as a free `invalid-input` row and
the other sites still run.

***

### Input

| Field | Default | What it does |
|---|---|---|
| `sites` | prefill: NVIDIA | Workday career-site addresses (see above). |
| `searchText` | `""` | Passed to the site's own search box, e.g. `engineer`. |
| `facets` | `{}` | Workday's own filters: `{ "jobFamilyGroup": ["Engineering"], "locationCountry": ["Germany"] }`. A facet is named by its `facetParameter` or its label; a value by its id or name, ignoring case. |
| `listFacets` | `false` | Also return a free `facet` row per facet value of each site. |
| `includeDescription` | `true` | Fetch each posting's detail document: description, every location, time and remote type, country, exact date. |
| `descriptionFormat` | `text` | `text` → `descriptionText`, `markdown` → `descriptionMarkdown`, `html` → `descriptionHtml` (sanitized). The other two stay null. |
| `titleFilter` / `titleExclude` | `[]` | Keep / drop postings whose title contains any of these (case-insensitive). |
| `locationFilter` | `[]` | Keep postings with a location containing any of these, across every location the posting lists. |
| `postedWithinDays` | empty | Keep postings posted at most this many days ago. |
| `remoteOnly` | `false` | Keep remote postings only. |
| `maxJobsPerSite` | `200` (prefill 20) | Posting rows per site, 1–10,000; list pages stop once it is reached. |
| `maxJobsTotal` | `1000` | Posting rows per run, across every site. |
| `maxDetailFetches` | `1000` | Detail documents per run. Beyond it postings still come back, with `descriptionText: null` and `descriptionTruncatedReason: "maxDetailFetches"`. |
| `maxConcurrency` | `3` | Sites read at once (different employers only — see *Speed*). |
| `maxRunSecs` | `240` | The run's time budget, 30–3,600 s. |
| `proxyConfiguration` | `{ "useApifyProxy": true }` | Apify datacenter proxy. |

A run with no usable site, unreadable `facets`, or a `postedWithinDays` that is
not a whole number finishes FAILED before a single request — and costs nothing.

***

### Facets: Workday's own filters

Every Workday site has its own facets, and **their ids differ per employer** —
NVIDIA's "Engineering" is not Adobe's. So the Actor reads each site's first
page, looks your names up there, and applies the matching ids:

| Site | Facets it offered in the capture |
|---|---|
| NVIDIA | `jobFamilyGroup` (Job Category, 14), `workerSubType`, `timeType`, `locationHierarchy2` (Office / Remote), `locationHierarchy1` (36 countries), `locations` (130 sites) |
| Adobe | `jobFamilyGroup` (12), `workerSubType`, `timeType`, `locationCountry` (19), `locations` (69) |
| Boeing | `remoteType` (Onsite Job / Hybrid Job), `jobFamilyGroup` (48), `workerSubType`, `timeType`, `locationCountry`, `locations` (173), `distance` |
| Salesforce | a custom `CF_-_REC_-_…Country…` facet (38 countries), `jobFamilyGroup` (18), `workerSubType`, `timeType`, `locations` (172) |

```json
{ "sites": ["https://boeing.wd1.myworkdayjobs.com/EXTERNAL_CAREERS"],
  "facets": { "Job Category": ["Software Engineering (6J)"], "remoteType": ["Hybrid Job"] } }
```

Several values of one facet mean *any of them*; several facets mean *all of
them*, as on the career site. A value a site does not list comes back as a free
`facet-not-found` row naming the first 20 values it does list; the facet's other
values still apply. A facet with **no** matching value — or a facet the site
does not have at all — skips that site with the same free row, rather than
reading it unfiltered and charging for postings you did not ask for.

`jobFamilyGroup`, `timeType` and `remoteType` are also filled from the facets
when that is certain: the run filtered on exactly one value, or the site lists
only one value and every posting carries it (Boeing: "Full time", 770 of 770).

***

### Output reference

| Column | Rows | Meaning |
|---|---|---|
| `ok`, `rowType`, `input`, `error`, `errorType`, `scrapedAt`, `source`, `sourceUrl` | all | The envelope. `rowType` is `job-posting`, `site`, `facet` or `diagnostic`; `input` is the `sites` entry as you gave it; `sourceUrl` is the Workday API address the row came from. |
| `jobId` | posting | The requisition id Workday shows on the list (`JR2026139`), else the detail's `jobReqId`. |
| `title`, `url`, `applyUrl` | posting | `applyUrl` is `url` + `/apply` when the detail was read and lists the posting as open. |
| `company`, `siteName` | posting, site, facet | The tenant title-cased (`Nvidia`) and the site id. |
| `locationsText` | posting | The list's own wording — a place, or a count like `2 Locations`. |
| `locations` | posting | Every place named, in Workday's wording. A count is never an entry; the detail document supplies the names. |
| `city`, `region`, `countryCode` | posting | Best-effort, from the primary location; the country from the detail when read (ISO alpha-2). |
| `remoteType`, `isRemote` | posting | Workday's label as the employer words it, and true / false / null. Hybrid is not remote. |
| `timeType`, `jobFamilyGroup` | posting | See *Facets* for when `jobFamilyGroup` is known. |
| `postedOn`, `postedAt`, `postedAtPrecision` | posting | See *Posted dates*. |
| `descriptionText`, `descriptionMarkdown`, `descriptionHtml` | posting | One of them, per `descriptionFormat`. |
| `descriptionTruncatedReason` | posting | Why a requested description is missing: `maxDetailFetches`, `detail-unavailable` or `deadline`. Null otherwise. |
| `rank` | posting | 1-based position on the site, in Workday's order. |
| `totalPostings`, `returned`, `filteredOut`, `facetNames` | site | The total Workday reported for your search and facets, what this run returned and filtered out, and every facet the site offers. |
| `facetParameter`, `facetLabel`, `valueId`, `valueLabel`, `count` | facet | One facet value. |

Diagnostic `errorType`s: `invalid-input`, `board-not-found` (HTTP 404, Workday's
`S21` "not found"), `board-unavailable` (HTTP 422 from a tenant that does not
answer anonymous visitors, a refusal from two exit IPs, or a 5xx that failed
again on its retry), `facet-not-found`, `timeout`, `deadline` and `http`.

***

### Posted dates

Workday's list says when a posting went up in words — "Posted Today", "Posted 5
Days Ago", "Posted 30+ Days Ago" — and the detail document says it exactly
(`startDate`, `2026-09-01`).

- With the detail read, `postedAt` is that date and `postedAtPrecision` is
  `exact`.
- Without it, `postedAt` is counted back from the run's own date
  (`scrapedAt`) and is `derived`: "Today" is the run's date, "Yesterday" one day
  back, "5 Days Ago" five. "30+ Days Ago" is 31 days back — a lower bound.

`postedWithinDays` uses the same numbers ("30+" = 31): a "30+" posting is too old
for any window under 31 days, and for a wider one the detail's exact date
decides. Without search text Workday lists a site's postings newest first (every
capture agrees), so a walk with `postedWithinDays` stops at the first page that
is entirely older.

***

### What you are never charged for

- Every `site` and `facet` row.
- Every `diagnostic` row: a site id that does not exist, a tenant that refuses
  anonymous visitors, a facet the site does not have, a timeout, the deadline.
- Postings dropped by your filters — filters run before the charge, and most run
  before the detail document is even fetched.
- A run that returns nothing at all: it finishes **SUCCEEDED with zero results**
  and a "0 results. N diagnostic row(s) explain why. Nothing was charged." status
  message, and bills nothing, **start fee included**.

***

### Pricing

| Event | What it is | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|---|
| `actor-start` | Once per run, only after the run has returned a posting | $0.001 | $0.001 | $0.001 | $0.001 |
| **`job-posting`** | One posting row, with or without its description | **$0.001** | **$0.001** | **$0.0008** | **$0.0006** |

**$1 per 1,000 postings (+ $0.001 per run).**

| Run | Cost |
|---|---|
| The prefill — NVIDIA's 20 newest postings with descriptions | **$0.021** |
| 1,000 postings with descriptions: 1,000 × 0.001 + 0.001 | **$1.001** |
| The same at GOLD | **$0.601** |
| A daily monitor of 5 sites finding ~40 new postings | **$0.041** a day |
| A site that does not exist, a tenant that refuses anonymous visitors | **$0.00** |

Charging is charge-after-push: rows are in your dataset before the event is
recorded. `ACTOR_MAX_TOTAL_CHARGE_USD` is respected — room for each posting is
checked before its detail document is fetched, with the start fee kept in
reserve — and when it is reached the run stops fetching, says so in its status
message, and finishes SUCCEEDED.

***

### Speed, proxy and politeness

Requests to one Workday host go **one at a time, 250–600 ms apart**, list pages
and detail documents alike; a 403 or 429 is retried **once** from a fresh proxy
session, and a second refusal becomes a free row. So:

- With descriptions on, one site runs at roughly **one posting per 1.2–1.5 s** —
  about 200 postings in the default 240-second budget. For a big site raise
  `maxRunSecs`, or switch `includeDescription` off: the list alone is 20
  postings per request.
- Several **different** employers run in parallel (`maxConcurrency`, default 3);
  two sites on one host share its queue.
- The default proxy is Apify's **datacenter** pool: NVIDIA, Adobe, Boeing and
  Salesforce all answered through it in the capture.

***

### Use it from an AI agent, or from code

One JSON object in, one flat array out — the shape agent runtimes want. The
Actor runs with **limited permissions**, uses **pay-per-event** pricing and never
enters Standby, so it works over the Apify MCP server and with x402 agentic
payments. The **Integrations** tab pushes results to Slack, a webhook, Zapier,
Make, Google Sheets, Snowflake or BigQuery.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~workday-jobs-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sites":["https://adobe.wd5.myworkdayjobs.com/external_experienced"],"searchText":"engineer","postedWithinDays":7,"maxJobsPerSite":100}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/workday-jobs-api").call(run_input={
    "sites": [
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
        "https://boeing.wd1.myworkdayjobs.com/EXTERNAL_CAREERS",
    ],
    "facets": {"Job Category": ["Software Engineering (6J)", "Engineering"]},
    "maxJobsPerSite": 300,
    "maxRunSecs": 900,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["rowType"] == "job-posting":
        print(row["company"], row["jobId"], row["title"], row["countryCode"], row["postedAt"], sep=" | ")
```

(That run applies NVIDIA's "Engineering" and Boeing's "Software Engineering
(6J)": each site applies the names it has, and a free `facet-not-found` row notes
the one it lacks.)

***

### FAQ

**How many postings does a site have?** The `site` row's `totalPostings` is what
Workday reports on the first page for your search and facets. Workday appears to
cap it: NVIDIA reported **2,000** while its Time Type facet counts add up to
2,700. To reach everything on a very large site, split the run by a facet — one
country or job category at a time.

**Why do some postings have no description?** Either the run's
`maxDetailFetches` was reached, the detail document could not be read (the
posting was withdrawn, or Workday refused it), or the time budget ran out —
`descriptionTruncatedReason` says which. The row is still there, and still has
everything the list carries.

**Why is `locations` empty and `locationsText` "3 Locations"?** Workday's list
gives a count for a posting in several places; the names are only in the detail
document. Turn `includeDescription` on.

**Why is `jobFamilyGroup` null?** Workday's list does not say which category a
posting is in; the Actor fills it only when the facets make it certain (see
*Facets*). Filter on one category and every row carries it.

**Does it sign in, or read internal postings?** No. It reads what an anonymous
visitor sees, never sends a cookie and never asks for credentials. A tenant that
does not serve its jobs anonymously — Walmart's answered HTTP 422 in the capture
— comes back as a free `board-unavailable` row.

**Does it remove personal data?** A posting is the employer's own publication,
but recruiters sometimes sign one with a name and a mailbox. E-mail addresses,
`mailto:` links, recruiter sign-off lines and LinkedIn profile links are removed
from every description format before the row is written.

**Can I monitor a site for new postings?** Schedule a run with
`postedWithinDays: 1` (or 7) and no search text: the walk stops at the first page
that is entirely older, so a daily check of a large site is a few requests.

***

### Limitations

- **Workday's career-site API is undocumented and may change.** Every captured
  tenant answered the same shape, but Workday can change it at any time; a shape
  the Actor does not recognise comes back as a free `http` row saying so.
- **20 postings per list request** — Workday's own limit 20 (asking for 50 is an
  HTTP 400) — and descriptions cost one more request each, one at a time per
  host. Large sites take time; see *Speed*.
- **Anonymous access only.** Some tenants require a signed-in visitor for their
  job list and answer HTTP 422; you get a free `board-unavailable` row.
- `totalPostings` appears to be capped by Workday (2,000 on NVIDIA); split very
  large sites by facet.
- Only `*.myworkdayjobs.com` career sites are read; the less common
  `myworkdaysite.com` form is not.
- `city`, `region` and `countryCode` are parsed from Workday's location wording,
  which each employer chooses; they are a careful guess that never invents a
  country, and `locations` always keeps the original text.
- `company` is the tenant name title-cased ("Nvidia"), not the legal name.
- The posting date is exact only when the detail document was read; otherwise it
  is derived from "Posted N Days Ago", and "30+" is a lower bound.

Not affiliated with Workday, Inc., or with any employer whose postings you
retrieve. Workday is a trademark of its owner, used only to describe which public
career sites this Actor reads.

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript API](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments API](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel API](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [GitHub Repos, Trending & Releases API](https://apify.com/insight.solutions/github-repos-api) — repository facts, trending lists, releases and search, no token needed for small runs.
- [Discourse Forum API](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown — Content Extractor for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [WordPress Posts & Pages API](https://apify.com/insight.solutions/wordpress-posts-api) — posts and pages from any WordPress site as clean text or Markdown, with categories, tags and images.
- [Website Metadata API](https://apify.com/insight.solutions/website-metadata-api) — any URL's meta tags, Open Graph, Twitter cards, hreflang, feeds, JSON-LD and microdata, with normalised Product, Article, Event and FAQ entities.
- [Subdomain Finder API](https://apify.com/insight.solutions/subdomain-finder-api) — every subdomain of a domain from certificate-transparency logs, resolved over DNS, with an optional live HTTP check.
- [Internet Archive API](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Toolkit](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Intelligence API](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Page Audit](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions API](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Releases API](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress & Insider Trades API](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [Y Combinator Companies, Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Career Site Jobs API](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [New Job Postings Monitor](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [WooCommerce Products API](https://apify.com/insight.solutions/woocommerce-products-api) — any WooCommerce store's catalogue, prices, variants and stock through its public Store API.
- [Shopify App Store API](https://apify.com/insight.solutions/shopify-app-store-api) — Shopify App Store listings by category, collection or developer: pricing plans, ratings and merchant reviews.
- [Luma Events API](https://apify.com/insight.solutions/luma-events-api) — upcoming Luma events by city, category or calendar: dates, venue, price, capacity and organiser calendar, no host names.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit & IRS 990 Lookup API](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews API](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews API](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.
- [Sports Scores & Schedules API](https://apify.com/insight.solutions/sports-scores-api) — scores, schedules, standings, teams and headlines for the NFL, NBA, MLB, NHL, soccer and more, no key.
- [App Store Monitor](https://apify.com/insight.solutions/app-store-monitor) — App Store and Google Play listings watched between runs: new versions with release notes, price, rating and listing changes, one row per change.

# Actor input Schema

## `sites` (type: `array`):

One or more Workday career sites — any address on `*.myworkdayjobs.com`: the site itself (`https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`), a page with a locale (`…/en-US/NVIDIAExternalCareerSite`), a link to one posting (`…/NVIDIAExternalCareerSite/job/…`, which means its whole site), or just `host/Site`. Duplicates are read once. An entry that is not a Workday career site comes back as a free `invalid-input` row and the rest still run.

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

Passed to the site's own search box (Workday's `searchText`), e.g. `engineer` or `data scientist`. Empty lists every posting, newest first.

## `facets` (type: `object`):

Workday's own filters, applied server-side: `{ "<facet>": ["<value>", …] }`. The facet is its `facetParameter` (`jobFamilyGroup`, `timeType`, `locationCountry`, …) or its label (`Job Category`); a value is its id or its name, ignoring case (`Engineering`). Names are looked up on each site's first page, because ids differ per employer. A facet or value a site does not have comes back as a free `facet-not-found` row listing what it does have, and that site is skipped rather than read unfiltered. Run once with `listFacets` to see every id.

## `listFacets` (type: `boolean`):

Also return one free `facet` row per facet value of each site — facet, value name, value id and how many postings carry it — so you can find the ids and names to filter by.

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

Fetch each posting's detail document for its description, every location, time and remote type, country and exact posting date — one extra request per posting, capped by `maxDetailFetches`. Off returns what the list pages carry (20 postings a request).

## `descriptionFormat` (type: `string`):

Which column the description goes in: `descriptionText` (plain text), `descriptionMarkdown` or `descriptionHtml` (sanitized). The other two stay null. E-mail addresses and recruiter sign-offs are removed in every format.

## `titleFilter` (type: `array`):

Keep only postings whose title contains one of these (case-insensitive). Excluded postings are never charged.

## `titleExclude` (type: `array`):

Drop postings whose title contains any of these (case-insensitive), e.g. `intern`. Never charged.

## `locationFilter` (type: `array`):

Keep only postings with a location containing one of these (case-insensitive), across `locationsText` and every additional location. A posting Workday lists as "3 Locations" is checked against its detail document's locations, so with descriptions off it can only match on that text.

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

Keep only postings posted at most this many days ago: from the detail's exact `startDate` when it was fetched, else from Workday's "Posted N Days Ago" ("Today" = 0, "30+" = 31). Without search text the walk stops at the first page that is entirely older. Leave empty for no limit.

## `remoteOnly` (type: `boolean`):

Keep only postings whose Workday remote type says remote (and not hybrid), or — when there is none — whose location says "Remote".

## `maxJobsPerSite` (type: `integer`):

The most posting rows returned per site; list pages stop once it is reached.

## `maxJobsTotal` (type: `integer`):

The most posting rows this run returns across every site.

## `maxDetailFetches` (type: `integer`):

The most detail documents this run fetches, across every site. Beyond it postings are still returned, with `descriptionText: null` and `descriptionTruncatedReason: "maxDetailFetches"`.

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

Sites read at once. Requests to one Workday host are always one at a time, 250–600 ms apart, so this only helps across different employers.

## `maxRunSecs` (type: `integer`):

Stop after this many seconds. Rows already returned are kept and a free `deadline` row names each site that was cut short.

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

Workday's career-site API answered the Apify datacenter proxy on every captured tenant, so datacenter is the default. Switch to residential only if a site starts refusing requests.

## Actor input object example

```json
{
  "sites": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
  ],
  "searchText": "",
  "facets": {},
  "listFacets": false,
  "includeDescription": true,
  "descriptionFormat": "text",
  "titleFilter": [],
  "titleExclude": [],
  "locationFilter": [],
  "remoteOnly": false,
  "maxJobsPerSite": 20,
  "maxJobsTotal": 1000,
  "maxDetailFetches": 1000,
  "maxConcurrency": 3,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Job-posting, site and facet rows from Workday's public career-site JSON, in one schema, plus free diagnostic rows. Delivered as JSON items in the default dataset.

# 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 = {
    "sites": [
        "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
    ],
    "searchText": "",
    "facets": {},
    "listFacets": false,
    "includeDescription": true,
    "descriptionFormat": "text",
    "titleFilter": [],
    "titleExclude": [],
    "locationFilter": [],
    "remoteOnly": false,
    "maxJobsPerSite": 20,
    "maxJobsTotal": 1000,
    "maxDetailFetches": 1000,
    "maxConcurrency": 3,
    "maxRunSecs": 240,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/workday-jobs-api").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 = {
    "sites": ["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"],
    "searchText": "",
    "facets": {},
    "listFacets": False,
    "includeDescription": True,
    "descriptionFormat": "text",
    "titleFilter": [],
    "titleExclude": [],
    "locationFilter": [],
    "remoteOnly": False,
    "maxJobsPerSite": 20,
    "maxJobsTotal": 1000,
    "maxDetailFetches": 1000,
    "maxConcurrency": 3,
    "maxRunSecs": 240,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/workday-jobs-api").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 '{
  "sites": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
  ],
  "searchText": "",
  "facets": {},
  "listFacets": false,
  "includeDescription": true,
  "descriptionFormat": "text",
  "titleFilter": [],
  "titleExclude": [],
  "locationFilter": [],
  "remoteOnly": false,
  "maxJobsPerSite": 20,
  "maxJobsTotal": 1000,
  "maxDetailFetches": 1000,
  "maxConcurrency": 3,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insight.solutions/workday-jobs-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insight.solutions/workday-jobs-api"
        }
    }
}
```

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/DucvKJqXBUsSPZssm/builds/J5eVrQEgqihks2DN2/openapi.json