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

Linktree Email Scraper extracts publicly available email addresses from Linktree pages and linked websites. Build targeted creator contact lists for partnerships, promotions, and direct outreach at scale.

- **URL**: https://apify.com/scraper-engine/linktree-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Automation, Lead generation, Other
- **Stats:** 7 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. It is designed to collect **contact** information and other relevant details efficiently.

The tool focuses on gathering publicly available email addresses from **Linktree** profiles. Additionally, it can **extract** associated meta**data** such as profile names, links, and descriptions.

This **data** can be used for outreach, research, or other legitimate purposes. By automating the **data** collection process, the scraper saves time and ensures accuracy.

It is an essential tool for businesses, researchers, and marketers seeking to connect with individuals or analyze trends on **Linktree**.

Linktree Email Scraper is a powerful tool designed to extract emails from Linktree profiles efficiently and accurately. It helps users gather contact information from public profiles for legitimate and ethical purposes.

With the growing popularity of Linktree, many businesses and individuals use it to share their contact details. This scraper simplifies the process of finding and collecting these emails for outreach or research purposes.

Our Linktree email extraction tool is automated, saving you time and effort compared to manual data collection. It is ideal for marketers, researchers, and businesses looking to connect with potential clients or collaborators.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract publicly available email addresses from Linktree profiles. |
| Profile names | Retrieve the names associated with Linktree profiles. |
| Profile descriptions | Capture the text descriptions provided on Linktree profiles. |
| Links | Extract all links shared on the Linktree profiles. |
| Social media handles | Collect social media account links from the profiles. |
| Profile images | Download profile images if publicly available. |
| Custom link titles | Retrieve the custom titles provided for shared links. |
| Metadata | Gather additional metadata such as timestamps or profile IDs. |

### 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 to save time and effort
- ⭐ **High** accuracy in identifying and collecting publicly available email addresses
- ⭐ Ability to extract multiple data types including links descriptions and social media handles
- ⭐ User-friendly interface designed for both technical and non-technical users
- ⭐ **Customizable** scraping options to target specific data fields or profiles
- ⭐ Scalable solution capable of handling large-scale data extraction projects
- ⭐ Built-in compliance features to ensure ethical and legal data collection
- ⭐ Real-time data processing for quick and efficient results
- ⭐ **Secure** data handling to protect user information and extracted data
- ⭐ **Comprehensive** support and documentation to assist users at every step

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

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

1. ✅ **Sign up** or **log in** to the platform hosting the **Linktree** Email Scraper
2. ✅ Navigate to the **Linktree** Email Scraper tool in the dashboard
3. ✅ **Input** the URLs of the **Linktree** profiles you want to scrape emails from
4. ✅ **Select** the specific data fields you want to extract such as emails or links
5. ✅ Adjust the scraper settings to customize the data extraction process if needed
6. ✅ **Start** the scraping process by clicking the Run or **Start** button
7. ✅ Monitor the scraping progress in real-time through the dashboard
8. ✅ Download the extracted data in your preferred format such as CSV or JSON
9. ✅ **Review** the collected data to ensure it meets your requirements
10. ✅ Use the data for legitimate purposes such as outreach or research

### Use Cases 🎯

Marketing and Outreach
🎯 Extract emails from **Linktree** profiles to build targeted email lists
🎯 **Use** the data for personalized marketing campaigns and outreach efforts

Research and Analysis
🎯 Gather data from **Linktree** profiles for market research
🎯 **Analyze** trends and patterns in how individuals use **Linktree**

Business Development
🎯 **Find** potential collaborators or clients by extracting contact details
🎯 **Use** the tool to identify leads and grow your professional network

Content Creation
🎯 Discover influencers or creators by analyzing **Linktree** profiles
🎯 **Use** the extracted data to connect with individuals for partnerships

### Why choose us? 💎

Our **Linktree** Email Scraper stands out for its efficiency, accuracy, and **user-friendly** design. It is tailored to meet the needs of businesses, researchers, and marketers seeking to extract data from **Linktree** profiles.

The tool offers customizable scraping options, allowing users to target specific data fields. It is built with compliance in mind, ensuring all data collection adheres to legal and ethical standards.

The scraper is **scalable**, capable of handling both small and large-scale projects. We prioritize data security, ensuring your information and extracted data are protected.

Our dedicated support team and comprehensive documentation make it easy for users to get started and resolve any issues. With our tool, you can save time, reduce manual effort, and achieve your data collection goals effectively.

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

The **Linktree** Email Scraper is designed to handle projects of all sizes, making it suitable for individual users and large organizations alike. It can process multiple profiles simultaneously, ensuring **efficient** data collection even for **extensive** datasets.

The tool's infrastructure supports high-performance scraping, minimizing downtime and maximizing output. Users can customize scraping parameters to focus on specific data fields, optimizing the process for their unique needs.

Whether you need to scrape a few profiles or thousands, the tool adapts **seamless**ly to your requirements. This scalability ensures that businesses, researchers, and marketers can rely on the scraper for both small-scale tasks and **large-scale** campaigns.

### **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 only scrape publicly available information from **Linktree** profiles
⚖️ **Do not** use the tool to collect data for spamming or unsolicited marketing purposes
⚖️ Comply with all relevant data protection laws such as GDPR or CCPA when using the scraper
⚖️ **Obtain** proper consent if required before using the extracted data for outreach
⚖️ **Avoid** scraping profiles that explicitly prohibit data collection in their terms of service
⚖️ **Use** the tool responsibly and ethically to maintain the integrity of your operations
⚖️ **Do not** attempt to bypass security measures or access private data on **Linktree**
⚖️ Regularly review and adhere to **Linktree**s terms of service and privacy policies

### 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**?

It is a tool designed to extract **publicly available** email addresses and other data from Linktree profiles.

#### Is it **legal** to scrape emails from Linktree?

**Yes**, as long as you only collect **publicly available** information and comply with data protection laws.

#### Can I use this tool for marketing purposes?

**Yes**, you can use the extracted data for legitimate marketing campaigns, provided you adhere to legal and ethical guidelines.

#### How accurate is the email **extract**ion process?

The tool is highly accurate and designed to extract only **publicly available** email addresses.

#### What data formats are supported for **export**?

The extracted data can be downloaded in formats such as **CSV** or **JSON**.

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

**Yes**, the tool supports bulk scraping for efficient data collection.

#### Is the tool user-friendly for non-technical users?

**Yes**, the scraper features an intuitive interface suitable for all users.

#### Does the scraper comply with GDPR?

**Yes**, the tool is designed to comply with GDPR and other data protection regulations.

#### Is there a **limit** to the number of profiles I can scrape?

The tool is scalable and can handle projects of various sizes, depending on your requirements.

#### What support is available if I encounter issues?

We offer comprehensive documentation and a **dedicated support** team to assist you.

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

**Yes**, the tool provides options to customize scraping parameters based on your needs.

#### How **secure** is the **extract**ed data?

We prioritize data security and ensure that all extracted data is handled with care.

#### What types of data can I **extract** besides emails?

You can extract profile names, descriptions, links, social media handles, and more.

#### Is there a free trial available?

Please check our pricing page for details on free trials or demo options.

#### How long does the scraping process take?

The duration depends on the number of profiles and data fields selected, but the tool is optimized for quick results.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraper-engine/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 publicly available email addresses from Linktree pages and linked websites. Build targeted creator contact lists for partnerships, promotions, and direct outreach at scale.",
        "version": "0.1",
        "x-build-id": "cOwUvDa9UvPaiuA2M"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~linktree-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-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-engine~linktree-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-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-engine~linktree-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```