# Terraform Registry Modules Scraper (`parseforge/terraform-registry-modules-scraper`) Actor

Browse the HashiCorp Terraform Registry for module metadata across every provider. Pull namespace, name, version, owner, source repo URL, usage counts, and verified status. Filter by keyword, provider, or namespace. Handy for module catalogs, version tracking, and provenance audits.

- **URL**: https://apify.com/parseforge/terraform-registry-modules-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🧱 Terraform Registry Modules Scraper

> 🚀 **Pull Terraform module metadata in seconds.** Turn the public HashiCorp Terraform Registry into a clean feed of modules with version, owner, source repo, download counts, and verified status.

> 🕒 **Last updated:** 2026-06-05 · **📊 14 fields** per record · Thousands of public modules · Every provider in the registry

Browse and collect module metadata straight from the official Terraform Registry public API. List the most recently published modules, search by keyword, or narrow by provider and namespace. Each module becomes one structured record you can drop into a spreadsheet, a database, or a dependency dashboard.

Coverage spans the whole public registry: AWS, Google Cloud, Azure, Kubernetes, Oracle, Docker, and any other provider that publishers ship modules for. Records include verified status so you can tell official partner modules apart from community ones.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Platform and DevOps engineers | Discover and compare infrastructure modules |
| Cloud architects | Track module versions and source repositories |
| Security and compliance teams | Audit module provenance and verified status |
| Data and research teams | Map the Terraform module ecosystem |

### 📋 What the Terraform Registry Modules Scraper does

This Actor reads the HashiCorp Terraform Registry public API and returns one record per module. For every module it captures the identifier, namespace, name, provider, latest version, owner, description, source repository URL, version tag, publish date, download count, and verified flag. You can list the latest modules, run a keyword search, or filter by provider and namespace.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

All inputs are optional. With no input the Actor lists the most recently published modules in the registry.

| Field | Type | Description |
|---|---|---|
| `searchQuery` | string | Keyword to search modules by, for example `vpc` or `eks`. Leave empty to list the latest modules. |
| `provider` | string | Provider to filter by, for example `aws`, `google`, `azurerm`. |
| `namespace` | string | Publisher namespace to filter the listing by, for example `terraform-aws-modules`. Ignored when a search query is set. |
| `maxItems` | integer | Cap on how many module records are produced. Free plan is limited to 10. |

Example 1. List the latest modules.

```json
{
    "maxItems": 25
}
````

Example 2. Search VPC modules on AWS.

```json
{
    "searchQuery": "vpc",
    "provider": "aws",
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** The Terraform Registry namespace filter applies only to the plain listing, not to keyword search. When you set a `searchQuery`, the `namespace` value is ignored and results come from the registry search ranking.

### 📊 Output

Each record describes one Terraform module.

| Field | Description |
|---|---|
| 🆔 `id` | Full module identifier (namespace/name/provider/version) |
| 🏷 `namespace` | Publisher namespace |
| 📦 `name` | Module name |
| ☁️ `provider` | Target provider |
| 🔖 `version` | Latest published version |
| 👤 `owner` | Registry account that owns the module |
| 📝 `description` | Module description |
| 📂 `sourceUrl` | Source repository URL |
| 🔖 `tag` | Git tag for the latest version |
| 🕒 `publishedAt` | Publish timestamp of the latest version |
| ⬇️ `downloads` | Total download count |
| ✅ `verified` | Whether the module is verified by HashiCorp |
| 🔗 `url` | Public registry page for the module |
| 🕒 `scrapedAt` | When the record was collected |

Sample records from a live run:

```json
{
    "id": "GoogleCloudPlatform/lb-http/google/14.2.0",
    "namespace": "GoogleCloudPlatform",
    "name": "lb-http",
    "provider": "google",
    "version": "14.2.0",
    "owner": "danisla",
    "description": "Creates a global HTTP load balancer for Compute Engine by using forwarding rules",
    "sourceUrl": "https://github.com/terraform-google-modules/terraform-google-lb-http",
    "tag": "v14.2.0",
    "publishedAt": "2026-01-15T00:10:36.13339Z",
    "downloads": 10521796,
    "verified": true,
    "url": "https://registry.terraform.io/modules/GoogleCloudPlatform/lb-http/google",
    "scrapedAt": "2026-06-05T17:19:02.613Z",
    "error": null
}
```

```json
{
    "id": "GoogleCloudPlatform/managed-instance-group/google/1.1.15",
    "namespace": "GoogleCloudPlatform",
    "name": "managed-instance-group",
    "provider": "google",
    "version": "1.1.15",
    "owner": "danisla",
    "description": "Modular Google Compute Engine managed instance group for Terraform.",
    "sourceUrl": "https://github.com/GoogleCloudPlatform/terraform-google-managed-instance-group",
    "tag": "1.1.15",
    "publishedAt": "2019-02-14T16:55:26.567562Z",
    "downloads": 175062,
    "verified": true,
    "url": "https://registry.terraform.io/modules/GoogleCloudPlatform/managed-instance-group/google",
    "scrapedAt": "2026-06-05T17:19:02.775Z",
    "error": null
}
```

```json
{
    "id": "GoogleCloudPlatform/lb-internal/google/9.0.4",
    "namespace": "GoogleCloudPlatform",
    "name": "lb-internal",
    "provider": "google",
    "version": "9.0.4",
    "owner": "danisla",
    "description": "Creates an internal load balancer for Compute Engine by using forwarding rules",
    "sourceUrl": "https://github.com/terraform-google-modules/terraform-google-lb-internal",
    "tag": "v9.0.4",
    "publishedAt": "2026-06-05T06:17:56.286307Z",
    "downloads": 5349203,
    "verified": true,
    "url": "https://registry.terraform.io/modules/GoogleCloudPlatform/lb-internal/google",
    "scrapedAt": "2026-06-05T17:19:02.820Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Reads the official public Terraform Registry API, so the data matches what you see on the registry website.
- One clean record per module with consistent fields, ready for analysis.
- Verified flag included, so you can separate HashiCorp partner modules from community ones.
- Flexible inputs: list the latest modules, search by keyword, or filter by provider and namespace.
- No API key or login required.

### 📈 How it compares to alternatives

| Approach | Setup | Structured output | Verified flag | Maintenance |
|---|---|---|---|---|
| This Actor | None | Yes | Yes | Handled for you |
| Manual browsing of the registry | High | No | Manual | Ongoing |
| Writing your own API client | Medium | Build it yourself | Build it yourself | On you |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Terraform Registry Modules Scraper.
3. Leave the input empty for the latest modules, or add a search query, provider, or namespace.
4. Click Start and let the run finish.
5. Open the results and review or connect them to your tools.

### 💼 Business use cases

#### Platform engineering

| Goal | How this helps |
|---|---|
| Build an internal module catalog | Pull modules by provider or namespace and keep a single list |
| Track upgrades | Compare versions and publish dates across runs |

#### Security and compliance

| Goal | How this helps |
|---|---|
| Audit provenance | Capture source repository URLs and owners for every module |
| Flag unverified modules | Filter records by the verified field |

#### Vendor and ecosystem research

| Goal | How this helps |
|---|---|
| Measure adoption | Use download counts as a popularity signal |
| Map publishers | Group modules by namespace and provider |

#### Tooling and automation

| Goal | How this helps |
|---|---|
| Feed dashboards | Push records into a database or BI tool |
| Trigger alerts | Watch for new versions of modules you depend on |

### 🔌 Automating Terraform Registry Modules Scraper

Connect the output to the tools your team already uses:

- **Make** and **Zapier** for no-code workflows.
- **Slack** to post new or updated modules to a channel.
- **Airbyte** to sync records into a warehouse.
- **GitHub** to open issues when a tracked module ships a new version.
- **Google Drive** to archive snapshots of the catalog.

### 🌟 Beyond business use cases

- **Research:** study how the Terraform module ecosystem grows over time.
- **Personal:** keep a watchlist of modules you use in side projects.
- **Non-profit:** maintain a shared catalog of vetted infrastructure modules.
- **Experimentation:** prototype dependency graphs and popularity rankings.

### 🤖 Ask an AI assistant

Paste a few records into your favorite assistant and ask it to summarize, rank, or compare:

- [ChatGPT](https://chat.openai.com)
- [Claude](https://claude.ai)
- [Perplexity](https://www.perplexity.ai)
- [Microsoft Copilot](https://copilot.microsoft.com)

### ❓ Frequently Asked Questions

**Does this need a Terraform Registry API key?**
No. The registry public API is keyless.

**How many modules can I collect?**
Free plan runs are limited to 10 records. Paid plans can collect far more, up to your configured cap.

**Can I search by keyword?**
Yes. Set the search query field and the Actor uses the registry search endpoint.

**Can I filter by provider?**
Yes. The provider filter applies to both listing and search.

**Can I filter by namespace?**
Yes for plain listing. When a search query is set, the namespace value is ignored.

**What does the verified flag mean?**
It indicates whether HashiCorp has verified the module as an official partner module.

**Where does the owner value come from?**
The Actor enriches each module with the owner from the registry module detail endpoint.

**Is the download count cumulative?**
Yes. It reflects total downloads reported by the registry.

**Does it include the source repository?**
Yes, when the registry exposes a source URL for the module.

**How fresh is the data?**
Each run reads live from the registry, so values match the registry at run time.

**Can I run this on a schedule?**
Yes. Use the Apify scheduler to run it as often as you need.

### 🔌 Integrate with any app

Every run produces structured records you can pull through the Apify API or connect to Make, Zapier, and other platforms. Wire the output into spreadsheets, databases, dashboards, or messaging tools.

### 🔗 Recommended Actors

- [deps.dev Package Insights Scraper](https://apify.com/parseforge)
- [Libraries.io Scraper](https://apify.com/parseforge)
- [crt.sh Certificate Transparency Scraper](https://apify.com/parseforge)
- [SEC XBRL Company Facts Scraper](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with HashiCorp or Terraform. Only publicly available data collected.

# Actor input Schema

## `searchQuery` (type: `string`):

Optional keyword to search modules by (for example vpc, eks, network). Leave empty to list the most recently published modules.

## `provider` (type: `string`):

Optional provider to filter by (for example aws, google, azurerm). Applied to both search and listing.

## `namespace` (type: `string`):

Optional namespace (publisher) to filter the listing by (for example terraform-aws-modules, GoogleCloudPlatform). Ignored when a search query is set.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/terraform-registry-modules-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/terraform-registry-modules-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 '{
  "maxItems": 10
}' |
apify call parseforge/terraform-registry-modules-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/terraform-registry-modules-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Terraform Registry Modules Scraper",
        "description": "Browse the HashiCorp Terraform Registry for module metadata across every provider. Pull namespace, name, version, owner, source repo URL, usage counts, and verified status. Filter by keyword, provider, or namespace. Handy for module catalogs, version tracking, and provenance audits.",
        "version": "0.1",
        "x-build-id": "mjScnSjZdgwlTeRDL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~terraform-registry-modules-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-terraform-registry-modules-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/parseforge~terraform-registry-modules-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-terraform-registry-modules-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/parseforge~terraform-registry-modules-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-terraform-registry-modules-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Optional keyword to search modules by (for example vpc, eks, network). Leave empty to list the most recently published modules."
                    },
                    "provider": {
                        "title": "Provider Filter",
                        "type": "string",
                        "description": "Optional provider to filter by (for example aws, google, azurerm). Applied to both search and listing."
                    },
                    "namespace": {
                        "title": "Namespace Filter",
                        "type": "string",
                        "description": "Optional namespace (publisher) to filter the listing by (for example terraform-aws-modules, GoogleCloudPlatform). Ignored when a search query is set."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```