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

Twitch Email Scraper extracts publicly available email addresses, profile details, social links, follower counts, and contact information from Twitch channels. Perfect for lead generation, influencer outreach, creator discovery, market research, and building targeted prospect lists quickly.

- **URL**: https://apify.com/scrapevanta/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 ⚡

Finding emails for Twitch outreach can be painfully slow—copying bios one by one doesn’t scale. **Twitch Email Scraper** automatically scrapes emails from Twitch profiles using your chosen keywords and email-domain filters. It’s a **twitch email scraper** and **twitch email extractor** built for lead gen, creator outreach, and researcher workflows where you need contact details fast. This actor is ideal for growth teams, marketers, and analysts building a twitch creator email list at scale. In one run, you can collect up to your configured maximum number of emails and export immediately.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "network": "Twitch.com",
  "keyword": "founder",
  "title": "Example Twitch page title",
  "description": "Example page description text that includes john@gmail.com and related context",
  "url": "https://example.com/some-twitch-result",
  "email": "john@gmail.com",
  "proxyGroups": ["GOOGLE_SERP"]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network for the record (always Twitch.com in this actor). |
| `keyword` | string | The keyword that triggered finding this contact (useful for campaign tagging). |
| `title` | string | The page/result title associated with the extracted email—helps validate relevance. |
| `description` | string | The text snippet where the email was detected (great for manual review and notes). |
| `url` | string | The webpage URL that contains the email you can verify. |
| `email` | string | The extracted email address matching your domain filters. |
| `proxyGroups` | array | The proxy configuration reference used during the run (useful for debugging and traceability). |
| `status` | n/a | Not present in the pushed dataset rows by this actor (results are pushed as records when found). |
| `error_message` | n/a | Not present in the pushed dataset rows by this actor (errors are handled in logs). |
| `success` | n/a | Not present in the pushed dataset rows by this actor (no explicit success flag is pushed). |

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": ["founder", "marketing"],
  "location": "",
  "platform": "Twitch",
  "customDomains": ["@gmail.com"],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords the actor uses to search for Twitch-related content where emails may appear. |
| `location` | ⬜ | A location string used to filter search results. Leave it empty to avoid location filtering. |
| `platform` | ⬜ | Select platform. This actor supports `Twitch` (default: `Twitch`). |
| `customDomains` | ⬜ | A list of custom email domains to target (for example, `@gmail.com`). Only emails matching these domains are collected. |
| `maxEmails` | ⬜ | Upper limit for how many emails to collect before stopping. Higher limits can take longer and still may return fewer than requested. |
| `engine` | ⬜ | Chooses the scraping engine mode. `cost-effective` is the Cost Effective (New) option; `legacy` is the Legacy option. |
| `proxyConfiguration` | ⬜ | Proxy settings for this run (use Apify Proxy settings here if you want managed proxy support). |

***

### What It Does

**Twitch Email Scraper** searches publicly available Twitch-related pages using your `keywords`, then extracts matching email addresses from the text where they appear, filtered by your `customDomains`.

#### Extracts Twitch emails using your keyword + domain targeting

You provide a list of `keywords` and one or more `customDomains`. The actor collects email addresses that match those domains, helping you build a more relevant **twitch email database** for outreach.

#### Finds emails from public bios and related posts

The actor looks for emails in Twitch bios and posts related to your keywords. This makes it a practical **twitch email harvester** when your goal is “find twitch user emails” rather than manual browsing.

#### Stops at your `maxEmails` cap

You can set `maxEmails` to control how many unique emails to collect. The run stops once your limit is reached, which helps you manage time and costs while testing **twitch outreach email scraper** workflows.

#### Writes results to your dataset as they’re found

Each time an email is found, the actor pushes a record to your Apify dataset immediately. That means you don’t have to wait until the entire job finishes to start exporting or reviewing.

#### Includes progress tracking during the run

The actor persists progress (including a cursor and the set of `seen_emails`) while collecting results. If a run is interrupted, you can re-run with confidence rather than starting from zero every time.

#### Works with built-in proxy support for more reliable runs

You can configure proxy usage using the `proxyConfiguration` input, and you can choose between the `engine` options to fit your reliability and performance needs. This is helpful for large **twitch contact email scraper** jobs where stability matters.

Overall, **Twitch Email Scraper** turns keyword-driven discovery into export-ready contact records.

***

### Why Twitch Email Scraper?

There are plenty of ways to pull data from Twitch — here’s why **Twitch Email Scraper** stands out.

#### Domain filtering keeps your list relevant

By using `customDomains`, you avoid collecting unwanted emails and focus on domains that match your targeting strategy. This makes your **twitch streamer email scraper** output more usable for outreach lists.

#### Keyword-driven scraping for faster sourcing

Instead of copying bios by hand, **Twitch Email Scraper** uses your `keywords` to drive email discovery. It’s a straightforward approach for building a **twitch creator email list** quickly.

#### Stops cleanly using a hard results cap

`maxEmails` gives you practical control over how much you collect per run. That helps you run tighter experiments without committing to massive scrapes every time.

***

### Real-World Use Cases

Here's how different teams put **Twitch Email Scraper** to work:

**Sales Development Teams**\
SDRs often need to contact creators or communities but lack reliable emails. They run the actor with keywords like “founder” and target domains such as `@gmail.com`, then export results straight into their outreach workflow—saving hours of manual **twitch email mining tool** work.

**Influencer Marketing Managers**\
When building a creator shortlist for a campaign, marketers need contact details alongside relevance. They use **twitch email extractor** output to validate the email context using the `description` and `url`, ensuring the list matches their campaign theme.

**Freelance Researchers**\
Researchers collecting creator contact data for reports want consistency and traceability. They run **extract emails from twitch** using focused keywords and domain filters, then store the dataset with the provided `network`, `keyword`, and source `url`.

**Community & Partner Managers**\
Community managers look for partners and organizers who share contact info publicly. With **twitch email harvester** results, they can find emails tied to relevant Twitch bios and posts without spending days on scraping and cleaning.

**Automation Specialists (Developers / Data Engineers)**\
Developers need structured records to feed downstream systems. They trigger runs via Apify, then ingest dataset rows containing `email`, `url`, and `keyword` into their pipeline for enrichment and deduplication.

***

### 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 find **Twitch Email Scraper**.
2. **Enter your inputs** — set `keywords` (required), then add `customDomains` and optionally `location` and `maxEmails`.
3. **Choose your engine** — pick `engine` as either `legacy` or `cost-effective` depending on your needs.
4. **Configure proxy settings (optional but recommended for scale)** — fill `proxyConfiguration` if you want managed proxy support.
5. **Start the run and watch the live log** — monitor progress while emails are discovered and pushed.
6. **Open the Dataset tab** — records appear as results are found.
7. **Export your data** — download JSON/CSV/Excel from the dataset tab for analysis or outreach.

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** fits directly into your existing workflow.

Export formats are available directly from the Apify dataset: JSON, CSV, or Excel. You can review and validate entries using fields like `email`, `url`, and `description`.

For integrations, you can pull results programmatically via the Apify API, connect to tools using no-code options like Zapier/Make, and automate downstream steps using webhooks or scheduled runs (configured in Apify). For deeper details, refer to Apify’s official documentation for dataset export and API usage.

***

### Pricing

**Twitch Email Scraper** runs on Apify, which includes a **free tier** — no credit card needed to start.

On Apify, you’ll use free tier credits for initial tests, and then scale using Apify’s pay-as-you-go compute model (billed per Actor compute unit). For heavier workloads or frequent runs, use Apify plans suited to your volume. Start free at [apify.com](https://apify.com) — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Proxy support | You can configure `proxyConfiguration` and select an `engine` mode to match reliability needs. |
| Result limits | `maxEmails` caps how many unique emails to collect before stopping. |
| Resilient collecting behavior | The actor manages pagination flow and keeps progress during the run. |
| Data availability variability | If fewer matching emails exist for your keywords/domains, the actor may return fewer than `maxEmails`. |

**Limitations:** This actor only collects emails that are present in publicly available Twitch-related content. It cannot access private or login-gated information, and it can’t guarantee finding a specific number of emails for every keyword set.

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

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. Apify provides a free tier with credits for testing **twitch email scraper** runs before scaling up to paid usage.

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

No. This actor is designed to work with publicly available Twitch-related data. You only configure keywords and filters in Apify—no Twitch login is required for this workflow.

#### How accurate is the extracted data?

Accuracy depends on what’s actually published in Twitch bios and related content. The actor extracts emails that match your `customDomains`, and each record includes the `url` and `description` so you can verify context.

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

You can control the maximum using `maxEmails` (minimum 1, maximum 10000). The actor stops once that limit is reached, but it doesn’t guarantee reaching `maxEmails` if fewer matching emails are available.

#### How fresh is the data?

The results reflect what is publicly visible at the time of the run. If bios or posts change later, rerunning the actor can produce updated contact records.

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

Use responsibly. Since this tool collects **publicly available data**, it can help with legitimate research and outreach workflows, but compliance (including GDPR/CCPA and any applicable anti-spam rules) is ultimately your responsibility.

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

Yes. You can export your full dataset as JSON, CSV, or Excel from the Apify dashboard. From there, you can import into Google Sheets or other systems.

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

Yes. Apify supports scheduled runs for actors, so you can automate **twitch email extractor** jobs on a recurring basis through Apify’s scheduling features.

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

Yes. After the run finishes (or while you manage results through Apify), you can access dataset records programmatically using the Apify API.

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

If requests fail or scraping yields no results for certain pages, the actor handles these situations during the run and continues according to its pagination and retry behavior. You’ll see the details in the run logs, and the dataset will contain every successfully pushed record.

***

### Get Help & Use Responsibly

Got a question about **Twitch Email Scraper** or a feature you'd like added? Reach out to <dataforleads@gmail.com>. We’re happy to help with keyword/domain targeting improvements and practical ideas to better fit your **twitch outreach email scraper** workflow.

**Twitch Email Scraper** collects **publicly available data** from Twitch-related pages. It does not access private accounts, login-gated pages, or password-protected content. Please ensure your use of this data complies with GDPR, CCPA, platform Terms of Service, and applicable anti-spam laws. 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 to search for.

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

Location to filter search results.

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

Select platform.

## `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.

## `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`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Twitch",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapevanta/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 publicly available email addresses, profile details, social links, follower counts, and contact information from Twitch channels. Perfect for lead generation, influencer outreach, creator discovery, market research, and building targeted prospect lists quickly.",
        "version": "0.0",
        "x-build-id": "JwYBQN8eUJeOwlDf1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapevanta~twitch-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapevanta-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~twitch-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapevanta-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~twitch-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapevanta-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": "A list of keywords to search for.",
                        "default": [
                            "founder",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Twitch"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Twitch"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "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
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "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": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
