# Spotify Email Scraper (`scrapio/spotify-email-scraper`) Actor

Spotify Email Scraper helps you collect artist and business emails directly from Spotify profiles. Use the data for promotions, partnerships, and campaign coordination. Fast, scalable scraping with clean, export-ready results.

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

## Pricing

$14.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

### **Spotify** Email Scraper 📱

**Spotify** Email Scraper allows users to **extract** valuable **contact** information from **Spotify** profiles. It focuses on collecting email addresses and other relevant **data** to help businesses and individuals build targeted outreach strategies.

The tool ensures accurate **data** **extract**ion by scanning **Spotify** profiles for publicly available **contact** details. Users can also gather supplementary information such as profile names, genres, and follower counts to enrich their **contact** **data**base.

This scraper is designed to handle large-scale **data** **extract**ion tasks while maintaining compliance with ethical and legal standards. By using **Spotify** Email Scraper, users can streamline their **data** collection processes and focus on their core business activities.

Spotify Email Scraper is a powerful tool designed to extract contact information from Spotify profiles efficiently. It enables businesses and individuals to streamline their outreach processes by gathering accurate email data from Spotify users.

With the Spotify email extraction tool, you can automate the process of finding relevant contact information on Spotify. This helps save time and ensures precision in data collection for marketing or networking purposes.

Spotify email harvesting software provides a reliable way to build a contact database from Spotify profiles. It is ideal for businesses looking to enhance their marketing campaigns or connect with potential collaborators.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.scrapio@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract publicly available email addresses from Spotify profiles. |
| Profile names | Retrieve the names associated with Spotify profiles for identification purposes. |
| Follower counts | Collect data on the number of followers for each Spotify profile. |
| Genres | Identify the genres associated with Spotify profiles to target specific audiences. |
| Profile links | Extract direct links to Spotify profiles for easy access. |
| Bio information | Gather bio details from Spotify profiles to understand user interests. |
| Location data | Retrieve location information if publicly available on Spotify profiles. |
| Activity metrics | Collect engagement metrics such as playlist activity or recent updates. |

### Key Features of **Spotify** Email Scraper

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

- ⭐ **Automated** **Spotify** email extraction tool for efficient data collection
- ⭐ Ability to extract emails from **Spotify** profiles with high accuracy
- ⭐ Supports large-scale data scraping for extensive contact databases
- ⭐ Includes additional data types such as genres and follower counts
- ⭐ User-friendly interface with straightforward setup and operation
- ⭐ **Customizable** scraping options to target specific profile attributes
- ⭐ **Secure** and compliant data extraction processes to protect user privacy
- ⭐ **Fast** processing speeds for timely data retrieval
- ⭐ Detailed reporting and export options for organized data management
- ⭐ **Integration** capabilities with CRM systems and marketing tools
- ⭐ **Regular** updates to ensure compatibility with **Spotify** platform changes
- ⭐ Reliable customer support for troubleshooting and assistance

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

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

1. ✅ **Sign up** for the **Spotify** Email Scraper tool and **log in** to your account
2. ✅ Navigate to the scraping dashboard and input your target keywords or profile criteria
3. ✅ Customize the scraping settings to specify the data types you wish to extract
4. ✅ **Start** the scraping process and monitor progress via the live dashboard
5. ✅ Once the scraping is complete review the extracted data for accuracy
6. ✅ **Export** the collected data to your preferred file format such as CSV or Excel
7. ✅ **Integrate** the exported data with your CRM or marketing tools for further use
8. ✅ Repeat the process as needed to update your contact database regularly

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for **Spotify**-focused marketing initiatives
🎯 **Identify** potential collaborators or influencers in specific genres

Research and Analysis
🎯 Gather data for analyzing **Spotify** user demographics and preferences
🎯 **Study** engagement metrics to understand audience behavior

Networking Opportunities
🎯 Connect with **Spotify** users for professional collaborations
🎯 Expand your network by reaching out to relevant profiles

Business Development
🎯 Develop partnerships with **Spotify** users in your industry
🎯 Enhance outreach strategies with accurate contact information

### Why choose us? 💎

**Spotify** Email Scraper offers a **reliable** and efficient solution for extracting contact information from **Spotify** profiles. Our tool is designed to save time and effort by automating the data collection process while ensuring accuracy and compliance.

With **advanced** features like customizable scraping options and integration capabilities, users can tailor the tool to meet their specific needs. We prioritize user privacy and legal compliance, making our scraper a trustworthy choice for businesses and individuals.

Our team provides **regular** updates to maintain compatibility with **Spotify**'s platform changes, ensuring uninterrupted data extraction. Additionally, our customer support team is available to assist with any issues or queries, ensuring a seamless user experience.

By choosing **Spotify** Email Scraper, you gain access to a powerful tool that enhances your outreach strategies and supports your business goals.

### **Spotify** Email Scraper Scalability 📈

**Spotify** Email Scraper is built to handle **large-scale** data extraction tasks with ease. Whether you're targeting a few profiles or thousands, our tool ensures **efficient** processing and accurate results.

The scraper's **advanced** algorithms are optimized for speed and reliability, making it suitable for businesses with **extensive** data needs. Users can customize the scraping settings to focus on specific data types or profile attributes, enabling targeted data collection at scale.

Our tool supports integration with CRM systems and marketing platforms, allowing users to manage and utilize their data **seamless**ly. With regular updates and robust infrastructure, **Spotify** Email Scraper is equipped to grow alongside your business and adapt to increasing data demands.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Spotify**s terms of service when using the scraper
⚖️ **Only** extract publicly available information from **Spotify** profiles
⚖️ **Do not** use the tool to collect sensitive or private user data
⚖️ **Avoid** using scraped data for unsolicited or spam marketing campaigns
⚖️ Respect user privacy and adhere to data protection regulations in your region
⚖️ **Use** the scraper ethically and responsibly to maintain platform integrity
⚖️ Verify the legality of data scraping practices in your jurisdiction
⚖️ **Do not** share or sell extracted data without proper authorization

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is Spotify **Email Scraper**?

Spotify Email Scraper is a tool designed to extract contact information, such as email addresses, from Spotify profiles.

#### How does the Spotify email **extract**ion tool work?

The tool scans Spotify profiles for **publicly available** contact details and compiles them into a structured format.

#### Is Spotify **Email Scraper** **legal** to use?

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

#### Can I **extract** other data types besides email addresses?

**Yes**, the tool can also extract profile names, genres, follower counts, and more.

#### How accurate is the email scraper for Spotify?

The scraper is designed to provide highly accurate results by focusing on **publicly available** data.

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

**Yes**, Spotify Email Scraper is optimized for handling extensive data scraping tasks efficiently.

#### Can I customize the scraping settings?

**Yes**, users can adjust settings to target specific data types or profile attributes.

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

The tool supports exporting data in formats such as **CSV** and Excel.

#### Does Spotify **Email Scraper** integrate with other tools?

**Yes**, the scraper can integrate with CRM systems and marketing platforms for **seamless** data management.

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

**Yes**, our support team is available to assist with any issues or questions.

#### How often is the tool updated?

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

#### Can I use the tool for personal networking?

**Yes**, the tool is suitable for connecting with Spotify users for professional collaborations.

#### What precautions should I take when using the scraper?

Ensure **compliance** with legal guidelines and avoid using scraped data for unethical purposes.

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

**Yes**, Spotify Email Scraper uses **secure** processes to protect user data during extraction.

#### Can I cancel my subscription at any time?

**Yes**, users can cancel their subscription at any time without penalties.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Email Scraper",
        "description": "Spotify Email Scraper helps you collect artist and business emails directly from Spotify profiles. Use the data for promotions, partnerships, and campaign coordination. Fast, scalable scraping with clean, export-ready results.",
        "version": "0.1",
        "x-build-id": "1U9tlXsIxec4pq5pz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~spotify-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-spotify-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/scrapio~spotify-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-spotify-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/scrapio~spotify-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-spotify-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 Spotify (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Spotify profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Spotify"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Spotify"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```