# Threads Email Scraper (`api-empire/threads-email-scraper`) Actor

Automate email extraction from Threads with Threads Email Scraper. The actor scans profiles and links to pull available contact emails into structured datasets for CRM enrichment and outreach automation.

- **URL**: https://apify.com/api-empire/threads-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

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

### **Social Media** Email Scraper 📱

Threads Email Scraper allows users to **extract** valuable email **data** from Threads profiles and posts. The tool is designed to capture publicly available information for marketing, networking, and lead generation purposes.

It can identify and collect email addresses from threads, comments, and user profiles, ensuring comprehensive **data** collection. This email **extract**or software is optimized for speed and accuracy, making it one of the best email scraping tools for Threads.

Users can also customize their scraping parameters to target specific **data** sets. The **extract**ed **data** can be exported in various formats, making it easy to integrate into existing workflows.

Threads Email Scraper is an essential tool for businesses and individuals looking to harness the potential of Threads for their communication needs.

Threads Email Scraper is a powerful tool designed to extract email addresses from Threads, enabling businesses and individuals to streamline communication efforts. It simplifies the process of gathering valuable contact information for marketing, networking, or lead generation purposes.

With the rise of Threads as a popular social media platform, finding ways to efficiently extract data has become essential. Threads Email Scraper offers a reliable solution for accessing email data without manual effort.

This email scraping tool is ideal for professionals looking to automate their data collection workflows. By leveraging Threads automation tools, users can save time and focus on more strategic tasks.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract email addresses from Threads profiles and posts. |
| Usernames | Capture usernames associated with the extracted emails. |
| Profile URLs | Collect the URLs of Threads profiles containing email addresses. |
| Post content | Retrieve text content from posts where emails are mentioned. |
| Comments | Extract email addresses mentioned in the comments section. |
| Timestamps | Record the time and date of posts or comments containing emails. |
| Hashtags | Identify hashtags used in posts where emails are found. |
| Custom fields | Capture additional user-defined data points from Threads. |

### Key Features of **Social Media** Email Scraper

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

- ⭐ **Automated** email extraction from Threads profiles and posts
- ⭐ **Customizable** scraping parameters for targeted data collection
- ⭐ **High**-speed data processing for efficient email extraction
- ⭐ **Accurate** identification of publicly available email addresses
- ⭐ Export data in multiple formats including CSV and JSON
- ⭐ User-friendly interface with minimal setup required
- ⭐ Built-in compliance with legal and ethical data scraping standards
- ⭐ Real-time data updates for the most recent information
- ⭐ **Advanced** filtering options to refine search results
- ⭐ **Secure** data handling to protect user privacy and integrity
- ⭐ Compatible with various operating systems and devices
- ⭐ **Comprehensive** support and documentation for easy usage

### How to use **Social Media** Email Scraper 🚀

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

1. ✅ Download and install the Threads Email Scraper on your device
2. ✅ Launch the tool and **log in** with your credentials
3. ✅ Enter the target Threads profile URLs or keywords to start scraping
4. ✅ Set your scraping parameters such as specific hashtags or post types
5. ✅ Click the **Start** button to begin the email extraction process
6. ✅ Monitor the scraping progress through the tools dashboard
7. ✅ **Review** the extracted data in the preview section for accuracy
8. ✅ **Export** the data in your preferred format such as CSV or JSON
9. ✅ **Integrate** the exported data into your CRM or email marketing tools
10. ✅ Adjust your scraping settings for future sessions as needed
11. ✅ Refer to the documentation or support team for any troubleshooting
12. ✅ Log out of the tool once you have completed your tasks

### Use Cases 🎯

Marketing Campaigns
🎯 **Collect** email addresses for targeted email marketing campaigns
🎯 **Identify** potential customers based on Threads activity and interests

Lead Generation
🎯 Build a database of leads from Threads profiles and posts
🎯 **Automate** the process of finding new business opportunities

Networking
🎯 Connect with professionals by extracting their contact information
🎯 Expand your professional network using Threads data

Market Research
🎯 **Analyze** user behavior and trends on Threads for business insights
🎯 Gather data to inform product development and marketing strategies

Content Creation
🎯 **Identify** influencers and collaborators for content partnerships
🎯 **Use** Threads data to create relevant and engaging content

### Why choose us? 💎

Threads Email Scraper stands out as one of the **best** email scraping tools for Threads due to its efficiency and reliability. Our tool is designed to provide accurate and comprehensive data extraction, ensuring users get the most out of their Threads experience.

With **advanced** automation features, it eliminates the need for manual data collection, saving time and effort. Our software is built with user privacy and data security in mind, adhering to legal and ethical standards.

We offer a **user-friendly** interface that requires minimal technical expertise, making it accessible to all. Whether you are a marketer, researcher, or business owner, Threads Email Scraper is tailored to meet your specific needs.

Our dedicated support team and detailed documentation ensure a seamless user experience. Choose Threads Email Scraper for a **reliable**, efficient, and secure email extraction solution.

### **Social Media** Email Scraper Scalability 📈

Threads Email Scraper is designed to handle data extraction tasks of any scale, making it suitable for both small businesses and large enterprises. The tool’s robust infrastructure ensures consistent performance, even when processing large volumes of data.

Users can customize their scraping parameters to target specific data sets, ensuring scalability without compromising accuracy. Our software supports batch processing, allowing users to extract data from multiple profiles or posts simultaneously.

This makes it an ideal choice for businesses looking to scale their lead generation or marketing efforts. With regular updates and optimizations, Threads Email Scraper remains a reliable solution for growing data needs.

Whether you are extracting data for a small project or a **large-scale** campaign, our tool adapts to your requirements effortlessly.

### **Social Media** Email Scraper Legal Guidelines ⚖️

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** that you only scrape publicly available data from Threads
⚖️ **Do not** use Threads Email Scraper to collect private or sensitive information
⚖️ Comply with Threads terms of service and community guidelines
⚖️ **Obtain** consent from users before using their email addresses for marketing purposes
⚖️ **Avoid** using the tool for spamming or unethical practices
⚖️ Regularly review and adhere to local data privacy laws and regulations
⚖️ **Use** the tool responsibly to maintain a positive online reputation
⚖️ **Do not** attempt to bypass security measures on Threads or other platforms

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is Threads **Email Scraper**?

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

#### Is Threads **Email Scraper** **legal** to use?

**Yes**, it is legal to use as long as you comply with Threads' terms of service and scrape only **publicly available** data.

#### Can I use Threads **Email Scraper** for **lead generation**?

**Yes**, the tool is ideal for lead generation by extracting email addresses from Threads.

#### What formats can I **export** the data in?

You can export the data in formats such as **CSV** and **JSON** for easy integration.

#### Is the tool user-friendly?

**Yes**, Threads Email Scraper features a **user-friendly** interface with minimal setup required.

#### Does it support batch processing?

**Yes**, you can scrape data from multiple profiles or posts simultaneously.

#### How accurate is the email **extract**ion process?

The tool is designed for high accuracy, ensuring reliable data extraction.

#### Can I customize the scraping parameters?

**Yes**, you can customize parameters such as hashtags, keywords, and post types.

#### Is my data **secure** with Threads **Email Scraper**?

**Yes**, the tool is built with **secure** data handling to protect user privacy.

#### What if I encounter issues while using the tool?

You can refer to the documentation or contact our support team for assistance.

#### Does the tool comply with data privacy laws?

**Yes**, Threads Email Scraper is designed to comply with legal and ethical standards.

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

**No**, the tool only allows scraping of **publicly available** data from Threads.

#### Is there a **limit** to the number of profiles I can scrape?

**No**, the tool is scalable and can handle data extraction tasks of any size.

#### Does Threads **Email Scraper** work on all devices?

**Yes**, the tool is compatible with various operating systems and devices.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility and optimal performance.

# Actor input Schema

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

List of keywords to search for on Threads (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Threads 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": "Threads",
  "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("api-empire/threads-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("api-empire/threads-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 api-empire/threads-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Threads Email Scraper",
        "description": "Automate email extraction from Threads with Threads Email Scraper. The actor scans profiles and links to pull available contact emails into structured datasets for CRM enrichment and outreach automation.",
        "version": "0.1",
        "x-build-id": "d85nTkhDU3yYlD4Mn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~threads-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-threads-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/api-empire~threads-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-threads-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/api-empire~threads-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-threads-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 Threads (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Threads profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Threads"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Threads"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```