# Twitch Email Scraper (`scraperx/twitch-email-scraper`) Actor

📧 Twitch Email Scraper extracts email addresses from Twitch profiles quickly and accurately. 🚀 Great for creator outreach, lead generation, and B2B research—save time, streamline targeting, and improve campaign results. 🔥

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

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **Twitch** Email Scraper 📱

**Twitch** Email Scraper enables users to **extract** essential **contact** information from **Twitch** profiles. It focuses on gathering publicly available **data**, ensuring compliance with privacy regulations.

The tool is designed to retrieve **emails** associated with **Twitch** users who have made their **contact** details accessible. This **data** can be used for marketing campaigns, influencer outreach, or audience analysis.

In addition to email addresses, the tool can also collect supplementary profile information to provide context. By automating the **data** collection process, **Twitch** Email Scraper ensures efficiency and accuracy.

It is a valuable resource for businesses, researchers, and marketers aiming to connect with **Twitch** users.

Twitch Email Scraper is a powerful tool designed to extract email addresses from Twitch profiles efficiently and securely. It helps users access valuable contact information for networking, marketing, or research purposes.

With Twitch being a leading platform for streamers and content creators, extracting emails can help businesses and individuals connect with relevant audiences. This tool simplifies the process and ensures accurate results.

Using an automated Twitch email scraping tool saves time and effort compared to manual data collection. It provides a streamlined solution for gathering user contact details legally and responsibly.

### 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 publicly available email addresses from Twitch profiles. |
| Usernames | Retrieve Twitch usernames for identification and outreach purposes. |
| Profile descriptions | Collect profile bios to understand user interests and content focus. |
| Follower count | Gather follower statistics to evaluate user popularity and influence. |
| Profile links | Extract direct links to Twitch profiles for easy access. |
| Streaming categories | Identify the categories users stream in to target specific niches. |
| Social media links | Retrieve links to external social media accounts shared by Twitch users. |
| Location information | Collect location details if publicly available on profiles. |

### Key Features of **Twitch** Email Scraper

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

- ⭐ **Automated** data extraction ensures efficient and accurate results
- ⭐ Supports scraping of publicly available email addresses from **Twitch** profiles
- ⭐ Includes additional profile data such as usernames bios and follower counts
- ⭐ User-friendly interface simplifies the setup and usage process
- ⭐ **Customizable** scraping parameters allow targeting specific niches or categories
- ⭐ Ensures compliance with legal and ethical guidelines for data collection
- ⭐ Provides detailed data reports for analysis and decision-making
- ⭐ **High**ly scalable tool capable of handling large datasets efficiently
- ⭐ Offers robust security measures to protect user data during scraping
- ⭐ Compatible with various operating systems and platforms for flexibility
- ⭐ **Regular** updates ensure optimal performance and feature enhancements
- ⭐ 247 customer support available to assist with any issues or queries

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

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

1. ✅ Download and install the **Twitch** Email Scraper software on your system
2. ✅ Launch the tool and **log in** using your credentials
3. ✅ **Configure** scraping parameters such as target categories or user profiles
4. ✅ Set filters to specify the type of data you want to extract such as emails or follower counts
5. ✅ **Start** the scraping process and monitor progress through the interface
6. ✅ Once completed export the extracted data in your preferred format such as CSV or Excel
7. ✅ **Review** the data to ensure accuracy and completeness
8. ✅ Use the extracted information for your intended purpose such as outreach or analysis

### Use Cases 🎯

Influencer Outreach
🎯 **Identify** **Twitch** influencers in specific categories
🎯 Extract contact details for collaboration opportunities
🎯 Streamline communication with potential partners

Marketing Campaigns
🎯 Build targeted email lists for promotional campaigns
🎯 **Analyze** user profiles to tailor marketing strategies
🎯 Reach out to **Twitch** users who fit your audience criteria

Audience Analysis
🎯 Understand **Twitch** user demographics and interests
🎯 Evaluate follower counts to gauge influencer impact
🎯 **Collect** data to refine audience targeting

Research and Insights
🎯 Gather data for academic or market research purposes
🎯 **Analyze** streaming categories to identify trends
🎯 **Study** user profiles for behavioral insights

### Why choose us? 💎

**Twitch** Email Scraper is a trusted solution for extracting emails and other profile data from **Twitch** efficiently. Our tool is designed with user-friendliness and accuracy in mind, ensuring a seamless experience for all users.

We prioritize compliance with legal and ethical guidelines, offering a responsible approach to data collection. Our software is equipped with **advanced** features to customize scraping parameters and target specific niches.

With robust security measures, we protect your data during the extraction process. Our team provides **regular** updates to enhance functionality and ensure compatibility with **Twitch**'s evolving platform.

Whether you're a marketer, researcher, or business owner, our tool is tailored to meet your needs. We offer 24/7 customer support to assist with any issues or queries.

Choose **Twitch** Email Scraper for **reliable**, **scalable**, and compliant email harvesting.

### **Twitch** Email Scraper Scalability 📈

**Twitch** Email Scraper is built to handle data extraction at scale without compromising performance. Whether you need to scrape a small list of profiles or thousands of users, our tool delivers consistent results **efficient**ly.

It is optimized for large datasets, ensuring quick processing and accurate data retrieval. Users can customize parameters to focus on specific categories or niches, enhancing scalability for diverse needs.

Our software is designed to adapt to growing demands, making it suitable for businesses of all sizes. With robust infrastructure, **Twitch** Email Scraper ensures smooth operation even during intensive scraping tasks.

By leveraging **advanced** technology, we provide a scalable solution for **Twitch** data extraction.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Twitch**s terms of service when using the tool
⚖️ **Only** scrape publicly available data from **Twitch** profiles
⚖️ **Do not** use the tool to collect sensitive or private information without consent
⚖️ **Avoid** using the extracted data for spamming or unethical practices
⚖️ Respect user privacy and adhere to relevant data protection laws
⚖️ **Use** the tool responsibly and for legitimate purposes only
⚖️ Consult legal experts if unsure about the legality of specific use cases
⚖️ Regularly review **Twitch**s policies to stay updated on permissible activities

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Twitch Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Twitch",
  "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 (Twitch) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Twitch",
    "keyword": "Twitch 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 Twitch as the source |
| keyword | Keyword that triggered the result (Twitch Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Twitch profile link |
| email | Extracted email address |

### FAQ ❓

#### Is Twitch **Email Scraper** **legal** to use?

**Yes**, as long as you comply with Twitch's terms of service and only scrape **publicly available** data.

#### Can I **extract** **private** emails using this tool?

**No**, the tool only retrieves publicly accessible email addresses from Twitch profiles.

#### Does the tool work for all Twitch profiles?

It works for profiles that have publicly shared their contact information.

#### What formats can I **export** the data in?

You can export the data in formats like **CSV** or Excel for easy analysis.

#### Is the tool easy to use for **beginners**?

**Yes**, Twitch Email Scraper features a **user-friendly** interface for **seamless** operation.

#### Can I customize scraping parameters?

**Yes**, you can set filters to target specific categories or types of data.

#### Is **customer support** available?

**Yes**, we offer 24/7 customer support to assist with any issues or queries.

#### How often is the tool updated?

We provide **regular updates** to ensure optimal performance and compatibility.

#### Does the tool support **large-scale** data **extract**ion?

**Yes**, Twitch Email Scraper is designed to handle large datasets efficiently.

#### What security measures are in place?

The tool includes robust security features to protect user data during scraping.

#### Can I use the tool for influencer outreach?

**Yes**, it is ideal for extracting contact details for collaboration opportunities.

#### Is the tool compatible with all operating systems?

**Yes**, Twitch Email Scraper works on various platforms for flexibility.

#### What is the pricing model for the tool?

Please visit our website for detailed pricing information and plans.

#### Can I scrape social media links from Twitch profiles?

**Yes**, the tool can retrieve social media links shared by Twitch users.

#### Does the tool comply with data protection laws?

**Yes**, Twitch Email Scraper is designed to adhere to relevant legal guidelines.

# Actor input Schema

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

List of keywords to search for on Twitch (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Twitch 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": "Twitch",
  "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("scraperx/twitch-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("scraperx/twitch-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 scraperx/twitch-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Email Scraper",
        "description": "📧 Twitch Email Scraper extracts email addresses from Twitch profiles quickly and accurately. 🚀 Great for creator outreach, lead generation, and B2B research—save time, streamline targeting, and improve campaign results. 🔥",
        "version": "0.1",
        "x-build-id": "QteliXGeVh24Y7kt1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~twitch-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-twitch-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/scraperx~twitch-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-twitch-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/scraperx~twitch-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-twitch-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 Twitch (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Twitch profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Twitch"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Twitch"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```