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

Automate email extraction from Linktree with Linktree Email Scraper. The actor scans Linktree links and connected pages to pull available contact emails into structured datasets for CRM enrichment.

- **URL**: https://apify.com/api-empire/linktree-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **Linktree** Email Scraper 📱

The **Linktree** Email Scraper allows users to **extract** valuable **data** from public **Linktree** profiles with ease. This tool focuses on gathering email addresses listed on **Linktree** pages, ensuring accuracy and efficiency.

It can also identify associated meta**data**, such as profile names and social media links, to provide additional context. By automating the email harvesting process, this software eliminates the need for manual **data** collection.

It is designed for professionals who need to scrape email addresses from **Linktree** for legitimate purposes, such as outreach campaigns or market research. The **extract**ed **data** is structured and ready to use, making it easy to integrate into your workflow.

This **Linktree** **data** scraping tool is optimized for speed and reliability, ensuring consistent results.

Linktree Email Scraper is a powerful tool designed to extract emails from Linktree profiles quickly and efficiently. It simplifies the process of gathering contact information from public Linktree pages for legitimate and ethical purposes.

Many professionals and businesses use Linktree to centralize their online presence, making it a valuable source for contact details. With the Linktree Email Scraper, you can automate the process of finding emails without manual effort.

This tool is ideal for marketers, researchers, and businesses looking to connect with individuals or organizations listed on Linktree. It ensures accurate and reliable email harvesting while saving time and resources.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract email addresses listed on public Linktree profiles. |
| Profile names | Capture the name of the Linktree profile for context. |
| Social media links | Identify social media accounts linked on the profile. |
| Website URLs | Extract URLs of websites linked on Linktree profiles. |
| Profile descriptions | Retrieve any descriptions or bios provided on the profile. |
| Custom links | Extract custom links added by the profile owner. |
| Timestamps | Record the time and date of data extraction for reference. |

### 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** email extraction from public **Linktree** profiles
- ⭐ **Accurate** and reliable data scraping for professional use
- ⭐ User-friendly interface requiring no technical expertise
- ⭐ Supports bulk processing of multiple **Linktree** URLs
- ⭐ Extracts additional metadata such as profile names and links
- ⭐ **Customizable** settings for specific data extraction needs
- ⭐ **Fast** and efficient scraping with minimal resource usage
- ⭐ **Secure** data handling to protect user privacy
- ⭐ Export data in various formats for easy integration
- ⭐ **Regular** updates to ensure compatibility with **Linktree** changes

### 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 on the platform
2. ✅ Log in to your account and navigate to the dashboard
3. ✅ Enter the **Linktree** profile URLs you want to scrape emails from
4. ✅ Adjust the settings to specify the data you want to extract
5. ✅ **Start** the scraping process and monitor the progress in real-time
6. ✅ Once the scraping is complete review the extracted data on the dashboard
7. ✅ **Export** the data in your preferred format such as CSV or JSON
8. ✅ Use the extracted email addresses for your outreach or research purposes

### Use Cases 🎯

Marketing Campaigns
🎯 Extract emails from **Linktree** profiles to build targeted email lists
🎯 Reach out to potential clients or collaborators efficiently

Research and Analysis
🎯 Gather data for market research or competitor analysis
🎯 **Identify** trends by analyzing **Linktree** profiles and linked content

Networking and Outreach
🎯 **Find** contact information for influencers or professionals
🎯 Streamline communication with individuals listed on **Linktree**

Business Development
🎯 **Identify** potential partners or leads through **Linktree** profiles
🎯 Expand your network by connecting with relevant contacts

### Why choose us? 💎

Our **Linktree** Email Scraper is the **best** **Linktree** scraper tool for professionals and businesses seeking efficient email extraction. It is designed with user convenience in mind, offering a simple interface and powerful features.

With this tool, you can automate the process of finding emails on **Linktree** profiles, saving time and effort. We prioritize data accuracy and reliability, ensuring that the extracted information is useful and actionable.

Additionally, our software is **regular**ly updated to stay compatible with **Linktree**'s platform changes. Whether you need to scrape email addresses from **Linktree** for marketing, research, or networking, our tool delivers consistent results.

By choosing us, you gain access to a secure and efficient solution tailored to your needs. We are committed to providing excellent customer support and ensuring your satisfaction with our services.

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

The **Linktree** Email Scraper is built to handle projects of all sizes, from small-scale extractions to **large-scale** operations. Whether you need to extract emails from a few profiles or thousands, our tool can scale to meet your requirements.

It supports bulk processing, allowing you to scrape multiple **Linktree** URLs simultaneously without compromising performance. Our software is optimized for speed and efficiency, ensuring that even large datasets are processed quickly.

Additionally, we offer **customizable** settings to tailor the scraping process to your specific needs. This flexibility makes our tool suitable for businesses, researchers, and individuals alike.

With our scalable solution, you can confidently tackle projects of any size with ease.

### **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
⚖️ **Only** scrape data from public **Linktree** profiles with visible email addresses
⚖️ **Do not** use the tool to access private or restricted information
⚖️ **Ensure** compliance with data protection laws such as GDPR and CCPA
⚖️ **Use** the extracted data only for legitimate and ethical purposes
⚖️ **Avoid** spamming or unsolicited communication using the harvested emails
⚖️ Respect the terms of service of **Linktree** and other linked platforms
⚖️ Regularly review and adhere to applicable legal and ethical guidelines
⚖️ Seek legal advice if unsure about the permissible use of scraped data

### 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 email addresses from public Linktree profiles quickly and efficiently.

#### Can I use this tool to scrape **private** profiles?

**No**, the Linktree Email Scraper only works with public profiles and visible email addresses.

#### Is the tool user-friendly?

**Yes**, the tool features a simple interface that requires no technical expertise to operate.

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

You can extract email addresses, profile names, social media links, website URLs, and more.

#### Is the **extract**ed data accurate?

**Yes**, the tool is designed to provide accurate and reliable data extraction results.

#### Can I **export** the data?

**Yes**, you can export the extracted data in various formats, such as **CSV** or **JSON**.

#### Is this tool compatible with all Linktree profiles?

The tool works with most public Linktree profiles, but compatibility may vary based on profile settings.

#### How fast is the scraping process?

The tool is optimized for speed, allowing you to scrape data quickly and efficiently.

#### Is the tool **secure**?

**Yes**, we prioritize data security and ensure that user data is handled safely.

#### Do you offer **customer support**?

**Yes**, we provide excellent customer support to assist with any issues or questions.

#### Can I scrape multiple profiles at once?

**Yes**, the tool supports bulk processing for scraping multiple Linktree URLs simultaneously.

#### What are the **legal** guidelines for using this tool?

You must comply with data protection laws, respect Linktree's terms of service, and use the tool ethically.

#### Is this tool updated regularly?

**Yes**, we ensure the tool is updated to remain compatible with Linktree's platform changes.

#### Can I customize the scraping process?

**Yes**, the tool offers customizable settings to tailor the data extraction to your needs.

#### Who can benefit from using this tool?

Marketers, researchers, **businesses**, and individuals looking to extract **emails** from Linktree can all benefit from this tool.

# 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("api-empire/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("api-empire/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 api-empire/linktree-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linktree Email Scraper",
        "description": "Automate email extraction from Linktree with Linktree Email Scraper. The actor scans Linktree links and connected pages to pull available contact emails into structured datasets for CRM enrichment.",
        "version": "0.1",
        "x-build-id": "8A4cN3cD4zqnkV6s9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~linktree-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-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/api-empire~linktree-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-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/api-empire~linktree-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```