# Workday Enterprise Jobs Scraper (`coregent/workday-enterprise-jobs-scraper`) Actor

Scrape public Workday career sites (\*.myworkdayjobs.com) for enterprise job postings and turn them into clean, CSV-ready hiring-intelligence data - no login, cookies, or residential proxy required.

- **URL**: https://apify.com/coregent/workday-enterprise-jobs-scraper.md
- **Developed by:** [Delowar Munna](https://apify.com/coregent) (community)
- **Categories:** Jobs, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 job-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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Workday Enterprise Jobs Scraper

![Workday Enterprise Jobs Scraper](https://raw.githubusercontent.com/coregentdevspace/workday-enterprise-jobs-scraper-assets/main/thumbnail-workday-enterprise-jobs-scraper.png)

Scrape **public Workday career sites** (`*.myworkdayjobs.com`) for enterprise job
postings and turn them into clean, flat, CSV-ready rows enriched with lightweight,
non-AI hiring-signal fields (remote/hybrid flags, location breakdown, seniority hint,
recency label, keyword hits, and signal tags).

It uses Workday's **public, unauthenticated career-site JSON API** ("CXS") over plain
HTTP — **no login, no cookies, no tenant credentials, no residential proxy**. Output is
a flat **28-field row per job**, built for recruiters, sales teams, agencies, lead-gen,
and market researchers.

---

### ✨ What it does

- Accepts one or more public Workday career/search/job URLs.
- Pages the public Workday listing endpoint and (optionally) fetches each job's public
  detail page for the full description, employment type, exact locations, posting date,
  and apply URL.
- Normalizes everything into a flat, stable, CSV-friendly schema.
- Deduplicates by Workday requisition ID and canonical job URL.
- Adds non-AI hiring-signal fields derived only from visible scraped data.
- Charges **only** for valid, unique, saved rows (pay-per-result).

### 🔗 Supported URLs

Any public Workday career site, for example:

````

https://company.wd1.myworkdayjobs.com/en-US/External
https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite
https://company.wd3.myworkdayjobs.com/External/job/Location/Title\_R-12345   (single job)

````

Only `*.myworkdayjobs.com` URLs are supported. Other URLs are skipped and counted as
failed inputs (the run still succeeds).

---

### 📥 Input

| Field                   | Type             | Default        | Description                                                                                                          |
| ----------------------- | ---------------- | -------------- | -------------------------------------------------------------------------------------------------------------------- |
| `startUrls`             | array of strings | NVIDIA example | Public Workday career/search/job URLs. Career/search URLs are paginated; `/job/...` URLs return that single posting. |
| `maxResults`            | integer          | `500`          | Max saved unique jobs across the whole run (1–5000).                                                                 |
| `keywords`              | array of strings | `[]`           | Keep only jobs whose title/department/job family/location/description contains one of these terms.                   |
| `locations`             | array of strings | `[]`           | Keep only jobs whose location text contains one of these terms.                                                      |
| `remoteOnly`            | boolean          | `false`        | Keep only jobs that look remote or hybrid.                                                                           |
| `postedWithinDays`      | integer / null   | `null`         | Keep only jobs posted within N days (1–365).                                                                         |
| `strictDateFilter`      | boolean          | `false`        | When a recency filter is set, drop jobs whose date couldn't be parsed.                                               |
| `includeJobDescription` | boolean          | `true`         | Fetch each job's detail page for description + richer fields. Off = faster, fewer fields.                            |
| `includeDerivedSignals` | boolean          | `true`         | Add `signal_tags` and `keyword_hits`.                                                                                |
| `deduplicate`           | boolean          | `true`         | Remove duplicate jobs by requisition ID / canonical URL.                                                             |
| `proxyConfiguration`    | object           | Apify Proxy    | Datacenter, no-proxy, or custom proxy URLs. **Apify Residential is rejected.**                                       |

#### Sample input — keyword + location filtering

```json
{
    "startUrls": ["https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite"],
    "maxResults": 250,
    "keywords": ["data", "engineer", "security"],
    "locations": ["Australia", "Remote"],
    "remoteOnly": false,
    "postedWithinDays": 30,
    "includeJobDescription": true,
    "deduplicate": true,
    "proxyConfiguration": { "useApifyProxy": true }
}
````

#### Sample input — fast listing-only run (no descriptions)

```json
{
    "startUrls": ["https://company.wd1.myworkdayjobs.com/en-US/External"],
    "maxResults": 1000,
    "includeJobDescription": false,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

***

### 📤 Output

Each row is a flat object with these 28 fields:

`job_id`, `requisition_id`, `job_title`, `company_name`, `workday_tenant`, `department`,
`job_family`, `employment_type`, `locations_text`, `primary_location`, `city`, `region`,
`country`, `is_remote`, `is_hybrid`, `posted_date`, `posted_date_raw`, `recency_label`,
`job_url`, `apply_url`, `description_text`, `description_html`, `seniority_hint`,
`keyword_hits`, `signal_tags`, `source_input_url`, `source_platform`, `scraped_at`.

#### Output preview

![Workday Enterprise Jobs Scraper output — all fields](https://raw.githubusercontent.com/coregentdevspace/workday-enterprise-jobs-scraper-assets/main/workday-enterprise-jobs-scraper-output-all-fields-table-view.png)

#### Sample record

```json
{
    "job_id": "JR2019248",
    "requisition_id": "JR2019248",
    "job_title": "Software Engineer, DGX Cloud AI Infrastructure",
    "company_name": "NVIDIA",
    "workday_tenant": "nvidia",
    "department": "Engineering",
    "job_family": "Engineering",
    "employment_type": "Full time",
    "locations_text": "US, CA, Santa Clara; US, TX, Austin; US, OR, Remote; US, WA, Remote; US, WA, Redmond",
    "primary_location": "US, CA, Santa Clara",
    "city": "Santa Clara",
    "region": "CA",
    "country": "United States of America",
    "is_remote": true,
    "is_hybrid": false,
    "posted_date": "2026-06-03",
    "posted_date_raw": "Posted Today",
    "recency_label": "last_7_days",
    "job_url": "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Software-Engineer--DGX-Cloud-AI-Infrastructure_JR2019248",
    "apply_url": "https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite/job/US-CA-Santa-Clara/Software-Engineer--DGX-Cloud-AI-Infrastructure_JR2019248",
    "description_text": "NVIDIA is at the forefront of the generative AI revolution, building the software and systems that power the world's most advanced large language model workloads. We are ...",
    "description_html": "<p><span>NVIDIA is at the forefront of the generative AI revolution, building th ...",
    "seniority_hint": "mid",
    "keyword_hits": 0,
    "signal_tags": "remote;recent_posting;newer_than_30_days;engineering;data",
    "source_input_url": "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite",
    "source_platform": "workday",
    "scraped_at": "2026-06-04T05:50:24.326Z"
}
```

> Sample from a real run. `keyword_hits` is `0` here because this run supplied no
> `keywords`; set `keywords` to count and filter on your own terms.

> `region` and `description_html` depend on what a given Workday tenant exposes publicly
> and may be `null`. `department` and `job_family` are rarely published by Workday tenants;
> with `includeDerivedSignals` on (default) they're filled from a title-inferred role
> category (e.g. `Engineering`, `Data & Analytics`) — an inferred label, not Workday's own
> classification. Turn `includeDerivedSignals` off to keep them strictly source-only.

#### Run summary

A 14-field `RUN_SUMMARY` object is written to the default key-value store:
`inputs_total`, `successful_inputs`, `failed_inputs`, `raw_results_found`,
`results_saved`, `duplicates_removed`, `filtered_out`, `charged_events`,
`blocked_requests`, `retry_count`, `detail_pages_requested`, `detail_pages_failed`,
`runtime_seconds`, `scraped_at`.

***

### 💲 Pricing — Pay Per Result

This actor uses **pay-per-event** pricing with a single event:

| Event        | Fires                                                                                      |
| ------------ | ------------------------------------------------------------------------------------------ |
| `job-result` | Once per unique job row that passed all filters and was successfully saved to the dataset. |

Duplicates, filtered-out rows, and failed requests are **never** charged. The per-event
price is set on the Apify Store listing.

#### 🚦 Proxy policy

Use **Apify Datacenter** proxy or **no proxy** for normal runs — both work reliably for
public Workday career sites at this actor's conservative concurrency.

**Apify Residential proxy is not supported.** The actor fails at startup if
`apifyProxyGroups` includes `RESIDENTIAL`. Reason: in pay-per-event actors, residential
bandwidth (billed per GB) is charged to the developer, not the run user, so a single
bandwidth-heavy run could exceed the per-result revenue.

If you genuinely need residential routing, supply your own provider via the proxy
editor's **Custom proxy URLs** field — that traffic goes through your provider, not
Apify, and is unaffected:

```
http://user:pass@proxy.iproyal.com:12321
http://user:pass@proxy.brightdata.com:22225
http://user:pass@proxy.oxylabs.io:7777
```

***

### ⚙️ How it works

1. **Collection** — for each search/career URL the actor POSTs the public Workday CXS
   `/jobs` endpoint and pages by offset, building one row per posting. When
   `includeJobDescription` is on, each kept job's public detail endpoint is fetched and
   the row is enriched in place. A directly-pasted `/job/...` URL is fetched as a single
   posting.
2. **Finalize** — keyword filters are applied, signal tags + keyword hits are computed,
   the valid-row rule is enforced (`job_title` plus a `job_url`/`job_id`/`requisition_id`),
   and each surviving row is pushed and charged.

No browser is used; everything runs over HTTP/JSON, so runs are fast and cheap.

### 🚫 Limitations

- Public data only — no login, cookies, internal Workday APIs, or candidate data.
- Fields are limited to what each tenant exposes publicly; some tenants expose less.
- Workday caps search results at ~10,000 per query; slice by site/keyword for more.
- No AI scoring, enrichment, salary normalization, or cross-site crawling in V1.

# Actor input Schema

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

One or more public Workday career-site URLs (for example https://company.wd1.myworkdayjobs.com/en-US/External). Career/search URLs are paginated for you; direct /job/... URLs return that single posting. Only \*.myworkdayjobs.com URLs are supported; other URLs are skipped.

## `maxResults` (type: `integer`):

Maximum number of saved unique jobs across the whole run (not per URL). Range 1-5000.

## `keywords` (type: `array`):

Keep only jobs whose title, department, job family, location, or description (when loaded) contains one of these terms (case-insensitive). Leave empty to keep all.

## `locations` (type: `array`):

Keep only jobs whose location text contains one of these terms (case-insensitive), for example "Australia", "Remote", "London". Leave empty to keep all.

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

Return only jobs that appear remote or hybrid based on visible location/title text.

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

Keep only jobs posted within this many days. Range 1-365. Leave empty for no recency filter.

## `strictDateFilter` (type: `boolean`):

When a recency filter is set, drop jobs whose posting date could not be parsed. When off, such jobs are kept.

## `includeJobDescription` (type: `boolean`):

Fetch each job's public detail page to extract the full description plus employment type, exact locations, posting date, and apply URL. Turning this off makes runs faster (listing only) but returns fewer fields.

## `includeDerivedSignals` (type: `boolean`):

Add low-cost, non-AI derived fields: signal\_tags (remote, senior, engineering, recent\_posting, ...) and keyword\_hits. Also fills department/job\_family from a title-inferred role category when the Workday tenant doesn't expose them (most don't). Turn off for strict source-only data. Uses only visible scraped fields.

## `deduplicate` (type: `boolean`):

Remove duplicate jobs by Workday requisition ID and canonical job URL so you are not charged for duplicates across overlapping URLs.

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

Apify Proxy configuration. Defaults to Apify Proxy enabled. Apify Residential is NOT supported and will fail the run at startup; if you need residential routing, supply your own provider via Custom proxy URLs (proxyUrls).

## Actor input object example

```json
{
  "startUrls": [
    "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite"
  ],
  "maxResults": 500,
  "keywords": [],
  "locations": [],
  "remoteOnly": false,
  "postedWithinDays": null,
  "strictDateFilter": false,
  "includeJobDescription": true,
  "includeDerivedSignals": true,
  "deduplicate": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Flat 28-field table view of every job row pushed to the dataset, including job identity, company/tenant, location breakdown, posting details, apply URL, description, and derived hiring-signal fields.

# 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 = {
    "startUrls": [
        "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("coregent/workday-enterprise-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 = {
    "startUrls": ["https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("coregent/workday-enterprise-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call coregent/workday-enterprise-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=coregent/workday-enterprise-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Workday Enterprise Jobs Scraper",
        "description": "Scrape public Workday career sites (*.myworkdayjobs.com) for enterprise job postings and turn them into clean, CSV-ready hiring-intelligence data - no login, cookies, or residential proxy required.",
        "version": "1.0",
        "x-build-id": "GS8ngglcIbGpFfXoQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/coregent~workday-enterprise-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-coregent-workday-enterprise-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/coregent~workday-enterprise-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-coregent-workday-enterprise-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/coregent~workday-enterprise-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-coregent-workday-enterprise-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Workday career/search/job URLs",
                        "type": "array",
                        "description": "One or more public Workday career-site URLs (for example https://company.wd1.myworkdayjobs.com/en-US/External). Career/search URLs are paginated for you; direct /job/... URLs return that single posting. Only *.myworkdayjobs.com URLs are supported; other URLs are skipped.",
                        "default": [
                            "https://nvidia.wd5.myworkdayjobs.com/en-US/NVIDIAExternalCareerSite"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of saved unique jobs across the whole run (not per URL). Range 1-5000.",
                        "default": 500
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Keep only jobs whose title, department, job family, location, or description (when loaded) contains one of these terms (case-insensitive). Leave empty to keep all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Keep only jobs whose location text contains one of these terms (case-insensitive), for example \"Australia\", \"Remote\", \"London\". Leave empty to keep all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Return only jobs that appear remote or hybrid based on visible location/title text.",
                        "default": false
                    },
                    "postedWithinDays": {
                        "title": "Posted within days",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Keep only jobs posted within this many days. Range 1-365. Leave empty for no recency filter.",
                        "default": null
                    },
                    "strictDateFilter": {
                        "title": "Strict date filter",
                        "type": "boolean",
                        "description": "When a recency filter is set, drop jobs whose posting date could not be parsed. When off, such jobs are kept.",
                        "default": false
                    },
                    "includeJobDescription": {
                        "title": "Include job descriptions",
                        "type": "boolean",
                        "description": "Fetch each job's public detail page to extract the full description plus employment type, exact locations, posting date, and apply URL. Turning this off makes runs faster (listing only) but returns fewer fields.",
                        "default": true
                    },
                    "includeDerivedSignals": {
                        "title": "Add derived hiring-signal fields",
                        "type": "boolean",
                        "description": "Add low-cost, non-AI derived fields: signal_tags (remote, senior, engineering, recent_posting, ...) and keyword_hits. Also fills department/job_family from a title-inferred role category when the Workday tenant doesn't expose them (most don't). Turn off for strict source-only data. Uses only visible scraped fields.",
                        "default": true
                    },
                    "deduplicate": {
                        "title": "Deduplicate jobs",
                        "type": "boolean",
                        "description": "Remove duplicate jobs by Workday requisition ID and canonical job URL so you are not charged for duplicates across overlapping URLs.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. Defaults to Apify Proxy enabled. Apify Residential is NOT supported and will fail the run at startup; if you need residential routing, supply your own provider via Custom proxy URLs (proxyUrls).",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
