# Linktree Email Scraper (`scrapeengine/linktree-email-scraper`) Actor

📧 Linktree Email Scraper extracts email addresses from Linktree profiles quickly and accurately. Perfect for B2B lead gen, outreach, and market research. 🚀 Save time, find contacts faster, and streamline your pipeline.

- **URL**: https://apify.com/scrapeengine/linktree-email-scraper.md
- **Developed by:** [ScrapeEngine](https://apify.com/scrapeengine) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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

### **Linktree** Email Scraper 📱

The **Linktree** Email Scraper enables users to **extract** various types of **data** from **Linktree** profiles with ease. It focuses on collecting accurate and relevant **contact** information, such as email addresses, for outreach or marketing purposes.

This tool is designed to ensure the **data** **extract**ed is up-to-date and useful for your specific needs. By automating the process, it eliminates the need for manual **data** collection, saving time and reducing errors.

The **extract**ed **data** can be used for lead generation, research, or other professional purposes, making it a versatile solution for individuals and businesses alike.

Linktree Email Scraper is a powerful tool designed to help users extract emails from Linktree profiles efficiently and accurately. It simplifies the process of gathering contact information for outreach or lead generation purposes.

With the Linktree Email Scraper, businesses and individuals can automate the extraction of valuable contact data from Linktree profiles. This tool is ideal for marketers, researchers, and anyone looking to streamline their data collection efforts.

Extracting emails from Linktree profiles manually can be time-consuming and prone to errors. The Linktree Email Scraper eliminates these challenges by providing a reliable and automated solution for data extraction.

### 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 listed on Linktree profiles. |
| Profile URLs | Retrieve the URLs of Linktree profiles for reference or further analysis. |
| Social media links | Collect links to social media platforms associated with Linktree profiles. |
| Website links | Extract links to external websites shared on Linktree profiles. |
| Contact forms | Identify and extract contact form links provided on Linktree profiles. |
| Profile names | Retrieve the names or titles of Linktree profiles for identification. |
| Profile descriptions | Extract text descriptions or bios from Linktree profiles. |
| Custom links | Gather any custom links shared on Linktree profiles for additional insights. |

### Key Features of **Linktree** Email Scraper

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

- ⭐ **Automated** extraction of emails from **Linktree** profiles for efficient data collection
- ⭐ Supports bulk scraping to handle large-scale data extraction projects
- ⭐ User-friendly interface for easy setup and operation of the tool
- ⭐ **Accurate** and reliable data extraction to ensure high-quality results
- ⭐ **Customizable** scraping options to target specific data types or profiles
- ⭐ **Fast** processing speeds to save time and enhance productivity
- ⭐ **Secure** and compliant scraping methods to protect user data and privacy
- ⭐ Exportable data in various formats for seamless integration into workflows
- ⭐ **Regular** updates to ensure compatibility with **Linktree** platform changes
- ⭐ Detailed documentation and support for troubleshooting and optimization

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

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

1. ✅ **Sign up** for the **Linktree** Email Scraper tool and **log in** to your account
2. ✅ Enter the **Linktree** profile URLs you want to scrape into the tools input field
3. ✅ **Select** the data types you wish to extract such as emails or profile descriptions
4. ✅ **Configure** any advanced settings such as filters or scraping speed preferences
5. ✅ **Start** the scraping process by clicking the Run button in the tool interface
6. ✅ Monitor the progress of the scraping operation using the real-time dashboard
7. ✅ Once completed review the extracted data for accuracy and completeness
8. ✅ **Export** the data in your preferred format such as CSV or JSON for further use

### Use Cases 🎯

Lead Generation
🎯 Extract emails from **Linktree** profiles to build targeted email lists
🎯 **Use** the tool to gather contact information for outreach campaigns

Market Research
🎯 **Analyze** **Linktree** profiles to understand user trends and preferences
🎯 **Collect** data for competitor analysis or industry insights

Networking and Collaboration
🎯 **Find** potential collaborators by extracting contact details from **Linktree** profiles
🎯 Reach out to influencers or professionals using their shared contact information

Content Promotion
🎯 **Identify** creators or businesses to promote your content or services
🎯 **Use** the extracted data to establish partnerships or sponsorships

### Why choose us? 💎

The **Linktree** Email Scraper stands out as the **best** tool for extracting emails from **Linktree** profiles due to its accuracy, efficiency, and ease of use. It is designed to cater to the needs of marketers, researchers, and businesses looking for **reliable** data extraction solutions.

With automated scraping capabilities, this tool saves time and minimizes errors compared to manual methods. It offers customizable options to target specific data types, ensuring you get the information you need.

The tool is secure and compliant, prioritizing user data privacy and ethical practices. Regular updates ensure compatibility with **Linktree** platform changes, making it a dependable choice for long-term use.

Whether you need a **Linktree** contact scraper for lead generation, research, or networking, this tool provides unmatched versatility and performance.

### **Linktree** Email Scraper Scalability 📈

The **Linktree** Email Scraper is designed to handle projects of any size, making it suitable for both small-scale and **large-scale** data extraction needs. Its bulk scraping capabilities allow users to process multiple **Linktree** profiles simultaneously, saving time and enhancing productivity.

The tool’s **advanced** features ensure **efficient** performance even with high volumes of data, making it ideal for businesses and organizations. Whether you’re extracting a few emails or thousands, the **Linktree** Email Scraper maintains accuracy and reliability throughout the process.

Its scalable design ensures that users can adapt the tool to their specific requirements, providing flexibility and convenience for diverse use cases.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** you have permission to scrape data from **Linktree** profiles to comply with privacy laws
⚖️ **Do not** use the tool to extract data for malicious or unethical purposes
⚖️ Respect the terms of service of the **Linktree** platform during data extraction
⚖️ **Avoid** scraping profiles that explicitly prohibit data collection or sharing
⚖️ **Use** the extracted data responsibly and in accordance with applicable regulations
⚖️ **Do not** share or sell extracted data without the consent of the profile owners
⚖️ **Ensure** compliance with GDPR CCPA and other relevant data protection laws
⚖️ Regularly review legal guidelines to stay updated on changes in data scraping regulations

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is the Linktree **Email Scraper**?

The Linktree Email Scraper is a tool designed to extract **emails** and other contact information from Linktree profiles efficiently.

#### How does the Linktree **Email Scraper** work?

It automates the process of scraping data from Linktree profiles by using advanced algorithms to collect specified information.

#### Is the Linktree **Email Scraper** **legal** to use?

**Yes**, as long as you comply with Linktree’s terms of service and relevant data protection laws.

#### What data can I **extract** using this tool?

You can extract **emails**, profile URLs, social media links, website links, contact forms, and more.

#### Is the tool suitable for **large-scale** data **extract**ion?

**Yes**, the Linktree Email Scraper supports bulk scraping for handling large projects efficiently.

#### Can I customize the data **extract**ion process?

**Yes**, the tool offers customizable options to target specific data types or profiles.

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

You can export the data in formats like **CSV** or **JSON** for easy integration into your workflows.

#### Does the tool ensure data accuracy?

**Yes**, the Linktree Email Scraper is designed to provide accurate and reliable results.

#### Is the tool **secure** to use?

**Yes**, it uses **secure** methods to protect user data and ensure **compliance** with privacy standards.

#### Can I use the tool for **lead generation**?

**Yes**, the Linktree Email Scraper is ideal for building targeted email lists for outreach campaigns.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with Linktree platform changes.

#### Do I need technical expertise to use the tool?

**No**, the tool features a **user-friendly** interface that makes it accessible to everyone.

#### What industries can benefit from this tool?

Marketers, researchers, and **businesses** across various industries can benefit from using the Linktree Email Scraper.

#### Is **customer support** available for this tool?

**Yes**, detailed documentation and support are provided for troubleshooting and optimization.

#### Can I scrape profiles with restricted data access?

**No**, you should only scrape data from profiles that allow data collection and sharing.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linktree Email Scraper",
        "description": "📧 Linktree Email Scraper extracts email addresses from Linktree profiles quickly and accurately. Perfect for B2B lead gen, outreach, and market research. 🚀 Save time, find contacts faster, and streamline your pipeline.",
        "version": "0.1",
        "x-build-id": "4FAKCZu2hHMIWLpBe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~linktree-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-linktree-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/scrapeengine~linktree-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-linktree-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/scrapeengine~linktree-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-linktree-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 Linktr (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Linktr profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Linktr"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Linktr"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```