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

- **URL**: https://apify.com/scrapapi/twitch-email-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

from $2.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** publicly available **contact** information from **Twitch** profiles. This **data** includes email addresses, usernames, and other relevant details that are accessible on the platform.

By automating the **extract**ion process, users can save time and effort while building targeted email lists. The tool is designed to ensure compliance with legal and ethical guidelines, making it a safe and reliable solution for scraping **Twitch** user **data**.

Extracted **data** can be used for marketing campaigns, research, or networking purposes, depending on your goals. With its advanced capabilities, **Twitch** Email Scraper provides accurate and organized **data** that can be easily integrated into your workflows.

Twitch Email Scraper is a powerful tool designed to help users extract contact information from Twitch profiles efficiently. It is ideal for businesses, marketers, and researchers aiming to connect with Twitch content creators.

With Twitch Email Scraper, you can automate the process of gathering email addresses from Twitch users, saving time and reducing manual effort. This tool is perfect for generating targeted email lists for outreach campaigns.

Twitch has become a hub for creators and influencers, making it a valuable platform for networking and collaboration. Twitch Email Scraper simplifies the process of finding contact details for these users.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@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 URLs | Collect profile links to access additional user information. |
| Follower count | Gather data on the number of followers for each Twitch user. |
| Stream categories | Identify the categories or genres of streams hosted by users. |
| Location data | Extract location details if publicly shared by Twitch users. |
| Profile bios | Scrape biographical information from user profiles. |
| Social media links | Collect links to social media accounts shared on Twitch 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** extraction of publicly available **Twitch** user emails
- ⭐ Supports scraping usernames and profile URLs for detailed insights
- ⭐ Ability to gather follower count and stream category data
- ⭐ Extracts location data if shared by **Twitch** users publicly
- ⭐ Collects profile bios and social media links from **Twitch** profiles
- ⭐ Ensures compliance with legal and ethical standards during scraping
- ⭐ Provides organized and exportable data formats for easy integration
- ⭐ Offers scalable solutions for large-scale **Twitch** email scraping projects
- ⭐ User-friendly interface for seamless operation and setup
- ⭐ **Advanced** filtering options to target specific **Twitch** user groups
- ⭐ **Regular** updates to ensure compatibility with **Twitch** platform changes
- ⭐ **High**ly secure and efficient data extraction processes

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

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

1. ✅ Download and install **Twitch** Email Scraper on your device
2. ✅ Log in to the tool using your credentials to access its features
3. ✅ Enter the **Twitch** profile URLs or keywords to begin scraping data
4. ✅ Specify the data types you want to extract such as emails or usernames
5. ✅ Set filters to target specific users based on categories or follower counts
6. ✅ **Start** the scraping process and monitor progress in real-time
7. ✅ **Export** the extracted data into your preferred format such as CSV or Excel
8. ✅ **Review** the data to ensure accuracy and completeness before use
9. ✅ **Integrate** the scraped data into your marketing or research workflows
10. ✅ Adjust settings to optimize scraping speed and accuracy for future use
11. ✅ Use advanced features like scheduling for automated scraping tasks
12. ✅ Ensure compliance with legal guidelines while using the extracted data

### Use Cases 🎯

Marketing and Outreach
🎯 Generate targeted email lists for **Twitch** influencers
🎯 Reach out to content creators for brand collaborations

Research and Analysis
🎯 **Study** **Twitch** user demographics and follower trends
🎯 **Analyze** stream categories for market insights

Networking and Collaboration
🎯 **Identify** potential partners for **Twitch**-based projects
🎯 Connect with creators for joint streaming events

Event Promotion
🎯 Invite **Twitch** users to participate in online events
🎯 Promote gaming tournaments to relevant **Twitch** creators

### Why choose us? 💎

**Twitch** Email Scraper stands out as the **best** **Twitch** scraper software due to its **advanced** features and reliability. It is designed to streamline the process of extracting **Twitch** user contacts, ensuring efficiency and accuracy.

Our tool offers automated **Twitch** email scraping capabilities, saving users time and effort compared to manual methods. With robust filtering options, users can target specific **Twitch** user groups based on categories or follower counts.

We prioritize user privacy and legal compliance, ensuring that all scraped data is obtained ethically and within platform guidelines. Our software is **regular**ly updated to adapt to changes in **Twitch**'s structure, guaranteeing consistent performance.

Whether you need to scrape **Twitch** emails for marketing, research, or networking, **Twitch** Email Scraper provides a comprehensive solution tailored to your needs. Choose us for **scalable**, secure, and **user-friendly** email scraping for **Twitch**.

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

**Twitch** Email Scraper is designed to handle projects of any size, making it suitable for both small-scale and **large-scale** data extraction needs. Whether you need to extract a few contacts or generate **extensive** **Twitch** email lists, our tool offers scalable solutions.

Its **advanced** features ensure **efficient** performance even when scraping thousands of profiles simultaneously. Users can customize settings to optimize scraping speed and accuracy based on project requirements.

With automated scheduling, you can set up recurring scraping tasks for continuous data collection. Our software is built to adapt to growing demands, ensuring reliable performance as your needs expand.

**Twitch** Email Scraper is the ideal choice for businesses and researchers seeking scalable **Twitch** email extraction solutions.

### **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 scraper
⚖️ **Only** extract publicly available data shared by **Twitch** users
⚖️ **Do not** use scraped data for spam or unsolicited communication
⚖️ Respect user privacy and avoid collecting sensitive information
⚖️ Verify the legality of email scraping in your jurisdiction before use
⚖️ **Use** extracted data ethically and for legitimate purposes only
⚖️ **Avoid** scraping **Twitch** profiles that explicitly restrict data access
⚖️ Regularly review legal updates related to data scraping practices

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

#### What is Twitch **Email Scraper**?

Twitch Email Scraper is a tool designed to extract **publicly available** contact information from Twitch profiles.

#### How does Twitch **Email Scraper** work?

It automates the process of gathering data like **emails**, usernames, and profile URLs from Twitch users.

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

**Yes**, it complies with legal guidelines by extracting **publicly available** data only.

#### Can I use Twitch **Email Scraper** for marketing?

**Yes**, it is ideal for generating targeted email lists for marketing campaigns.

#### Does Twitch **Email Scraper** support **large-scale** projects?

**Yes**, it offers scalable solutions for both small and large-scale data extraction.

#### What data types can I **extract** with Twitch **Email Scraper**?

You can extract **emails**, usernames, profile URLs, follower counts, stream categories, and more.

#### Is the tool user-friendly?

**Yes**, Twitch Email Scraper features a simple interface for **seamless** operation.

#### How do I ensure compliance with **legal** guidelines?

Follow ethical practices and only extract **publicly available** data shared by Twitch users.

#### Can I **export** the **extract**ed data?

**Yes**, you can export data in formats like **CSV** or Excel for easy integration.

#### Does Twitch **Email Scraper** offer filtering options?

**Yes**, it provides advanced filters to target specific Twitch user groups.

#### Is the tool regularly updated?

**Yes**, it is updated to ensure compatibility with Twitch platform changes.

#### Can I automate scraping tasks?

**Yes**, you can schedule recurring tasks for continuous data collection.

#### What are the main use cases for Twitch **Email Scraper**?

It is used for marketing, research, networking, and event promotion.

#### Does Twitch **Email Scraper** prioritize user privacy?

**Yes**, it ensures **compliance** with privacy regulations and ethical standards.

#### How do I get started with Twitch **Email Scraper**?

Download and install the tool, then follow the step-by-step instructions to begin scraping.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Email Scraper",
        "version": "0.1",
        "x-build-id": "8SASMXT6sLtobMxm4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~twitch-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~twitch-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~twitch-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```