# Tech Stack Hiring Signal Scraper — Global B2B Intent Data (`actorpilot/global-tech-hiring-signal-scraper`) Actor

Scan public Greenhouse and Lever job boards to detect tech stack hiring signals across 90+ global companies. Find which companies are hiring for Salesforce, Kubernetes, Snowflake, AI, and more, then rank them by B2B buying intent.

- **URL**: https://apify.com/actorpilot/global-tech-hiring-signal-scraper.md
- **Developed by:** [S. Klein](https://apify.com/actorpilot) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 33.3% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

Your sales team manually checks dozens of company websites looking for signs that they're evaluating your technology. This Actor automates that — and turns public job posting data from Greenhouse and Lever into ranked B2B buying signals for 90+ global tech companies.

**The insight:** When a company posts 5+ roles requiring Salesforce, they're actively expanding their CRM stack. When they post for Kubernetes engineers, they're scaling infrastructure. Hiring patterns are one of the most reliable proxies for technology buying intent available in public data — and they're completely free to access.

Try it free — click **Try for free** above. Most signal scans cost under $0.10.

---

### What does Tech Stack Hiring Signal Scraper do?

This Actor queries the public job boards of 90+ global tech companies via the Greenhouse and Lever ATS APIs — no login, no proxy, no JavaScript rendering. It extracts job titles, detects technology keywords, and returns a ranked list of companies with the strongest current hiring signal for your target technology.

In one run you can:

- Find every company in the directory currently hiring for Salesforce, Kubernetes, Snowflake, or any of 40+ technologies
- Get the full tech signal profile of one specific company
- List the companies with the highest overall tech hiring velocity right now

All results export as JSON or CSV, ready for CRM import.

---

### Why use Tech Stack Hiring Signal Scraper?

#### Hiring signals are buying signals

| Signal | What it means |
|---|---|
| Company hiring 5+ Salesforce roles | CRM expansion — SI partners and ISVs take note |
| Company hiring Kubernetes engineers | Cloud infrastructure investment underway |
| Company hiring dbt and Snowflake analysts | Data stack build-out in progress |
| Company hiring ML engineers + PyTorch | AI product development starting |

#### Public data, no authentication required

This Actor uses the public job listing APIs of Greenhouse.io and Lever — the same endpoints job seekers use. No login. No API key. No scraping of protected data. Just clean structured signal.

#### Global coverage, three regions

| Region | Companies covered |
|---|---|
| United States | 50+ major tech companies |
| Europe (incl. DACH) | 30+ companies |
| Asia-Pacific | 10+ companies |

---

### Who uses Tech Stack Hiring Signal Scraper

- **SaaS Sales Development Reps** building hyper-targeted prospect lists based on current technology adoption signals
- **Business Development at consulting firms** identifying clients about to expand a platform they know
- **VC and growth equity analysts** mapping which portfolio companies are scaling specific technologies
- **Recruiters and staffing agencies** mapping which companies are in active hiring mode for a specific stack
- **Competitive intelligence teams** tracking which companies are adopting or replacing a technology

---

### How to use Tech Stack Hiring Signal Scraper

1. Click **Try for free**
2. Choose a `mode`
3. For `search_by_technology`: enter a technology name like `Salesforce` or `Kubernetes`
4. Set `region` to filter by geography (optional)
5. Set `maxResults` and `minSignalScore` to control output size
6. Start the run
7. Download results as JSON or CSV and import into your CRM

---

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search_by_technology` | One of: `search_by_technology`, `get_company_signals`, `list_top_signals` |
| `technology` | string | — | Required for `search_by_technology`. Example: `Salesforce`, `Kubernetes`, `Snowflake` |
| `companyName` | string | — | Required for `get_company_signals`. Use company slug (e.g. `stripe`, `n26`) |
| `region` | string | `all` | Filter: `all`, `us`, `eu`, `dach`, `apac` |
| `maxResults` | integer | `20` | Maximum results to return (1–100) |
| `minSignalScore` | integer | `0` | Only return results with score ≥ this value |

Example: Find US companies hiring for Kubernetes with a strong signal:

```json
{
  "mode": "search_by_technology",
  "technology": "Kubernetes",
  "region": "us",
  "maxResults": 25,
  "minSignalScore": 30
}
````

Example: Get full tech profile for Stripe:

```json
{
  "mode": "get_company_signals",
  "companyName": "stripe"
}
```

***

### Output

Each result represents one company with its hiring signal data.

```json
{
  "companyName": "Stripe",
  "companySlug": "stripe",
  "region": "us",
  "hiringSignalScore": 74,
  "technologyMatches": ["Kubernetes", "AWS", "Go", "Python", "Terraform"],
  "openRoleCount": 89,
  "relevantRoleCount": 7,
  "sampleJobTitles": [
    "Staff Infrastructure Engineer — Kubernetes Platform",
    "Senior SRE (Kubernetes, AWS)",
    "Platform Engineer — Container Orchestration"
  ],
  "atsSource": "greenhouse",
  "companyUrl": "https://stripe.com",
  "sourceUrls": ["https://boards.greenhouse.io/stripe"],
  "detectedAt": "2026-06-11T10:30:00.000Z"
}
```

Key output fields:

- `companyName`, `companySlug`, `region`
- `hiringSignalScore` — 0–100, higher = stronger buying signal
- `technologyMatches` — technologies detected across all open roles
- `openRoleCount` — total open positions at this company right now
- `relevantRoleCount` — positions matching the target technology
- `sampleJobTitles` — raw job titles that triggered the match
- `atsSource` — `greenhouse` or `lever`
- `sourceUrls` — direct links to verify the job board

***

### Understanding the signal score

The signal score (0–100) combines two factors:

1. **Ratio signal** — what share of a company's open roles require the target technology (up to 60 points)
2. **Absolute signal** — raw number of matching roles (up to 40 points)

A company with 7 Kubernetes roles out of 89 total openings (8% ratio) plus the absolute weight scores ~74. A company with 1 role out of 5 would score lower despite a higher ratio — because one role is a weak signal.

***

### Coverage

**ATS sources:**

- **Greenhouse** — public JSON API at `boards-api.greenhouse.io/v1/boards/{slug}/jobs`
- **Lever** — public JSON API at `api.lever.co/v0/postings/{slug}`

**Detected technologies (40+):**

CRM/ERP: Salesforce, HubSpot, SAP, Microsoft Dynamics

Data: Snowflake, dbt, Databricks, Apache Spark, Kafka, Airflow, Power BI, Tableau, Looker

Cloud/DevOps: AWS, Azure, GCP, Kubernetes, Terraform, Docker, ArgoCD, GitHub Actions

Languages: Python, TypeScript, Go, Rust, Java/Kotlin

Frontend: React, Vue

AI/ML: PyTorch, TensorFlow, LangChain, OpenAI

Security: Splunk, CrowdStrike, SentinelOne

**Limitations:** Companies using Workable, Jobvite, or direct career-site postings are not currently covered. The company directory contains ~90 manually curated entries — contact us to add your target company.

***

### How much does it cost?

| Run type | Companies processed | Estimated cost |
|---|---|---|
| Single company lookup | 1 company | ~$0.005 |
| Technology search (US only) | ~50 companies | ~$0.05 |
| Technology search (global) | ~90 companies | ~$0.08 |
| Full top-signals scan | ~90 companies | ~$0.10 |

New Apify accounts receive $5 in free monthly credits — enough for 50+ full scans.

***

### Real-World Workflow Examples

**SaaS Sales Pipeline: Find Salesforce Expansion Targets**

1. Run `search_by_technology` with `technology: "Salesforce"` and `region: "us"`
2. Filter results where `hiringSignalScore > 50`
3. Export to CSV and import into Salesforce or HubSpot as new accounts
4. Repeat weekly — hiring pipelines turn over fast

**Competitive Intelligence: Who is adopting Kubernetes?**

1. Run `search_by_technology` with `technology: "Kubernetes"` and `region: "all"`
2. Compare results month-over-month to identify new entrants
3. Cross-reference with funding data for highest-priority accounts

**Account Research: Before a sales call**

1. Run `get_company_signals` for the target company
2. Review `technologyMatches` to understand their full stack
3. Tailor your pitch to the technologies they are actively hiring for

***

### Use with AI agents via Apify MCP

This Actor can be used from Claude, Cursor, VS Code, Windsurf, n8n, and other MCP-compatible tools via Apify's Actors MCP server.

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": {
        "APIFY_TOKEN": "your_apify_api_token_here"
      }
    }
  }
}
```

Copy-paste prompt for Claude or Cursor:

```text
Please set up Apify's Actors MCP server in my MCP configuration.
Use command: npx, args: -y @apify/actors-mcp-server
Set my APIFY_TOKEN in the MCP environment.
After setup, use the actor "global-tech-hiring-signal-scraper" to find which companies are hiring for Salesforce right now.
```

***

### FAQ

**Is this legal to use?**
Yes. This Actor only accesses publicly available job listings from Greenhouse and Lever — the same pages visible to any job seeker without authentication. No personal data is collected. You remain responsible for compliant use under applicable regulations.

**How fresh is the data?**
Each run fetches live data at the time of the run. Schedule the Actor weekly for continuous monitoring — hiring pipelines change fast.

**How is the signal score calculated?**
See the "Understanding the signal score" section above. The score is a weighted combination of ratio (relevant roles / total roles) and absolute role count.

**Can I add companies not in the directory?**
The built-in directory covers ~90 curated companies. Contact us through the Apify platform to request additions, or use `get_company_signals` with any valid Greenhouse or Lever company slug.

**Why does some company return zero results?**
Either the company had no open roles at the time of the run, or the slug in the directory no longer matches their current ATS setup. Use the `sourceUrls` field to verify directly.

**Can I use this for a specific list of target accounts?**
Currently the Actor uses a built-in directory. For a custom account list, contact us through Apify — we can extend the Actor for your use case.

**How does this compare to Apollo.io or Clay.com?**
Apollo and Clay provide broader company databases with contact enrichment. This Actor provides deeper, more current tech-stack signal data from actual job postings. It is a complementary input to Apollo/Clay workflows, not a replacement.

**Do you support Workable or other ATS platforms?**
Not currently. Greenhouse and Lever cover the majority of global tech companies. Workable has begun blocking automated access. Additional ATS sources are planned.

# Actor input Schema

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

Choose how to use the scraper.

## `technology` (type: `string`):

Required for search\_by\_technology. Example: Salesforce, Kubernetes, Snowflake, dbt, Terraform, HubSpot, SAP.

## `companyName` (type: `string`):

Required for get\_company\_signals. Use the exact company slug from Greenhouse or Lever (e.g. stripe, airbnb, shopify).

## `region` (type: `string`):

Filter companies by region.

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

Maximum number of companies to return.

## `minSignalScore` (type: `integer`):

Only return companies with a signal score at or above this threshold. 0 = return all.

## Actor input object example

```json
{
  "mode": "list_top_signals",
  "technology": "Salesforce",
  "companyName": "stripe",
  "region": "all",
  "maxResults": 20,
  "minSignalScore": 0
}
```

# 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("actorpilot/global-tech-hiring-signal-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("actorpilot/global-tech-hiring-signal-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call actorpilot/global-tech-hiring-signal-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=actorpilot/global-tech-hiring-signal-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tech Stack Hiring Signal Scraper — Global B2B Intent Data",
        "description": "Scan public Greenhouse and Lever job boards to detect tech stack hiring signals across 90+ global companies. Find which companies are hiring for Salesforce, Kubernetes, Snowflake, AI, and more, then rank them by B2B buying intent.",
        "version": "1.0",
        "x-build-id": "eSSnu26JGdxsG0ENe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/actorpilot~global-tech-hiring-signal-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-actorpilot-global-tech-hiring-signal-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/actorpilot~global-tech-hiring-signal-scraper/runs": {
            "post": {
                "operationId": "runs-sync-actorpilot-global-tech-hiring-signal-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/actorpilot~global-tech-hiring-signal-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-actorpilot-global-tech-hiring-signal-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search_by_technology",
                            "get_company_signals",
                            "list_top_signals"
                        ],
                        "type": "string",
                        "description": "Choose how to use the scraper.",
                        "default": "list_top_signals"
                    },
                    "technology": {
                        "title": "Technology",
                        "type": "string",
                        "description": "Required for search_by_technology. Example: Salesforce, Kubernetes, Snowflake, dbt, Terraform, HubSpot, SAP."
                    },
                    "companyName": {
                        "title": "Company name",
                        "type": "string",
                        "description": "Required for get_company_signals. Use the exact company slug from Greenhouse or Lever (e.g. stripe, airbnb, shopify)."
                    },
                    "region": {
                        "title": "Region filter",
                        "enum": [
                            "all",
                            "us",
                            "eu",
                            "dach",
                            "apac"
                        ],
                        "type": "string",
                        "description": "Filter companies by region.",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of companies to return.",
                        "default": 20
                    },
                    "minSignalScore": {
                        "title": "Minimum signal score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return companies with a signal score at or above this threshold. 0 = return all.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
