# Twitter Email Scraper (`scraper-engine/twitter-email-scraper`) Actor

Twitter Email Scraper extracts publicly available email addresses from Twitter profiles, bios, and linked pages. Build targeted contact lists by keyword or niche. Ideal for marketers, agencies, and founders running outreach campaigns.

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **Twitter** Email Scraper 📱

**Twitter** Email Scraper allows users to **extract** valuable **contact** information from public **Twitter** profiles. The tool focuses on gathering email addresses, which are essential for outreach and communication.

It also collects additional **data** such as profile names, usernames, and bio details to provide context for the **extract**ed **emails**. The scraper ensures that all collected **data** is organized and ready for use in marketing campaigns, research projects, or networking efforts.


### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract email addresses listed in public Twitter profiles. |
| Profile names | Retrieve the full names associated with Twitter profiles. |
| Usernames | Collect Twitter usernames for identification and outreach. |
| Bio information | Extract bio details to understand user interests or affiliations. |
| Location data | Gather location information shared by Twitter users. |
| Profile URLs | Retrieve direct links to Twitter profiles for reference. |
| Follower count | Extract follower counts to assess profile influence. |
| Profile images | Download profile pictures for visual identification. |

### Key Features of **Twitter** Email Scraper

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

- ⭐ **Automated** email extraction from public **Twitter** profiles
- ⭐ User-friendly interface for seamless operation
- ⭐ **Accurate** and reliable data collection with minimal errors
- ⭐ Ability to extract multiple data points beyond email addresses
- ⭐ **Customizable** scraping options to target specific profiles or criteria
- ⭐ **High**-speed data processing for efficient results
- ⭐ Export data in various formats for easy integration into workflows
- ⭐ **Secure** and compliant scraping methods to protect user privacy
- ⭐ **Regular** updates to ensure compatibility with **Twitter**s platform changes
- ⭐ Scalable solution for small to large-scale data extraction needs
- ⭐ Detailed documentation and support for users of all levels
- ⭐ **Advanced** filtering options to refine search results

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

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

1. ✅ **Sign up** or **log in** to your account on the **Twitter** Email Scraper platform
2. ✅ Navigate to the dashboard and select the **Twitter** email extraction tool
3. ✅ Enter the criteria for profiles you want to scrape such as keywords or hashtags
4. ✅ Set preferences for data types to be extracted including email addresses and other details
5. ✅ **Start** the scraping process and monitor progress through the dashboard
6. ✅ **Review** the extracted data once the process is complete to ensure accuracy
7. ✅ **Export** the data in your preferred format such as CSV or Excel
8. ✅ Use the extracted data for marketing research or networking purposes

### Use Cases 🎯

Marketing Campaigns
🎯 **Use** extracted emails to reach potential customers on **Twitter**
🎯 Build targeted email lists for promotional campaigns

Networking and Outreach
🎯 **Find** contact information for influencers and professionals
🎯 Connect with **Twitter** users for collaboration opportunities

Research and Analysis
🎯 Gather data for academic or market research purposes
🎯 **Analyze** **Twitter** profiles to understand user demographics

Business Development
🎯 **Identify** potential leads and partners on **Twitter**
🎯 Expand your business network using extracted contact details

### Why choose us? 💎

**Twitter** Email Scraper is the **best** solution for extracting emails from **Twitter** profiles efficiently and securely. Our tool combines **advanced** technology with a **user-friendly** design to ensure seamless operation for users of all levels.

With customizable scraping options, you can target specific profiles or criteria to meet your unique needs. The tool is built to deliver accurate and **reliable** results, minimizing errors and maximizing productivity.

We prioritize user privacy and compliance with legal guidelines to ensure ethical data collection. Regular updates keep the scraper compatible with **Twitter**'s platform changes, making it a dependable choice for businesses, marketers, and researchers.

Whether you're looking to build email lists, connect with influencers, or conduct research, our automated **Twitter** email scraper is tailored to help you achieve your goals effectively.

### **Twitter** Email Scraper Scalability 📈

**Twitter** Email Scraper is designed to handle data extraction tasks of any size, making it suitable for both small-scale and **large-scale** projects. The tool's high-speed processing capabilities ensure **efficient** results, even when scraping thousands of profiles.

With **customizable** options, users can scale their scraping efforts based on specific needs, whether targeting niche groups or broader audiences. Our platform supports **seamless** integration with other tools and workflows, allowing users to manage and utilize extracted data effectively.

Regular updates and robust infrastructure ensure the scraper remains reliable and **efficient** as your data extraction requirements grow. Whether you're a solo marketer or a large organization, **Twitter** Email Scraper adapts to your scalability needs effortlessly.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Twitter**s terms of service when using the scraper
⚖️ **Only** extract data from public profiles to respect user privacy
⚖️ **Avoid** using scraped data for unauthorized or unethical purposes
⚖️ **Do not** resell or distribute extracted data without proper permissions
⚖️ **Use** the tool responsibly and adhere to applicable data protection laws
⚖️ Regularly review legal and ethical guidelines to stay compliant

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

### Output Format 📤

📝 Example Output (JSON)

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

### 🔗 What are other Twitter (X) scraping tools?

If you want to scrape specific Twitter (X) data, you can use any of the dedicated scrapers below for faster and more targeted results.\
Just enter profile URLs, usernames, post links, keywords, or hashtags and start scraping instantly.

| [🔁 Twitter User Following Scraper](https://apify.com/scraper-engine/twitter-user-following-scraper) | [📈 Twitter Trends Scraper](https://apify.com/scraper-engine/twitter-trends-scraper) |
|---|---|
| [🐦 Twitter (X.com) Tweets & Profiles Scraper](https://apify.com/scraper-engine/twitter-x-scraper) | [👤 Twitter Profile Scraper](https://apify.com/scraper-engine/twitter-profile-scraper) |
| [📝 Twitter/X Posts Scraper](https://apify.com/scraper-engine/twitter-x-posts-scraper)| [💬 Twitter (X) Tweets Scraper](https://apify.com/scraper-engine/twitter-x-tweets-scraper-scraper) |
| [🔎 X (Twitter) Posts Search](https://apify.com/scraper-engine/x-twitter-posts-search) | [📞 Twitter Phone Number Scraper](https://apify.com/scraper-engine/twitter-phone-number-scraper) |
| [📨 Twitter Profile Email Scraper](https://apify.com/scraper-engine/twitter-profile-email-scraper) | [☎️ Twitter Profile Phone Number Scraper](https://apify.com/scraper-engine/twitter-profile-phone-number-scraper) |
| [📩 X Twitter Email Scraper](https://apify.com/scraper-engine/x-twitter-email-scraper) | [📱 X Twitter Phone Number Scraper](https://apify.com/scraper-engine/x-twitter-phone-number-scraper) |

### FAQ ❓

#### What is Twitter **Email Scraper**?

Twitter Email Scraper is a tool designed to extract email addresses and other data from public Twitter profiles.

#### How does the Twitter email **extract**ion tool work?

The tool automates the process of gathering email addresses and other details from Twitter profiles based on user-defined criteria.

#### Is the Twitter email scraping service **legal**?

**Yes**, the service is legal when used to extract data from public profiles and in **compliance** with Twitter's terms of service.

#### Can I scrape emails from **private** Twitter profiles?

**No**, the tool only extracts data from public profiles to respect user privacy and comply with legal guidelines.

#### What data can I **extract** using Twitter **Email Scraper**?

You can extract email addresses, profile names, usernames, bio information, location data, profile URLs, follower counts, and profile images.

#### Is the Twitter email finder software easy to use?

**Yes**, the tool features a **user-friendly** interface and detailed documentation to assist users of all levels.

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

**Yes**, you can export data in various formats, such as **CSV** or Excel, for easy integration into your workflows.

#### Is the scraper compatible with all Twitter profiles?

The scraper works with public Twitter profiles and adapts to platform changes through **regular updates**.

#### How **secure** is the Twitter contact scraper?

The tool uses **secure** methods to protect user data and ensures **compliance** with legal and ethical guidelines.

#### Do you offer support for the tool?

**Yes**, we provide detailed documentation and customer support to assist with any issues or questions.

#### Can I customize the scraping process?

**Yes**, the tool offers customizable options to target specific profiles or criteria for data extraction.

#### What industries can benefit from Twitter **Email Scraper**?

Industries such as marketing, research, business development, and networking can benefit from the tool.

#### How fast is the data **extract**ion process?

The tool is designed for high-speed data processing to deliver efficient results.

#### Is the tool scalable for large projects?

**Yes**, Twitter Email Scraper is scalable and can handle data extraction tasks of any size.

#### Do you update the tool regularly?

**Yes**, we provide **regular updates** to ensure compatibility with Twitter's platform changes.

# Actor input Schema

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

List of keywords to search for on Twitter (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Twitter 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": "Twitter",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/twitter-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/twitter-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/twitter-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitter Email Scraper",
        "description": "Twitter Email Scraper extracts publicly available email addresses from Twitter profiles, bios, and linked pages. Build targeted contact lists by keyword or niche. Ideal for marketers, agencies, and founders running outreach campaigns.",
        "version": "0.1",
        "x-build-id": "Vym0jLD4dPbeEfjSK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~twitter-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-twitter-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraper-engine~twitter-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-twitter-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraper-engine~twitter-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-twitter-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 Twitter (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Twitter profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Twitter"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Twitter"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```