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

\[𝗖𝗼𝘀𝘁-𝗘𝗳𝗳𝗲𝗰𝘁𝗶𝘃𝗲] Linktree Email Scraper extracts publicly available emails from Linktree profiles using targeted keywords and domains. Get niche-specific leads instantly—quick, precise, and effortless for outreach, research, and marketing.

- **URL**: https://apify.com/scraper-mind/linktree-email-scraper.md
- **Developed by:** [Scraper Mind](https://apify.com/scraper-mind) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 33 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Linktree Email Scraper – Targeted, Scalable & Cost-Effective

The **Linktree Email Scraper** is a powerful tool designed to extract **Linktree email** contacts directly from public Linktree profiles using specific keywords, custom domains, and filters. 🔍 This scraper helps marketers, lead-generation specialists, and digital researchers quickly gather **high-intent Linktree leads** from creators, influencers, and businesses across any niche.

By analyzing public bios and associated links, the scraper identifies emails that match your filters—such as *@gmail.com*—ensuring clean and relevant outreach lists.✨
From **influencer marketing** to **brand partnerships**, this tool accelerates data collection while supporting SEO-driven research and audience profiling. Its keyword-based search makes it ideal for discovering creators in niches like *fashion, fitness, beauty, gaming,* and more.

---

### 🔎 What **Linktree Email Scraper** can I extract?

Below is a clear snapshot of the types of data you can gather using the **Linktree Email Scraper**. Each row represents valuable insights for outreach, lead generation, and market research. 📊

> **Word count: ~160**

#### 📘 Extractable Data Table

| Data Type       | Description                                                        |
| --------------- | ------------------------------------------------------------------ |
| **Keyword**     | The keyword used to find the Linktree lead (e.g., *fashion*).      |
| **Title**       | The Linktree profile title connected to the keyword.               |
| **Description** | Public bio or snippet containing details and possible email clues. |
| **URL**         | Direct link to the Linktree profile.                               |
| **Email**       | Extracted **Linktree email** matching your domain filters.         |
| **Network**     | Indicates Linktree as the source platform.                         |

This scraped data helps build precise email lists, discover niche creators, and unlock new opportunities for brand collaborations. Whether you're targeting influencers or researching markets, this scraper delivers clean, structured **Linktree leads** ready for instant use. 🚀

---

### ⭐ H3: Key Features of **Linktree Email Scraper**

> **Word count: ~190**

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

* ✅ **Keyword-Based Targeting**
  Search for Linktree profiles using hyper-relevant keywords such as *fashion*, *beauty*, *crypto*, etc.

* 🎯 **Custom Email Domain Filtering**
  Extract only emails with domains like *@gmail.com*, *@outlook.com*, or any domain that fits your target audience.

* ⚡ **Fast, Cost-Effective Engine**
  Use the modern **cost-effective engine** for faster scraping with residential proxies and optimized async requests.

* 🔐 **Privacy-Compliant Scraping**
  The scraper collects only public data from publicly accessible Linktree profiles.

* 📁 **Structured Output**
  Receive ready-to-use JSON data that integrates easily with CRMs, outreach tools, or data pipelines.

* 🌍 **Scalable Searches**
  Collect up to **10,000 emails** depending on your configuration and available public results.

* 🔍 **Precise Results**
  Filters ensure your leads are **highly relevant** and niche-specific.

This feature-rich tool ensures you capture **quality Linktree leads** with unmatched efficiency and accuracy. 🚀

---

### 🛠️ How to use **Linktree Email Scraper**

> **Word count: ~190**

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

#### 📌 Step-by-Step Guide

1. **Log in to Apify**
   Create a free account or sign in to your existing one.

2. **Select the Actor**
   Visit the Apify Store and search for **“Linktree Email Scraper.”**

3. **Enter Input Data**
   Add your target **keywords**, domains, and any location filter into the input fields.
   Example: *fashion*, *@gmail.com*.

4. **Choose Options**
   Adjust `maxEmails`, set your preferred engine (e.g., **cost-effective**), and configure proxy settings if needed.

5. **Run the Actor** 🚀
   Click **Start**, and the scraper will begin extracting emails from Linktree profiles that match your criteria.

6. **Download Results**
   Export your results in JSON, CSV, or Excel for outreach, analytics, or CRM upload.

With this streamlined workflow, you can generate thousands of **Linktree leads** in just minutes. ⚡

---

### 🎯 Use Cases

> **Word count: ~190**

The **Linktree Email Scraper** unlocks powerful opportunities across multiple industries:

#### 💼 Business & Marketing

* Build outreach lists for influencer marketing campaigns.
* Discover micro-influencers in niches like *fashion*, *fitness*, *travel*, or *beauty*.
* Generate B2C or B2B lead lists from creators relevant to your brand.

#### 🧪 Research & Analytics

* Analyze trends across Linktree bios for market insights.
* Collect datasets for brand sentiment or audience profiling.

#### 🤝 Creator Partnerships

* Identify creators open to collaborations via publicly listed emails.
* Discover new talent for ambassador programs.

#### 📣 Agency Use

* Automate lead generation for client campaigns.
* Scale influencer scouting without manual searching.

This tool transforms raw Linktree profiles into high-value, actionable **Linktree leads**, saving hours of manual work while delivering targeted, niche-specific results. 📧✨

---

### 💎 Why choose us?

> **Word count: ~190**

Choosing the **Linktree Email Scraper** means choosing efficiency, accuracy, and reliability:

* 🌐 **Advanced Targeting Filters**
  Use keywords, domains, and location filters for precise lead extraction.

* ⚡ **Lightning-Fast Performance**
  Our **cost-effective engine** dramatically speeds up scraping while reducing costs.

* 🛡️ **Safe & Ethical**
  We collect only publicly available data and adhere to compliance guidelines.

* 📊 **High-Quality Output**
  Clean and structured JSON ensures immediate integration into tools and workflows.

* 🤝 **Trusted by Agencies & Brands**
  Built for scale—perfect for marketing teams, researchers, and automated pipelines.

* 📞 **Support Included**
  Need custom features? Contact us anytime at **[scrapermindapi@gmail.com](mailto:scrapermindapi@gmail.com)**.

We deliver a tool that balances speed, accuracy, affordability, and reliability—everything you need for high-performance **Linktree lead scraping**. 🚀

---

### 📈 How many results can you scrape with **Linktree Email Scraper**?

> **Word count: ~260**

The **Linktree Email Scraper** is built for serious scalability. Whether you need **10**, **100**, or **10,000+ Linktree emails**, this tool can adapt to your goals.

#### 🌍 Scalability Highlights

* **Max Email Setting:**
  You can specify up to **10,000 results** using the `maxEmails` parameter. The scraper will automatically stop once that number is reached.

* **Realistic Expectations:**
  While the scraper can fetch thousands of emails, the actual number depends on your:

  * Keyword depth
  * Email domain filters
  * Niche saturation
  * Competition and search volume

* **High-Volume Campaigns:**
  For common niches like *fashion*, *fitness*, *gaming*, and *beauty*, it’s possible to collect hundreds or thousands of emails in a single run.

* **Performance:**
  The **cost-effective engine** uses residential proxies and parallel requests, making large-scale scraping faster and more affordable.

#### 🚀 Bottom Line

If the email exists publicly on Linktree and matches your keyword/domain filters, this scraper will find it—at scale. It's ideal for agencies, marketers, and researchers who depend on consistent, bulk **Linktree lead generation**.

---

### ⚖️ Is it legal to scrape **Linktree**?

> **Word count: ~190**

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:

* Only public data is accessed.
* No private accounts or password-protected content are scraped.
* The tool respects platform terms when used responsibly.
* Users must follow their local data laws (e.g., GDPR, CCPA).

#### 🔒 Best Practices:

* Use scraped emails only for lawful purposes.
* Offer opt-outs during outreach.
* Avoid spam or unsolicited mass emailing.

In short, the scraper is a tool—*how you use it determines compliance*. When used ethically, it becomes a powerful asset for gathering **Linktree leads**.

---

### 🧩 Input Parameters

#### 📦 Example Input (JSON)

```json
{
  "customDomains": ["@gmail.com"],
  "keywords": ["fashion"],
  "maxEmails": 10,
  "location": "",
  "platform": "Linktree",
  "engine": "cost-effective"
}
````

#### 📊 Input Table

| Parameter          | Type    | Description                                      |
| ------------------ | ------- | ------------------------------------------------ |
| keywords           | array   | Keywords to find relevant Linktree profiles.     |
| location           | string  | Optional location filter.                        |
| platform           | string  | Platform to scrape (Linktree).                   |
| customDomains      | array   | Email domains to filter (e.g., @gmail.com).      |
| maxEmails          | integer | Maximum number of emails to collect.             |
| engine             | string  | Choose between cost-effective or legacy engines. |
| proxyConfiguration | object  | Optional proxy settings.                         |

***

### 📤 Output Format

#### 📝 Example Output (JSON)

```json
[
  {
    "network": "Linktree.com",
    "keyword": "fashion",
    "title": "alllthingsfashion | TikTok",
    "description": "the perfect guide to all things fashion ✉️alllthingsfashion@gmail.com...",
    "url": "https://linktr.ee/alllthingsfashion",
    "email": "alllthingsfashion@gmail.com"
  }
]
```

#### 📊 Output Table

| Field       | Description                        |
| ----------- | ---------------------------------- |
| network     | Identifies Linktree as the source. |
| keyword     | Keyword that triggered the result. |
| title       | Profile title or username.         |
| description | Public bio snippet.                |
| url         | Direct Linktree profile link.      |
| email       | Extracted email address.           |

***

### ❓ FAQ

#### 1. **Does the Linktree Email Scraper work for all niches?**

Yes! Any niche with public Linktree profiles—fashion, fitness, gaming, travel, etc.

#### 2. **Can I filter by specific email domains?**

Absolutely. Use `customDomains` like *@gmail.com* or *@yahoo.com*.

#### 3. **How fast is the cost-effective engine?**

Very fast—optimized for parallel scraping with lower costs.

#### 4. **Is the scraper safe to use?**

Yes. It collects only publicly available data.

#### 5. **Can it scrape thousands of Linktree leads?**

Yes, depending on niche density and your `maxEmails` setting.

#### 6. **Do I need proxies?**

They’re optional but recommended for large-scale searches.

#### 7. **Can I run multiple keywords at once?**

Yes! The scraper accepts an array of keywords.

#### 8. **Is JSON the only output format?**

You can export JSON, CSV, XLSX, and more via Apify.

# Actor input Schema

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

A list of keywords to search for.

## `location` (type: `string`):

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## `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`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "fashion"
  ],
  "location": "",
  "platform": "Linktree",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

# 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": [
        "fashion"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-mind/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": ["fashion"],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-mind/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": [
    "fashion"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scraper-mind/linktree-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mass Linktree Email Scraper",
        "description": "[𝗖𝗼𝘀𝘁-𝗘𝗳𝗳𝗲𝗰𝘁𝗶𝘃𝗲] Linktree Email Scraper extracts publicly available emails from Linktree profiles using targeted keywords and domains. Get niche-specific leads instantly—quick, precise, and effortless for outreach, research, and marketing.",
        "version": "0.0",
        "x-build-id": "V9ym3EFoyLPStuO5r"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-mind~linktree-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-mind-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/scraper-mind~linktree-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-mind-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/scraper-mind~linktree-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-mind-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": "A list of keywords to search for.",
                        "default": [
                            "fashion"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Linktree"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Linktree"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "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": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```