# Telegram Email Scraper (`scraper-engine/telegram-email-scraper`) Actor

Telegram Email Scraper extracts publicly available email addresses from Telegram profiles, groups, and channels. Build targeted contact lists by niche or region. Ideal for marketers and sales teams running outreach campaigns.

- **URL**: https://apify.com/scraper-engine/telegram-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Social media, Other
- **Stats:** 8 total users, 0 monthly users, 100.0% runs succeeded, 0 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** Email Scraper 📱

The **Telegram** Email Scraper allows you to **extract** a variety of **data** from **Telegram** groups and channels. It is specifically designed to retrieve email addresses shared by users in public or private groups.

Additionally, the tool can collect other relevant details such as usernames, group names, and message timestamps. By organizing this **data** into a structured format, the **Telegram** email **extract**or makes it easy to analyze and utilize the information for your needs.

With its advanced scraping capabilities, you can efficiently generate targeted email lists for marketing, research, or networking purposes. The **Telegram** email scraping tool is versatile and adaptable, ensuring you can **extract** the most relevant **data** for your specific use case.

Telegram Email Scraper is a powerful tool designed to help you extract email addresses from Telegram groups and channels efficiently. It simplifies the process of gathering valuable contact information for various purposes.

By using a Telegram email extractor, you can save time and effort while building targeted email lists. This tool is ideal for businesses, marketers, and researchers looking to connect with specific audiences.

With the Telegram Email Scraper, you can access and organize email data from Telegram communities in a structured format. It is a reliable solution for email harvesting and contact management.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract email addresses shared by users in Telegram groups or channels. |
| Usernames | Retrieve the usernames of members in the targeted Telegram groups or channels. |
| Group names | Capture the names of the Telegram groups or channels being scraped. |
| Message timestamps | Collect the timestamps of messages containing email addresses. |
| Profile links | Extract profile links of users who share email addresses. |
| Group descriptions | Retrieve descriptions of the Telegram groups or channels for additional context. |
| Message content | Capture the content of messages that include email addresses. |
| Group member count | Record the total number of members in the targeted groups or channels. |

### Key Features of **Telegram** Email Scraper

Here are the **standout features** that make the **Telegram** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ Efficiently extracts email addresses from **Telegram** groups and channels
- ⭐ Supports both public and private **Telegram** groups with proper access permissions
- ⭐ User-friendly interface that requires no advanced technical skills
- ⭐ Organizes extracted data into structured formats such as CSV or JSON
- ⭐ Offers advanced filtering options to target specific groups or keywords
- ⭐ Ensures high accuracy and minimizes duplicate email entries
- ⭐ Compatible with various **Telegram** versions and platforms
- ⭐ Provides real-time email scraping for up-to-date contact information
- ⭐ Includes robust data security measures to protect user privacy
- ⭐ **Customizable** settings to adapt to different scraping requirements
- ⭐ Offers detailed logs and reports for tracking scraping activities
- ⭐ Supports integration with third-party tools for seamless data management

### How to use **Telegram** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Telegram** emails today:

1. ✅ Download and install the **Telegram** Email Scraper software on your device
2. ✅ Log in to your **Telegram** account through the scraper tool
3. ✅ **Select** the target **Telegram** group or channel you wish to scrape emails from
4. ✅ **Configure** the scraping settings including filters and output format
5. ✅ **Start** the scraping process and allow the tool to collect email addresses
6. ✅ Monitor the progress of the scraping process through the tools dashboard
7. ✅ **Export** the extracted data to your preferred format such as CSV or JSON
8. ✅ **Review** and organize the extracted email list for your specific needs
9. ✅ Repeat the process for additional groups or channels if necessary
10. ✅ Ensure compliance with legal and ethical guidelines when using the data

### Use Cases 🎯

Marketing Campaigns
🎯 Generate targeted email lists for promotional campaigns
🎯 Reach out to potential customers from specific **Telegram** groups

Research and Analysis
🎯 **Collect** email data for market research purposes
🎯 **Analyze** user engagement in **Telegram** channels

Networking Opportunities
🎯 Connect with professionals in your industry through **Telegram** groups
🎯 Build a contact list for collaboration or partnerships

Lead Generation
🎯 **Identify** potential leads from **Telegram** communities
🎯 Expand your business outreach with targeted email lists

### Why choose us? 💎

Our **Telegram** Email Scraper stands out as the **best** **Telegram** email scraper tool due to its efficiency, accuracy, and **user-friendly** design. It is specifically developed to cater to a wide range of users, from marketers to researchers, ensuring that everyone can benefit from its features.

With **advanced** filtering options and real-time scraping capabilities, this tool allows you to extract only the most relevant data. We prioritize user privacy and data security, implementing robust measures to protect your information.

Our software is compatible with various **Telegram** platforms and versions, making it versatile and adaptable. Additionally, we offer excellent customer support to assist you with any questions or issues.

By choosing our **Telegram** email extraction software, you gain access to a **reliable** and efficient solution for all your email scraping needs. Whether you are looking to extract emails from **Telegram** groups or generate email lists, our tool is designed to deliver exceptional results.

### **Telegram** Email Scraper Scalability 📈

The **Telegram** Email Scraper is built to handle projects of any size, making it a scalable solution for email extraction. Whether you need to scrape emails from a single **Telegram** group or multiple channels, the tool can accommodate your requirements.

Its **advanced** algorithms ensure **efficient** data collection, even for **large-scale** scraping tasks. The software is optimized to process high volumes of data without compromising on speed or accuracy.

With **customizable** settings, you can tailor the scraping process to suit your specific needs. This makes it an ideal choice for businesses, researchers, and marketers seeking to extract large amounts of email data.

By leveraging the scalability of our **Telegram** email scraping tool, you can achieve your goals **efficient**ly and effectively.

### **Telegram** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Telegram** is **legal** as long as you follow **ethical** and **compliant** practices. The **Telegram** Email Scraper extracts only **publicly available** information from **public** **Telegram** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** you have proper permissions to scrape data from **Telegram** groups or channels
⚖️ **Do not** use the tool to collect data from private groups without consent
⚖️ **Avoid** using the extracted data for spamming or unsolicited marketing purposes
⚖️ Comply with all relevant data protection laws and regulations such as GDPR
⚖️ Respect the privacy of **Telegram** users and handle their data responsibly
⚖️ **Do not** share or sell the extracted data without proper authorization
⚖️ **Use** the tool only for ethical and legitimate purposes
⚖️ Regularly review and update your practices to align with legal requirements

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Telegram Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Telegram",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails 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 Email 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",
    "email": "before@gmail.com"
  }
]
```

### Output Table

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

### FAQ ❓

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

The Telegram Email Scraper is a tool designed to extract email addresses and other relevant data from Telegram groups and channels.

#### Can I use the tool for **private** Telegram groups?

**Yes**, but only if you have proper permissions or access to the private group.

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

The tool supports exporting data in formats such as **CSV** and **JSON**.

#### Is the Telegram **Email Scraper** easy to use?

**Yes**, the tool features a **user-friendly** interface suitable for users of all technical skill levels.

#### Can I scrape data from multiple Telegram groups?

**Yes**, the tool allows you to scrape data from multiple groups or channels.

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

**Yes**, the Telegram Email Scraper is compatible with various Telegram versions and platforms.

#### Does the tool offer filtering options?

**Yes**, you can configure filters to target specific groups or keywords.

#### Is the **extract**ed data **secure**?

**Yes**, the tool includes robust data security measures to protect user privacy.

#### Can I use the tool for marketing purposes?

**Yes**, but ensure **compliance** with legal and ethical guidelines when using the data.

#### What support is available for the tool?

We offer customer support to assist with any questions or issues related to the tool.

#### How accurate is the email **extract**ion process?

The tool is designed to ensure high accuracy and minimize duplicate entries.

#### Can I scrape emails in real-time?

**Yes**, the tool provides real-time scraping capabilities for up-to-date data.

#### Are there any restrictions on the number of emails I can **extract**?

**No**, the tool is scalable and can handle projects of any size.

#### Do I need technical skills to use the tool?

**No**, the Telegram Email Scraper is designed to be **user-friendly** and requires no advanced technical skills.

#### Is the tool **legal** to use?

**Yes**, as long as you comply with legal and ethical guidelines, the tool is legal to use.

# 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("scraper-engine/telegram-email-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("scraper-engine/telegram-email-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 scraper-engine/telegram-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telegram Email Scraper",
        "description": "Telegram Email Scraper extracts publicly available email addresses from Telegram profiles, groups, and channels. Build targeted contact lists by niche or region. Ideal for marketers and sales teams running outreach campaigns.",
        "version": "0.1",
        "x-build-id": "6DOCfIGKemJvf83IC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~telegram-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-telegram-email-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/scraper-engine~telegram-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-telegram-email-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/scraper-engine~telegram-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-telegram-email-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```