# MyWorkdayJobs Scraper \[$0.9💰] | Workday Jobs | Hiring Data (`ahmed_jasarevic/myworkdayjobs-scraper`) Actor

Scrape job postings from any Workday career board (\*.myworkdayjobs.com): title, location, req ID, posting date, department and more. Built for job posting aggregation, hiring-signal monitoring and talent market research across thousands of employers. Runs via API, schedule or webhook.

- **URL**: https://apify.com/ahmed_jasarevic/myworkdayjobs-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 results

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

## Myworkdayjobs Scraper — Extract Workday Job Postings From Any Company Career Page

Scrape job postings from any company's **Workday ATS career board** (`*.myworkdayjobs.com`) — NVIDIA, Salesforce, Adobe, Cisco, Intel, Pfizer, Mastercard, Visa, Disney, Target, Boeing and thousands more — into **18 structured fields per job**: title, location, requisition ID, posting date, department, workplace type, time type, full HTML description, plain-text description and direct apply URL. Built for job posting aggregation, hiring signals and job market research, it reads each board's public Workday CXS JSON endpoint over plain HTTP — no browser, no login — and accepts many company boards in a single bulk run.

### Use Cases: Job Posting Aggregation, Hiring Signals & Talent Market Intelligence

- **Job posting aggregation** — feed hundreds of company boards into one job postings database or job aggregator, one normalized row per posting.
- **Hiring signals & job lead generation** — track when target accounts open new requisitions (`reqId` + `postedDate`) as B2B hiring-intent signals.
- **Job market research & talent market intelligence** — analyze where, when and what companies are hiring: department, location, country, workplace type, time type.
- **Monitor new job postings** — schedule recurring runs against specific career pages and get alerted when listings appear or close.
- **Get all jobs at one company (bulk export)** — pull every open role off any Workday careers site into CSV, Excel or JSON in one run.
- **Find companies hiring, by country or region** — every row carries `country`, `location`, `company` and `postedDate`, so postings slice cleanly by market.

### How The Myworkdayjobs Scraper Works: Plain HTTP, No Browser

Workday career sites are JavaScript single-page apps — the raw HTML is an empty `<div id="root">`. Every board is backed by Workday's **CXS internal JSON API**, the same endpoint the site's own frontend calls. This actor talks to that API directly with plain HTTP (CheerioCrawler, no browser): a paginated list request returns jobs 20 at a time, then one detail request per job returns the full record — no page rendering, no DOM parsing. The full endpoint contract is documented below.

### Input Parameters: Board URLs, Job Limits, Concurrency & Proxy

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `boards` | array | **Yes** | — | One or more Workday careers URLs, min. 1 item, e.g. `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`. Locale-prefixed URLs (`/en-US/...`) work; the path after the domain is the site ID. |
| `searchText` | string | No | `""` | Keyword filter, same behavior as the careers-page search box. Empty string returns all jobs. |
| `maxJobsPerBoard` | integer | No | `0` | Maximum jobs to scrape from each board. `0` = all jobs on the board. |
| `maxItems` | integer | No | `0` | Maximum total jobs across all boards. `0` = unlimited — free Apify users are capped at 10 jobs. |
| `includeDetails` | boolean | No | `true` | `true` fetches the full detail record per job (HTML description, posting date, time type, apply URL). `false` = list-only mode, one request per 20 jobs. |
| `maxConcurrency` | integer | No | `5` | Parallel requests, range 1–20. Keep 2–5 on large boards to avoid rate limiting. |
| `proxy` | object | No | `{"useApifyProxy": false}` | Standard Apify proxy picker. Off by default — the CXS API is usually reachable directly. |

### Output Fields: 18 Workday Job Posting Fields Per Row

One dataset row per job:

| Field | What it contains |
|---|---|
| `title` | Job title. |
| `location` | Primary location text. |
| `reqId` | Job requisition ID (e.g. `JR2025645`) — a stable per-posting key. |
| `postedDate` | ISO posting date (the detail record's `startDate`). |
| `postedOn` | Relative posting label from the board. |
| `endDate` | ISO valid-through date. |
| `department` | Department — populated only when the board's detail record exposes it; otherwise `null`. |
| `workplaceType` | Remote / hybrid / on-site — populated only when the board exposes it; otherwise `null`. |
| `timeType` | Full time / Part time — always present. |
| `country` | Country descriptor. |
| `descriptionHtml` | Full job description as HTML. |
| `descriptionText` | Full job description as plain text. |
| `applyUrl` | Direct apply URL. |
| `company` | Company/tenant name. |
| `tenant` | Workday tenant. |
| `site` | Workday job posting site ID. |
| `boardUrl` | Careers board URL the row came from. |
| `scrapedAt` | ISO timestamp of the scrape. |

> **Note on `department` and `workplaceType`:** Workday does not expose these fields uniformly — they are populated when the board's detail record includes them (many boards do); otherwise they are `null`. `timeType` (Full time / Part time) is always present.

The dataset ships with an **Overview** view rendering a table of `title`, `location`, `reqId`, `postedDate`, `department`, `workplaceType` and `applyUrl` (as a clickable link). The output schema exposes a single `results` field resolving to the default dataset's `/items` URL, so consumers read results from the dataset.

### Example Input And Output

#### Example Input

```json
{
  "boards": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "https://salesforce.wd1.myworkdayjobs.com/External_Careers"
  ],
  "searchText": "engineer",
  "maxJobsPerBoard": 100,
  "maxItems": 200,
  "includeDetails": true,
  "maxConcurrency": 4,
  "proxy": { "useApifyProxy": false }
}
```

#### Example Output

```json
{
  "title": "Software Engineer, Data Center Compute Software Tools (RDSS Intern)",
  "location": "Taiwan, Taipei",
  "reqId": "JR2025645",
  "postedDate": "2026-10-06",
  "postedOn": "Posted Today",
  "endDate": "2027-04-30",
  "department": null,
  "workplaceType": null,
  "timeType": "Full time",
  "country": "Taiwan",
  "descriptionHtml": "<p><b>What you'll be doing:</b>...</p>",
  "descriptionText": "What you'll be doing: ...",
  "applyUrl": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite/job/...",
  "company": "nvidia",
  "tenant": "nvidia",
  "site": "NVIDIAExternalCareerSite",
  "boardUrl": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
  "scrapedAt": "2026-10-06T06:01:59.000Z"
}
```

### How The Workday CXS API Works: The Documented /wday/cxs Bypass

Two endpoints, both under `https://{host}/wday/cxs/{tenant}/{site}/`:

| Step | Endpoint | Method | Purpose |
|------|----------|--------|---------|
| List | `{origin}/wday/cxs/{tenant}/{site}/jobs` | `POST` | Paginated job list. Body: `{"appliedFacets":{},"limit":20,"offset":N,"searchText":""}`. Returns `total` + `jobPostings[]` with `title`, `externalPath`, `locationsText`, `postedOn`, `bulletFields` (req ID). |
| Detail | `{origin}/wday/cxs/{tenant}/{site}{externalPath}` | `GET` | Full record per job. Header `Accept: application/json`. Returns `jobPostingInfo` with `jobDescription` (full HTML), `jobReqId`, `location`, `country`, `startDate` (real ISO posting date), `endDate`, `timeType`, `externalUrl` (apply URL). |

Host, tenant and site come straight from the careers URL:

```
https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite
        └─host─┘   └─tenant─┘   └──────site──────┘
```

Locale-prefixed URLs (`/en-US/NVIDIAExternalCareerSite`) are handled automatically.

**Why this extraction path was chosen over the alternatives:**

- **Embedded JSON blobs** (`__NEXT_DATA__` etc.): not present — Workday serves an empty SPA shell.
- **HTML scraping**: the job description is only rendered client-side; the static HTML only carries a plain-text `application/ld+json` summary (no HTML description, no department).
- **Browser rendering**: unnecessary — the CXS API returns everything the UI shows, including the full HTML description, in one request per job.

### Export Workday Jobs To CSV, JSON Or Excel

Every run lands as one row per job in an Apify dataset:

- **Apify Console** → dataset → *Export* → JSON, CSV, Excel (or XML, HTML).
- **Apify API** → `GET /v2/datasets/{datasetId}/items?format=csv` (or `json`).
- **Spreadsheet-ready** — `descriptionText` is plain text (no HTML to strip); the core fields map cleanly to columns.
- **Diffable snapshots** — `reqId` is stable per posting, `endDate` shows when a posting lapses, `scrapedAt` timestamps the run — so successive exports can be diffed.

### Monitor New Job Postings On Any Workday Board With Scheduled Runs

- **Schedule it** — a daily or weekly schedule in the Apify Console produces a fresh dataset snapshot per run; attach a webhook on run success (or per dataset item) to push new postings into Slack, a database, a CRM or Zapier/Make.
- **Cheap change detection** — set `includeDetails: false` for monitoring runs: one request per 20 jobs still returns `title`, `location`, `reqId` and `postedOn`, enough to spot newly opened roles.

### Workday Scraping Limits: 10,000-Result Search Cap, Rate Limits & Safety Caps

**Cost & limits**

- **No browser, no residential proxies required** for the API surface — runs are cheap (256 MB, plain HTTP; max memory 512 MB).
- Hard safety caps are built in: `maxRequestsPerCrawl` (50,000 absolute), `maxRequestRetries` (3), per-request timeout (60 s), and item caps from the input.
- Free Apify users get a 10-job preview; paid users get full runs.
- Workday caps a single search query at 10,000 results; boards larger than that need facet filtering (contact the author if you need this).

**Known limitations & troubleshooting**

- `department` / `workplaceType` depend on the board's data model (see Output Fields) — `null` is expected data, not a failed scrape.
- Some tenants use `myworkdaysite.com` instead of `myworkdayjobs.com` — the same CXS API applies; paste the site URL as-is.
- A small number of boards rate-limit aggressive pagination; keep `maxConcurrency` at 2–5 for large boards.
- A run returning only a fraction of jobs usually means an input cap truncated it or the query hit Workday's 10,000-result ceiling — not a pagination bug.

### Run Myworkdayjobs Scraper From The Apify API, Console Or Schedule

**Console:** open the actor, paste the input JSON, press *Run*. **CLI** (two boards, bounded):

```bash
apify call myworkdayjobs-scraper --input='{
  "boards": [
    "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite",
    "https://salesforce.wd1.myworkdayjobs.com/External_Careers"
  ],
  "maxJobsPerBoard": 100,
  "maxItems": 200,
  "includeDetails": true
}'
```

**REST API** (one-shot, returns the dataset directly):

```bash
curl -X POST "https://api.apify.com/v2/acts/ahmed_jasarevic~myworkdayjobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"boards":["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"],"maxJobsPerBoard":50}'
```

The actor ID `Oqmrfd9TuG6EX0AYy` replaces the name in any endpoint. For longer runs, `POST .../v2/acts/.../runs`, poll the run, then read `https://api.apify.com/v2/datasets/YOUR_DATASET_ID/items?format=json`. Recurring monitoring is configured in the *Schedules* tab.

### Integrations & Automation: Apify API, Webhooks, Zapier, Make & Schedules

- **Apify API** — start runs and read results from any backend, as shown above; Python and JavaScript SDKs wrap the same endpoints.
- **Webhooks** — fire on run success (or per dataset item added) to push results into your database, CRM or Slack channel.
- **Zapier / Make** — the Apify apps on both platforms trigger when a run finishes, so new Workday postings can become rows in Google Sheets or Airtable with no code.
- **Recommended cadence** — **daily** for hiring-signal and job-lead monitoring, **weekly** for job market research and hiring trend analysis, **hourly** only for live job alerts.

### Related Actors: Workday, Multi-ATS And Hiring-Signal Job Scrapers

- **[myworkdayjobs-scraper](https://apify.com/bovi/myworkdayjobs-scraper)** — a same-source Workday career-board scraper from another maintainer.
- **[workday-jobs-scraper](https://apify.com/bovi/workday-jobs-scraper)** — a Workday-focused jobs scraper (`bovi`) for the same boards.
- **[Apify-Workday-Careers-API](https://apify.com/johnisanerd/Apify-Workday-Careers-API)** — Workday careers data packaged as an API.
- **[greenhouse-lever-workday-jobs-scraper](https://apify.com/DeriverGe/greenhouse-lever-workday-jobs-scraper)** — multi-ATS scraper covering Workday alongside Greenhouse and Lever, for target lists that span platforms.
- **[ats-hiring-signals](https://apify.com/opensignals/ats-hiring-signals)** — ATS hiring-signals extraction, aligned with the hiring-signals and job-lead-generation use cases.

### FAQ: Workday Jobs API, CSV Export, Pagination Limits & Alternatives

#### Is there an official API for Workday job postings?

Workday offers platform APIs to its enterprise customers, but there is no public, documented job-postings API for arbitrary companies' career sites. What every `*.myworkdayjobs.com` board exposes is the browser-facing **CXS JSON endpoint** (`/wday/cxs/{tenant}/{site}/jobs`) that its own frontend calls — undocumented for public consumption, identical across thousands of tenants, and the endpoint this actor uses. Third-party "Workday jobs API" pages (parse.bot, JobsPipe, fantastic.jobs docs) exist because of that gap.

#### Why use this actor instead of the official API?

Because the official route does not exist for arbitrary boards (see above). Against building the calls yourself, this actor adds: **speed and cost** (JSON in, JSON out — no page rendering, no DOM parsing, 256 MB plain-HTTP runs), **stability** (the API shape is identical across thousands of tenants), **anti-bot resistance** (not behind the Cloudflare/Akamai wall that guards the HTML pages), bulk mode across many boards, one fixed 18-field schema — plus datasets, schedules, webhooks and exports.

#### What are the alternatives to this actor?

- **Other Store actors for the same source** — see [Related Actors](#related-actors-workday-multi-ats-and-hiring-signal-job-scrapers): two `bovi` Workday scrapers, `johnisanerd`'s Workday careers API, plus a Greenhouse/Lever/Workday multi-ATS actor and a hiring-signals actor.
- **Multi-ATS scrapers** — one run across Greenhouse, Lever, iCIMS and Workday if your company list is not Workday-only.
- **DIY** — call the two `/wday/cxs` endpoints directly (full contract above); free, but you build pagination, retries, scheduling and normalization yourself.
- **Technical fallbacks** — embedded JSON blobs are absent, plain HTML scraping loses the description and department, browser rendering is unnecessary overhead (details in the CXS API section).

#### How do you scrape a Workday career site without a browser?

Skip the HTML entirely: `POST` the list endpoint at `/wday/cxs/{tenant}/{site}/jobs` (20 jobs per page), then `GET` each job's `externalPath` with `Accept: application/json`. This actor does that with CheerioCrawler over plain HTTP — no headless browser, no DOM parsing, one request per job for the full record.

#### How do I export all jobs from a myworkdayjobs.com site to Excel or CSV?

Run the actor with the board URL (leave `maxJobsPerBoard` at `0` for everything), then export the dataset from the Apify Console as CSV or Excel, or call `GET /v2/datasets/{datasetId}/items?format=csv`.

#### How can I monitor new job postings on a company's careers page?

Schedule this actor daily or weekly on the boards you follow and attach a webhook for notifications. For cheap change detection, run with `includeDetails: false` (one request per 20 jobs) — `title`, `location`, `reqId` and `postedOn` detect new openings.

#### Why does my Workday scrape only return a fraction of the jobs?

Four causes, in order: (1) input caps truncated the run — `maxJobsPerBoard`, `maxItems`, or the 10-job cap free Apify users get; (2) Workday caps a single search query at 10,000 results, so very large boards need facet filtering; (3) the board rate-limited aggressive pagination — drop `maxConcurrency` to 2–5; (4) a request failed after 3 retries (60 s timeout). `maxRequestsPerCrawl` (50,000) is a safety rail, not a job limit.

#### What fields and data can you get from a Workday job posting?

All 18 fields listed under Output Fields. `department` and `workplaceType` are `null` when a board does not expose them; `timeType` is always present; `descriptionHtml`, `descriptionText`, `postedDate`, `timeType` and `applyUrl` come from the detail record (`includeDetails: true`, the default), while list-only mode keeps `title`, `location`, `reqId`, `postedOn`.

### SEO Keywords

myworkdayjobs scraper, workday jobs scraper, myworkdayjobs api, workday jobs api, workday career site scraper, workday cxs api, workday ats jobs data, export workday jobs to csv, monitor new job postings, job posting aggregation, job postings database, hiring signals, job lead generation, job market research, talent market intelligence, labor market data, hiring trend analysis, ats scraper, applicant tracking system scraper, job scraping tools, find companies hiring, get all jobs at one company, job postings by country, greenhouse lever icims jobs scraper

### For AI Agents & LLM Apps

**Purpose:** extract structured job-posting records (18 fields) from one or more Workday `*.myworkdayjobs.com` career boards over plain HTTP — no browser rendering.

Minimal working input:

```json
{ "boards": ["https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"] }
```

**Output fields:** `title`, `location`, `reqId`, `postedDate`, `postedOn`, `endDate`, `department`, `workplaceType`, `timeType`, `country`, `descriptionHtml`, `descriptionText`, `applyUrl`, `company`, `tenant`, `site`, `boardUrl`, `scrapedAt`.

**Behaviors an agent should know:**

- `boards` is the only required field (`minItems` 1); defaults are `searchText: ""` (all jobs), `maxJobsPerBoard: 0`, `maxItems: 0` (unlimited — free accounts capped at 10 jobs), `includeDetails: true`, `maxConcurrency: 5` (range 1–20), proxy off.
- `includeDetails` is the cost lever: `false` switches to list-only mode at one request per 20 jobs; the detail record supplies `descriptionHtml`, `descriptionText`, `postedDate`, `timeType` and `applyUrl`.
- Built-in safety caps: 50,000 requests per crawl, 3 request retries, 60-second per-request timeout; runs use 256 MB memory with no browser and no residential proxy by default.
- Workday caps a single search query at 10,000 results; boards beyond that need facet filtering. `department` and `workplaceType` may be `null` (board-dependent); `timeType` is always present. Keep `maxConcurrency` at 2–5 for large boards.
- Results are read from the default dataset; the run's output schema exposes one `results` field pointing at the dataset's `/items` URL.

### Legal & Compliance Disclaimer

- This actor is an independent third-party tool. It is **not** affiliated with, endorsed by, sponsored by or connected to Workday, Inc. or the `myworkdayjobs.com` platform.
- It accesses only publicly available career-board pages and the public JSON responses those pages load in a browser — no login, no credential use, no authentication bypass.
- Output is job-posting data published by employers on live public boards; listings change or disappear without notice, and `department` / `workplaceType` depend on what each board exposes.
- You are responsible for your own compliance with the source site's Terms of Service and with applicable data-protection law (including GDPR/CCPA where relevant to your use case and data).
- Some job descriptions embed personal contact details (recruiter names or emails). If your output includes personal data, it must not be used for unsolicited commercial outreach in violation of applicable law.

# Actor input Schema

## `boards` (type: `array`):

One or more Workday careers-site URLs, e.g. https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite. Locale-prefixed URLs (https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite) work too. The part after the domain is the site ID — copy it from the careers page address bar.

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

Optional keyword filter, same behavior as the search box on the careers page. Empty string returns all jobs.

## `maxJobsPerBoard` (type: `integer`):

Maximum number of jobs to scrape from each board. 0 = all jobs on the board.

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

Maximum total number of jobs to scrape across all boards. 0 = unlimited (free users are capped at 10).

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

Fetch the full detail record per job (HTML description, posting date, time type, apply URL). Disable for a fast list-only run (one request per 20 jobs).

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

Number of parallel requests. Keep modest (2-5) to avoid rate limiting.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "boards": [
    {
      "url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
    }
  ],
  "searchText": "",
  "maxJobsPerBoard": 0,
  "maxItems": 0,
  "includeDetails": true,
  "maxConcurrency": 5,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "boards": [
        {
            "url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
        }
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/myworkdayjobs-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 = {
    "boards": [{ "url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite" }],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/myworkdayjobs-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 '{
  "boards": [
    {
      "url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite"
    }
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/myworkdayjobs-scraper --silent --output-dataset

```

## MCP server setup

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