# Soundcloud Email Scraper (`scrapapi/soundcloud-email-scraper`) Actor

- **URL**: https://apify.com/scrapapi/soundcloud-email-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

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

### **SoundCloud** Email Scraper 📱

The Soundcloud Email Scraper allows users to **extract** valuable **data** from **SoundCloud** profiles. This includes email addresses, usernames, profile URLs, and other relevant **contact** information.

By using this tool, you can gather **data** for marketing, networking, or research purposes in a structured and organized format. The scraper is designed to retrieve publicly available information only, ensuring compliance with **SoundCloud**'s terms of service.

It supports automated **data** **extract**ion, making the process faster and more efficient than manual methods. This tool is ideal for professionals, businesses, and researchers who need accurate and reliable **data** from **SoundCloud** profiles.

Soundcloud Email Scraper is the ultimate tool for extracting email addresses from SoundCloud profiles quickly and efficiently. It is designed to help users gather contact information for networking, marketing, or research purposes.

With the Soundcloud Email Scraper, you can automate the process of finding email addresses on SoundCloud, saving time and effort. This tool is ideal for professionals looking to connect with artists, producers, or other SoundCloud users.

Soundcloud email extraction tools like this one are essential for businesses and individuals seeking to expand their outreach. By using this scraper, you can collect accurate and relevant contact information from SoundCloud profiles.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract publicly available email addresses from SoundCloud profiles. |
| Usernames | Retrieve the usernames associated with SoundCloud profiles. |
| Profile URLs | Collect direct links to SoundCloud user profiles. |
| Follower count | Gather information about the number of followers for each profile. |
| Location | Extract location details if provided on the user's profile. |
| Profile descriptions | Retrieve bio or description text from SoundCloud profiles. |
| Profile images | Download profile images associated with SoundCloud accounts. |
| Social media links | Extract links to other social media platforms shared on SoundCloud profiles. |

### Key Features of **SoundCloud** Email Scraper

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

- ⭐ **Automated** email extraction from **SoundCloud** profiles for fast and accurate results
- ⭐ Supports bulk scraping of multiple profiles to save time and effort
- ⭐ User-friendly interface requiring no advanced technical skills to operate
- ⭐ Provides detailed data such as email addresses usernames and profile URLs
- ⭐ Ensures compliance with **SoundCloud**s terms of service and ethical guidelines
- ⭐ **Customizable** scraping options to target specific data fields or profiles
- ⭐ **High**-speed data extraction with minimal errors or duplicates
- ⭐ Export data in various formats such as CSV or JSON for easy integration
- ⭐ **Secure** and private ensuring user data is protected during the scraping process
- ⭐ **Regular** updates to maintain compatibility with **SoundCloud**s platform

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

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

1. ✅ **Sign up** or **log in** to your account on the Soundcloud Email Scraper platform
2. ✅ Navigate to the dashboard and select the **SoundCloud** scraping tool
3. ✅ Enter the URLs of the **SoundCloud** profiles you want to scrape or upload a list of profile links
4. ✅ Choose the specific data fields you want to extract such as email addresses or usernames
5. ✅ Set any additional filters or parameters to refine your scraping results
6. ✅ **Start** the scraping process and monitor progress on the dashboard
7. ✅ Once the scraping is complete review the extracted data for accuracy
8. ✅ Download the data in your preferred format such as CSV or JSON for further use
9. ✅ Repeat the process as needed for additional profiles or data requirements
10. ✅ Contact support if you encounter any issues or need assistance with the tool

### Use Cases 🎯

Marketing and Outreach
🎯 Build targeted email lists for marketing campaigns
🎯 Connect with **SoundCloud** users who match your target audience
🎯 Promote your products or services to relevant **SoundCloud** users

Networking and Collaboration
🎯 **Find** contact information for artists and producers on **SoundCloud**
🎯 Reach out to potential collaborators for music projects
🎯 Expand your professional network within the music industry

Research and Analysis
🎯 **Collect** data for market research and trend analysis
🎯 **Analyze** **SoundCloud** user demographics and engagement metrics
🎯 **Study** the profiles of popular artists and influencers on **SoundCloud**

Business Development
🎯 **Identify** potential clients or partners on **SoundCloud**
🎯 **Use** extracted data to create personalized outreach strategies
🎯 Enhance your business growth by leveraging **SoundCloud** connections

### Why choose us? 💎

Our Soundcloud Email Scraper is designed to provide accurate and **reliable** data extraction for all your **SoundCloud** needs. With a **user-friendly** interface and **advanced** features, this tool is perfect for professionals, businesses, and researchers alike.

We prioritize compliance with **SoundCloud**'s terms of service and ethical guidelines, ensuring that all extracted data is publicly available and legally obtained. Our scraper offers customizable options, allowing you to target specific profiles or data fields based on your requirements.

We provide high-speed data extraction with minimal errors, saving you time and effort. Regular updates ensure compatibility with **SoundCloud**'s platform, so you can continue to rely on our tool for your data scraping needs.

Choose our Soundcloud Email Scraper for a secure, efficient, and **reliable** solution to your email extraction challenges.

### **SoundCloud** Email Scraper Scalability 📈

The Soundcloud Email Scraper is built to handle data extraction tasks of any size, making it suitable for individuals and enterprises alike. Whether you need to scrape a few profiles or thousands, our tool ensures consistent performance and accuracy.

It supports bulk scraping, allowing you to process multiple profiles simultaneously without compromising on speed or quality. Our scalable infrastructure is designed to accommodate growing data requirements, ensuring that you can rely on the tool as your needs evolve.

With **customizable** options and high-speed processing, the Soundcloud Email Scraper is the perfect solution for small-scale projects and **large-scale** operations. Trust our tool to deliver reliable results, no matter the size of your scraping task.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **SoundCloud**s terms of service and privacy policies before using the scraper
⚖️ **Only** extract publicly available data from **SoundCloud** profiles
⚖️ **Do not** use the scraper for illegal or unethical activities such as spamming or unauthorized marketing
⚖️ Respect the privacy and intellectual property rights of **SoundCloud** users
⚖️ **Obtain** proper consent before using extracted data for commercial purposes
⚖️ **Avoid** scraping profiles that explicitly prohibit data extraction in their descriptions
⚖️ **Use** the scraper responsibly to prevent overloading **SoundCloud**s servers
⚖️ Consult legal professionals if you are unsure about the legality of your scraping activities

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is the Soundcloud **Email Scraper**?

The Soundcloud Email Scraper is a tool designed to extract email addresses and other data from SoundCloud profiles.

#### Is the Soundcloud **Email Scraper** **legal**?

**Yes**, the scraper is legal as long as you comply with SoundCloud's terms of service and only extract **publicly available** data.

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

You can extract email addresses, usernames, profile URLs, follower counts, locations, and more from SoundCloud profiles.

#### Do I need technical skills to use the scraper?

**No**, the scraper is **user-friendly** and does not require advanced technical skills to operate.

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

**Yes**, the scraper supports bulk scraping, allowing you to process multiple profiles simultaneously.

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

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

#### In what formats can I download the data?

You can download the extracted data in formats such as **CSV** or **JSON** for easy integration.

#### Does the scraper comply with SoundCloud's policies?

**Yes**, the scraper is designed to comply with SoundCloud's terms of service and ethical guidelines.

#### How often is the scraper updated?

The scraper is regularly updated to maintain compatibility with SoundCloud's platform.

#### Can I use the **extract**ed data for marketing?

You can use the data for marketing purposes if you have obtained proper consent from the data owners.

#### What should I do if the scraper stops working?

Contact our support team for assistance if you encounter any issues with the scraper.

#### Can I use the scraper for research purposes?

**Yes**, the scraper is ideal for collecting data for research and analysis.

#### Is the scraper **secure**?

**Yes**, the scraper ensures that user data is protected during the extraction process.

#### How long does it take to scrape data?

The time required depends on the number of profiles being scraped, but the scraper is optimized for high-speed processing.

#### Can I customize the scraping process?

**Yes**, the scraper offers customizable options to target specific data fields or profiles.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Soundcloud Email Scraper",
        "version": "0.1",
        "x-build-id": "rWhinOuySLVsCicU9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~soundcloud-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-soundcloud-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/scrapapi~soundcloud-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-soundcloud-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/scrapapi~soundcloud-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-soundcloud-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 Soundcloud (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Soundcloud profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Soundcloud"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Soundcloud"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```