# Telegram Lead Scraper (`scrapapi/telegram-lead-scraper`) Actor

📲 Telegram Lead Scraper pulls targeted leads from public groups & channels — usernames, names, bios — with keyword filters and de-duplication. 🗂️ Export CSV/Excel for CRM. 🚀 Ideal for prospecting, outreach, sales and community growth.

- **URL**: https://apify.com/scrapapi/telegram-lead-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$19.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** Lead Scraper 📱

The **Telegram** Lead Scraper is designed to **extract** a variety of **data** points from **Telegram** groups, channels, and user profiles. It focuses on gathering lead addresses while ensuring compliance with **Telegram**'s policies and ethical guidelines.

Users can **extract** **leads** from **Telegram** users who have shared their **contact** information publicly or with consent. Additionally, the tool can gather supplementary **data** such as usernames, group names, and user activity details to provide context for the collected **leads**.

This comprehensive approach ensures that users can build accurate and actionable **contact** lists. The **Telegram** lead harvesting tool is versatile and can adapt to different use cases, including marketing, research, and networking.

By automating the **data** **extract**ion process, it reduces manual effort and enhances productivity for individuals and organizations alike.

Telegram Lead Scraper is a powerful tool designed to extract lead addresses from Telegram groups, channels, and user profiles efficiently. It simplifies the process of gathering contact information for marketing, research, and networking purposes.

With Telegram lead extraction tools, businesses can streamline their outreach strategies by collecting verified lead addresses from active Telegram users. This automation saves time and ensures accuracy in data collection.

The Telegram Lead Scraper is ideal for extracting leads from Telegram groups and channels, making it a valuable resource for lead generation and targeted campaigns. It works seamlessly with Telegram's interface to provide fast and reliable results.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead Addresses | Extract publicly shared or consented lead addresses from Telegram users. |
| Usernames | Collect usernames associated with the extracted lead addresses for better identification. |
| Group Names | Retrieve the names of Telegram groups where the leads were extracted from. |
| Channel Names | Identify the Telegram channels linked to the collected lead data. |
| User Activity | Analyze user activity levels within groups or channels for better targeting. |
| Profile Information | Gather additional public profile details like bio or profile picture links. |
| Group Member Count | Extract the total number of members in a group for context. |
| Message Metadata | Collect metadata such as timestamps or message counts for deeper insights. |

### Key Features of **Telegram** Lead Scraper

Here are the **standout features** that make the **Telegram** Lead Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ Efficiently extracts lead addresses from **Telegram** groups channels and user profiles
- ⭐ Supports both public and private groups with appropriate permissions for ethical data collection
- ⭐ User-friendly interface designed for beginners and advanced users alike
- ⭐ **Advanced** filtering options to target specific users or groups based on criteria
- ⭐ **Automated** data extraction to save time and reduce manual effort
- ⭐ Scalable design capable of handling large-scale lead scraping tasks
- ⭐ Provides supplementary data like usernames group names and user activity details
- ⭐ Ensures compliance with **Telegram** policies and ethical data collection standards
- ⭐ **Regular** updates to maintain compatibility with **Telegram**s platform changes
- ⭐ **Secure** data handling to protect user information and extracted data

### How to use **Telegram** Lead Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Telegram** leads today:

1. ✅ Download and install the **Telegram** Lead Scraper software on your device
2. ✅ Log in to your **Telegram** account through the scrapers secure interface
3. ✅ **Select** the target group channel or user list from which you want to extract leads
4. ✅ **Configure** the scraping parameters such as filters or data types to collect
5. ✅ **Start** the scraping process and monitor the progress through the dashboard
6. ✅ **Review** the extracted data and export it in your preferred format such as CSV or JSON
7. ✅ Use the built-in deduplication feature to clean and organize the collected leads
8. ✅ Save your project settings for future use or schedule automated scraping tasks

### Use Cases 🎯

Lead Generation
🎯 Extract leads from **Telegram** groups related to your industry for targeted outreach
🎯 Build a contact list of potential clients or collaborators from **Telegram** users

Market Research
🎯 **Analyze** user activity and group dynamics to identify trends and preferences
🎯 **Collect** lead data to survey **Telegram** users on specific topics or products

Networking
🎯 Connect with professionals in **Telegram** groups by extracting their contact details
🎯 Expand your professional network with verified lead addresses from **Telegram** users

Content Promotion
🎯 Share your content with a targeted audience by leading **Telegram** group members
🎯 Promote events or products to **Telegram** users who have shared their leads

### Why choose us? 💎

Our **Telegram** Lead Scraper stands out as the **best** **Telegram** scraper for leads due to its **advanced** features and **user-friendly** design. It is built to provide accurate and **reliable** lead extraction while maintaining compliance with ethical standards.

The tool is equipped with powerful automation capabilities, allowing users to save time and focus on their core activities. We prioritize data security and ensure that all extracted information is handled with care and confidentiality.

Our software is **regular**ly updated to adapt to changes in **Telegram**'s platform, ensuring uninterrupted service. Additionally, our dedicated support team is available to assist users with any queries or technical issues.

Whether you are a business owner, marketer, or researcher, our **Telegram** lead automation tool is tailored to meet your specific needs. With competitive pricing and robust functionality, we aim to deliver exceptional value to our users.

Trust our **Telegram** Lead Scraper to help you achieve your goals efficiently and ethically.

### **Telegram** Lead Scraper Scalability 📈

The **Telegram** Lead Scraper is designed to handle projects of all sizes, from small-scale data collection to **large-scale** lead harvesting tasks. Its robust architecture ensures consistent performance even when processing **extensive** **Telegram** groups or channels.

The tool's **advanced** filtering options allow users to customize their scraping tasks, making it suitable for diverse requirements. Additionally, the software supports batch processing and scheduling, enabling users to automate repetitive tasks and improve productivity.

Whether you need to extract a few hundred leads or thousands, the **Telegram** Lead Scraper can scale to meet your demands. Our development team continuously optimizes the software to ensure it remains **efficient** and reliable as your needs grow.

With its scalable design, the **Telegram** Lead Scraper is a valuable asset for businesses and individuals looking to maximize their data collection efforts.

### **Telegram** Lead Scraper Legal Guidelines ⚖️

**Yes**—scraping **Telegram** is **legal** as long as you follow **ethical** and **compliant** practices. The **Telegram** Lead Scraper extracts only **publicly available** information from **public** **Telegram** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** that you have permission to access and scrape data from **Telegram** groups or channels
⚖️ **Only** collect lead addresses that are publicly shared or provided with explicit consent
⚖️ **Do not** use the **Telegram** Lead Scraper for spamming or any other unethical activities
⚖️ Comply with **Telegram**s terms of service and privacy policies while using the tool
⚖️ **Adhere** to local and international data protection laws such as GDPR or CCPA
⚖️ **Avoid** scraping private or sensitive information without proper authorization
⚖️ **Use** the extracted data responsibly and for legitimate purposes only
⚖️ Regularly review and update your practices to maintain compliance with evolving regulations

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Telegram Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "Telegram",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads to collect (default 20) |
| platform | Platform to scrape (Telegram) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Telegram",
    "keyword": "Telegram Lead Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Telegram as the source |
| keyword | Keyword that triggered the result (Telegram Lead Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Telegram profile link |
| lead | Extracted lead address |

### FAQ ❓

#### What is the Telegram **Lead Scraper**?

The Telegram Lead Scraper is a tool designed to extract lead addresses and related data from Telegram groups, channels, and user profiles.

#### Is the Telegram **Lead Scraper** **legal** to use?

**Yes**, it is legal to use as long as you comply with Telegram's terms of service and collect data ethically and with consent.

#### Can the tool **extract** leads from **private** Telegram groups?

**Yes**, but only if you have permission to access the private group or if the data is shared publicly.

#### What data formats are supported for **export**?

The Telegram Lead Scraper supports exporting data in formats like **CSV**, **JSON**, and Excel.

#### Is the tool compatible with all Telegram versions?

**Yes**, the tool is regularly updated to ensure compatibility with the latest versions of Telegram.

#### Can I use the scraper on multiple devices?

**Yes**, the tool supports multi-device usage with a valid license.

#### Does the scraper work for large Telegram groups?

**Yes**, the tool is scalable and can handle large groups or channels efficiently.

#### Is technical support available?

**Yes**, our **dedicated support** team is available to assist with any technical issues or queries.

#### Can I schedule automated scraping tasks?

**Yes**, the tool includes scheduling features for **automated** scraping tasks.

#### How **secure** is the **extract**ed data?

The extracted data is stored **secure**ly and handled with strict confidentiality to protect user information.

#### What are the system requirements for the scraper?

The tool is compatible with Windows, Mac, and Linux systems with standard hardware configurations.

#### Can I filter the data before scraping?

**Yes**, the tool offers advanced **filtering** options to target specific groups or users.

#### Is there a free trial available?

**Yes**, a free trial is available to help users evaluate the tool's features and performance.

#### How often is the software updated?

The software is updated regularly to maintain compatibility and improve functionality.

#### Can I use the tool for bulk lead **extract**ion?

**Yes**, the tool is designed to handle bulk lead extraction tasks efficiently.

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for on Telegram (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Telegram profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

## `location` (type: `string`):

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

## `maxEmails` (type: `integer`):

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `proxyConfiguration` (type: `object`):

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Telegram",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/telegram-lead-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 = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/telegram-lead-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 '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapapi/telegram-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telegram Lead Scraper",
        "description": "📲 Telegram Lead Scraper pulls targeted leads from public groups & channels — usernames, names, bios — with keyword filters and de-duplication. 🗂️ Export CSV/Excel for CRM. 🚀 Ideal for prospecting, outreach, sales and community growth.",
        "version": "0.1",
        "x-build-id": "edqShlsuyzGbLxQpT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~telegram-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-telegram-lead-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/scrapapi~telegram-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-telegram-lead-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/scrapapi~telegram-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-telegram-lead-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Telegram (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Telegram profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Telegram"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Telegram"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
