# Workday Jobs Scraper (`vamsi-krishna/workday-jobs-scraper`) Actor

Extract public job listings from Workday career sites (API-first), with optional descriptions, deduplication, and per-source limits.

- **URL**: https://apify.com/vamsi-krishna/workday-jobs-scraper.md
- **Developed by:** [Vamsi Krishna](https://apify.com/vamsi-krishna) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 job listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Jobs Scraper

Extract public job listings from Workday career sites into a clean, structured Apify dataset.

This actor is built for recruiting research, job-board enrichment, hiring-market monitoring, and company career-page tracking. It only works with publicly accessible Workday career pages.

### Why Use It

- API-first extraction from Workday public CXS endpoints when available.
- Correct public job URLs with locale and career-site paths preserved.
- Enriched records with requisition IDs, Workday tenant/site, locations, remote/workplace signals, job family/category, and description text.
- Practical filters for India, city targeting, IT roles, fresher/entry-level jobs, remote roles, and recently posted jobs.
- Per-source limits so large companies do not consume the whole run.
- Cost controls with `maxItems` and `maxItemsPerSource`, so users can cap paid results before starting large runs.
- Run summary diagnostics for debugging empty or filtered runs.

### What It Does

- Reads one or more Workday career site URLs.
- Uses Workday public CXS endpoints when available for faster and cleaner extraction.
- Falls back to public page crawling when needed.
- Saves one dataset item per job listing.
- Deduplicates jobs by requisition ID, URL, or title/location/company.
- Supports keyword, location, freshness, IT-role, and fresher/entry-level filters.
- Can fetch job descriptions using CXS detail endpoints or public HTML pages.

### Supported URLs

Examples:

```text
https://company.wd1.myworkdayjobs.com/en-US/External
https://company.wd5.myworkdayjobs.com/en-US/Careers
https://wd1.myworkdaysite.com/en-US/recruiting/tenant/site
````

The actor supports common public Workday hosts such as:

- `myworkdayjobs.com`
- `wd1.myworkdayjobs.com`
- `wd3.myworkdayjobs.com`
- `wd5.myworkdayjobs.com`
- `myworkdaysite.com`

### Input

Key fields:

- `startUrls` - Workday career URLs to scrape.
- `companyOverrides` - Optional friendly company-name mapping by URL, tenant, or site.
- `keyword` - Optional keyword search, for example `software engineer`.
- `location` - Optional location filter, for example `India`.
- `country` and `cities` - Optional location filters for cleaner country/city targeting.
- `remoteOnly` - Keep only jobs detected as remote.
- `experienceLevel` - `all`, `fresher`, `entry_level`, `mid`, or `senior`.
- `jobFunction` - `all`, `software`, `data`, `cloud`, `security`, `qa`, `support`, or `product`.
- `maxItems` - Maximum jobs to save for the whole run.
- `maxItemsPerSource` - Optional per-company/source limit.
- `includeDescription` - Fetch job descriptions when available.
- `descriptionMode` - `auto`, `cxs`, `html`, or `none`.
- `postedWithinDays` - Keep recently posted jobs only, when dates are available.
- `itOnly` - Best-effort filter for IT/software/data/engineering roles.
- `fresherOnly` - Best-effort filter for fresher, graduate, trainee, intern, and entry-level roles.
- `dedupeMode` - `requisitionId`, `url`, `titleLocationCompany`, or `none`.
- `proxyConfiguration` - Optional Apify proxy settings.

Example input:

```json
{
  "startUrls": [
    {
      "url": "https://relx.wd3.myworkdayjobs.com/en-US/relx"
    }
  ],
  "companyOverrides": {
    "relx": "RELX"
  },
  "keyword": "software engineer",
  "location": "India",
  "country": "India",
  "cities": ["Bengaluru", "Hyderabad", "Pune"],
  "experienceLevel": "entry_level",
  "jobFunction": "software",
  "maxItems": 100,
  "maxItemsPerSource": 25,
  "includeDescription": true,
  "descriptionMode": "auto",
  "dedupeMode": "requisitionId"
}
```

### Output

Each saved dataset item may include:

- `jobId`
- `title`
- `company`
- `sourceCompany`
- `requisitionId`
- `tenant`
- `site`
- `location`
- `locations`
- `country`
- `city`
- `remoteType`
- `workplaceType`
- `isRemote`
- `employmentType`
- `timeType`
- `jobFamily`
- `jobCategory`
- `detectedSeniority`
- `detectedFunction`
- `postedDate`
- `jobUrl`
- `applyUrl`
- `descriptionHtml`
- `description`
- `requirements`
- `salary`
- `externalPath`
- `detailApiUrl`
- `sourceUrl`
- `sourceType`
- `scrapedAt`

The actor also saves a `RUN_SUMMARY` record to the default key-value store with per-source counts and diagnostic information.

### API Usage

Run from JavaScript:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('YOUR_USERNAME/workday-jobs-scraper').call({
  startUrls: [{ url: 'https://relx.wd3.myworkdayjobs.com/en-US/relx' }],
  keyword: 'software engineer',
  country: 'India',
  maxItems: 50,
  includeDescription: true
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Run with curl:

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~workday-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://relx.wd3.myworkdayjobs.com/en-US/relx"}],"maxItems":25}'
```

### Cost Guidance

Pricing is pay per saved job listing plus a small start event. The actor only charges the result event when a job is saved to the default dataset. Use `maxItems` and `maxItemsPerSource` to control spend before running large source lists.

Examples:

- `maxItems: 25` saves up to 25 paid job listings.
- `maxItems: 100` saves up to 100 paid job listings.
- `maxItemsPerSource: 20` spreads results across companies instead of letting one employer consume the full run.

### Recommended Settings

For fast runs:

```json
{
  "includeDescription": false,
  "descriptionMode": "none",
  "maxItemsPerSource": 25
}
```

For richer job descriptions:

```json
{
  "includeDescription": true,
  "descriptionMode": "auto"
}
```

For fresher IT jobs:

```json
{
  "keyword": "software engineer",
  "location": "India",
  "country": "India",
  "experienceLevel": "entry_level",
  "jobFunction": "software",
  "itOnly": true,
  "fresherOnly": true,
  "includeDescription": true
}
```

### Reliability Notes

Workday implementations vary by company. Some tenants expose rich public CXS data, while others expose limited metadata or block public detail endpoints. The actor handles these differences best-effort and avoids saving incomplete records when required fields such as `title` or `jobUrl` are missing.

If a run returns no jobs:

- Check that the URL is a public Workday career site.
- Try removing restrictive filters such as `postedWithinDays`, `itOnly`, or `fresherOnly`.
- Try `descriptionMode: "none"` for a faster listing-only run.
- Use `RUN_SUMMARY` to see which sources returned jobs and which did not.

### Local Development

```bash
npm install
npm run build
npm test
apify run
apify push
```

### Compliance

This actor only targets publicly accessible job listings. It does not bypass login, CAPTCHA, paywalls, private APIs, or access controls. Use it responsibly and respect the target website's terms of service and applicable laws.

# Actor input Schema

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

One or more public Workday career site URLs.

## `companyOverrides` (type: `object`):

Optional mapping of Workday tenant/site/source URL to friendly company names, e.g. { "wf": "Wells Fargo", "WellsFargoJobs": "Wells Fargo" }.

## `descriptionMode` (type: `string`):

How to fetch job descriptions when includeDescription is enabled. auto=cxs (preferred) with html fallback.

## `keyword` (type: `string`):

Optional keyword to filter job listings.

## `location` (type: `string`):

Optional location text to filter job listings.

## `country` (type: `string`):

Optional country filter, for example India or United States.

## `cities` (type: `array`):

Optional list of city names to match in job locations.

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

If enabled, keeps only jobs detected as remote.

## `experienceLevel` (type: `string`):

Best-effort seniority filter based on job title and description.

## `jobFunction` (type: `string`):

Best-effort function filter based on job title and description.

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

Maximum number of job listings to save.

## `maxItemsPerSource` (type: `integer`):

If set, the Actor will save up to this many jobs per startUrl (source), while still respecting maxItems global.

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

If enabled, fetch job detail pages for description and metadata.

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

Only include jobs posted within the last N days (best-effort).

## `fresherOnly` (type: `boolean`):

If enabled, keeps only jobs that look like fresher / entry-level roles based on title/description text (best-effort).

## `itOnly` (type: `boolean`):

If enabled, keeps only jobs that look like IT/Software/Engineering roles based on title/description text (best-effort).

## `dedupeMode` (type: `string`):

How to deduplicate jobs. requisitionId uses tenant+site+jobId when available.

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

If enabled, deduplicate jobs by jobId (preferred) or canonical jobUrl.

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

Apify Proxy configuration.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://relx.wd3.myworkdayjobs.com/en-US/relx"
    }
  ],
  "descriptionMode": "auto",
  "remoteOnly": false,
  "experienceLevel": "all",
  "jobFunction": "all",
  "maxItems": 100,
  "includeDescription": true,
  "fresherOnly": false,
  "itOnly": false,
  "dedupeMode": "requisitionId",
  "deduplicate": true
}
```

# Actor output Schema

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

The job listings saved by the Actor (default dataset).

## `runSummary` (type: `string`):

Per-source counts and totals saved to the default key-value store.

# 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": [
        {
            "url": "https://relx.wd3.myworkdayjobs.com/en-US/relx"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vamsi-krishna/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 = { "startUrls": [{ "url": "https://relx.wd3.myworkdayjobs.com/en-US/relx" }] }

# Run the Actor and wait for it to finish
run = client.actor("vamsi-krishna/workday-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": [
    {
      "url": "https://relx.wd3.myworkdayjobs.com/en-US/relx"
    }
  ]
}' |
apify call vamsi-krishna/workday-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Workday Jobs Scraper",
        "description": "Extract public job listings from Workday career sites (API-first), with optional descriptions, deduplication, and per-source limits.",
        "version": "0.1",
        "x-build-id": "IZ2yqJkPApCzZaJNK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vamsi-krishna~workday-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vamsi-krishna-workday-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/vamsi-krishna~workday-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-vamsi-krishna-workday-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/vamsi-krishna~workday-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-vamsi-krishna-workday-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more public Workday career site URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "Public Workday career site URL."
                                }
                            }
                        }
                    },
                    "companyOverrides": {
                        "title": "Company overrides",
                        "type": "object",
                        "description": "Optional mapping of Workday tenant/site/source URL to friendly company names, e.g. { \"wf\": \"Wells Fargo\", \"WellsFargoJobs\": \"Wells Fargo\" }."
                    },
                    "descriptionMode": {
                        "title": "Description mode",
                        "enum": [
                            "auto",
                            "cxs",
                            "html",
                            "none"
                        ],
                        "type": "string",
                        "description": "How to fetch job descriptions when includeDescription is enabled. auto=cxs (preferred) with html fallback.",
                        "default": "auto"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Optional keyword to filter job listings."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional location text to filter job listings."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Optional country filter, for example India or United States."
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Optional list of city names to match in job locations.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "If enabled, keeps only jobs detected as remote.",
                        "default": false
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "enum": [
                            "all",
                            "fresher",
                            "entry_level",
                            "mid",
                            "senior"
                        ],
                        "type": "string",
                        "description": "Best-effort seniority filter based on job title and description.",
                        "default": "all"
                    },
                    "jobFunction": {
                        "title": "Job function",
                        "enum": [
                            "all",
                            "software",
                            "data",
                            "cloud",
                            "security",
                            "qa",
                            "support",
                            "product"
                        ],
                        "type": "string",
                        "description": "Best-effort function filter based on job title and description.",
                        "default": "all"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of job listings to save.",
                        "default": 100
                    },
                    "maxItemsPerSource": {
                        "title": "Max items per source",
                        "minimum": 1,
                        "type": "integer",
                        "description": "If set, the Actor will save up to this many jobs per startUrl (source), while still respecting maxItems global."
                    },
                    "includeDescription": {
                        "title": "Include description",
                        "type": "boolean",
                        "description": "If enabled, fetch job detail pages for description and metadata.",
                        "default": true
                    },
                    "postedWithinDays": {
                        "title": "Posted within days",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only include jobs posted within the last N days (best-effort)."
                    },
                    "fresherOnly": {
                        "title": "Fresher / entry-level only",
                        "type": "boolean",
                        "description": "If enabled, keeps only jobs that look like fresher / entry-level roles based on title/description text (best-effort).",
                        "default": false
                    },
                    "itOnly": {
                        "title": "IT roles only",
                        "type": "boolean",
                        "description": "If enabled, keeps only jobs that look like IT/Software/Engineering roles based on title/description text (best-effort).",
                        "default": false
                    },
                    "dedupeMode": {
                        "title": "Dedupe mode",
                        "enum": [
                            "requisitionId",
                            "url",
                            "titleLocationCompany",
                            "none"
                        ],
                        "type": "string",
                        "description": "How to deduplicate jobs. requisitionId uses tenant+site+jobId when available.",
                        "default": "requisitionId"
                    },
                    "deduplicate": {
                        "title": "Deduplicate results",
                        "type": "boolean",
                        "description": "If enabled, deduplicate jobs by jobId (preferred) or canonical jobUrl.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```