# Telegram Info Scraper (`automation-lab/telegram-info-scraper`) Actor

Resolve public Telegram handles, channels, groups, bots, and profiles into clean metadata rows without Telegram login.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Telegram Info Scraper

Resolve public Telegram channels, groups, bots, and profiles into clean metadata rows without logging in to Telegram.

### What does Telegram Info Scraper do?

Telegram Info Scraper turns Telegram usernames, @handles, `t.me` links, and `tg://resolve` links into structured public profile data. It reads the same public Telegram preview pages that are visible in a normal browser and exports one dataset row per target.

Use it when you need to enrich a list of Telegram entities before outreach, research a community, check whether a bot or channel is verified, or build a repeatable monitoring workflow around public Telegram metadata.

### Who is it for?

- 🧑‍💼 **SDR and partnerships teams** resolving Telegram handles from lead lists.
- 🕵️ **Trust and safety analysts** checking visible scam, fake, and verification indicators.
- 📣 **Community managers** comparing channel or group subscriber/member signals.
- 🤖 **Automation builders** enriching Telegram URLs in Clay, Make, Zapier, or custom scripts.
- 📊 **Market researchers** collecting public profile descriptions, avatars, and visible counts.

### Why use this actor?

- No Telegram account or API key is required.
- Handles, usernames, and `t.me` URLs can be mixed in one input.
- Invalid, private, or inaccessible targets are reported with a clear status instead of crashing the run.
- Public channel preview pages can add recent public activity hints such as visible preview post count and latest post date.
- Output is flat and integration-friendly for spreadsheets, CRMs, and databases.

### What public Telegram data can it extract?

| Field | Description |
| --- | --- |
| `input` | Original value you submitted. |
| `username` | Normalized Telegram username when available. |
| `entityType` | Inferred type: channel, group, bot, profile, unknown, or inaccessible. |
| `title` | Public display title or name. |
| `bio` | Public description/bio shown on Telegram preview pages. |
| `avatarUrl` | Public avatar/photo URL when Telegram exposes it. |
| `subscriberCount` | Visible subscriber count for channels. |
| `memberCount` | Visible member count for groups. |
| `monthlyUsers` | Visible monthly user count for bots. |
| `isVerified` | Whether Telegram shows a verified badge. |
| `isScam` | Whether a public scam indicator is visible. |
| `isFake` | Whether a public fake indicator is visible. |
| `isBot` | Whether the target appears to be a bot. |
| `previewPostCount` | Number of posts visible on the fetched public preview page. |
| `latestPostDate` | Latest visible public preview post timestamp. |
| `status` | `ok`, `invalid`, `private`, `not_found`, or `error`. |

### How much does it cost to resolve Telegram profiles?

This actor uses pay-per-event pricing with a small run-start fee and a per-result event. Formula-derived launch pricing starts around **$0.05 per 1,000 resolved Telegram entities** on the BRONZE tier, plus the small start fee. Higher-volume tiers receive lower per-result prices.

### Input options

#### `targets`

Paste public Telegram usernames, handles, and links:

```json
[
  "@telegram",
  "BotFather",
  "https://t.me/durov",
  "tg://resolve?domain=telegram"
]
````

#### `startUrls`

Use this optional field when another Apify integration passes request-list style URL objects:

```json
[
  { "url": "https://t.me/telegram" },
  { "url": "https://t.me/s/durov" }
]
```

#### `maxResults`

Caps the number of unique targets processed after de-duplication. Keep the default low for a cheap first run, then increase for bulk enrichment.

#### `includePreviewStats`

When enabled, the actor follows Telegram's public `/s/<username>` preview link where available. This adds public preview activity fields, but uses one extra HTTP request for those targets.

#### `requestDelayMs`

Adds a polite delay between Telegram requests. Increase it for very large lists.

### Example input

```json
{
  "targets": ["@telegram", "BotFather", "https://t.me/durov"],
  "maxResults": 3,
  "includePreviewStats": true,
  "requestDelayMs": 350
}
```

### Example output

```json
{
  "input": "@telegram",
  "sourceUrl": "https://t.me/telegram",
  "canonicalUrl": "https://t.me/telegram",
  "username": "telegram",
  "entityType": "channel",
  "title": "Telegram News",
  "bio": "The official Telegram on Telegram. Much recursion. Very Telegram. Wow.",
  "avatarUrl": "https://cdn...jpg",
  "isVerified": true,
  "isScam": false,
  "isFake": false,
  "isBot": false,
  "memberCount": null,
  "subscriberCount": 10387917,
  "monthlyUsers": null,
  "visibleMetricText": "10 387 917 subscribers",
  "previewUrl": "https://t.me/s/telegram",
  "previewPostCount": 20,
  "latestPostDate": "2026-02-10T17:43:45+00:00",
  "status": "ok",
  "errorMessage": null,
  "scrapedAt": "2026-06-16T08:18:04.119Z"
}
```

### How to scrape Telegram profile metadata

1. Open the actor on Apify.
2. Add Telegram handles or URLs to **Telegram handles or URLs**.
3. Keep `maxResults` small for your first test.
4. Run the actor.
5. Download the dataset as JSON, CSV, Excel, or via API.
6. Increase limits for your production enrichment job.

### Tips for best results

- Use public usernames and `https://t.me/<username>` links.
- Do not use private invite links if you need metadata; Telegram does not expose private group data publicly.
- Keep `includePreviewStats` on when you care about public channel activity hints.
- Turn `includePreviewStats` off for the fastest possible enrichment run.
- Use the `status` and `errorMessage` fields to filter inaccessible targets.

### Handling private or inaccessible Telegram links

This actor does not join channels, groups, or chats. Private invite links such as `https://t.me/+...` are marked as invalid/inaccessible because resolving them would require a Telegram account and membership. That behavior is intentional and keeps the actor focused on public data only.

### Integrations

- 🔁 **CRM enrichment:** Upload Telegram handles from a lead list, export `title`, `bio`, `entityType`, and `canonicalUrl` to your CRM.
- 🧪 **Fraud review:** Flag rows where `isScam`, `isFake`, or `status != ok` for manual review.
- 📈 **Community tracking:** Run the same list on a schedule and compare visible subscriber/member counts over time.
- 🧰 **Clay or Make workflows:** Call the actor via API for every new Telegram URL found in a company or creator database.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/telegram-info-scraper').call({
  targets: ['@telegram', 'BotFather'],
  maxResults: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/telegram-info-scraper').call(run_input={
    'targets': ['@telegram', 'BotFather'],
    'maxResults': 2,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~telegram-info-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"targets":["@telegram","BotFather"],"maxResults":2}'
```

### MCP usage

Use the Apify MCP server with this actor when you want an AI assistant to enrich Telegram handles during research.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/telegram-info-scraper
```

Add it to Claude Code with the HTTP transport:

```bash
claude mcp add apify-telegram-info --transport http "https://mcp.apify.com/?tools=automation-lab/telegram-info-scraper"
```

Claude Desktop, Cursor, and VS Code can use the same remote MCP server entry. Add this JSON configuration to your MCP settings in the relevant app:

```json
{
  "mcpServers": {
    "apify-telegram-info": {
      "url": "https://mcp.apify.com/?tools=automation-lab/telegram-info-scraper"
    }
  }
}
```

Where to paste it:

- **Claude Desktop:** Settings → Developer → Edit Config, then restart Claude Desktop.
- **Cursor:** Settings → Cursor Settings → MCP → Add new global MCP server.
- **VS Code:** Add the server in your MCP extension or agent settings that accept `mcpServers` JSON.

Example prompts:

- "Use the Telegram Info Scraper tool to resolve these Telegram channels and return a table of titles, bios, and subscriber counts."
- "Use MCP to check whether these Telegram bots are verified and export their public descriptions."
- "Resolve handles from this CSV with the Apify Telegram tool and group them by ok, private, invalid, and error status."

### Scheduling

Schedule the actor daily, weekly, or monthly to monitor a fixed list of public channels, groups, or bots. Store each run's dataset and compare counts externally to detect growth, inactivity, or profile changes.

### Data quality notes

Telegram controls what is visible on public preview pages. Some profiles expose a bio and avatar but no counts. Some bots expose monthly users. Some public channels expose subscriber counts and preview posts. The actor preserves missing values as `null` instead of guessing.

### Legality and ethical use

This actor extracts publicly available Telegram preview metadata. It does not bypass login, scrape private content, join groups, or access messages that Telegram does not expose publicly. Always follow Telegram's terms, Apify's terms, and applicable privacy laws. Do not use the data for spam, harassment, or unlawful profiling.

### FAQ and troubleshooting

#### Why did a target return `invalid`?

The input may be empty, malformed, contain spaces, or be a private invite link. Use public usernames such as `@telegram` or URLs such as `https://t.me/telegram`.

#### Why is `subscriberCount` empty?

Telegram does not show every metric for every entity type. Bots often show monthly users, profiles may show no counts, and some groups/channels hide or omit metrics on public previews.

#### Why is `previewPostCount` empty?

The target may not expose a public `/s/<username>` preview page, or `includePreviewStats` may be disabled.

### Related scrapers

- https://apify.com/automation-lab/telegram-scraper
- https://apify.com/automation-lab/contact-info-scraper
- https://apify.com/automation-lab/social-media-stats-checker

### Changelog

- Initial build: public Telegram entity metadata resolver with status handling and optional preview stats.

# Actor input Schema

## `targets` (type: `array`):

Public Telegram usernames, @handles, t.me URLs, or tg://resolve links. Private invite links are reported as inaccessible because they require joining Telegram.

## `startUrls` (type: `array`):

Optional request-list style input for t.me URLs. Values are combined with Telegram handles above and de-duplicated.

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

Maximum number of unique Telegram targets to resolve from the combined input.

## `includePreviewStats` (type: `boolean`):

For public channels and groups, fetch the /s/ preview page to add visible post count and latest post date. Disable for the fastest metadata-only run.

## `requestDelayMs` (type: `integer`):

Polite delay between Telegram requests. Increase if you process large lists.

## Actor input object example

```json
{
  "targets": [
    "@telegram",
    "BotFather",
    "https://t.me/durov"
  ],
  "startUrls": [
    {
      "url": "https://t.me/telegram"
    }
  ],
  "maxResults": 10,
  "includePreviewStats": true,
  "requestDelayMs": 350
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "targets": [
        "@telegram",
        "BotFather",
        "https://t.me/durov"
    ],
    "startUrls": [
        {
            "url": "https://t.me/telegram"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/telegram-info-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 = {
    "targets": [
        "@telegram",
        "BotFather",
        "https://t.me/durov",
    ],
    "startUrls": [{ "url": "https://t.me/telegram" }],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/telegram-info-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 '{
  "targets": [
    "@telegram",
    "BotFather",
    "https://t.me/durov"
  ],
  "startUrls": [
    {
      "url": "https://t.me/telegram"
    }
  ]
}' |
apify call automation-lab/telegram-info-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telegram Info Scraper",
        "description": "Resolve public Telegram handles, channels, groups, bots, and profiles into clean metadata rows without Telegram login.",
        "version": "0.1",
        "x-build-id": "YqUQfVDwo0186xSQM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~telegram-info-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-telegram-info-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~telegram-info-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-telegram-info-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~telegram-info-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-telegram-info-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "Telegram handles or URLs",
                        "type": "array",
                        "description": "Public Telegram usernames, @handles, t.me URLs, or tg://resolve links. Private invite links are reported as inaccessible because they require joining Telegram.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (optional)",
                        "type": "array",
                        "description": "Optional request-list style input for t.me URLs. Values are combined with Telegram handles above and de-duplicated.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum targets to process",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of unique Telegram targets to resolve from the combined input.",
                        "default": 10
                    },
                    "includePreviewStats": {
                        "title": "Include public preview stats",
                        "type": "boolean",
                        "description": "For public channels and groups, fetch the /s/ preview page to add visible post count and latest post date. Disable for the fastest metadata-only run.",
                        "default": true
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (milliseconds)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between Telegram requests. Increase if you process large lists.",
                        "default": 350
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
