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

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

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

Threads Email Scraper allows users to **extract** email addresses and related **data** from Threads profiles and posts. It captures information essential for marketing and lead generation campaigns.

With Threads automation tools, users can retrieve structured **data** without manual intervention. The scraper is designed to ensure accuracy and compliance with **data** protection regulations.

Extracted **data** can be used for targeted outreach, customer segmentation, and industry analysis. Threads Email Scraper is ideal for businesses looking to enhance their marketing strategies and streamline **data** collection processes.

It is compatible with various email scraper software and supports diverse use cases.

Threads Email Scraper is a powerful tool designed to extract email addresses from Threads for marketing and lead generation purposes. It simplifies the process of collecting valuable data from Threads profiles and posts.

Email scraping tools like Threads Email Scraper are essential for businesses looking to automate data collection and streamline outreach efforts. With advanced Threads automation tools, users can efficiently extract emails without manual effort.

Threads data extraction is crucial for marketers aiming to build targeted email lists. Threads Email Scraper ensures accurate and reliable data collection for effective campaigns.

### 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 verified email addresses from Threads profiles and posts. |
| Profile names | Capture the names associated with Threads profiles. |
| User IDs | Retrieve unique identifiers for Threads users. |
| Post content | Extract text and metadata from Threads posts. |
| Engagement metrics | Collect data on likes, comments, and shares for posts. |
| Profile URLs | Extract direct links to Threads profiles. |
| Timestamp data | Retrieve the date and time of posts and interactions. |
| Location information | Capture location data if available in Threads profiles or posts. |

### 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
- ⭐ **High** accuracy in capturing verified email addresses
- ⭐ Supports bulk data extraction for large-scale operations
- ⭐ User-friendly interface for seamless data scraping
- ⭐ **Customizable** scraping parameters for targeted data collection
- ⭐ Compliance with data protection regulations and guidelines
- ⭐ **Integration** with other email scraping tools and software
- ⭐ Real-time data updates for accurate and current information
- ⭐ Scalable functionality for businesses of all sizes
- ⭐ Detailed reporting and export options for extracted data
- ⭐ **Advanced** filtering options to refine data extraction results
- ⭐ **Secure** and reliable Threads email extractor for all use cases

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

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

1. ✅ **Sign up** for an account on the Threads Email Scraper platform
2. ✅ Log in and navigate to the dashboard to access scraping tools
3. ✅ Enter the Threads profile or post URLs you want to scrape
4. ✅ **Configure** scraping parameters such as data types and filters
5. ✅ **Start** the scraping process and monitor progress in real-time
6. ✅ **Review** extracted data in the dashboard once scraping is complete
7. ✅ **Export** the data to your preferred format for further use
8. ✅ Use the extracted data for marketing lead generation or analysis

### Use Cases 🎯

Marketing Campaigns
🎯 Extract email addresses for targeted outreach
🎯 Build email lists for promotional campaigns
🎯 **Use** Threads data extraction for customer segmentation

Lead Generation
🎯 Capture contact information from Threads profiles
🎯 **Identify** potential clients using Threads automation tools
🎯 Enhance lead generation strategies with verified data

Data Analysis
🎯 **Analyze** engagement metrics from Threads posts
🎯 Extract post content for sentiment analysis
🎯 **Use** Threads email scraping tools for industry insights

Networking and Outreach
🎯 **Find** professional contacts on Threads
🎯 **Use** Threads email extractor for event invitations
🎯 **Automate** outreach efforts with email scraping tools

### Why choose us? 💎

Threads Email Scraper is the **best** email scraper for Threads, offering unmatched functionality and reliability. Our software is designed to simplify Threads data extraction and automate the process for businesses and individuals.

With **advanced** features and customizable parameters, users can extract emails from Threads efficiently. Threads Email Scraper ensures compliance with data protection regulations, making it a secure option for all your data scraping needs.

Our platform integrates seamlessly with other email scraper software, providing flexibility and scalability. Whether you're looking to enhance marketing campaigns or streamline lead generation, Threads Email Scraper is the ideal solution.

Our team is dedicated to providing top-notch support and continuous updates to meet evolving user requirements. Choose Threads Email Scraper for accurate, **reliable**, and efficient email scraping for marketing, networking, and analysis.

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

Threads Email Scraper is designed to scale with your business needs, whether you're a small startup or a large enterprise. Our platform supports bulk data extraction, allowing users to scrape thousands of Threads profiles and posts simultaneously.

With **advanced** Threads automation tools, you can customize scraping parameters to suit specific requirements. Threads Email Scraper ensures high performance and reliability, even for **large-scale** operations.

Our software integrates **seamless**ly with other tools, enabling **efficient** workflows and data management. As your data needs grow, Threads Email Scraper adapts to provide consistent and accurate results.

Choose Threads Email Scraper for scalable email scraping solutions that meet your business objectives.

### **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** compliance with Threads terms of service when using Threads Email Scraper
⚖️ **Do not** use extracted data for illegal or unethical purposes
⚖️ **Obtain** consent before using personal information for marketing campaigns
⚖️ Follow data protection regulations such as GDPR and CCPA
⚖️ **Avoid** scraping sensitive or restricted information from Threads profiles
⚖️ **Use** Threads automation tools responsibly and ethically
⚖️ **Do not** share extracted data with unauthorized third parties
⚖️ Regularly review legal guidelines to ensure compliance

### 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 related data from Threads profiles and posts for marketing and lead generation purposes.

#### How does Threads **Email Scraper** work?

Threads Email Scraper automates the process of data extraction from Threads profiles and posts, capturing email addresses and other relevant information.

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

**Yes**, Threads Email Scraper is legal to use when operated in **compliance** with Threads' terms of service and data protection regulations.

#### Can I use Threads **Email Scraper** for marketing campaigns?

**Yes**, Threads Email Scraper is ideal for building targeted email lists for marketing campaigns and outreach efforts.

#### What data can Threads **Email Scraper** **extract**?

Threads Email Scraper can extract email addresses, profile names, user IDs, post content, engagement metrics, profile URLs, timestamps, and location information.

#### Is Threads **Email Scraper** suitable for **large-scale** operations?

**Yes**, Threads Email Scraper supports bulk data extraction and is scalable for **businesses** of all sizes.

#### Does Threads **Email Scraper** comply with data protection regulations?

**Yes**, Threads Email Scraper is designed to comply with GDPR, CCPA, and other data protection regulations.

#### Can I customize the scraping parameters?

**Yes**, Threads Email Scraper allows users to configure scraping parameters for targeted data collection.

#### How do I **export** **extract**ed data?

You can export extracted data to various formats directly from the Threads Email Scraper dashboard.

#### Is Threads **Email Scraper** user-friendly?

**Yes**, Threads Email Scraper features a **user-friendly** interface for **seamless** data scraping.

#### Can I integrate Threads **Email Scraper** with other tools?

**Yes**, Threads Email Scraper integrates with other email scraping tools and software for efficient workflows.

#### What are the benefits of using Threads **Email Scraper**?

Threads Email Scraper simplifies data extraction, enhances marketing strategies, and automates lead generation processes.

#### How accurate is Threads **Email Scraper**?

Threads Email Scraper ensures high accuracy in capturing verified email addresses and other relevant data.

#### Do I need technical expertise to use Threads **Email Scraper**?

**No**, Threads Email Scraper is designed for users of all skill levels, with an intuitive interface and easy-to-follow instructions.

#### Can I scrape data from multiple Threads profiles at once?

**Yes**, Threads Email Scraper supports bulk data extraction for simultaneous scraping of multiple profiles and posts.

# 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("scrapapi/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("scrapapi/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 scrapapi/threads-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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