# Workday Jobs Scraper - Any Company by Name (+Greenhouse, Lever) (`kadi_bence/workday-jobs-scraper`) Actor

Get open jobs of any company by name: NVIDIA, Salesforce, Intel (Workday) and Stripe, Ramp (Greenhouse, Lever, Ashby, Workable, Personio) in one run, system auto-detected. Filters: title, country, date. Returns per job: title, team, location, salary, date, URL. Default: 20/company. $0.90/1K.

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

## Pricing

from $0.90 / 1,000 jobs

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: export jobs from any myworkdayjobs.com career site

### What is Workday Jobs Scraper?

Workday Jobs Scraper collects job postings from company career sites that run on Workday (`*.myworkdayjobs.com` and `*.myworkdaysite.com`). You type a company name such as `NVIDIA` or `salesforce.com`, and you get every open job as JSON, CSV or Excel, with title, all locations, country, remote status, exact posted date, parsed salary range and the full description.

It reads the same public JSON endpoints that the career site itself uses. There is no browser, no login and no API key, so runs are fast and cheap.

**What makes it different**

- **Company names in, jobs out.** It finds the company's Workday boards for you, including subsidiaries. Board URLs work too, and you can mix many companies and URLs in one run.
- **Companies not on Workday work too.** If a name has no Workday site (Stripe, Ramp, Hugging Face), its Greenhouse, Lever, Ashby, Workable, Recruitee or Personio board is used instead. `NVIDIA` and `Stripe` in one run give one dataset with the same fields; `ats` shows where each job came from and `department` the team (on those boards). Turn off with `otherSystemsFallback: false`.
- **Newest jobs first** on those boards, so a small limit gives recent openings instead of the A-Z top of the list.
- **No 2,000-job cap.** Workday stops paging at about 2,000 results. This Actor splits big boards by country or category, so you get all jobs, even on boards with 10,000+ openings.
- **Real locations.** Instead of "Multiple Locations" you get every location of the posting in `locations`, plus `country`, `countryCode` and `workMode`.
- **Salary included.** Pay ranges in the posting become `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod`.
- **Real dates.** `postedDate` and `firstPostedDate` are ISO dates instead of "Posted 30+ Days Ago".
- **Only new jobs.** Monitoring mode outputs, and charges for, only postings you haven't seen before.

#### Use cases

- **Sales and recruiting agencies:** find companies that are hiring for specific roles or regions (hiring signals for outreach).
- **Job boards and aggregators:** keep listings fresh from hundreds of corporate career sites with one schema.
- **Salary and labour-market research:** compare openings, locations and pay bands across employers.
- **Competitive intelligence:** see which teams and locations your competitors are growing, week by week.
- **Job alerts:** send a daily Slack message, e-mail or Google Sheet of new postings at your target companies.
- **AI agents and RAG apps:** give an LLM fresh, structured job data through the API or the Apify MCP server.

#### Data fields you get

| Field | Description | Example |
|---|---|---|
| `title` | Job title | `Distinguished Engineer, Storage – AI Cloud` |
| `company` | Company you searched for (or the tenant name) | `NVIDIA` |
| `hiringOrganization` | Legal entity named in the posting | `2100 NVIDIA USA` |
| `jobId` | Company requisition ID | `JR2018037` |
| `url` | Link to the live job page | `https://nvidia.wd5.myworkdayjobs.com/...` |
| `location` | Primary location | `US, CA, Santa Clara` |
| `locations` | All locations of the posting | `["US, CA, Santa Clara", "US, Remote"]` |
| `country` | Country of the primary location | `United States of America` |
| `countryCode` | ISO country code | `US` |
| `workMode` | `remote`, `hybrid`, `onsite` or empty when unknown | `remote` |
| `remoteType` | Remote type as shown by Workday, when the site sets it | `Hybrid` |
| `timeType` | Full or part time | `Full time` |
| `postedDate` | Date the site shows as "posted" (ISO) | `2026-10-04` |
| `postedOnText` | Original posted text from the site | `Posted Yesterday` |
| `firstPostedDate` | When the requisition was first opened | `2026-10-04` |
| `salaryMin` / `salaryMax` | Parsed pay range (numbers) | `320000` / `488750` |
| `salaryCurrency` | Currency code | `USD` |
| `salaryPeriod` | `YEAR`, `MONTH`, `HOUR`, ... | `YEAR` |
| `salaryText` | Original pay text from the posting | `320,000 USD - 488,750 USD` |
| `description` | Job description as plain text | `NVIDIA has been transforming...` |
| `descriptionHtml` | Description as HTML (if you choose HTML or both) | `<p>NVIDIA has been...</p>` |
| `canApply` | Whether the posting accepts applications | `true` |
| `workdayJobId` | Workday's internal posting ID | `53f6029432351007dee0993540380000` |
| `tenant` | Workday tenant name | `nvidia` |
| `careerSite` | Career site (board) name | `NVIDIAExternalCareerSite` |
| `boardUrl` | Board the job came from | `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite` |
| `isNew` | Set in monitoring mode for jobs not seen before | `true` |
| `scrapedAt` | When the job was scraped (UTC) | `2026-10-05T07:07:47Z` |

### How to use Workday Jobs Scraper

1. Open the Actor and type one or more **company names or websites** in "Company names or websites". The prefill is `NVIDIA` with 50 jobs, which finishes in about 20 seconds and costs about $0.05.
2. Optional: add **search keywords**, **title include/exclude words**, **countries** or **posted within N days**. Set **Max jobs per career site** to `0` to get every job.
3. Click **Start**.
4. When the run finishes, open the **Output** tab and download the data as JSON, CSV, Excel or HTML, or connect it to Google Sheets, Zapier, Make, n8n or your own code.
5. To get only new jobs every day, turn on **Only new jobs** and create a **Schedule** (see [Integrations and scheduling](#integrations-and-scheduling)).

#### Input guide

**Company names or websites (`companies`)**

Type the company's name or domain, one per line. The Actor searches for the company's Workday tenant and checks its public career sites. The `RUN_SUMMARY` record in the run's key-value store lists every board URL it found for each company, so you can check the match.

- Good: `NVIDIA`, `salesforce.com`, `intel.com`, `Pfizer`
- Bad: `NVIDIA jobs in California` (put locations in **Countries** and words in **Search keywords**), `NVDA` (stock tickers are not matched)
- Tip: a domain is often more precise than a name for common words (e.g. `target.com` instead of `Target`).
- Warning: not every company uses Workday. If a company uses Greenhouse, Lever, Oracle or another system, it won't be found here; try our [ATS Jobs Scraper](https://apify.com/kadi_bence/ats-jobs-scraper) or [ATS+ Jobs Scraper](https://apify.com/kadi_bence/ats-plus-jobs-scraper).

**Workday career site URLs (`startUrls`)**

Use this when a company isn't found by name, or when you want one exact board. Open the company's careers page, click through to the job list, and copy the address from your browser.

- Good: `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`
- Good: a filtered URL, e.g. after picking "Job Category = Engineering" on the site. The Actor keeps the filters.
- Good: a single job URL. The whole board is scraped.
- Bad: the company's own careers landing page (e.g. `https://www.nvidia.com/careers`). Paste the Workday address the job list lives on.

**Which career sites (`careerSites`)**

Large companies often have several boards (main, students, subsidiaries). `All public boards` (default) scrapes all of them; `Main board only` picks the primary external board. Use `main` if you see student or internal-transfer boards you don't want.

**Search keywords (`searchKeywords`)**

Works exactly like the search box on the career site, so it also matches descriptions. Use a precise phrase such as `data engineer`. For title-only matching, use **Job title must contain** instead.

**Max jobs per career site (`maxJobsPerSite`)**

A limit per board, not per run. `0` means no limit. The Console prefill is 50 for a quick test; the default when calling via API, MCP or an AI agent is 20. With 10 companies and a limit of 100 you can get up to 1,000 jobs.

**Posted within (days) (`postedWithinDays`)**

Only jobs posted in the last N days, e.g. `7`. Leave empty for any date.

**Title filters (`titleIncludes`, `titleExcludes`)**

`titleIncludes` keeps a job if its title contains ANY of the words; `titleExcludes` drops it if the title contains ANY of them. It is a simple, case-insensitive "contains" check.

- Good: include `engineer`, `data scientist`; exclude `internship`, `senior`
- Warning: `intern` also matches "International". Use `internship` when that matters.

**Countries (`countries`)**

Names or ISO codes, e.g. `US`, `Germany`, `GB`. A job with several locations is kept if ANY location matches. When the career site has its own country filter, the Actor uses it, so only matching jobs are downloaded (faster and cheaper). Other words, such as `California`, are matched as location text.

Jobs removed by any filter are not saved, don't count toward the limit and are **not charged**.

**Only new jobs (`onlyNewJobs`) and Monitor name (`monitorName`)**

See [Monitoring mode](#monitoring-mode-only-new-jobs) below.

**Output options**

- `includeDetails` (default on): opens each job to get the description, exact dates, all locations and salary. Turn it off for a much faster title-and-location list.
- `descriptionFormat`: `text` (default), `html`, `both` or `none`.
- `stripContactInfo` (default on): removes e-mails and phone numbers from descriptions. Keep it on to avoid storing personal data.

**Advanced**

- `maxConcurrency`: parallel requests per run (default 4, max 10). Higher is not always faster, because sites slow down busy clients.
- `proxyConfiguration`: off by default. Workday sites are public; enable Apify Proxy (Datacenter) only if you see many 403 or 429 errors in the log.

Example input:

```json
{
  "companies": ["NVIDIA", "salesforce.com"],
  "startUrls": [{ "url": "https://intel.wd1.myworkdayjobs.com/External" }],
  "searchKeywords": "data engineer",
  "titleExcludes": ["internship", "senior"],
  "countries": ["US", "Canada"],
  "maxJobsPerSite": 0,
  "postedWithinDays": 7,
  "onlyNewJobs": true
}
```

### Output

Each job is one item in the run's dataset. Here is one real item from the prefill run on 2026-10-05 (description shortened):

```json
{
  "title": "Distinguished Engineer, Storage – AI Cloud",
  "company": "NVIDIA",
  "hiringOrganization": "2100 NVIDIA USA",
  "jobId": "JR2018037",
  "url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Distinguished-Engineer--Storage---AI-Cloud_JR2018037",
  "location": "US, CA, Santa Clara",
  "locations": ["US, CA, Santa Clara"],
  "country": "United States of America",
  "countryCode": "US",
  "workMode": null,
  "remoteType": null,
  "timeType": "Full time",
  "postedDate": "2026-10-04",
  "postedOnText": "Posted Yesterday",
  "firstPostedDate": "2026-10-04",
  "salaryMin": 320000,
  "salaryMax": 488750,
  "salaryCurrency": "USD",
  "salaryPeriod": "YEAR",
  "salaryText": "320,000 USD - 488,750 USD",
  "description": "NVIDIA has been transforming computer graphics, PC gaming, and accelerated computing for more than 25 years. …",
  "canApply": true,
  "workdayJobId": "53f6029432351007dee0993540380000",
  "tenant": "nvidia",
  "careerSite": "NVIDIAExternalCareerSite",
  "boardUrl": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
  "scrapedAt": "2026-10-05T07:07:47Z"
}
```

Notes:

- `postedDate` is the date the site displays; `firstPostedDate` is when the requisition was first opened. They differ when a job is reposted.
- When a posting has several pay bands (per level or location), they are merged into one `salaryMin`–`salaryMax` span, and the original text stays in `salaryText`.
- Empty values are `null`, so every item has the same columns in CSV and Excel.

#### Dataset views

The **Output** tab has two views of the same data:

| View | What it shows |
|---|---|
| **Jobs** | A compact table: title, company, location, work mode, posted date, salary range and URL. Best for a quick look. |
| **Full details** | Adds hiring organization, job ID, all locations, country, time type, salary text and description. |

Every export (JSON, CSV, Excel, API) contains all fields, whichever view you look at. The run also writes a `RUN_SUMMARY` record to the key-value store: board URLs found per company, jobs listed and saved per board, and how many were skipped as old, already seen or filtered.

#### How to export the data

- **In the Console:** Output tab > **Export** > JSON, CSV, Excel, HTML, XML or RSS. You can pick fields and the view.
- **Google Sheets:** add the Google Sheets integration to the Actor or a schedule (Integrations tab), or use `=IMPORTDATA("https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&token=<TOKEN>")`.
- **API:** `https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json` (also `csv`, `xlsx`, `xml`). Add `&view=overview` for the compact table.

### Pricing

This Actor uses **pay per event**. You pay **$0.90 per 1,000 jobs** ($0.0009 per job saved to the dataset), plus Apify's standard Actor start fee of **$0.00005 per run**. Platform compute is included in the price.

| Example run | Jobs saved | Cost |
|---|---|---|
| Prefill test (NVIDIA, 50 jobs) | 50 | about $0.05 |
| 20 companies, 50 jobs each | 1,000 | about $0.90 |
| One large board, complete | 10,000 | about $9.00 |
| Daily monitoring, ~100 new jobs per day for 30 days | 3,000 | about $2.70 per month |

What you don't pay for:

- jobs removed by your filters (title, country, posted date),
- jobs already seen in monitoring mode,
- jobs that failed to load,
- the `RUN_SUMMARY` record.

To cap spending, set **Max charge per run** in the run options; the Actor stops cleanly at that limit and keeps what it saved. Apify's free plan includes monthly platform credit you can use for this Actor.

### Use it via API

Get your API token in the Apify Console under **Settings > API & Integrations**. The examples below run the Actor, wait for it to finish and read the jobs.

**JavaScript / Node.js** (`npm install apify-client`)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('kadi_bence/workday-jobs-scraper').call({
    companies: ['NVIDIA', 'salesforce.com'],
    titleIncludes: ['engineer'],
    countries: ['US'],
    maxJobsPerSite: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`${items.length} jobs`, items[0]);
```

**Python** (`pip install apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("kadi_bence/workday-jobs-scraper").call(run_input={
    "companies": ["NVIDIA", "salesforce.com"],
    "titleIncludes": ["engineer"],
    "countries": ["US"],
    "maxJobsPerSite": 100,
})

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["location"], job["salaryMin"], job["url"])
```

**cURL** (runs the Actor and returns the jobs in one request; best for runs under 5 minutes)

```bash
curl -X POST "https://api.apify.com/v2/acts/kadi_bence~workday-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["NVIDIA"], "maxJobsPerSite": 50}'
```

**Apify CLI**

```bash
apify call kadi_bence/workday-jobs-scraper --input '{"companies": ["NVIDIA"], "maxJobsPerSite": 50}' --output-dataset
```

**MCP server for AI agents** (Claude, Cursor, VS Code and other MCP clients)

Add the Apify MCP server with this Actor as a tool. Your client will ask you to sign in to Apify (OAuth), or you can send your token as an `Authorization: Bearer YOUR_APIFY_TOKEN` header.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?actors=kadi_bence/workday-jobs-scraper"
    }
  }
}
```

Then ask your agent, for example: "Find all open data engineering jobs at NVIDIA and Salesforce in the US and summarize the salary ranges."

### Integrations and scheduling

- **Schedules:** in the Console go to **Schedules > Create new**, pick this Actor (or a saved task with your input) and a time, e.g. every day at 07:00. Each run gets its own dataset.
- **Webhooks:** on the Actor's **Integrations** tab, add a webhook for "Run succeeded" to send the run and dataset ID to your server.
- **Zapier, Make and n8n:** use the Apify app or node. Trigger "Actor run finished", then "Get dataset items", then send each job to Slack, e-mail, a CRM or Airtable.
- **Google Sheets:** the Google Sheets integration appends each run's jobs to a sheet, which is the easiest job-alert setup.
- **Slack and e-mail:** Apify's built-in Slack and e-mail integrations can notify you when a run finishes.

#### Monitoring mode (only new jobs)

Turn on **Only new jobs** (`onlyNewJobs: true`) and schedule the Actor:

1. The first run outputs all matching jobs and saves their IDs as a baseline.
2. Every later run outputs only jobs that weren't returned before, marked with `isNew: true`.
3. You pay only for those new jobs.

The "already seen" list is stored in a named key-value store (`workday-jobs-monitor`) in your own Apify account, separately for each board, search and filter combination. If you run two schedules on the same companies (e.g. one for engineers, one for sales), give them different **Monitor names** so their lists stay separate. To start over, use a new monitor name.

### Other job scrapers by the same developer

All of them use the same output fields where possible, so you can merge datasets.

- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/kadi_bence/ats-jobs-scraper): jobs from Greenhouse, Lever, Ashby, Workable, Recruitee and Personio boards, by company name.
- [Oracle, Taleo, BambooHR & Rippling Jobs Scraper](https://apify.com/kadi_bence/ats-plus-jobs-scraper): nine more applicant tracking systems, including Oracle Recruiting Cloud, Taleo, Teamtailor and Jobvite.
- [Germany Jobs Scraper - Arbeitsagentur](https://apify.com/kadi_bence/arbeitsagentur-jobs-scraper): 1M+ German job offers from the federal employment agency's Jobbörse.
- [Sweden Jobs Scraper - Platsbanken](https://apify.com/kadi_bence/sweden-jobs-scraper): all Swedish job ads from Arbetsförmedlingen, with an archive since 2016.
- [EURES Jobs Scraper](https://apify.com/kadi_bence/eures-jobs-scraper): EU job vacancies from 31 countries via the official European Job Mobility Portal.
- [Remote Jobs Scraper](https://apify.com/kadi_bence/remote-jobs-scraper): remote jobs from RemoteOK, Himalayas, Jobicy and Arbeitnow in one de-duplicated feed.

Related company data for B2B leads: [SEC Form D Scraper](https://apify.com/kadi_bence/sec-form-d-funding) (startup funding rounds), [New Business Filings USA](https://apify.com/kadi_bence/us-new-business-filings) (newly registered companies) and [Website Tech Stack Detector](https://apify.com/kadi_bence/tech-stack-detector) (technologies a company uses).

### FAQ

**How does Workday Jobs Scraper work?**
Every Workday career site loads its jobs from a public JSON endpoint. The Actor finds the company's boards, pages through that endpoint, and (with full details on) opens each job's detail endpoint. It doesn't use a browser, so it's fast and cheap.

**Is there an official Workday jobs API?**
Workday doesn't offer a public jobs API for third parties. This Actor gives you API-style structured data from the public career sites, and you can call it through the Apify API.

**How many jobs can I get? Is there a limit?**
All open jobs on a board. Boards with more than 2,000 openings are split automatically by country, category and similar filters, and duplicates are removed. Your only limit is `maxJobsPerSite`, which you can set to `0`.

**How fast is it?**
The 50-job prefill run takes about 20 seconds. With full details, plan on roughly 4–5 minutes per 1,000 jobs, because requests are kept polite. Turn off `includeDetails` for a much faster title-and-location list.

**Why do I get fewer jobs than the career site shows?**
Usually because of a filter (title, country, posted date) or `maxJobsPerSite`. The `RUN_SUMMARY` record shows how many jobs were listed, saved and skipped per board. Postings that are closed or hidden on the site are not returned. With **Main board only**, other boards of the company are not scraped.

**Why are some salaries empty?**
Many postings don't publish pay. Salary is filled only when the posting has a clear range with a currency. Most US postings in pay-transparency states have one.

**Do I need proxies?**
Usually not. Default is no proxy. If a site starts returning 403 or 429 errors, enable Apify Proxy (Datacenter) in the Advanced section.

**Is it legal to scrape Workday career sites?**
The Actor reads only public job postings that companies publish for everyone, without a login. It keeps request rates polite and removes e-mails and phone numbers from descriptions by default, so it doesn't collect personal data (GDPR). You are responsible for how you use the data, including the site's terms and data-protection law in your country.

**Can I use it from Python or another app?**
Yes. Use the Apify API, the JavaScript or Python client, the CLI, or the MCP server, as shown in [Use it via API](#use-it-via-api).

**How do I get only new jobs every day?**
Turn on **Only new jobs** and create a schedule. See [Monitoring mode](#monitoring-mode-only-new-jobs).

**Does it work for career sites in other languages?**
Yes. The fields are the same for every language; text comes back in the language of the posting.

**The run failed or a field is missing. What should I do?**
Open an issue on the **Issues** tab with the run link or your input. Fixes usually land within 24–48 hours. See the changelog below for recent changes.

### Companies tested by name

These companies were found by typing just their name (tested 2026-10-05): **NVIDIA, Salesforce (incl. Slack, Tableau, MuleSoft), Intel, Adobe, Target, Cisco, Mastercard, Workday, PayPal, Boeing, HP, Accenture (incl. Avanade), Netflix, Capital One, Pfizer**.

Some companies use a Workday site name that differs from their brand. The Actor knows a few of them, e.g. typing `Bank of America` (or `BofA`) scrapes `https://ghr.wd1.myworkdayjobs.com/Lateral-US`. For others, paste the career-site URL.

If a career site exists but answers with errors, the run says "career site found but it refuses requests; try again later" instead of "no Workday career site found".

### Related Actors

More low-cost Actors by the same developer, built on official APIs and public data:

- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/kadi_bence/ats-jobs-scraper) — all open jobs of a company from 6 applicant systems, plus Workday
- [Oracle, Taleo, BambooHR & Rippling Jobs Scraper](https://apify.com/kadi_bence/ats-plus-jobs-scraper) — jobs from 9 more applicant tracking systems
- [ATS Jobs Feed](https://apify.com/kadi_bence/ats-jobs-feed) — search a daily database of jobs from 1,000+ companies, no crawling wait
- [Remote Jobs Scraper](https://apify.com/kadi_bence/remote-jobs-scraper) — remote jobs from We Work Remotely, RemoteOK, Himalayas and more
- [EURES Jobs Scraper](https://apify.com/kadi_bence/eures-jobs-scraper) — EU job vacancies from 31 countries
- [Website Tech Stack Detector](https://apify.com/kadi_bence/tech-stack-detector) — CMS, ecommerce, analytics and frameworks of any website
- [SEC Form D Scraper](https://apify.com/kadi_bence/sec-form-d-funding) — new startup funding rounds from SEC EDGAR

All my Actors: [apify.com/kadi_bence](https://apify.com/kadi_bence)

### Changelog

- **2026-10-05:** Companies not on Workday are found on Greenhouse, Lever, Ashby, Workable, Recruitee or Personio (`otherSystemsFallback`, on by default). New output fields `ats`, `department`, `team`.
- **2026-10-05:** Added title include/exclude filters (`titleIncludes`, `titleExcludes`) and a country filter (`countries`, names or ISO codes; uses the career site's own country facet when available). Filtered-out jobs are not charged.
- **2026-10-05, 1.0:** first public release: company-name discovery, no 2,000-job cap, salary parsing, posted-date filter, monitoring mode, output schema with two dataset views.

# Actor input Schema

## `companies` (type: `array`):

Easiest option: type company names or domains, one per line, e.g. NVIDIA, Salesforce, intel.com. The Actor finds their Workday career site(s) automatically; the RUN_SUMMARY record lists the boards it found. A domain is more precise than a common word (target.com instead of Target). Companies not on Workday (e.g. Stripe) are looked up on Greenhouse, Lever, Ashby, Workable, Recruitee and Personio automatically. If a company is still not found, paste its career site URL below.

## `startUrls` (type: `array`):

Or paste Workday career site URLs, e.g. https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite. A URL with filters applied on the career site (location, category, search) keeps those filters. Single job URLs work too (the whole board is scraped).

## `careerSites` (type: `string`):

Large companies often run several Workday boards (main, students, subsidiaries). 'All' scrapes every public board; 'Main only' picks the primary external board.

## `otherSystemsFallback` (type: `boolean`):

When a company name has no Workday career site, look for its Greenhouse, Lever, Ashby, Workable, Recruitee or Personio job board instead (e.g. Stripe, Ramp, Hugging Face), so one run covers big employers and startups. Same output fields; the 'ats' field shows the source.

## `searchKeywords` (type: `string`):

Optional full-text search, exactly like the search box on the career site (e.g. "data engineer"). Leave empty for all jobs.

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

Stop after this many jobs per career site. 0 = no limit (all jobs, even boards with 10,000+ postings). The Console prefill is 50 for a quick test run. The default without input (API, MCP and AI-agent calls) is 20.

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

Only return jobs posted in the last N days (e.g. 7). Leave empty for any date.

## `titleIncludes` (type: `array`):

Keep only jobs whose title contains ANY of these words, e.g. engineer, data scientist. Not case-sensitive. Leave empty for all titles. Filtered-out jobs are not saved and not charged.

## `titleExcludes` (type: `array`):

Drop jobs whose title contains ANY of these words, e.g. intern, senior, manager. Not case-sensitive ('intern' also drops 'International'; use 'internship' to be precise). Filtered-out jobs are not charged.

## `countries` (type: `array`):

Keep only jobs in these countries: names or ISO codes, e.g. US, Germany, GB. Jobs with several locations are kept if ANY location matches. Uses the career site's own country filter when it has one (faster). Other words (e.g. California) are matched as location text. Filtered-out jobs are not charged.

## `onlyNewJobs` (type: `boolean`):

Remember which jobs were already returned and output only NEW postings on the next runs. Ideal for scheduled runs (daily alerts). The first run outputs everything and stores a baseline. You only pay for new jobs.

## `monitorName` (type: `string`):

Use different names to keep separate 'already seen' lists for different schedules with the same URLs.

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

Fetch each job's detail page: description, exact posted date, all locations, country, salary. Turn off for a faster, cheaper title/location-only list.

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

How to output the job description.

## `stripContactInfo` (type: `boolean`):

Recommended (GDPR). Some postings include a recruiter's personal contact details; this removes them.

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

Parallel requests to the career site. Keep it low to be polite; 4 is fast enough for most boards.

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

Usually not needed: Workday career sites are public. Enable Apify Proxy only if you see many 403/429 errors.

## Actor input object example

```json
{
  "companies": [
    "NVIDIA"
  ],
  "careerSites": "all",
  "otherSystemsFallback": true,
  "maxJobsPerSite": 50,
  "onlyNewJobs": false,
  "monitorName": "default",
  "includeDetails": true,
  "descriptionFormat": "text",
  "stripContactInfo": true,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped jobs (table view).

## `jobsFull` (type: `string`):

All scraped jobs with every field.

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

Per-site/company counts, what was found and any problems.

# 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 = {
    "companies": [
        "NVIDIA"
    ],
    "maxJobsPerSite": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kadi_bence/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 = {
    "companies": ["NVIDIA"],
    "maxJobsPerSite": 50,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kadi_bence/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 '{
  "companies": [
    "NVIDIA"
  ],
  "maxJobsPerSite": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kadi_bence/workday-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kadi_bence/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/kcbqJ3oGPA3RVyYnO/builds/nbLHrHueUETV4aJkO/openapi.json