# Advanced Twitch Email Scraper (`scrapevanta/advanced-twitch-email-scraper`) Actor

Twitch Email Scraper helps you extract publicly available email addresses and contact data from Twitch profiles at scale. Fast, advanced, and affordable, it's perfect for lead generation, influencer outreach, market research, and building targeted prospect lists with ease.

- **URL**: https://apify.com/scrapevanta/advanced-twitch-email-scraper.md
- **Developed by:** [ScrapeVanta](https://apify.com/scrapevanta) (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 $5.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 - Fast, Advanced and Cheapest ⚡

Searching for Twitch creator emails manually is slow, inconsistent, and kills outreach momentum. **Twitch Email Scraper - Fast, Advanced and Cheapest** pulls email addresses from Twitch at scale using your chosen keywords and email-domain filters. You’ll use it as a **Twitch email scraper** for lead generation, a **Twitch contacts email finder** for sales targeting, or a **Twitch creator email extractor** for influencer outreach. It’s ideal for marketers, data analysts, and researchers who need a ready-to-use Twitch email list builder. In one run, you can collect up to your configured email limit without constantly monitoring the process.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "network": "Twitch.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "hello@gmail.com"
}
````

What you’ll get in your dataset (Scraped Leads view):

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | The source network for the lead record (shown as `Twitch.com`). |
| `keyword` | string | The keyword (from your inputs) tied to the lead discovery. |
| `title` | string | The title text associated with the found listing/result. |
| `description` | string | The extracted text around the email (useful for review and context). |
| `url` | string | The associated URL for reference and validation. |
| `email` | string | The extracted email address (deduplicated across the run). |
| `status` | string | Not included as a dataset field by this actor (errors are handled by logging and the run continues where possible). |
| `error_message` | string | Not included as a dataset field by this actor (errors are logged; successful records are pushed to the dataset). |
| `max_emails` | integer | Not included per-record; controlled by the `maxEmails` input for the run. |
| `location` | string | Not included per-record; used only to influence which results are searched. |
| `customDomains` | array | Not included per-record; used only to filter which email domains to extract. |
| `timestamp` | string | Not included by this actor in pushed records. |
| `charged_event_name` | string | Not included in the dataset; internally set when pushing records (`charged_event_name="result"`). |

Export your full dataset as JSON, CSV, or Excel from the Apify dashboard.

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

```json
{
  "keywords": ["manager", "founder"],
  "location": "",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | Provide a list of keywords/queries. The actor uses each keyword to find Twitch-related public web data and extract matching emails. |
| `location` | ⬜ | Optional text filter to narrow results by location. Leave it empty to search without a location filter. |
| `customDomains` | ⬜ | Limits extracted emails to the domains you specify (for example `@gmail.com` or `@yahoo.com`). |
| `maxEmails` | ⬜ | Sets a maximum number of unique emails to collect. The actor stops when the limit is reached (it may collect fewer if results run out). |

***

### What It Does

This actor extracts email addresses from Twitch-related publicly available sources using your keywords and domain filters.

#### Extracts Twitch emails using your keywords

You control discovery by providing `keywords` (a list of terms/queries). The actor then extracts email addresses found in the matched results and ties each pushed record back to the originating `keyword`.

#### Filters emails by domains for cleaner outreach

With `customDomains`, you can focus on the email types you actually want (for example `@gmail.com` or other specific domains). This makes Twitch marketing email scraper workflows more targeted, helping reduce irrelevant emails.

#### Produces an integration-friendly dataset record

Every result pushed to the dataset includes `network`, `keyword`, `title`, `description`, `url`, and `email`. That structure is designed to be easy to review, deduplicate in downstream tools, and import directly into your lead pipeline.

#### Stops safely at your `maxEmails` limit

Use `maxEmails` (1–10000) to control how many unique emails the run collects. Setting a limit helps manage scraping time and cost by preventing the actor from continuing indefinitely.

#### Handles run continuation with progress saving

If a run is interrupted, the actor resumes using saved progress (keywords/domains cursor and the already `seen_emails` list). This is useful for long keyword/domain combinations when you’re building a Twitch email database tool over multiple attempts.

Overall, **Twitch Email Scraper - Fast, Advanced and Cheapest** turns Twitch email harvesting software work into a hands-off dataset you can use for outreach.

***

### Why Twitch Email Scraper - Fast, Advanced and Cheapest?

There are plenty of ways to pull contact data from the web—here’s why **Twitch Email Scraper - Fast, Advanced and Cheapest** stands out.

#### Keyword-and-domain control from day one

You’re not stuck with generic scraping. With `keywords` and `customDomains`, you can run a Twitch email lookup tool that’s aligned with your outreach strategy (like Twitch lead generation email scraper campaigns).

#### Fast enough for iterative lead research

Bigger searches take longer, but you can iterate quickly by changing keywords/domains and re-running. That makes the actor a solid choice when you need a fast Twitch email extraction tool for ongoing testing.

#### Built for practical lead collection at scale

The actor deduplicates emails using a `seen_emails` set and stops at `maxEmails` to keep runs predictable. You also get records pushed incrementally to the dataset, so you don’t lose everything if you stop or pause a run.

***

### Real-World Use Cases

Here's how different teams put **Twitch Email Scraper - Fast, Advanced and Cheapest** to work:

**Sales Development Teams**\
A SDR team needs Twitch creator email addresses for a weekly prospecting batch. They run the actor with role-focused `keywords` and domain filters in `customDomains`, then import the dataset fields (`email`, `url`, and `keyword`) into their CRM to start outreach faster.

**Influencer Marketing Managers**\
An influencer marketer building a campaign shortlist wants cleaner contacts than “random emails from the internet.” They use a tighter set of keywords and target-specific domains to reduce noise, then use the dataset to prioritize creators before writing tailored pitches.

**Freelance Researchers & Analysts**\
A researcher running lead discovery for multiple client briefs wants structured results, not spreadsheets full of junk. They collect data with consistent dataset fields and tie each email back to the driving `keyword`, making it easier to analyze which terms produce the best contact coverage.

**Automation & Data Pipeline Builders**\
A data engineer schedules runs and feeds results into downstream workflows. They rely on the actor’s stable pushed dataset schema—`keyword`, `title`, `description`, `url`, and `email`—so automated enrichment and deduplication steps can be built around predictable outputs.

**Growth Marketers**\
A growth team tests outreach angles for Twitch creator partnerships. They run multiple iterations with different keyword sets and email domains, compare results, and refine targeting until they see stronger response rates from their Twitch email list builder process.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open **Twitch Email Scraper - Fast, Advanced and Cheapest**.
2. **Enter your inputs** — add your `keywords` (required), optionally set `location`, choose `customDomains`, and set `maxEmails` if you want a cap.
3. **Configure proxy settings briefly** — in the Apify run UI, enable proxy settings if available for reliable scraping at scale.
4. **Start the run and watch the live log** — track progress in the Apify Logs to confirm emails are being found and pushed.
5. **Open the Dataset tab to see live results** — your dataset view (“Scraped Leads”) updates as records are pushed.
6. **Export your results** — download as JSON, CSV, or Excel from the dataset export options.
7. **Iterate for better coverage** — if you hit the limit early or get fewer emails than expected, expand your keyword coverage or add more domains.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, **Twitch Email Scraper - Fast, Advanced and Cheapest** fits directly into your existing workflow.

Export formats are available directly from the Apify dataset tab: **JSON, CSV, and Excel**. If you’re building a Twitch influencer email scraper process into reporting, this makes it easy to move results into BI tools or spreadsheets.

You can also automate downstream steps using Apify integrations such as **Zapier/Make**, or access the collected dataset via the **Apify API** and trigger your own pipeline. For larger operations, consider scheduled runs to refresh your Twitch email database tool on a cadence.

***

### Pricing

**Twitch Email Scraper - Fast, Advanced and Cheapest** runs on Apify, which includes a **free tier** — no credit card needed to start. Free tier usage gives you platform credits that are enough for several real test runs.

For heavier workloads, Apify uses pay-as-you-go billing based on Actor compute units (CU). There’s no per-row markup from this actor itself—your cost is tied to platform compute and your run configuration. Start free at <https://apify.com> — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Result volume control | Uses `maxEmails` to stop once your unique email cap is reached. |
| Resumable runs | Saves progress (cursor and `seen_emails`) so runs can continue after interruptions. |
| Duplicate prevention | Deduplicates by email using a `seen_emails` set. |
| Data delivery | Pushes results incrementally to the Apify dataset as they’re found. |
| Email-domain filtering | Uses `customDomains` to limit what emails are extracted. |
| Run continuation on issues | Errors are logged; successful records are still pushed as the run proceeds. |

**Limitations:** This actor only works with email addresses it can detect in publicly available data and cannot guarantee that every email you want will be found. If your keyword/domain coverage is too narrow, you may collect fewer emails than `maxEmails` before results run out.

For enterprise-scale needs or custom configurations, reach out and we’ll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. Apify offers a free tier with usage credits, which is typically enough for a few test runs. For larger Twitch lead generation email scraper workloads, you’ll likely need a paid plan.

#### Do I need to log in or create an account on Twitch?

No. The actor extracts emails from publicly available data and does not require a Twitch login or account access.

#### How accurate is the extracted data?

Accuracy depends on what the email is associated with in publicly available sources. The actor extracts email addresses that match the patterns implied by your `customDomains` filters and then stores them in the dataset fields like `email` and `url`.

#### How many results can I get per run?

You control the maximum number of unique emails using `maxEmails` (1–10000). If results run out before reaching your cap, the actor will stop early.

#### How fresh is the data?

Freshness depends on what’s currently available in the public sources the actor reads during the run. Each run reflects the state of those publicly available pages at the time the actor executes.

#### Is this legal? Does it comply with GDPR / CCPA?

You should treat this as GDPR/CCPA compliance responsibility on your side. The actor works with **publicly available data**, but you must ensure your use, storage, and outreach practices comply with GDPR, CCPA, applicable regulations, and Twitch-related terms.

#### Can I export to Google Sheets or Excel?

Yes. You can export the Apify dataset as JSON, CSV, or Excel from the dataset tab, then import it into Google Sheets or any spreadsheet tool.

#### Can I schedule this to run automatically?

Yes. You can schedule Apify actors to run automatically using Apify’s scheduling features. This is useful if you’re maintaining a rolling Twitch email list builder.

#### Can I access results via the API?

Yes. Apify supports accessing actor runs and datasets via the Apify API, so you can pull results programmatically into your systems.

#### What happens when the actor encounters an error?

Errors are logged, and the actor continues processing where possible. The actor also saves progress (including `seen_emails` and cursor state) so you can resume later instead of starting from scratch.

***

### Get Help & Use Responsibly

Got a question about Twitch Email Scraper - Fast, Advanced and Cheapest or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We’re happy to help you improve your keyword/domain targeting for faster Twitch contacts email finder results.

**publicly available data** only. The actor does not access private accounts, login-gated pages, or password-protected content. You’re responsible for GDPR, CCPA, and platform terms. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords or queries to search for.

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

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

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

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapevanta/advanced-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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapevanta/advanced-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": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scrapevanta/advanced-twitch-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Advanced Twitch Email Scraper",
        "description": "Twitch Email Scraper helps you extract publicly available email addresses and contact data from Twitch profiles at scale. Fast, advanced, and affordable, it's perfect for lead generation, influencer outreach, market research, and building targeted prospect lists with ease.",
        "version": "1.0",
        "x-build-id": "xpEivfZ95HibyANm2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapevanta~advanced-twitch-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapevanta-advanced-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/scrapevanta~advanced-twitch-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapevanta-advanced-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/scrapevanta~advanced-twitch-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapevanta-advanced-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 or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
