# Lever Public Jobs Tech Stack Extractor (`catalini82/lever-public-jobs-tech-stack`) Actor

Turn public Lever postings into AI and tech hiring intelligence with detected skills, role families, relevance scores, salary/remote/seniority parsing when available, and whyItMatches explanations.

- **URL**: https://apify.com/catalini82/lever-public-jobs-tech-stack.md
- **Developed by:** [Catalin Ionut Iliescu](https://apify.com/catalini82) (community)
- **Categories:** Jobs, Developer tools, AI
- **Stats:** 2 total users, 0 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Lever Public Jobs Tech Stack Extractor

Extract public Lever job postings and enrich them with tech stack, AI/ML/infra relevance, seniority, salary, remote type, and role-family signals.

### What it does

This Actor queries the public Lever Postings API for one or more company site slugs, normalizes published job postings, strips HTML content, and outputs deterministic enrichment fields for job-market, recruiting, and research workflows.

For each posting, it can detect:

- AI, ML, LLM, MLOps, LLMOps, GPU, Kubernetes, cloud infrastructure, data platform, DevOps/SRE, and software-engineering signals
- Matched keywords and detected technical skills
- Role families such as `ai_engineering`, `ai_infrastructure`, `llmops`, `mlops`, `gpu_platform`, `kubernetes_platform`, `data_platform`, and `software_engineering`
- Seniority from title and content
- Remote, hybrid, or onsite signals from Lever workplace type and text
- Visible USD salary ranges when present
- Location and posting freshness filters

### Why this Actor

A raw Lever API fetch gives public job postings. This Actor adds deterministic AI/ML/infrastructure relevance scoring, detected skills, role families, salary parsing, seniority parsing, remote parsing, and `whyItMatches` explanations.

It is useful for recruiting, company research, job-board enrichment, and AI infrastructure job tracking. It uses only public GET Lever Postings API endpoints, and no applications are submitted.

### Who it is for

- Job seekers tracking AI infrastructure and technical roles
- Recruiters and sourcers researching hiring demand
- Market researchers studying company hiring signals
- Job-board builders enriching public postings
- Sales and business-development teams researching target accounts
- AI infrastructure career-tracking workflows

### Example use cases

- Company job-board monitoring across public Lever sites
- AI infrastructure job search and alerting
- Tech stack market research from active hiring pages
- Recruiting and sourcing prioritization
- Job board enrichment with normalized skills and relevance scores
- Competitive hiring intelligence

### Input

```json
{
  "siteSlugs": ["shieldai", "spotify", "lyrahealth", "binance", "mistral"],
  "keywords": [
    "AI",
    "machine learning",
    "ML",
    "LLM",
    "LLMOps",
    "MLOps",
    "AI infrastructure",
    "GPU",
    "CUDA",
    "Kubernetes",
    "inference",
    "model serving",
    "RAG",
    "vector database",
    "Ray",
    "vLLM",
    "Terraform",
    "platform engineer",
    "SRE",
    "data platform",
    "Python",
    "backend",
    "distributed systems"
  ],
  "maxJobsPerSite": 100,
  "maxItems": 500,
  "minRelevanceScore": 25,
  "includeGenericEngineering": true,
  "includeDataPlatform": true,
  "includeNonEngineering": false,
  "locations": [],
  "postedOrUpdatedWithinDays": 3650
}
````

- `siteSlugs`: Public Lever site slugs to query, up to 50.
- `keywords`: Optional custom keywords added to the built-in deterministic classifier, up to 150.
- `maxJobsPerSite`: Maximum public jobs inspected per site slug.
- `maxItems`: Maximum enriched records written to the dataset.
- `minRelevanceScore`: Minimum score from 0 to 100 required for output.
- `includeGenericEngineering`: Allows generic software, backend, platform, cloud infrastructure, DevOps, and SRE roles to match without direct AI terms.
- `includeDataPlatform`: Allows data platform roles to match.
- `includeNonEngineering`: Allows non-engineering roles such as marketing, sales, recruiting, legal, finance, and support. Defaults to `false`.
- `locations`: Optional text filters matched against location, categories, title, description, and list text.
- `postedOrUpdatedWithinDays`: Filters by Lever `updatedAt` or `createdAt` when available.

### Output example

```json
{
  "source": "lever",
  "siteSlug": "shieldai",
  "postingId": "abc123",
  "hostedUrl": "https://jobs.lever.co/shieldai/abc123",
  "applyUrl": "https://jobs.lever.co/shieldai/abc123/apply",
  "title": "Senior AI Infrastructure Engineer",
  "company": "shieldai",
  "location": "San Diego, CA",
  "team": "Engineering",
  "department": "Engineering",
  "commitment": "Full-time",
  "workplaceType": "hybrid",
  "createdAt": "2026-07-01T00:00:00Z",
  "updatedAt": "2026-07-01T00:00:00Z",
  "descriptionText": "Build AI infrastructure for autonomous systems.",
  "listsText": "Requirements\n- Python\n- Kubernetes\n- GPU systems",
  "detectedSkills": ["Python", "Kubernetes", "GPU"],
  "roleFamilies": ["ai_engineering", "ai_infrastructure", "gpu_platform", "kubernetes_platform", "software_engineering"],
  "seniority": "senior",
  "remoteType": "hybrid",
  "salaryMinUsd": 120000,
  "salaryMaxUsd": 180000,
  "salaryRaw": "$120,000 - $180,000",
  "relevanceScore": 82,
  "confidence": "high",
  "matchedKeywords": ["AI infrastructure", "GPU", "Kubernetes", "Python"],
  "whyItMatches": "Mentions AI infrastructure, GPU, Kubernetes, and Python."
}
```

### Suggested pricing

Suggested starting price: **$2 per 1,000 enriched job records** using Apify Pay Per Event / default dataset item pricing.

### Salary Field Availability

Lever public postings often do not expose salary. In validation data, salary fields were empty for roughly 90% of records. Salary parsing is best-effort and only populated when public posting text includes salary information.

### Suggested public tasks

- Track AI Infrastructure Jobs on Lever
- Enrich Lever Jobs with Tech Stack Signals
- Monitor Shield AI, Spotify, Binance, Mistral, and Lyra Health Jobs

### Data source and disclaimer

This Actor is unofficial. It is not affiliated with Lever or any company whose public Lever site slug is queried.

It uses publicly accessible Lever Postings API data from `https://api.lever.co/v0/postings/{site}?mode=json`. Output includes source job URLs so downstream users can verify and attribute records.

The Actor only reads public GET endpoints. It does not use Lever Data API v1 authenticated endpoints, application submission endpoints, browser automation, proxies, paid APIs, local LLMs, or personal-data enrichment. No applications are submitted.

### Limitations

- Classification is heuristic and deterministic, not human-reviewed.
- Site slugs must be valid public Lever postings sites.
- Some sites may be empty, disabled, moved, or vanity-routed.
- Some postings may omit salary, location, workplace type, department, or rich descriptions.
- Lever feed and API shapes may change.
- No personal-data enrichment is performed.
- No applications are submitted.

### Changelog

#### v0.1

- Initial release with public Lever postings fetching, HTML cleanup, tech-stack detection, role-family classification, salary parsing, seniority parsing, remote-type parsing, filtering, and bounded dataset output.

# Actor input Schema

## `siteSlugs` (type: `array`):

Public Lever site slugs, such as shieldai, spotify, lyrahealth, scaleai, or anduril.

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

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

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

Maximum number of public Lever jobs to inspect from each site slug.

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

Maximum number of enriched records to output.

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

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

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

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

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

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

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

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

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

Optional location filters matched against location, categories, title, description, and list text.

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

Only include jobs posted or updated within this many days when Lever provides createdAt or updatedAt.

## Actor input object example

```json
{
  "siteSlugs": [
    "shieldai",
    "spotify",
    "lyrahealth",
    "binance",
    "mistral"
  ],
  "keywords": [
    "AI",
    "machine learning",
    "ML",
    "LLM",
    "LLMOps",
    "MLOps",
    "AI infrastructure",
    "GPU",
    "CUDA",
    "Kubernetes",
    "inference",
    "model serving",
    "RAG",
    "vector database",
    "Ray",
    "vLLM",
    "Terraform",
    "platform engineer",
    "SRE",
    "data platform",
    "Python",
    "backend",
    "distributed systems"
  ],
  "maxJobsPerSite": 100,
  "maxItems": 500,
  "minRelevanceScore": 25,
  "includeGenericEngineering": true,
  "includeDataPlatform": true,
  "includeNonEngineering": false,
  "locations": [],
  "postedOrUpdatedWithinDays": 3650
}
```

# Actor output Schema

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

Default dataset items with job metadata, AI/ML infrastructure relevance signals, detected skills, and match explanations.

# 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/lever-public-jobs-tech-stack").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/lever-public-jobs-tech-stack").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/lever-public-jobs-tech-stack --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lever Public Jobs Tech Stack Extractor",
        "description": "Turn public Lever postings into AI and tech hiring intelligence with detected skills, role families, relevance scores, salary/remote/seniority parsing when available, and whyItMatches explanations.",
        "version": "0.1",
        "x-build-id": "io6YCCdekUyDqZNuG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/catalini82~lever-public-jobs-tech-stack/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-catalini82-lever-public-jobs-tech-stack",
                "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~lever-public-jobs-tech-stack/runs": {
            "post": {
                "operationId": "runs-sync-catalini82-lever-public-jobs-tech-stack",
                "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~lever-public-jobs-tech-stack/run-sync": {
            "post": {
                "operationId": "run-sync-catalini82-lever-public-jobs-tech-stack",
                "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": {
                    "siteSlugs": {
                        "title": "Site Slugs",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Public Lever site slugs, such as shieldai, spotify, lyrahealth, scaleai, or anduril.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": [
                            "shieldai",
                            "spotify",
                            "lyrahealth",
                            "binance",
                            "mistral"
                        ]
                    },
                    "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",
                            "machine learning",
                            "ML",
                            "LLM",
                            "LLMOps",
                            "MLOps",
                            "AI infrastructure",
                            "GPU",
                            "CUDA",
                            "Kubernetes",
                            "inference",
                            "model serving",
                            "RAG",
                            "vector database",
                            "Ray",
                            "vLLM",
                            "Terraform",
                            "platform engineer",
                            "SRE",
                            "data platform",
                            "Python",
                            "backend",
                            "distributed systems"
                        ]
                    },
                    "maxJobsPerSite": {
                        "title": "Max Jobs Per Site",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of public Lever jobs to inspect from each site slug.",
                        "default": 100
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of enriched records to output.",
                        "default": 500
                    },
                    "minRelevanceScore": {
                        "title": "Minimum Relevance Score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only output jobs with a relevance score at or above this threshold.",
                        "default": 25
                    },
                    "includeGenericEngineering": {
                        "title": "Include Generic Engineering",
                        "type": "boolean",
                        "description": "Allow generic software, backend, platform, cloud 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, warehouses, lakehouses, ETL, dbt, and Snowflake 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 product-management roles.",
                        "default": false
                    },
                    "locations": {
                        "title": "Locations",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Optional location filters matched against location, categories, title, description, and list 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 Lever provides createdAt or updatedAt.",
                        "default": 3650
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
