# ATS Jobs + Tech-Stack & Hiring-Signal Intelligence (`catalini82/ats-jobs-tech-stack-intelligence`) Actor

Track public jobs across Greenhouse, Lever, Ashby, SmartRecruiters, and Workable with unified fields, tech-stack detection, relevance scoring, and delta-mode hiring signals.

- **URL**: https://apify.com/catalini82/ats-jobs-tech-stack-intelligence.md
- **Developed by:** [Catalin Ionut Iliescu](https://apify.com/catalini82) (community)
- **Categories:** Jobs, Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 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.

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

## ATS Jobs + Tech-Stack & Hiring-Signal Intelligence

Build a normalized job-intelligence feed from public ATS job boards. Provide company targets or ATS board slugs, and this Actor fetches public postings, normalizes them into one schema, detects technical stack signals, scores AI/infra relevance, and can emit only job changes between runs.

It is built for investors, GTM teams, recruiters, founders, talent-intelligence workflows, and agentic research tasks that need more than raw ATS records.

### Supported ATS platforms

- Greenhouse
- Lever
- Ashby
- SmartRecruiters, when the company's public Posting API feed is enabled
- Workable, through the public careers widget JSON feed when available

Workday and Personio are intentionally not included in v0.1.

### What makes it different

- One unified output schema across multiple ATS sources.
- Deterministic tech-stack enrichment: no LLM runtime calls and no unpredictable model cost.
- AI, ML, infrastructure, platform, data, DevOps, security, product, and non-engineering role-family detection.
- Relevance scores designed to separate strong AI/infra matches from generic engineering roles.
- Delta mode for new, changed, removed, and optionally unchanged job events.
- Curated company registry for common public boards, while still accepting explicit ATS slugs.

### Input example

```json
{
  "targets": [
    {
      "company": "Databricks",
      "ats": "greenhouse",
      "slug": "databricks"
    },
    {
      "company": "Shield AI",
      "ats": "lever",
      "slug": "shieldai"
    },
    {
      "company": "OpenAI",
      "ats": "ashby",
      "slug": "OpenAI"
    }
  ],
  "keywords": ["AI", "ML", "machine learning", "LLM", "Kubernetes", "GPU", "inference"],
  "maxJobsPerCompany": 100,
  "maxItems": 500,
  "minRelevanceScore": 25,
  "includeGenericEngineering": true,
  "includeDataPlatform": true,
  "includeNonEngineering": false,
  "locations": [],
  "postedOrUpdatedWithinDays": 365,
  "mode": "full",
  "deltaKey": "default"
}
````

If `mode` is present, it is canonical. `enableDeltaMode=true` is only a compatibility shortcut when `mode` is omitted.

### Output example

```json
{
  "source": "greenhouse",
  "ats": "greenhouse",
  "company": "Databricks",
  "companySlug": "databricks",
  "jobId": "7890123",
  "internalJobId": "REQ-4567",
  "title": "Senior ML Infrastructure Engineer, Inference Platform",
  "department": "Engineering",
  "team": "AI Platform",
  "location": "San Francisco, CA",
  "office": "San Francisco",
  "remoteType": "hybrid",
  "workplaceType": "hybrid",
  "employmentType": "Full-time",
  "seniority": "senior",
  "roleFamilies": ["ai_infrastructure", "mlops", "gpu_platform", "inference_serving", "kubernetes_platform"],
  "detectedSkills": ["Python", "Kubernetes", "GPU", "CUDA", "MLOps", "vLLM", "Triton"],
  "detectedClouds": [],
  "detectedFrameworks": [],
  "detectedDataTools": [],
  "detectedInfraTools": ["Kubernetes", "GPU", "CUDA", "vLLM", "Triton"],
  "salaryMin": 160000,
  "salaryMax": 220000,
  "salaryCurrency": "USD",
  "salaryRaw": "$160,000 - $220,000",
  "postedAt": "2026-06-24T17:12:00Z",
  "updatedAt": "2026-07-02T09:30:00Z",
  "absoluteUrl": "https://job-boards.greenhouse.io/databricks/jobs/7890123",
  "contentText": "Build GPU inference platforms on Kubernetes with CUDA, vLLM, Triton, Python, and MLOps workflows.",
  "relevanceScore": 94,
  "aiInfraScore": 96,
  "confidence": "high",
  "whyItMatches": "Matches ML infrastructure, GPU, CUDA, vLLM, Triton with ai infrastructure, mlops, gpu platform role signals.",
  "hiringSignalTags": ["strong_fit", "gpu_hiring", "inference_hiring", "kubernetes_platform_hiring", "ai_infra_stack"],
  "isNew": false,
  "isChanged": false,
  "isRemoved": false,
  "changeType": "full",
  "previousHash": "",
  "currentHash": "a8d9f8b2e18f88d4a67f9f74d8c3b4e63873a8f0bff26795c8f8d3f0a8b9c123",
  "firstSeenAt": "2026-07-07T13:10:04Z",
  "lastSeenAt": "2026-07-07T13:10:04Z",
  "runTimestamp": "2026-07-07T13:10:04Z"
}
```

`team` may be empty for ATS sources that do not expose team data.

### Full mode vs delta mode

`mode=full` emits all matching enriched records for the current run.

`mode=delta` stores a prior snapshot in a named Actor key-value store, scoped by this Actor, runtime user/task context when Apify provides it, and `deltaKey`. It compares the current run with that snapshot and emits:

- `new_job`
- `changed_job`
- `removed_job`
- `unchanged`, only when `emitUnchangedInDeltaMode=true`

**Delta baseline behavior:** On the first delta run for a given `deltaKey`, all matching current jobs are emitted as `new_job` and saved as the baseline. Later runs with the same scope and `deltaKey` emit only `new_job`, `changed_job`, `removed_job`, and optionally `unchanged` when `emitUnchangedInDeltaMode=true`.

For scheduled monitors or multiple saved tasks, use a unique `deltaKey` per monitor/task. Apify task/user context is included when available, but unique keys avoid accidental collisions in manual runs or custom orchestration.

### Source policy and disclaimer

This Actor uses public, unauthenticated job-board JSON endpoints only. It does not log in, use browser automation, use proxies, call paid APIs, submit applications, enrich personal data, or scrape candidate/recruiter private data.

This Actor is not affiliated with Greenhouse, Lever, Ashby, SmartRecruiters, Workable, or any hiring company. Availability and fields depend on each company's public ATS configuration.

### Limitations

- Public ATS fields vary by company and platform.
- Salary is parsed only when visibly present in public data.
- SmartRecruiters and Workable feeds may not be enabled for every company.
- Delta mode compares jobs after input filtering, so removed events refer to jobs that previously matched the same task configuration.

### Pricing suggestion

Suggested starting price later: $2 per 1,000 full records. A future delta/change-event tier could be $4-5 per 1,000 delta events. This repository change does not configure monetization or publish the Actor.

# Actor input Schema

## `targets` (type: `array`):

Companies or public ATS board slugs to inspect. Provide company, ats, and slug. If company is in the built-in registry, ats and slug can be omitted.

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

Custom keywords to match in addition to the built-in deterministic tech-stack classifier.

## `maxJobsPerCompany` (type: `integer`):

Maximum public postings to inspect from each ATS target.

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

Maximum enriched records or delta events to output.

## `minRelevanceScore` (type: `integer`):

Only output jobs with a deterministic relevance score at or above this threshold.

## `includeGenericEngineering` (type: `boolean`):

Allow generic software, backend, platform, infrastructure, DevOps, and SRE roles to match without direct AI terms.

## `includeDataPlatform` (type: `boolean`):

Allow data-platform terms such as Spark, Kafka, Airflow, dbt, Snowflake, warehouses, and lakehouses to contribute.

## `includeNonEngineering` (type: `boolean`):

Allow non-engineering roles such as sales, marketing, recruiting, support, legal, finance, and customer success.

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

Optional location filters matched against location, office, title, department, and description text.

## `postedOrUpdatedWithinDays` (type: `integer`):

Only include jobs posted or updated within this many days when the ATS provides a timestamp.

## `mode` (type: `string`):

full emits all matching enriched rows. delta compares against prior persistent state scoped by this Actor, runtime context, and deltaKey, then emits job-change events.

## `enableDeltaMode` (type: `boolean`):

Backward-compatible shortcut. If mode is omitted and this is true, the Actor runs in delta mode. If mode is present, mode wins.

## `deltaKey` (type: `string`):

State namespace for delta comparisons. Use a unique value per monitor or saved task to avoid accidental collisions.

## `emitUnchangedInDeltaMode` (type: `boolean`):

When true, delta mode also emits unchanged jobs with changeType=unchanged.

## Actor input object example

```json
{
  "targets": [
    {
      "company": "Databricks",
      "ats": "greenhouse",
      "slug": "databricks"
    },
    {
      "company": "Shield AI",
      "ats": "lever",
      "slug": "shieldai"
    }
  ],
  "keywords": [
    "AI",
    "ML",
    "machine learning",
    "LLM",
    "infrastructure",
    "platform",
    "Kubernetes",
    "GPU",
    "inference",
    "MLOps",
    "LLMOps"
  ],
  "maxJobsPerCompany": 100,
  "maxItems": 500,
  "minRelevanceScore": 25,
  "includeGenericEngineering": true,
  "includeDataPlatform": true,
  "includeNonEngineering": false,
  "locations": [],
  "postedOrUpdatedWithinDays": 365,
  "mode": "full",
  "enableDeltaMode": false,
  "deltaKey": "default",
  "emitUnchangedInDeltaMode": false
}
```

# Actor output Schema

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

Default dataset items with normalized ATS metadata, deterministic tech-stack enrichment, AI/infra relevance scores, and optional delta 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("catalini82/ats-jobs-tech-stack-intelligence").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("catalini82/ats-jobs-tech-stack-intelligence").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 '{}' |
apify call catalini82/ats-jobs-tech-stack-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=catalini82/ats-jobs-tech-stack-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ATS Jobs + Tech-Stack & Hiring-Signal Intelligence",
        "description": "Track public jobs across Greenhouse, Lever, Ashby, SmartRecruiters, and Workable with unified fields, tech-stack detection, relevance scoring, and delta-mode hiring signals.",
        "version": "0.1",
        "x-build-id": "5pdXA8NVhZDdNdIUJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/catalini82~ats-jobs-tech-stack-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-catalini82-ats-jobs-tech-stack-intelligence",
                "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/catalini82~ats-jobs-tech-stack-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-catalini82-ats-jobs-tech-stack-intelligence",
                "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/catalini82~ats-jobs-tech-stack-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-catalini82-ats-jobs-tech-stack-intelligence",
                "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": {
                    "targets": {
                        "title": "ATS Targets",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Companies or public ATS board slugs to inspect. Provide company, ats, and slug. If company is in the built-in registry, ats and slug can be omitted.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "company": {
                                    "type": "string",
                                    "title": "Company",
                                    "description": "Company display name. Registry names such as Databricks can resolve ats and slug automatically."
                                },
                                "ats": {
                                    "type": "string",
                                    "title": "ATS",
                                    "description": "Public ATS platform for this target.",
                                    "enum": [
                                        "greenhouse",
                                        "lever",
                                        "ashby",
                                        "smartrecruiters",
                                        "workable"
                                    ]
                                },
                                "slug": {
                                    "type": "string",
                                    "title": "Public board slug",
                                    "description": "Public board, site, account, or company slug used by the ATS endpoint."
                                }
                            }
                        },
                        "default": [
                            {
                                "company": "Databricks",
                                "ats": "greenhouse",
                                "slug": "databricks"
                            },
                            {
                                "company": "Shield AI",
                                "ats": "lever",
                                "slug": "shieldai"
                            }
                        ]
                    },
                    "keywords": {
                        "title": "Keywords",
                        "maxItems": 150,
                        "type": "array",
                        "description": "Custom keywords to match in addition to the built-in deterministic tech-stack classifier.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": [
                            "AI",
                            "ML",
                            "machine learning",
                            "LLM",
                            "infrastructure",
                            "platform",
                            "Kubernetes",
                            "GPU",
                            "inference",
                            "MLOps",
                            "LLMOps"
                        ]
                    },
                    "maxJobsPerCompany": {
                        "title": "Max Jobs Per Company",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum public postings to inspect from each ATS target.",
                        "default": 100
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum enriched records or delta events to output.",
                        "default": 500
                    },
                    "minRelevanceScore": {
                        "title": "Minimum Relevance Score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only output jobs with a deterministic relevance score at or above this threshold.",
                        "default": 25
                    },
                    "includeGenericEngineering": {
                        "title": "Include Generic Engineering",
                        "type": "boolean",
                        "description": "Allow generic software, backend, platform, infrastructure, DevOps, and SRE roles to match without direct AI terms.",
                        "default": true
                    },
                    "includeDataPlatform": {
                        "title": "Include Data Platform",
                        "type": "boolean",
                        "description": "Allow data-platform terms such as Spark, Kafka, Airflow, dbt, Snowflake, warehouses, and lakehouses to contribute.",
                        "default": true
                    },
                    "includeNonEngineering": {
                        "title": "Include Non-Engineering",
                        "type": "boolean",
                        "description": "Allow non-engineering roles such as sales, marketing, recruiting, support, legal, finance, and customer success.",
                        "default": false
                    },
                    "locations": {
                        "title": "Locations",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Optional location filters matched against location, office, title, department, and description text.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "postedOrUpdatedWithinDays": {
                        "title": "Posted Or Updated Within Days",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Only include jobs posted or updated within this many days when the ATS provides a timestamp.",
                        "default": 365
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "full",
                            "delta"
                        ],
                        "type": "string",
                        "description": "full emits all matching enriched rows. delta compares against prior persistent state scoped by this Actor, runtime context, and deltaKey, then emits job-change events.",
                        "default": "full"
                    },
                    "enableDeltaMode": {
                        "title": "Enable Delta Mode",
                        "type": "boolean",
                        "description": "Backward-compatible shortcut. If mode is omitted and this is true, the Actor runs in delta mode. If mode is present, mode wins.",
                        "default": false
                    },
                    "deltaKey": {
                        "title": "Delta Key",
                        "minLength": 1,
                        "maxLength": 80,
                        "type": "string",
                        "description": "State namespace for delta comparisons. Use a unique value per monitor or saved task to avoid accidental collisions.",
                        "default": "default"
                    },
                    "emitUnchangedInDeltaMode": {
                        "title": "Emit Unchanged In Delta Mode",
                        "type": "boolean",
                        "description": "When true, delta mode also emits unchanged jobs with changeType=unchanged.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
