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

Turn public Greenhouse job boards into AI and tech hiring intelligence with detected skills, role families, relevance scores, salary/remote/seniority parsing, and whyItMatches explanations.

- **URL**: https://apify.com/catalini82/greenhouse-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

## Greenhouse Public Jobs Tech Stack Extractor

Extract public Greenhouse job-board roles and enrich them with tech-stack, AI/ML/infra relevance, seniority, remote, salary, and role-family signals.

### What It Does

This Actor queries public Greenhouse Job Board API endpoints for one or more company board tokens, normalizes published job records, strips Greenhouse HTML content, and outputs deterministic enrichment fields for market and recruiting workflows.

It detects skills such as Python, Kubernetes, Terraform, GPU, CUDA, LLM, MLOps, Ray, vLLM, Spark, Kafka, Airflow, dbt, and cloud platforms. It also classifies roles into AI engineering, AI infrastructure, LLMOps, MLOps, GPU platform, Kubernetes platform, cloud infrastructure, data platform, DevOps/SRE, software engineering, and non-engineering families.

### Why this Actor

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

It is useful for job-board enrichment, recruiting workflows, competitor hiring research, and AI infrastructure career tracking. It has no LLM costs and does not use browser automation or proxies.

### Who It Is For

- Job seekers tracking AI infrastructure and technical hiring
- Recruiters and sourcers building structured target lists
- Market researchers studying company hiring signals
- Job board builders enriching public job feeds
- Sales and BD teams researching technical buyers and target accounts
- AI infrastructure career and labor-market analysts

### Example Use Cases

- Company job-board monitoring across public Greenhouse boards
- AI infrastructure job search and alerting
- Tech stack market research by company or role family
- Recruiting and sourcing for infra, platform, ML, and data roles
- Job board enrichment with normalized skills and relevance scores
- Competitive hiring intelligence across AI, cloud, and data teams

### Input

```json
{
  "boardTokens": ["databricks", "anthropic", "scaleai", "cloudflare"],
  "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"
  ],
  "maxJobsPerBoard": 100,
  "maxItems": 100,
  "minRelevanceScore": 25,
  "includeGenericEngineering": true,
  "includeDataPlatform": true,
  "includeNonEngineering": false,
  "locations": [],
  "fetchContent": true,
  "postedOrUpdatedWithinDays": 365
}
````

- `boardTokens`: Public Greenhouse board tokens to query.
- `keywords`: Extra deterministic keywords used for matching and explanation.
- `maxJobsPerBoard`: Maximum public jobs inspected per company board.
- `maxItems`: Maximum enriched records written to the dataset.
- `minRelevanceScore`: Minimum 0 to 100 score required for output.
- `includeGenericEngineering`: Allows generic backend, software, platform, cloud, DevOps, and SRE roles.
- `includeDataPlatform`: Allows data platform roles such as Spark, Kafka, Airflow, warehouse, lakehouse, ETL, dbt, and Snowflake.
- `includeNonEngineering`: Allows sales, marketing, recruiting, product, support, legal, finance, and similar roles.
- `locations`: Optional location filters matched against title, location, office, and description text.
- `fetchContent`: Uses public Greenhouse job detail endpoints when list responses omit job content.
- `postedOrUpdatedWithinDays`: Filters by Greenhouse `updated_at` when available.

### Output Example

```json
{
  "source": "greenhouse",
  "boardToken": "databricks",
  "jobId": "123456",
  "internalJobId": "98765",
  "absoluteUrl": "https://job-boards.greenhouse.io/databricks/jobs/123456",
  "title": "Senior AI Infrastructure Engineer",
  "company": "Databricks",
  "location": "San Francisco, CA",
  "updatedAt": "2026-07-01T18:31:32-04:00",
  "department": "Engineering",
  "office": "San Francisco",
  "contentText": "About the role Build LLM inference and Kubernetes platforms...",
  "detectedSkills": ["Python", "Kubernetes", "GPU", "CUDA", "LLM"],
  "roleFamilies": ["ai_engineering", "ai_infrastructure", "gpu_platform", "kubernetes_platform"],
  "seniority": "senior",
  "remoteType": "onsite",
  "salaryMinUsd": 120000,
  "salaryMaxUsd": 180000,
  "salaryRaw": "$120,000 - $180,000",
  "relevanceScore": 82,
  "confidence": "high",
  "matchedKeywords": ["LLM", "Kubernetes", "GPU", "CUDA", "Python"],
  "whyItMatches": "Mentions LLM, Kubernetes, GPU, CUDA, 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

Salary fields are included when visible in the public Greenhouse posting. Many boards omit salary; in validation data, salary coverage was partial, roughly around half of records depending on selected boards.

### Suggested public tasks

- Track AI Infrastructure Jobs on Greenhouse
- Enrich Greenhouse Jobs with Tech Stack Signals
- Monitor Databricks, Anthropic, Scale AI, and Cloudflare Jobs

### Data Source And Disclaimer

This Actor is unofficial. It is not affiliated with Greenhouse or any company whose public board token is queried.

It uses publicly accessible Greenhouse Job Board API data from `https://boards-api.greenhouse.io/v1/boards/{board_token}/jobs`. Output includes source job URLs so downstream users can verify and attribute records.

The Actor only reads public GET endpoints. It does not use Greenhouse Harvest API, Candidate Ingestion API, application submission endpoints, authenticated endpoints, browser automation, proxies, paid APIs, local LLMs, or personal-data enrichment.

### Limitations

- Classification is heuristic and deterministic.
- Board tokens must be valid public Greenhouse boards.
- Some boards may omit descriptions, salary, departments, offices, or location detail.
- Greenhouse feed and API shapes may change.
- No personal-data enrichment is performed.
- No applications are submitted.

### Changelog

#### v0.1

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

# Actor input Schema

## `boardTokens` (type: `array`):

Public Greenhouse board tokens, such as databricks, anthropic, scaleai, or cloudflare.

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

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

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

Maximum number of public jobs to inspect from each Greenhouse board.

## `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, office, title, and description text.

## `fetchContent` (type: `boolean`):

Fetch job descriptions through the public Greenhouse Job Board API when list responses do not include content.

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

Only include jobs updated within this many days when Greenhouse provides updated\_at.

## Actor input object example

```json
{
  "boardTokens": [
    "databricks",
    "anthropic",
    "scaleai",
    "cloudflare"
  ],
  "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"
  ],
  "maxJobsPerBoard": 100,
  "maxItems": 500,
  "minRelevanceScore": 25,
  "includeGenericEngineering": true,
  "includeDataPlatform": true,
  "includeNonEngineering": false,
  "locations": [],
  "fetchContent": true,
  "postedOrUpdatedWithinDays": 365
}
```

# 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/greenhouse-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/greenhouse-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/greenhouse-public-jobs-tech-stack --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Greenhouse Public Jobs Tech Stack Extractor",
        "description": "Turn public Greenhouse job boards into AI and tech hiring intelligence with detected skills, role families, relevance scores, salary/remote/seniority parsing, and whyItMatches explanations.",
        "version": "0.1",
        "x-build-id": "LvUQmAdVAKcbZ1W9d"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/catalini82~greenhouse-public-jobs-tech-stack/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-catalini82-greenhouse-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~greenhouse-public-jobs-tech-stack/runs": {
            "post": {
                "operationId": "runs-sync-catalini82-greenhouse-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~greenhouse-public-jobs-tech-stack/run-sync": {
            "post": {
                "operationId": "run-sync-catalini82-greenhouse-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": {
                    "boardTokens": {
                        "title": "Board Tokens",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Public Greenhouse board tokens, such as databricks, anthropic, scaleai, or cloudflare.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": [
                            "databricks",
                            "anthropic",
                            "scaleai",
                            "cloudflare"
                        ]
                    },
                    "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"
                        ]
                    },
                    "maxJobsPerBoard": {
                        "title": "Max Jobs Per Board",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of public jobs to inspect from each Greenhouse board.",
                        "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, office, title, and description text.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "fetchContent": {
                        "title": "Fetch Content",
                        "type": "boolean",
                        "description": "Fetch job descriptions through the public Greenhouse Job Board API when list responses do not include content.",
                        "default": true
                    },
                    "postedOrUpdatedWithinDays": {
                        "title": "Posted Or Updated Within Days",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Only include jobs updated within this many days when Greenhouse provides updated_at.",
                        "default": 365
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
