# CFTC Commitments of Traders Scraper (`automation-lab/cftc-commitments-of-traders-scraper`) Actor

📈 Extract public CFTC COT reports into structured futures positioning rows for trading research, dashboards, and risk monitoring.

- **URL**: https://apify.com/automation-lab/cftc-commitments-of-traders-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## CFTC Commitments of Traders Scraper

Extract public CFTC Commitments of Traders (COT) report files into structured market positioning rows for trading research, risk monitoring, and analytics.

### What does CFTC Commitments of Traders Scraper do?

CFTC Commitments of Traders Scraper downloads public text reports from the U.S. Commodity Futures Trading Commission and converts each market row into a typed Apify dataset item.

It starts with the current disaggregated futures-only report and can also read the combined futures and options disaggregated report.

The actor is designed for recurring weekly COT workflows where analysts need clean rows instead of hand-parsing fixed public text files.

### Who is it for?

- 📈 Commodity traders tracking producer, swap dealer, managed money, and non-reportable positioning.
- 🏦 Hedge fund research teams building weekly positioning dashboards.
- 🧮 Risk analysts monitoring open interest and concentration changes.
- 🧑‍💻 Data engineers feeding CFTC COT data into warehouses or notebooks.
- 📰 Market researchers who need repeatable source-backed COT extracts.

### Why use this actor?

The CFTC publishes valuable files, but the rows are wide, comma-delimited, and inconvenient for downstream tools.

This actor normalizes the most important columns, preserves source provenance, and exports data in formats supported by Apify datasets.

### Supported CFTC reports

- `disaggregated_futures_only` — current disaggregated futures-only report.
- `disaggregated_combined` — current disaggregated combined futures and options report.
- `custom_url` — direct CFTC text report URL for compatible files.

### Data you can extract

| Field group | Examples |
| --- | --- |
| Market identity | market name, report date, CFTC contract code, exchange, commodity code |
| Open interest | all open interest and weekly change |
| Producer/merchant | long, short, percent of open interest, trader counts |
| Swap dealer | long, short, spread |
| Managed money | long, short, spread |
| Other reportables | long and short positions |
| Non-reportables | long and short positions |
| Concentration | gross and net four-trader concentration fields |
| Provenance | contract units, source URL, row number, scrape timestamp |

### How much does it cost to scrape CFTC Commitments of Traders data?

The actor uses pay-per-event pricing.

There is a small start charge for each run and a per-row charge for each CFTC market row saved to the dataset.

The exact public pricing is shown on the Apify Store page and in the input sidebar before you run the actor.

### Quick start

1. Open the actor on Apify.
2. Keep `COT report type` set to `Disaggregated futures only`.
3. Set `Maximum rows` to a small number for your first test.
4. Optionally enter a market filter such as `WHEAT`, `CORN`, `GOLD`, or `CRUDE`.
5. Start the run.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Input options

#### COT report type

Choose the public CFTC report file to fetch.

Use the default when you want current disaggregated futures-only rows.

#### Custom CFTC report URL

Use this only when `COT report type` is `custom_url`.

The URL should point to a compatible CFTC comma-delimited text report.

#### Maximum rows

Limits the number of dataset items saved.

Use a low value for testing and a higher value for production refreshes.

#### Market name contains

Optional case-insensitive filter applied to the CFTC market name.

Examples:

- `WHEAT`
- `CORN`
- `CRUDE`
- `GOLD`
- `EURO`

#### Date filters

`From report date` and `To report date` use `YYYY-MM-DD` format.

They are useful when a custom report URL contains multiple report periods.

#### Include raw CFTC row array

Advanced option for audit workflows.

When enabled, the actor adds `rawRow` with the parsed source field array.

### Example input

```json
{
  "reportType": "disaggregated_futures_only",
  "marketNameFilter": "WHEAT",
  "maxRows": 25,
  "includeRawRow": false
}
````

### Example output

```json
{
  "marketName": "WHEAT-SRW - CHICAGO BOARD OF TRADE",
  "reportDate": "2026-06-23",
  "cftcContractMarketCode": "001602",
  "exchange": "CBT",
  "openInterestAll": 428305,
  "producerMerchantLongAll": 61192,
  "producerMerchantShortAll": 83194,
  "managedMoneyLongAll": 68457,
  "managedMoneyShortAll": 138890,
  "contractUnits": "(CONTRACTS OF 5,000 BUSHELS)",
  "sourceUrl": "https://www.cftc.gov/dea/newcot/f_disagg.txt"
}
```

### Output fields

The default dataset contains one item per CFTC market row.

Important fields include:

- `marketName`
- `reportDate`
- `openInterestAll`
- `producerMerchantLongAll`
- `producerMerchantShortAll`
- `swapDealerLongAll`
- `swapDealerShortAll`
- `managedMoneyLongAll`
- `managedMoneyShortAll`
- `totalReportableLongAll`
- `totalReportableShortAll`
- `nonReportableLongAll`
- `nonReportableShortAll`
- `contractUnits`
- `sourceUrl`

### Tips for best results

- Use a market filter for quick exploratory runs.
- Leave the filter blank to capture the full current weekly report.
- Schedule the actor weekly after the CFTC publishes fresh COT data.
- Keep `includeRawRow` disabled unless you need audit-level source mapping.
- Use dataset CSV export for spreadsheets and API export for automated pipelines.

### Integrations

Use this actor with:

- Apify Schedules for weekly report refreshes.
- Google Sheets or Excel exports for analyst workbooks.
- BigQuery, Snowflake, or S3 integrations for warehouse loading.
- Webhooks to notify trading desks when new COT data is available.
- Python notebooks for futures positioning research.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/cftc-commitments-of-traders-scraper').call({
  reportType: 'disaggregated_futures_only',
  marketNameFilter: 'WHEAT',
  maxRows: 25
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('automation-lab/cftc-commitments-of-traders-scraper').call(run_input={
    'reportType': 'disaggregated_futures_only',
    'marketNameFilter': 'WHEAT',
    'maxRows': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~cftc-commitments-of-traders-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"reportType":"disaggregated_futures_only","marketNameFilter":"WHEAT","maxRows":25}'
```

### MCP integration

Use the Apify MCP server to run this actor from Claude Code, Claude Desktop, or other MCP clients.

MCP tool URL:

`https://mcp.apify.com/?tools=automation-lab/cftc-commitments-of-traders-scraper`

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/cftc-commitments-of-traders-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-cftc-cot": {
      "url": "https://mcp.apify.com/?tools=automation-lab/cftc-commitments-of-traders-scraper"
    }
  }
}
```

Example prompts:

- "Run the CFTC COT scraper for WHEAT and summarize managed money positioning."
- "Fetch the latest disaggregated futures-only COT rows and show the largest open interest markets."
- "Create a weekly COT monitoring workflow for gold and crude oil."

### Scheduling weekly COT monitoring

CFTC reports are recurring datasets.

Create an Apify schedule to run this actor weekly and send the dataset to your storage integration.

This avoids manual downloads and keeps your downstream dashboards current.

### Data quality notes

The actor preserves CFTC source URLs and row numbers.

Numeric fields are parsed into numbers when possible.

Blank or dot values from the source are returned as `null`.

### Legality

This actor extracts publicly available CFTC report files.

Users are responsible for following Apify terms, CFTC website terms, and any internal compliance requirements for data use.

### FAQ

#### How often does CFTC COT data update?

CFTC COT reports are recurring public reports. Many teams schedule this actor weekly to refresh dashboards after the latest publication.

#### Does this actor require a login or API key for CFTC?

No. It reads public CFTC text report files and does not require a CFTC account.

### Troubleshooting

#### Why did I get zero rows?

Check whether your market name filter is too narrow.

Try removing the filter or using a broad commodity word such as `WHEAT`.

#### Why are some numeric values null?

CFTC files sometimes use `.` or blank cells for unavailable values.

The actor converts those values to `null` rather than inventing a number.

#### Can I scrape historical files?

Use `custom_url` with a compatible public CFTC report URL.

Historical file layouts may vary, so keep `includeRawRow` on for audit runs when testing a new URL.

### Related scrapers

Explore other Automation Lab actors at:

- https://apify.com/automation-lab

### Changelog

Initial version parses public CFTC disaggregated COT text files into typed dataset rows.

### Support

If a CFTC report URL changes or a field needs to be added, open an issue on the actor page with the run ID and example market row.

# Actor input Schema

## `reportType` (type: `string`):

Public CFTC COT text file to fetch. The default is the current disaggregated futures-only report.

## `customReportUrl` (type: `string`):

Optional direct CFTC .txt report URL, used only when COT report type is custom\_url.

## `maxRows` (type: `integer`):

Maximum market rows to save from the report.

## `marketNameFilter` (type: `string`):

Optional case-insensitive filter, for example WHEAT, CORN, CRUDE, GOLD, or EURODOLLAR.

## `fromDate` (type: `string`):

Optional inclusive report date filter in YYYY-MM-DD format.

## `toDate` (type: `string`):

Optional inclusive report date filter in YYYY-MM-DD format.

## `includeRawRow` (type: `boolean`):

Adds the original parsed CFTC field array for auditing and custom downstream mapping.

## Actor input object example

```json
{
  "reportType": "disaggregated_futures_only",
  "customReportUrl": "https://www.cftc.gov/dea/newcot/f_disagg.txt",
  "maxRows": 20,
  "marketNameFilter": "WHEAT",
  "includeRawRow": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "reportType": "disaggregated_futures_only",
    "customReportUrl": "https://www.cftc.gov/dea/newcot/f_disagg.txt",
    "maxRows": 20,
    "marketNameFilter": "WHEAT",
    "includeRawRow": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cftc-commitments-of-traders-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 = {
    "reportType": "disaggregated_futures_only",
    "customReportUrl": "https://www.cftc.gov/dea/newcot/f_disagg.txt",
    "maxRows": 20,
    "marketNameFilter": "WHEAT",
    "includeRawRow": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cftc-commitments-of-traders-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 '{
  "reportType": "disaggregated_futures_only",
  "customReportUrl": "https://www.cftc.gov/dea/newcot/f_disagg.txt",
  "maxRows": 20,
  "marketNameFilter": "WHEAT",
  "includeRawRow": false
}' |
apify call automation-lab/cftc-commitments-of-traders-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/cftc-commitments-of-traders-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CFTC Commitments of Traders Scraper",
        "description": "📈 Extract public CFTC COT reports into structured futures positioning rows for trading research, dashboards, and risk monitoring.",
        "version": "0.1",
        "x-build-id": "UK8y8cv8HFD8OwVmk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cftc-commitments-of-traders-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cftc-commitments-of-traders-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/automation-lab~cftc-commitments-of-traders-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cftc-commitments-of-traders-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/automation-lab~cftc-commitments-of-traders-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cftc-commitments-of-traders-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",
                "required": [
                    "reportType",
                    "maxRows"
                ],
                "properties": {
                    "reportType": {
                        "title": "COT report type",
                        "enum": [
                            "disaggregated_futures_only",
                            "disaggregated_combined",
                            "custom_url"
                        ],
                        "type": "string",
                        "description": "Public CFTC COT text file to fetch. The default is the current disaggregated futures-only report.",
                        "default": "disaggregated_futures_only"
                    },
                    "customReportUrl": {
                        "title": "Custom CFTC report URL",
                        "type": "string",
                        "description": "Optional direct CFTC .txt report URL, used only when COT report type is custom_url."
                    },
                    "maxRows": {
                        "title": "Maximum rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum market rows to save from the report.",
                        "default": 20
                    },
                    "marketNameFilter": {
                        "title": "Market name contains",
                        "type": "string",
                        "description": "Optional case-insensitive filter, for example WHEAT, CORN, CRUDE, GOLD, or EURODOLLAR."
                    },
                    "fromDate": {
                        "title": "From report date",
                        "type": "string",
                        "description": "Optional inclusive report date filter in YYYY-MM-DD format."
                    },
                    "toDate": {
                        "title": "To report date",
                        "type": "string",
                        "description": "Optional inclusive report date filter in YYYY-MM-DD format."
                    },
                    "includeRawRow": {
                        "title": "Include raw CFTC row array",
                        "type": "boolean",
                        "description": "Adds the original parsed CFTC field array for auditing and custom downstream mapping.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```