# Telegram Username Info — User, Group, Channel & Bot Lookup (`scrapepilot/telegram-username-info----user-group-channel-bot-lookup`) Actor

Check any Telegram username and get full profile: name, bio, photo, member count, account type, verified badge and scam warnings. Works for users, groups, channels and bots. No login required.

- **URL**: https://apify.com/scrapepilot/telegram-username-info----user-group-channel-bot-lookup.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** Social media, Lead generation, Other
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$12.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

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

---
## 📱 Telegram Username Info — User, Group, Channel & Bot Lookup

**Check Telegram usernames — users, groups, channels, bots — in bulk without login or API key.**  
**Telegram Username Info** extracts public profile data from `t.me/{username}`: existence, name, description, photo, member count, account type, verification status, scam flags. Perfect for lead validation, community research, and social intelligence.

✅ **Free 2‑hour trial** – test with your own usernames.  
✅ **$12.99/month** – unlimited lookups, residential proxy included.

---

### 💡 What is Telegram Username Info?

**Telegram Username Info** is a powerful Apify actor that retrieves **publicly available data** from any Telegram username, group, channel, or bot. It uses the official `t.me` preview page – no login, no Telegram API key, and no phone number required.

Just provide a list of usernames (or full `t.me/` URLs), and the actor returns:

- **Existence status** (whether the username is taken)
- **Account type** (user, group, channel, or bot)
- **Title / full name**
- **Description** (bio or group/channel info)
- **Profile photo URL**
- **Participant count** (members/subscribers for groups/channels)
- **Verification badge** (official ✅)
- **Scam / fake warning**
- **Direct link** to the account

The **Telegram Username Info** actor is the fastest, most reliable way to validate and enrich Telegram usernames for lead generation, community analytics, fraud detection, and social listening.

---

### 🚀 Key Features

| Feature                     | Description |
|-----------------------------|-------------|
| **Bulk Lookup**              | Process hundreds of usernames in one run (newline‑separated or JSON array). |
| **No API Key**               | No Telegram API required – uses public web interface. |
| **No Login**                 | Works without any Telegram account. |
| **Account Type Detection**   | Automatically identifies users, groups, channels, and bots. |
| **Member Count**             | Extracts participant/subscriber count for groups/channels. |
| **Verification & Scam Flags**| Returns `is_verified`, `is_bot`, `is_scam`. |
| **Residential Proxy**        | Avoids Telegram’s datacenter IP blocks (built‑in, always on). |
| **Clean JSON / CSV**         | Ready for CRM, spreadsheets, or APIs. |
| **Free 2‑hour trial**        | Test with your own usernames before subscribing. |
| **Flat monthly price**       | $12.99/month – no per‑request fees. |

---

### 📥 Input Parameters

The actor accepts a JSON object with the following fields:

| Parameter         | Type                | Required | Default | Description |
|-------------------|---------------------|----------|---------|-------------|
| `usernames`       | array or string     | **Yes**  | –       | List of Telegram usernames or `t.me/` URLs. Can be newline‑separated string or JSON array. |
| `proxyConfiguration` | object          | No       | –       | Apify proxy configuration. **Residential proxies are always used** – no need to configure. |

#### Example Input

```json
{
  "usernames": "durov\ntelegram\n@NASA\nhttps://t.me/binance\nBotFather"
}
````

***

### 📤 Output Fields

For each username, the actor returns an object with the following fields:

| Field                | Type    | Description |
|----------------------|---------|-------------|
| `username`           | string  | Normalized username (lowercase). |
| `exists`             | boolean | Whether the username is taken and accessible. |
| `isUser`             | boolean | True for individual user accounts. |
| `title`              | string  | Display name / channel title / user full name. |
| `description`        | string  | Bio, group/channel description (up to 1000 chars). |
| `photoUrl`           | string  | Direct URL to the profile photo (if available). |
| `participants_count` | integer | Number of members/subscribers (groups/channels only). |
| `account_type`       | string  | `user`, `group`, `channel`, `bot`, or `unknown`. |
| `is_verified`        | boolean | Official verification badge. |
| `is_bot`             | boolean | True for bot accounts. |
| `is_scam`            | boolean | Indicates if the preview page shows a scam/fake warning. |
| `url`                | string  | Direct `t.me/{username}` link. |
| `error`              | string  | Description if not found or private. |
| `fetched_at`         | string  | ISO 8601 timestamp. |

#### Example Output

```json
[
  {
    "username": "durov",
    "exists": true,
    "isUser": true,
    "title": "Pavel Durov",
    "description": "CEO of Telegram",
    "photoUrl": "https://cdn4.telesco.pe/file/...",
    "participants_count": null,
    "account_type": "user",
    "is_verified": true,
    "is_bot": false,
    "is_scam": false,
    "url": "https://t.me/durov",
    "error": null,
    "fetched_at": "2026-04-23T12:00:00Z"
  },
  {
    "username": "binance",
    "exists": true,
    "isUser": false,
    "title": "Binance Official",
    "description": "Official Binance announcements and updates",
    "photoUrl": "https://cdn4.telesco.pe/file/...",
    "participants_count": 1520000,
    "account_type": "channel",
    "is_verified": true,
    "is_bot": false,
    "is_scam": false,
    "url": "https://t.me/binance",
    "error": null,
    "fetched_at": "2026-04-23T12:00:01Z"
  }
]
```

***

### 💰 Pricing & Trial

| Plan                 | Price          | Description |
|----------------------|----------------|-------------|
| **Free Trial**       | **2 hours**     | Full access – test with your own usernames, no commitment. |
| **Monthly Subscription** | **$12.99** | Unlimited runs, residential proxy included, no per‑request fees. |

- You pay a flat monthly fee – not per username. Process hundreds of thousands of lookups for a fixed price.
- The actor automatically uses Apify’s residential proxies (no extra configuration needed).
- Cancel anytime.

***

### 🛠 How to Use on Apify

1. **Start a free 2‑hour trial** – click “Try for free” on the actor page.
2. **Create a task** and paste your usernames into the `usernames` field (one per line).
3. **Run** – the actor will check each username and push results to the Dataset.
4. **Export** – download as JSON, CSV, or Excel.
5. **Subscribe** – when you’re ready, upgrade to the $12.99/month plan for unlimited use.

#### Running via API

```bash
curl -X POST "https://api.apify.com/v2/acts/your-username~telegram-username-info/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "usernames": ["durov", "telegram", "binance"]
  }'
```

***

### 🎯 Use Cases for Telegram Username Info

- **Lead Validation** – Verify that a Telegram username exists before adding to your CRM.
- **Community Analytics** – Monitor growth of groups/channels by tracking member counts.
- **Social Listening** – Enrich influencer databases with description, photo, and verification status.
- **Fraud Detection** – Identify scam or fake accounts flagged by Telegram.
- **Market Research** – Collect public data on competitor channels.
- **Bot Discovery** – Find all active bots in a niche by scanning username lists.
- **Account Recovery** – Check if a desired username is available.

**Telegram Username Info** saves hours of manual checking and provides structured data for automation.

***

### ❓ Frequently Asked Questions

#### Q1. Do I need a Telegram account?

No. **Telegram Username Info** uses only the public `t.me` preview page. No login required.

#### Q2. Why do I need residential proxies?

Telegram blocks most datacenter IP addresses. The actor automatically uses Apify’s residential proxies, so you don’t have to worry about being blocked.

#### Q3. Is there a free trial?

Yes. You get **2 hours of full access** – enough to test hundreds of usernames. After the trial, you can subscribe for $12.99/month.

#### Q4. How many usernames can I check per run?

There is no hard limit. However, we recommend splitting very large lists (100,000+) into multiple runs to avoid timeouts. The actor processes about 2–3 usernames per second with residential proxies.

#### Q5. Does it work for private groups/channels?

No. Only public usernames (where the `t.me/username` page is visible) work. Private groups require an invite link and are not accessible.

#### Q6. What is the difference between `isUser` and `account_type`?

- `isUser` is boolean – true for individual user profiles.
- `account_type` can be `user`, `group`, `channel`, `bot`, or `unknown`. It provides more granular information.

#### Q7. Why is `participants_count` sometimes null?

For individual users, Telegram does not show a member count. For groups/channels, the actor extracts the number only if it appears on the preview page (e.g., “12 345 members”).

#### Q8. How accurate is the `is_scam` flag?

Telegram sometimes displays a warning banner on scam accounts. The actor detects that banner. However, not all scam accounts are flagged – use this as an additional signal.

***

### 📝 Technical Notes

- **No API key**: The actor scrapes `https://t.me/{username}` directly.
- **Residential proxy**: Always active – you cannot disable it because Telegram blocks datacenter IPs.
- **Rate limiting**: The actor adds a random 0.8–2.0 second delay between requests to avoid `429` errors.
- **Error handling**: If a request fails (timeout, 404, etc.), the actor returns `exists: false` with an error message.
- **Normalization**: Inputs like `@username`, `https://t.me/username`, `t.me/username/` are all converted to the clean username.

***

### 🔍 SEO Keywords

`Telegram Username Info`, `Telegram username checker`, `Telegram profile scraper`, `Telegram user lookup`, `Telegram group member count`, `Telegram channel info`, `Telegram bot detector`, `Telegram verification badge`, `Telegram scam alert`, `t.me scraper`, `Telegram public data extractor`, `Apify Telegram actor`, `bulk Telegram username validation`, `Telegram lead enrichment`

***

### 🔗 Related Actors

You might also find these useful:

- **[Telegram Profile Scraper (Full Profile)](https://apify.com/scrapepilot/telegram-profile-scraper----users-channels-groups)** – Extracts all public profile fields.
- **[Telegram Channel Member Extractor](https://apify.com/scrapepilot/telegram-group-member-scraper-fast-export-to-json-excel)** – Extracts member lists (requires API).

***

***

**Try it free for 2 hours → then $12.99/month. Verify Telegram usernames at scale.**

````

# Actor input Schema

## `usernames` (type: `array`):

List of Telegram usernames to look up.

✅ All formats accepted:
crypto
@durov
t.me/telegram
https://t.me/bitcoin

💡 Mix of users, groups, channels and bots all work.
## `proxyConfiguration` (type: `object`):

RESIDENTIAL proxy is required — Telegram blocks datacenter IPs.

✅ Always keep RESIDENTIAL proxy enabled.

## Actor input object example

```json
{
  "usernames": [
    "crypto",
    "telegram",
    "durov"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# 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 = {
    "usernames": [
        "crypto",
        "telegram",
        "durov"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/telegram-username-info----user-group-channel-bot-lookup").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 = {
    "usernames": [
        "crypto",
        "telegram",
        "durov",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/telegram-username-info----user-group-channel-bot-lookup").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 '{
  "usernames": [
    "crypto",
    "telegram",
    "durov"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapepilot/telegram-username-info----user-group-channel-bot-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapepilot/telegram-username-info----user-group-channel-bot-lookup",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telegram Username Info — User, Group, Channel & Bot Lookup",
        "description": "Check any Telegram username and get full profile: name, bio, photo, member count, account type, verified badge and scam warnings. Works for users, groups, channels and bots. No login required.",
        "version": "0.0",
        "x-build-id": "uxfWPPiLvrjweUMuj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~telegram-username-info----user-group-channel-bot-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-telegram-username-info----user-group-channel-bot-lookup",
                "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/scrapepilot~telegram-username-info----user-group-channel-bot-lookup/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-telegram-username-info----user-group-channel-bot-lookup",
                "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/scrapepilot~telegram-username-info----user-group-channel-bot-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-telegram-username-info----user-group-channel-bot-lookup",
                "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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "👤 Usernames",
                        "type": "array",
                        "description": "List of Telegram usernames to look up.\n\n✅ All formats accepted:\ncrypto\n@durov\nt.me/telegram\nhttps://t.me/bitcoin\n\n💡 Mix of users, groups, channels and bots all work.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy (RESIDENTIAL Required)",
                        "type": "object",
                        "description": "RESIDENTIAL proxy is required — Telegram blocks datacenter IPs.\n\n✅ Always keep RESIDENTIAL proxy enabled."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
