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

Spotify Email Scraper extracts publicly available email addresses from Spotify artist profiles and linked pages. Build targeted contact lists for artist management, labels, and promoters running outreach campaigns.

- **URL**: https://apify.com/scraper-engine/spotify-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Developer tools, Other
- **Stats:** 20 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

### **Spotify** Email Scraper 📱

The **Spotify** Email Scraper is capable of **extract**ing a wide range of **data** from **Spotify** user profiles. It enables users to gather **contact** information, such as email addresses, usernames, and profile details, in an organized manner.

This **data** can be used for various purposes, including marketing campaigns, research, and networking. Additionally, the tool can **extract** information about user playlists, followers, and other relevant **data** points.

By automating the **data** **extract**ion process, the **Spotify** Email Scraper saves time and ensures accuracy. It is designed to handle large volumes of **data**, making it suitable for both small-scale and enterprise-level projects.

Spotify Email Scraper is a powerful tool designed to help you extract email addresses and other contact information from Spotify user profiles efficiently. It is ideal for businesses and individuals looking to connect with Spotify users for marketing or networking purposes.

With the Spotify Email Scraper, you can quickly gather valuable data from Spotify accounts without manual effort. This tool simplifies the process of collecting contact information while adhering to ethical and legal standards.

Spotify email scraping allows you to build targeted email lists for your campaigns, saving you time and resources. It is a reliable solution for those who need accurate and up-to-date contact details from Spotify users.

### 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 verified email addresses from Spotify user profiles. |
| Usernames | Retrieve Spotify usernames for identification and communication. |
| Profile details | Collect public information available on Spotify user profiles. |
| Playlist information | Extract details about public playlists created by users. |
| Follower count | Gather data on the number of followers a user has. |
| Account creation date | Retrieve the date when the Spotify account was created. |
| Profile links | Generate direct links to Spotify user profiles. |
| User activity | Extract data on recent activities and interactions of users. |

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

- ⭐ Efficiently extracts email addresses and contact details from **Spotify** user profiles
- ⭐ Supports large-scale data scraping for enterprise-level projects
- ⭐ User-friendly interface for easy operation and minimal learning curve
- ⭐ **Advanced** algorithms ensure high accuracy and minimize errors in data extraction
- ⭐ **Customizable** settings to target specific data fields and user groups
- ⭐ **Secure** and compliant with legal standards for ethical data scraping
- ⭐ Generates organized and exportable data formats such as CSV or JSON
- ⭐ Provides real-time data extraction for up-to-date information
- ⭐ Offers robust customer support to assist with any issues or queries
- ⭐ Compatible with various operating systems and devices for seamless usage
- ⭐ **Automated** scraping process saves time and reduces manual effort
- ⭐ **Regular** updates to ensure compatibility with **Spotify**s platform changes

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

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

1. ✅ Download and install the **Spotify** Email Scraper software on your device
2. ✅ Log in to your **Spotify** account through the scrapers secure interface
3. ✅ Set your data extraction preferences such as target user profiles or playlists
4. ✅ **Select** the specific data fields you want to extract such as emails or usernames
5. ✅ **Input** any additional filters or criteria to refine your scraping process
6. ✅ **Start** the scraping process and monitor the progress in real-time
7. ✅ Pause or stop the scraping process at any time if needed
8. ✅ Once completed review the extracted data for accuracy and completeness
9. ✅ **Export** the data to your preferred format such as CSV or JSON
10. ✅ Use the extracted data for your marketing research or networking purposes
11. ✅ Refer to the user guide or contact support if you encounter any issues
12. ✅ Regularly update the scraper to ensure compatibility with **Spotify**s platform

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for **Spotify** users based on specific criteria
🎯 Promote your music products or services to a relevant audience

Research and Analytics
🎯 **Analyze** user behavior and trends on **Spotify** for market insights
🎯 Gather data on playlists and followers for strategic planning

Networking Opportunities
🎯 Connect with **Spotify** users for collaborations or partnerships
🎯 **Identify** influencers and reach out to them with personalized messages

Data Enrichment
🎯 Enhance your existing database with updated **Spotify** user information
🎯 Validate and verify email addresses for accurate communication

### Why choose us? 💎

Our **Spotify** Email Scraper stands out for its efficiency, accuracy, and **user-friendly** design. It is built with **advanced** algorithms that ensure precise data extraction while minimizing errors.

We prioritize user experience by offering a simple yet powerful interface that requires minimal technical expertise. Our tool is compatible with various operating systems and devices, making it accessible to a wide range of users.

Additionally, we provide robust customer support to assist with any issues or queries. Regular updates ensure that the scraper remains compatible with **Spotify**'s platform, so you can always rely on its performance.

We also prioritize data security and compliance with legal standards, giving you peace of mind while using our tool. Whether you're a small business or a large enterprise, our **Spotify** Email Scraper is designed to meet your needs and help you achieve your goals efficiently.

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

The **Spotify** Email Scraper is designed to handle projects of any size, from small-scale data extraction to enterprise-level operations. Its **advanced** algorithms ensure that the tool performs **efficient**ly even when processing large volumes of data.

With **customizable** settings, users can target specific data fields and user groups, making the tool adaptable to various requirements. The scraper's automated process minimizes manual effort, allowing you to focus on analyzing and utilizing the extracted data.

Additionally, our tool is optimized for speed and accuracy, ensuring that you receive reliable results in a timely manner. Whether you need to extract data from hundreds or millions of **Spotify** profiles, the **Spotify** Email Scraper can scale to meet your 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 before using the **Spotify** Email Scraper
⚖️ **Do not** use the scraper to collect data for illegal or unethical purposes
⚖️ **Obtain** consent from users before using their contact information for marketing purposes
⚖️ **Avoid** scraping private or sensitive information that is not publicly available
⚖️ **Use** the extracted data responsibly and in accordance with data protection laws
⚖️ **Do not** share or sell the extracted data without proper authorization
⚖️ Regularly review and comply with updates to **Spotify**s platform policies
⚖️ **Ensure** that your scraping activities do not disrupt **Spotify**s services or violate their guidelines

### 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 the Spotify **Email Scraper**?

The Spotify Email Scraper is a tool designed to extract email addresses and other contact information from Spotify user profiles.

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

**Yes**, as long as you comply with Spotify's terms of service and use the data responsibly.

#### What data can I **extract** using the Spotify **Email Scraper**?

You can extract email addresses, usernames, profile details, playlist information, and more.

#### Can I use the Spotify **Email Scraper** for **large-scale** projects?

**Yes**, the tool is designed to handle both small-scale and enterprise-level data scraping tasks.

#### Is the Spotify **Email Scraper** easy to use?

**Yes**, the tool features a **user-friendly** interface that requires minimal technical expertise.

#### What formats can I **export** the data to?

You can export the extracted data to formats such as **CSV** or **JSON**.

#### Does the scraper comply with data protection laws?

**Yes**, the Spotify Email Scraper is designed to adhere to data protection laws and ethical guidelines.

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

**Yes**, the tool allows you to set preferences and filters to target specific data fields and user groups.

#### Is **customer support** available?

**Yes**, we offer robust customer support to assist with any issues or queries.

#### How often is the scraper updated?

The Spotify Email Scraper is regularly updated to ensure compatibility with Spotify's platform changes.

#### Can I use the scraper on multiple devices?

**Yes**, the Spotify Email Scraper is compatible with various operating systems and devices.

#### Is the data **extract**ion process automated?

**Yes**, the Spotify Email Scraper automates the data extraction process to save you time and effort.

#### What is the accuracy rate of the **extract**ed data?

The Spotify Email Scraper uses advanced algorithms to ensure high accuracy in data extraction.

#### Can I pause or stop the scraping process?

**Yes**, you can pause or stop the scraping process at any time using the tool's interface.

#### Is there a free trial available?

Please visit our website to check for any available free trial options for the Spotify Email Scraper.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraper-engine/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 extracts publicly available email addresses from Spotify artist profiles and linked pages. Build targeted contact lists for artist management, labels, and promoters running outreach campaigns.",
        "version": "0.1",
        "x-build-id": "YjUmvv07xhozO1PtZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~spotify-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-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/scraper-engine~spotify-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-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/scraper-engine~spotify-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```