# Job Postings & Technographics API - Hiring Signals (`nabeelbaghoor/job-postings-technographics-api`) Actor

Search millions of job postings enriched with company technographics - filter by title, seniority, technology stack, company, country, salary and posting date. Returns job plus full company data and hiring signals. Pay per result. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/job-postings-technographics-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Jobs, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$15.00 / 1,000 job 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Job Postings and Technographics API - hiring signals with company data

**Job Postings and Technographics API** searches millions of job postings and returns each one enriched with the hiring company's full profile and detected technology stack. Filter by title, seniority, technology, company, country, salary and posting date, and export title, company, location, remote status, seniority, salary, technologies and apply links as JSON, CSV or Excel.

Powered by the TheirStack API. Bring your own API key (free to create) and pay only for the results you keep.

### Why use this actor?

- **Jobs plus company intelligence** - every posting comes with the hiring company's domain, size, country and detected tech stack, turning a job feed into a sales and market-research dataset.
- **Technographics filtering** - find companies hiring for a specific technology, or companies that already use a given tool in their stack.
- **Rich structured output** - job title, company, location, remote flag, seniority, employment type, USD salary range, technologies, posting date and job URL, parsed into flat columns.
- **Powerful filters** - job titles, exclude titles, seniority, employment type, job and company technologies, keywords, job country, company name/domain/country, company type, salary range and posting recency.
- **Pay per result** - you are charged only for the jobs actually returned, up to 5,000 per run.
- **No proxies, no blocks** - data comes through a stable API, so runs are fast and reliable.

### Use cases

- **B2B lead generation** - companies hiring for a role or technology are companies with budget and intent; build targeted lists with firmographics attached.
- **Competitive and market intelligence** - track who is hiring for what, where, and with which tools.
- **Recruiting and sourcing** - monitor demand for roles and skills across companies and countries.
- **Technographic research** - map technology adoption from real hiring activity.
- **Alerting automations** - schedule daily runs and push new matches to Slack, a CRM or your data warehouse.

### Input

Configure everything from the visual editor - every filter is a proper field, no code needed. Example JSON input:

```json
{
  "jobTitles": ["data engineer"],
  "jobCountryCodes": ["US"],
  "companyTechnologies": ["snowflake"],
  "postedWithinDays": 14,
  "maxResults": 100,
  "apiKey": "YOUR_API_KEY"
}
````

### Output

One clean JSON object per job (company detail and full posting fields included in the raw record):

```json
{
  "job_title": "Senior Data Engineer",
  "company_name": "Acme Analytics",
  "company_domain": "acme.com",
  "location": "New York, NY",
  "country": "US",
  "remote": true,
  "seniority": "senior",
  "employment_type": "full_time",
  "salary": "$150,000 - $190,000",
  "date_posted": "2026-07-15",
  "technologies": ["python", "snowflake", "dbt", "aws"],
  "url": "https://acme.com/careers/senior-data-engineer",
  "id": 123456789
}
```

### Do I need an API key?

Yes. This actor calls the TheirStack job postings API on your behalf, which requires your own API key. Create a free key at theirstack.com, paste it into the **API key** field, and run. Your key is stored securely and never logged.

### Pay per result

You pay only for the job listings the actor actually returns - no subscriptions, no minimums. Set **Maximum results** to cap each run's spend exactly.

### FAQ

#### What is a technographics job API?

A technographics job API returns job postings together with the hiring company's technology stack - the tools, frameworks and platforms it uses. This actor lets you filter postings both by technologies mentioned in the job and by technologies the company already runs, so you can find, for example, every company hiring a data engineer that also uses Snowflake.

#### What data comes with each job?

The job title, location, remote status, seniority, employment type and USD salary range, plus the hiring company's name, domain, country, size and detected technologies. The full raw record also includes the nested company object and posting metadata.

#### What filters can I use?

Job titles and exclude-titles, seniority, employment type, job technologies, company technologies, job keywords, job country, company name, company domain, company country, company type (direct employer vs recruiting agency), salary range and posting recency.

#### Why is a time or company filter required?

The underlying API requires every search to be scoped by a posting date window or a company filter, to keep result sets meaningful. This actor defaults to the last 30 days when you have not set a company filter, and you can change the window with **Posted within the last … days**.

#### How many results can I get per run?

Up to 5,000 jobs per run, collected 50 per page. For larger pulls, split by country, technology or title, or run on a schedule and collect new postings each day.

#### How much does it cost?

Pricing is pay-per-result: a small fixed amount per job returned, plus standard Apify platform usage, plus your own TheirStack credit usage against your key. A run that returns nothing costs almost nothing.

#### Can I run this on a schedule?

Yes. Use Apify Schedules to run it daily and connect the dataset to Zapier, Make, n8n, webhooks, a CRM or the API to pipe new jobs anywhere.

#### Is this legal?

The actor returns publicly available job postings and company data retrieved through a licensed API. No login-walled or personal data is collected.

### Keyword map

job postings api, technographics api, hiring signals api, job data api, company technology stack api, b2b lead generation api, jobs api, recruiting data api, sales intelligence api, tech stack data, company data api, job market api.

### Support and feedback

Found an issue or missing a filter? Open an issue in the **Issues** tab - it is monitored daily.

# Actor input Schema

## `jobTitles` (type: `array`):

Match jobs whose title contains any of these, e.g. `data engineer`, `account executive`. Leave empty to match all titles.

## `excludeJobTitles` (type: `array`):

Drop jobs whose title contains any of these words.

## `seniority` (type: `array`):

Seniority level of the role. Leave empty for all levels.

## `employmentType` (type: `array`):

Type of employment. Leave empty for all.

## `jobKeywords` (type: `array`):

Keyword slugs that must appear in the job posting, e.g. `kubernetes`, `salesforce`.

## `jobTechnologies` (type: `array`):

Technology slugs mentioned in the job posting, e.g. `python`, `react`, `aws`.

## `companyTechnologies` (type: `array`):

Technology slugs in the hiring company's detected stack, e.g. `snowflake`, `hubspot`.

## `remote` (type: `string`):

Restrict to remote or on-site roles.

## `jobCountryCodes` (type: `array`):

ISO-2 country codes for the job location, e.g. `US`, `GB`, `DE`.

## `companyNames` (type: `array`):

Only jobs from these companies, e.g. `Stripe`, `Datadog`.

## `companyDomains` (type: `array`):

Only jobs from companies with these domains, e.g. `stripe.com`, `datadoghq.com`.

## `companyCountryCodes` (type: `array`):

ISO-2 country codes for the hiring company's HQ, e.g. `US`, `GB`.

## `companyType` (type: `string`):

Direct employers only, recruiting agencies only, or all.

## `minSalaryUsd` (type: `integer`):

Lower bound for the annual salary in USD.

## `maxSalaryUsd` (type: `integer`):

Upper bound for the annual salary in USD.

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

E.g. `7` returns jobs posted in the last week. Defaults to 30 days when no company filter is set (the API requires a time or company scope).

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

Stop after this many jobs (1-5,000). Collected 50 per page. You are charged per result returned.

## `apiKey` (type: `string`):

Your own TheirStack API key (Bearer token). Required - the actor calls the API on your behalf using this key. Create one free at theirstack.com. Stored securely and never logged.

## Actor input object example

```json
{
  "jobTitles": [],
  "remote": "any",
  "companyType": "all",
  "postedWithinDays": 7,
  "maxResults": 100
}
```

# 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 = {
    "jobTitles": [],
    "postedWithinDays": 7,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/job-postings-technographics-api").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 = {
    "jobTitles": [],
    "postedWithinDays": 7,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/job-postings-technographics-api").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 '{
  "jobTitles": [],
  "postedWithinDays": 7,
  "maxResults": 100
}' |
apify call nabeelbaghoor/job-postings-technographics-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nabeelbaghoor/job-postings-technographics-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Job Postings & Technographics API - Hiring Signals",
        "description": "Search millions of job postings enriched with company technographics - filter by title, seniority, technology stack, company, country, salary and posting date. Returns job plus full company data and hiring signals. Pay per result. Bring your own API key.",
        "version": "0.1",
        "x-build-id": "fsb2y0US80CY3ZzKa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nabeelbaghoor~job-postings-technographics-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nabeelbaghoor-job-postings-technographics-api",
                "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/nabeelbaghoor~job-postings-technographics-api/runs": {
            "post": {
                "operationId": "runs-sync-nabeelbaghoor-job-postings-technographics-api",
                "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/nabeelbaghoor~job-postings-technographics-api/run-sync": {
            "post": {
                "operationId": "run-sync-nabeelbaghoor-job-postings-technographics-api",
                "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": {
                    "jobTitles": {
                        "title": "Job titles",
                        "type": "array",
                        "description": "Match jobs whose title contains any of these, e.g. `data engineer`, `account executive`. Leave empty to match all titles.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeJobTitles": {
                        "title": "Exclude job titles",
                        "type": "array",
                        "description": "Drop jobs whose title contains any of these words.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "seniority": {
                        "title": "Seniority",
                        "type": "array",
                        "description": "Seniority level of the role. Leave empty for all levels.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "c_level",
                                "staff",
                                "senior",
                                "mid_level",
                                "junior"
                            ],
                            "enumTitles": [
                                "C-level",
                                "Staff",
                                "Senior",
                                "Mid level",
                                "Junior"
                            ]
                        }
                    },
                    "employmentType": {
                        "title": "Employment type",
                        "type": "array",
                        "description": "Type of employment. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full_time",
                                "part_time",
                                "contract",
                                "temporary",
                                "internship"
                            ],
                            "enumTitles": [
                                "Full time",
                                "Part time",
                                "Contract",
                                "Temporary",
                                "Internship"
                            ]
                        }
                    },
                    "jobKeywords": {
                        "title": "Job keywords",
                        "type": "array",
                        "description": "Keyword slugs that must appear in the job posting, e.g. `kubernetes`, `salesforce`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobTechnologies": {
                        "title": "Technologies in the job",
                        "type": "array",
                        "description": "Technology slugs mentioned in the job posting, e.g. `python`, `react`, `aws`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyTechnologies": {
                        "title": "Technologies the company uses",
                        "type": "array",
                        "description": "Technology slugs in the hiring company's detected stack, e.g. `snowflake`, `hubspot`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "remote": {
                        "title": "Remote / on-site",
                        "enum": [
                            "any",
                            "remote",
                            "onsite"
                        ],
                        "type": "string",
                        "description": "Restrict to remote or on-site roles.",
                        "default": "any"
                    },
                    "jobCountryCodes": {
                        "title": "Job country codes",
                        "type": "array",
                        "description": "ISO-2 country codes for the job location, e.g. `US`, `GB`, `DE`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyNames": {
                        "title": "Company names",
                        "type": "array",
                        "description": "Only jobs from these companies, e.g. `Stripe`, `Datadog`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyDomains": {
                        "title": "Company domains",
                        "type": "array",
                        "description": "Only jobs from companies with these domains, e.g. `stripe.com`, `datadoghq.com`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyCountryCodes": {
                        "title": "Company country codes",
                        "type": "array",
                        "description": "ISO-2 country codes for the hiring company's HQ, e.g. `US`, `GB`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyType": {
                        "title": "Company type",
                        "enum": [
                            "all",
                            "direct_employer",
                            "recruiting_agency"
                        ],
                        "type": "string",
                        "description": "Direct employers only, recruiting agencies only, or all.",
                        "default": "all"
                    },
                    "minSalaryUsd": {
                        "title": "Minimum salary (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound for the annual salary in USD."
                    },
                    "maxSalaryUsd": {
                        "title": "Maximum salary (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound for the annual salary in USD."
                    },
                    "postedWithinDays": {
                        "title": "Posted within the last … days",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "E.g. `7` returns jobs posted in the last week. Defaults to 30 days when no company filter is set (the API requires a time or company scope)."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many jobs (1-5,000). Collected 50 per page. You are charged per result returned."
                    },
                    "apiKey": {
                        "title": "API key",
                        "type": "string",
                        "description": "Your own TheirStack API key (Bearer token). Required - the actor calls the API on your behalf using this key. Create one free at theirstack.com. Stored securely and never logged."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
