# X / Twitter Email Scraper (`scrapapi/x-twitter-email-scraper`) Actor

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

## Pricing

from $2.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **Twitter** Email Scraper 📱

The X / **Twitter** Email Scraper allows users to **extract** publicly available email addresses from **Twitter** profiles. This tool focuses on gathering **contact** information that users have shared on their profiles or tweets.

It can also retrieve additional meta**data** associated with the profiles to provide more context for the **extract**ed **data**. The **Twitter** **contact** scraper is designed to ensure high accuracy and relevance in the **data** it collects.

By automating the email **extract**ion process, it eliminates the need for manual searches and **data** entry. This makes it an ideal solution for businesses, researchers, and marketers who need reliable **contact** information.

The **data** is presented in a structured format, making it easy to integrate into your existing systems or workflows. With the ability to scrape **emails** from **Twitter** profiles at scale, this tool is a valuable asset for any **data**-driven project.

X / Twitter Email Scraper is a powerful tool designed to extract publicly available email addresses from Twitter profiles efficiently. It enables businesses, researchers, and marketers to gather contact information for outreach purposes seamlessly.

With the X platform email scraping tool, users can automate the process of finding email addresses associated with Twitter accounts. This saves time and eliminates the need for manual data collection.

The Twitter email extractor is ideal for those looking to build contact lists, conduct market research, or enhance their networking efforts. It is designed to work quickly and accurately to deliver reliable results.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract publicly available email addresses from Twitter profiles. |
| Profile names | Retrieve the names associated with the Twitter accounts. |
| Usernames | Collect the Twitter handles of the targeted profiles. |
| Bio information | Extract bio details shared by users on their profiles. |
| Profile URLs | Get direct links to the Twitter profiles for reference. |
| Location data | Retrieve location details if shared on the profiles. |
| Follower count | Collect the number of followers for each profile. |
| Profile creation date | Extract the date when the Twitter account was created. |

### 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** extraction of publicly available email addresses from **Twitter** profiles
- ⭐ User-friendly interface for easy configuration and operation
- ⭐ **High** accuracy and relevance in the data collected from **Twitter** profiles
- ⭐ Ability to scrape emails from **Twitter** accounts at scale for large projects
- ⭐ Structured data output for seamless integration into existing workflows
- ⭐ Support for additional metadata extraction such as profile names and bios
- ⭐ **Customizable** scraping parameters to target specific profiles or keywords
- ⭐ Compliance with ethical guidelines and data privacy regulations
- ⭐ **Fast** and efficient scraping process to save time and resources
- ⭐ Real-time data extraction with minimal manual intervention required
- ⭐ **Secure** handling of extracted data to ensure user privacy and safety
- ⭐ **Regular** updates and support to maintain compatibility with **Twitter**s platform

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

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

1. ✅ Log in to your Apify account or create a new account if you dont have one
2. ✅ Search for the X  **Twitter** Email Scraper in the Apify Store and open the actor page
3. ✅ Click on the Try for Free button to start using the scraper
4. ✅ **Configure** the input settings by specifying the target profiles keywords or hashtags
5. ✅ Set additional parameters such as the number of profiles to scrape or metadata to include
6. ✅ **Start** the scraper and wait for the process to complete
7. ✅ Download the extracted data in your preferred format such as CSV or JSON
8. ✅ **Integrate** the data into your existing tools or systems for further analysis or outreach

### Use Cases 🎯

Marketing and Outreach
🎯 Build targeted email lists for marketing campaigns
🎯 **Identify** potential leads and contacts for outreach efforts
🎯 Enhance networking opportunities by accessing public contact information

Market Research
🎯 **Analyze** **Twitter** profiles for trends and patterns
🎯 Gather data for competitor analysis and industry insights
🎯 Understand audience demographics and preferences through profile metadata

Academic and Research Projects
🎯 **Collect** data for social media studies and research papers
🎯 **Analyze** public behavior and communication trends on **Twitter**
🎯 Support data-driven academic initiatives with reliable information

Business Development
🎯 **Identify** potential partners or collaborators through **Twitter** profiles
🎯 Expand business networks by accessing publicly shared contact details
🎯 Streamline the process of finding relevant contacts for business growth

### Why choose us? 💎

The X / **Twitter** Email Scraper is a **reliable** and efficient tool for extracting publicly available email addresses from **Twitter** profiles. It is designed to provide accurate and relevant data to meet the needs of businesses, researchers, and marketers.

With its **user-friendly** interface and robust features, this tool simplifies the process of collecting contact information from **Twitter**. It ensures compliance with ethical guidelines and data privacy regulations, giving users peace of mind.

The **Twitter** email extractor offers scalability, allowing users to scrape data from a large number of profiles efficiently. It also supports additional metadata extraction, providing more context for the collected information.

Regular updates and dedicated support ensure that the tool remains compatible with **Twitter**'s platform and continues to deliver high-quality results. Whether you need to build email lists, conduct market research, or enhance your networking efforts, the X platform email scraping tool is the ideal solution for your data collection needs.

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

The X / **Twitter** Email Scraper is designed to handle data extraction at scale, making it suitable for projects of all sizes. Whether you need to scrape a few profiles or thousands, this tool can manage the workload **efficient**ly.

It offers **customizable** settings to target specific profiles, keywords, or hashtags, ensuring that you get the data you need. The scraper operates quickly and accurately, minimizing the time required for **large-scale** data collection.

Its structured data output makes it easy to integrate the extracted information into your existing systems or workflows. With its robust infrastructure and regular updates, the X email extraction software can adapt to the growing demands of your projects.

This ensures that you can rely on the tool for consistent and reliable performance, even as your data collection needs evolve.

### **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** that you only scrape publicly available information from **Twitter** profiles
⚖️ **Do not** use the extracted data for spamming or other unethical practices
⚖️ Comply with **Twitter**s terms of service and data usage policies at all times
⚖️ **Obtain** consent from individuals before using their contact information for outreach
⚖️ **Avoid** scraping sensitive or private information that is not publicly accessible
⚖️ **Use** the tool responsibly and for legitimate purposes only
⚖️ **Ensure** compliance with data privacy regulations such as GDPR and CCPA
⚖️ Regularly review and adhere to changes in **Twitter**s platform policies

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["X / 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": "X / 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 (X / Twitter Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Twitter profile link |
| email | Extracted email address |

### FAQ ❓

#### What is the X / Twitter **Email Scraper**?

The X / Twitter Email Scraper is a tool designed to extract **publicly available** email addresses and metadata from Twitter profiles.

#### Can I scrape **private** information with this tool?

**No**, the tool only extracts **publicly available** information from Twitter profiles.

#### Is the X / Twitter **Email Scraper** compliant with Twitter's policies?

**Yes**, the scraper is designed to comply with Twitter's terms of service and data usage policies.

#### What data formats are supported for **export**?

The extracted data can be exported in formats such as **CSV** and **JSON**.

#### Can I customize the scraping parameters?

**Yes**, you can configure the input settings to target specific profiles, keywords, or hashtags.

#### How many profiles can I scrape at once?

The tool is scalable and can handle data extraction from a large number of profiles efficiently.

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

**Yes**, the X / Twitter Email Scraper features a **user-friendly** interface for easy operation.

#### What additional metadata can be **extract**ed?

The scraper can extract profile names, usernames, bios, follower counts, and more.

#### Is the **extract**ed data **secure**?

**Yes**, the tool ensures **secure** handling of extracted data to protect user privacy.

#### Does the tool support real-time data **extract**ion?

**Yes**, the scraper provides real-time data extraction with minimal manual intervention.

#### Can I use the tool for market research?

**Yes**, the Twitter email extractor is ideal for market research and data analysis.

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

**Yes**, **regular updates** and **dedicated support** are provided to ensure compatibility and performance.

#### Can I scrape emails from **specific** hashtags or keywords?

**Yes**, the tool allows you to target specific hashtags or keywords for data extraction.

#### Is the tool compatible with all Twitter accounts?

The scraper works with publicly accessible Twitter profiles and data.

#### What happens if Twitter updates its platform?

The tool is regularly updated to maintain 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("scrapapi/x-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("scrapapi/x-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 scrapapi/x-twitter-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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