# 📊 Global Equities Screener MCP (`nexgendata/global-equities-screener-mcp`) Actor

MCP server bundling 26 regional stock screeners as agent tools — Bloomberg / Wind alternative for global market screening

- **URL**: https://apify.com/nexgendata/global-equities-screener-mcp.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Business, AI, Automation
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $25,000.00 / 1,000 global equities tool calls

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Global Equities Screener MCP — 26 World Markets, One AI-Native Endpoint

The only MCP server that gives an AI agent **direct access to 26 global stock screeners** — from BIST (Istanbul) to Eastmoney (Shanghai), from JSE (Johannesburg) to ASX (Sydney) — through a single Model Context Protocol connection. No Bloomberg terminal, no Wind subscription, no Refinitiv Eikon contract required.

If you've ever tried to run a screen across "every Chinese A-share trading below 10x P/E **and** every Saudi Tadawul stock with > 4% dividend yield **and** every Brazilian B3 small-cap with > 20% revenue growth" you know that Bloomberg charges $24,000 a seat, Wind charges ¥23,000, and Refinitiv won't even quote you under $15K/yr. Even FactSet's lighter Web Services tier starts around $12K and ramps to $30K+ per analyst. This MCP server lets your Claude / Cursor / Cline / n8n agent screen the entire emerging-markets equity universe for **less than the cost of a coffee per session**.

### Why this is defensible

No other vendor — open source or commercial — ships a single API that covers all of the following: **Mainland China A-shares, the STAR Market, ChiNext, the Beijing SME board, Chinese ADRs, Hong Kong / HKEX, Taiwan TWSE, KOSPI, NSE India, SGX Singapore, Tokyo TSE, ASX Australia, IDX Indonesia, SET Thailand, Bursa Malaysia, PSE Philippines, HOSE Vietnam, LSE UK, Xetra Germany, B3 Brazil, TSX Canada, BMV Mexico, Tadawul Saudi, JSE South Africa, BIST Turkey, and US Finviz**. Bloomberg charges by terminal, Wind charges by user, and neither is wired into the MCP ecosystem. Your agent literally cannot ask GPT to "screen Bursa Malaysia for dividend stocks" through any other tool today.

### The 26 tools (one per market)

#### US / Global
- `screen_us_finviz(criteria, limit)` — Finviz NYSE / NASDAQ / AMEX with 100+ filters

#### Greater China cluster (5 tools)
- `screen_china_a_shares(sector, market_cap_min, limit)` — Shanghai + Shenzhen via Eastmoney
- `screen_china_star_market(criteria, limit)` — Shanghai Sci-Tech Innovation Board (hard tech, biotech)
- `screen_china_chinext(criteria, limit)` — Shenzhen growth board (China's Nasdaq)
- `screen_china_bse(criteria, limit)` — Beijing Stock Exchange (SME board)
- `screen_chinese_adrs(criteria, limit)` — Chinese ADRs on US exchanges (BABA, JD, PDD, NIO, etc.)

#### Asia-Pacific (12 tools)
- `screen_hk_hang_seng(criteria, limit)` — HKEX Hang Seng + Mainboard + GEM
- `screen_taiwan_twse(criteria, limit)` — TSMC, MediaTek, ASE, Foxconn
- `screen_korea_kospi(criteria, limit)` — Samsung, SK Hynix, Hyundai, LG
- `screen_india_nse(criteria, limit)` — Nifty 50, Nifty Bank, full universe
- `screen_singapore_sgx(criteria, limit)` — STI + the SE-Asia REIT universe
- `screen_japan_tse(criteria, limit)` — Nikkei 225, TOPIX, Prime / Standard / Growth
- `screen_australia_asx(criteria, limit)` — ASX 200 + mining juniors
- `screen_indonesia_idx(criteria, limit)` — LQ45, IDX30
- `screen_thailand_set(criteria, limit)` — SET50, SET100
- `screen_malaysia_bursa(criteria, limit)` — FBM KLCI
- `screen_philippines_pse(criteria, limit)` — PSEi
- `screen_vietnam_hose(criteria, limit)` — VN30 + full HOSE

#### EMEA + Americas + GCC + Africa (8 tools)
- `screen_uk_lse(criteria, limit)` — LSE FTSE 100, FTSE 250, AIM
- `screen_germany_dax(criteria, limit)` — Xetra DAX 40, MDAX, SDAX, TecDAX
- `screen_brazil_b3(criteria, limit)` — B3 / Bovespa Index
- `screen_canada_tsx(criteria, limit)` — TSX Composite + TSX Venture (mining / energy)
- `screen_mexico_bmv(criteria, limit)` — Bolsa Mexicana, IPC components
- `screen_saudi_tadawul(criteria, limit)` — TASI, Aramco, banks, petrochems
- `screen_southafrica_jse(criteria, limit)` — JSE Top 40, mining majors
- `screen_turkey_bist(criteria, limit)` — BIST 100, BIST 30

### How it stacks up against the institutional incumbents

| Capability | Global Equities MCP | Bloomberg Terminal | Wind 万得 | Choice 东方财富 | FactSet Web Services | Refinitiv Eikon |
|---|---|---|---|---|---|---|
| Annual cost per seat | **$5–$50 / mo (PPE)** | $24,000 / yr | ¥23,000 / yr | ¥6,000 / yr | $12,000–$30,000 / yr | $22,000 / yr |
| Markets covered | **26 (incl. all China cluster + GCC + Vietnam)** | 100+ | China-focused | China-focused | 100+ | 100+ |
| AI-agent native (MCP) | **Yes — Claude, Cursor, Cline, n8n** | No | No | No | No | No |
| Setup time | **~60 seconds** | Sales cycle + hardware shipped | Sales call | Sales call | Sales call + license | Sales cycle |
| Eastmoney + STAR + ChiNext + BSE coverage | **Yes** | Partial | Yes (China only) | Yes (China only) | Partial | Partial |
| Vietnam HOSE | **Yes** | Limited | No | No | Limited | Limited |
| BIST + Tadawul + JSE | **Yes** | Yes | No | No | Yes | Yes |
| Pricing model | Pay-per-event | Seat license | Seat license | Seat license | Per-API tier | Seat license |
| Time to first screen for an LLM | **One MCP `tools/call`** | Multi-week integration | Custom build | Custom build | API glue code | API glue code |

### Install in your AI client

#### Claude Desktop / Claude Code
```json
{
  "mcpServers": {
    "global-equities-screener": {
      "url": "https://nexgendata--global-equities-screener-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN"
    }
  }
}
````

#### Cursor

Settings → MCP → Add server:

- URL: `https://nexgendata--global-equities-screener-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN`
- Transport: `streamable-http`

#### Cline / Continue / Windsurf

```yaml
mcp:
  servers:
    - name: global-equities-screener
      transport: streamable-http
      url: https://nexgendata--global-equities-screener-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN
```

#### n8n

Add an MCP node, point it at the URL above. All 26 tools auto-register.

### Three example agent workflows

#### 1. Global value screen across 5 markets in one prompt

> *"Find the cheapest large-cap banks across US, India, Brazil, Saudi Arabia and South Africa — sorted by P/B ratio."*

The agent calls `screen_us_finviz`, `screen_india_nse`, `screen_brazil_b3`, `screen_saudi_tadawul`, `screen_southafrica_jse` in parallel, merges the structured output, and ranks by P/B. **Cost: ~$0.65 per session.** A Bloomberg seat costs $24,000 / yr.

#### 2. China-cluster sector rotation

> *"Compare semiconductor names across A-shares, STAR, ChiNext, ADRs, Hong Kong, and Taiwan TWSE."*

The agent fans out to `screen_china_a_shares`, `screen_china_star_market`, `screen_china_chinext`, `screen_chinese_adrs`, `screen_hk_hang_seng`, `screen_taiwan_twse`, joins on sector tag, returns a unified table. Wind 万得 charges ¥23K/yr for less coverage of overseas-listed Chinese names.

#### 3. Emerging-Asia dividend basket

> *"Build me an SE-Asia dividend basket: Singapore REITs, Thai utilities, Malaysian banks, Indonesian consumer staples, Vietnamese industrials. Yield > 4 %, market cap > $500M."*

Hits SGX, SET, Bursa, IDX, HOSE in five tool calls. Total ~$0.50 per run, vs analyst-hours of manual work on a Refinitiv terminal.

### Pay-per-event pricing — institutional buyer tier

| Event | Price | When charged |
|---|---|---|
| `apify-actor-start` (MCP session start) | **$0.02** | Once per session |
| `tool-call` (market screen) | **$0.10** | Each screener invocation |
| `bulk-results` (>10 stocks in one screen) | **$0.15** | Premium tier for institutional pulls |

Typical session cost: **$0.10 – $0.50**. Heavy institutional usage: ~$5–$50 / month. Compare to $2,000+ / month for a single Bloomberg / Refinitiv seat.

### Related NexGenData MCP servers and screeners (cross-links)

| Use case | Actor |
|---|---|
| Single-market quotes + fundamentals | [Yahoo Finance Scraper](https://apify.com/nexgendata/yahoo-finance-scraper?fpr=2ayu9b) |
| US screener (raw, no MCP) | [Finviz Stock Screener](https://apify.com/nexgendata/finviz-stock-screener?fpr=2ayu9b) |
| Generic finance MCP | [Finance MCP Server](https://apify.com/nexgendata/finance-mcp-server?fpr=2ayu9b) |
| Yahoo Finance via MCP | [Yahoo Finance MCP Server](https://apify.com/nexgendata/yahoo-finance-mcp-server?fpr=2ayu9b) |
| China-only A-shares scraper | [Eastmoney China Stock Screener](https://apify.com/nexgendata/eastmoney-china-stock-screener?fpr=2ayu9b) |
| India only | [NSE India Stock Screener](https://apify.com/nexgendata/nse-india-stock-screener?fpr=2ayu9b) |
| Crypto MCP | [Crypto MCP Server](https://apify.com/nexgendata/crypto-mcp-server?fpr=2ayu9b) |
| News MCP for agent equity research workflows | [News MCP Server](https://apify.com/nexgendata/news-mcp-server?fpr=2ayu9b) |
| SEC EDGAR filings (US disclosure leg) | [SEC EDGAR Search](https://apify.com/nexgendata/sec-edgar-search?fpr=2ayu9b) |

Browse the full 260+-actor NexGenData catalog at [apify.com/nexgendata](https://apify.com/nexgendata?fpr=2ayu9b).

### FAQ

**Q: How do you cover all 26 markets?**
Each tool wraps a dedicated NexGenData screener actor for that exchange. The MCP server is the orchestration layer; the heavy lifting (HTML parsing, anti-bot, regional language quirks) happens in the per-exchange actors.

**Q: How fresh is the data?**
Live pulls from exchange data partners and aggregators (Eastmoney for China, Finviz for US, exchange direct where possible). Most markets are intraday-delayed by 15 min, in line with industry practice for non-licensed feeds.

**Q: Is this real-time enough for trading?**
For research, screening, agentic equity analysis — yes. For sub-second execution-grade quotes — no, that's what a Bloomberg market-data feed handle is for.

**Q: Can the agent run multiple screens in parallel?**
Yes. MCP supports concurrent `tools/call`. Most clients (Claude, Cursor) parallelize automatically.

**Q: What about EU MiFID coverage?**
Xetra (DAX) is included. Euronext, BME, OMX are on the roadmap — open an issue on the actor page and we'll prioritize.

**Q: Why MCP vs a normal REST API?**
With MCP your agent **discovers** the 26 tools dynamically — no glue code, no per-endpoint wrappers, no schema mapping. You change tool inventories, the agent automatically picks up new tools. With REST you're rewriting the integration every time.

### About NexGenData

NexGenData publishes 260+ buyer-intent actors and a fleet of MCP servers covering SEC filings, lead generation, real-estate, stock fundamentals across 30+ exchanges, and a growing fleet of AI-native tools. All pay-per-result. Browse the full catalog at [apify.com/nexgendata](https://apify.com/nexgendata?fpr=2ayu9b).

***

### How NexGenData pay-per-event pricing works

Every NexGenData actor uses **pay-per-event** pricing — you only pay for results actually delivered to your agent. No monthly minimum, no seat fees, no surprise overage bills. The Global Equities Screener MCP charges $0.10 per market screen with a small $0.02 session-start fee and an optional $0.15 premium when a single screen returns >10 stocks with full fundamentals.

# Actor input Schema

## Actor input object example

```json
{}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/global-equities-screener-mcp").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/global-equities-screener-mcp").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call nexgendata/global-equities-screener-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/global-equities-screener-mcp",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📊 Global Equities Screener MCP",
        "description": "MCP server bundling 26 regional stock screeners as agent tools — Bloomberg / Wind alternative for global market screening",
        "version": "0.0",
        "x-build-id": "ZUMNrEMPxPkNxb69V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~global-equities-screener-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-global-equities-screener-mcp",
                "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/nexgendata~global-equities-screener-mcp/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-global-equities-screener-mcp",
                "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/nexgendata~global-equities-screener-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-global-equities-screener-mcp",
                "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": {}
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```