# Threads Lead Scraper (`scrapapi/threads-lead-scraper`) Actor

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

Threads Lead Scraper allows users to **extract** lead 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 Lead Scraper is ideal for businesses looking to enhance their marketing strategies and streamline **data** collection processes.

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

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

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

Threads data extraction is crucial for marketers aiming to build targeted lead lists. Threads Lead 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
  *Lead: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead addresses | Extract verified lead 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** Lead Scraper

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

- ⭐ **Automated** lead extraction from Threads profiles and posts
- ⭐ **High** accuracy in capturing verified lead 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 lead 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 lead extractor for all use cases

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

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

1. ✅ **Sign up** for an account on the Threads Lead 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 lead addresses for targeted outreach
🎯 Build lead 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 lead scraping tools for industry insights

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

### Why choose us? 💎

Threads Lead Scraper is the **best** lead 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 leads from Threads efficiently. Threads Lead Scraper ensures compliance with data protection regulations, making it a secure option for all your data scraping needs.

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

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

### **Social Media** Lead Scraper Scalability 📈

Threads Lead 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 Lead 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 Lead Scraper adapts to provide consistent and accurate results.

Choose Threads Lead Scraper for scalable lead scraping solutions that meet your business objectives.

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

**Yes**—scraping **Social Media** is **legal** as long as you follow **ethical** and **compliant** practices. The **Social Media** Lead 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 Lead 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 Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "Social Media",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads 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 Lead 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",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Social Media as the source |
| keyword | Keyword that triggered the result (Threads Lead Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Social Media profile link |
| lead | Extracted lead address |

### FAQ ❓

#### What is Threads **Lead Scraper**?

Threads Lead Scraper is a tool designed to extract lead addresses and related data from Threads profiles and posts for marketing and lead generation purposes.

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

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

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

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

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

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

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

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

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

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

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

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

#### Can I customize the scraping parameters?

**Yes**, Threads Lead 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 Lead Scraper dashboard.

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

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

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

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

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

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

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

Threads Lead Scraper ensures high accuracy in capturing verified lead addresses and other relevant data.

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

**No**, Threads Lead 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 Lead 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-lead-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-lead-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-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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