# Soundcloud Email Scraper Fast Advanced And Cheapest (`scraperoka/soundcloud-email-scraper-fast-advanced-and-cheapest`) Actor

🚀 Soundcloud Email Scraper Fast Advanced & Cheapest extracts verified email contacts from SoundCloud profiles quickly. 🔥 Perfect for outreach, B2B lead gen & marketing lists. ✅ Affordable, efficient, and easy to use. 📩 Get leads fast!

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

## Pricing

from $1.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 - Fast, Advanced and Cheapest 🎯

Manually hunting for Soundcloud contact emails wastes hours and breaks your outreach workflow. **Soundcloud Email Scraper - Fast, Advanced and Cheapest** extracts emails from Soundcloud using keywords and domain filters, so marketers, recruiters, and growth teams can build lead lists quickly. It’s a Soundcloud email scraper and Soundcloud leads email scraper designed for fast, advanced, and cost-efficient harvesting—so you can collect up to thousands of records in minutes depending on your limits.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Soundcloud.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "example@gmail.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network as `Soundcloud.com` for consistent reporting |
| `keyword` | string | The keyword that was used to generate the contact you found (useful for audits and scaling) |
| `title` | string | The page/title text associated with the found email (helps you validate relevance) |
| `description` | string | The extracted surrounding text where the email was detected (great for context) |
| `url` | string | The related link for the record so your team can cross-check quickly |
| `email` | string | The email address extracted from Soundcloud publicly available data |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Soundcloud Email Scraper - Fast, Advanced and Cheapest?

There are a lot of ways to pull contact data from the web — here’s what sets **Soundcloud Email Scraper - Fast, Advanced and Cheapest** apart for anyone trying to scrape Soundcloud emails at scale.

#### Speed at Scale (Keyword × Domain Coverage)

This Soundcloud artist email scraper is built to iterate through your `keywords` and `customDomains`, collecting results until your `maxEmails` limit is reached. Bigger coverage usually means more chances to find relevant contacts, especially when you use a Soundcloud email scraping tool with targeted terms.

#### Flexible Input for Better Match Quality

You control the lead-finding strategy using `keywords`, optional `location`, and `customDomains` (for example `@gmail.com`). That makes this soundcloud email finder tool feel more like an advanced workflow than a one-size-fits-all scrape.

#### Resilient Progress & Resumable Runs

If a run is interrupted, it maintains a resume state using a saved cursor and the set of `seen_emails`. That means your automated soundcloud email harvesting can continue without losing what was already collected.

#### Clean, Integration-Ready Dataset Output

Results are pushed incrementally to the dataset with consistent fields like `keyword`, `url`, and `email`. This helps you move from scraping soundcloud leads email scraper outputs straight into downstream analysis or outreach systems.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["manager", "founder"],
  "location": "United States",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | Provide the keywords used to find relevant Soundcloud results and extract emails associated with those terms |
| `location` | ⬜ | Optional location filter to help narrow which results are considered |
| `customDomains` | ⬜ | Email domains to focus on (for example `@gmail.com`, `@yahoo.com`) so you get more targeted contact emails |
| `maxEmails` | ⬜ | Stops the scraper once this many unique emails have been collected (higher values can take longer and don’t guarantee hitting the exact number) |

***

### Core Capabilities

#### Targeted Soundcloud Email Extraction

This actor extracts email addresses from Soundcloud using your chosen `keywords` and `customDomains`. Using an advanced soundcloud email extractor approach (keywords + domains) typically yields better relevance than broad scraping.

#### Domain Filters for Cleaner Outreach Lists

If you only want emails from certain providers (like `@gmail.com`), `customDomains` lets you filter up front. That’s especially useful for building a soundcloud email database that fits your outreach strategy.

#### Resumable Progress for Reliable Automation

The actor saves progress and tracks `seen_emails`, so you don’t keep re-collecting duplicates. This makes it a solid foundation for automated soundcloud email harvesting in repeatable workflows.

#### Cost-Controlled Result Limits

`maxEmails` lets you cap how many unique emails the run collects. This helps control scraping time and costs while you test a Soundcloud email scraping tool strategy before scaling up.

#### Dataset Output Built for Analysis

Each saved record includes the context fields `keyword`, `title`, `description`, and `url`, alongside `email`. That gives data analysts and researchers the evidence trail they need to review and filter the soundcloud contact email finder results later.

***

### Who Gets the Most Out of This

Here’s how different teams put **Soundcloud Email Scraper - Fast, Advanced and Cheapest** to work:

**Growth Marketers & Outreach Teams** — They run a soundcloud outreach email scraper job to build a targeted list, focusing on specific email domains and job-title-like keywords, then use the dataset for rapid outreach segmentation.

**Recruiters & Talent Sourcing Leads** — They use this soundcloud email finder tool to find contact emails for creators and professionals, saving hours of manual searching and speeding up first-contact outreach.

**Freelance Researchers & Lead List Analysts** — They combine extracted context (`keyword`, `description`, and `url`) with the `email` field to validate relevance, remove duplicates, and enrich records for reports.

**Automation & Integration Developers** — They schedule or trigger runs via the Apify API, then feed the dataset rows (including `email` and source context like `url`) into pipelines for deduplication, CRM import, and analytics.

**Community & Agency Managers** — They use the location filter and domain filters to match the contact list to specific regions and outreach preferences, improving list quality before campaigns go live.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Soundcloud Email Scraper - Fast, Advanced and Cheapest from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open **Soundcloud Email Scraper - Fast, Advanced and Cheapest**.
2. **Enter your inputs** — set `keywords` (required), then optionally add `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — keep proxy options enabled for reliable scraping at scale (follow the Run Options UI).
4. **Hit Run and watch the live log** — monitor progress and see when new emails are found.
5. **View results in the dataset tab** — each record includes `keyword`, `url`, and the extracted `email`.
6. **Export as JSON, CSV, or Excel** — download directly from Apify and share with your team.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Soundcloud Email Scraper - Fast, Advanced and Cheapest** plugs directly into your existing workflow.

You can export your results from the Apify dataset tab in common formats like JSON, CSV, or Excel, which is ideal for importing into spreadsheets, BI tools, or CRMs. The consistent dataset fields also make it easier to automate cleanup steps like deduplication and domain-based segmentation.

For programmatic access, you can use the Apify API to pull results from your run (see: https://apify.com/docs/api). You can also connect your runs to automation tools such as Zapier/Make and use webhooks to trigger downstream actions when a run completes, depending on your Apify setup.

***

### Pricing & Free Trial

**Soundcloud Email Scraper - Fast, Advanced and Cheapest** runs on the Apify platform, which offers a **free tier** — no credit card required to get started. On free, there is a result limitation applied by the actor logic: it enforces a maximum of 100 emails maximum for free users. For paid users, the actor does not apply that free-tier cap.

For exact billing details and plan availability, check the Apify pricing page on apify.com and choose the tier that matches your expected volume. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Result caps & cost control | Stops once your unique email limit is reached via `maxEmails` |
| Reliability across runs | Saves progress (cursor and `seen_emails`) so you can resume instead of starting over |
| Resilience during scraping | Uses built-in retry and fallback behavior when results are sparse or requests fail |
| Data freshness during long runs | Pushes records incrementally to the dataset as they’re found |

**Limitations:** The actor works with publicly available sources and focuses on extracting email addresses tied to your provided keywords and email domains. If your chosen keywords/domains are too narrow, you may end up with fewer results than your `maxEmails` target.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes, Apify provides a free tier to get started. The actor applies a free-user limitation of 100 emails maximum, so if you need more, you’ll want a paid plan.

#### Do I need to log in to Soundcloud to use this?

No. This actor is designed to work with publicly available data and does not require Soundcloud login credentials.

#### How accurate is the data?

Accuracy depends on what’s published publicly and discoverable in the sources the actor reads. The actor extracts emails that match your provided domain filters from the available text context, so results are as reliable as the underlying public information.

#### How many results can I get per run?

You can control the unique email count with `maxEmails`. The scraper stops when the `maxEmails` limit is reached, and on free tier it enforces a maximum of 100 emails.

#### How often is the data updated / how fresh is it?

The actor captures data at the time of your run and pushes results incrementally to the dataset during execution. For up-to-date contacts, run it again when you need a fresh export.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor works with **publicly available data**, but compliance depends on how you use, store, and process that data. You’re responsible for following applicable laws (including GDPR/CCPA where relevant) and platform Terms of Service.

#### Can I export results to Google Sheets or Excel?

Yes. You can download your dataset as JSON, CSV, or Excel from the Apify dashboard. From there, you can import into tools like Google Sheets as needed.

#### Can I run this on a schedule automatically?

Yes. On Apify, you can schedule runs (depending on your plan and setup) so **Soundcloud Email Scraper - Fast, Advanced and Cheapest** runs automatically and keeps your dataset updated.

#### Can I access this via API?

Yes. You can trigger the actor via the Apify API and retrieve results programmatically. See https://apify.com/docs/api for details.

#### What happens if the actor hits an error?

Results already found are pushed incrementally to the dataset during the run. The actor also maintains saved progress (cursor and `seen_emails`) so you can resume after interruptions.

***

### Need Help or Have a Request?

Got a question about **Soundcloud Email Scraper - Fast, Advanced and Cheapest** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like batch CSV upload for inputs and webhook notifications when the run completes.

***

### Disclaimer & Responsible Use

*Soundcloud Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to extract Soundcloud contact emails — start your free run today.*

This actor collects **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and any other applicable regulations when using the scraped data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/soundcloud-email-scraper-fast-advanced-and-cheapest").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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/soundcloud-email-scraper-fast-advanced-and-cheapest").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": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scraperoka/soundcloud-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Soundcloud Email Scraper Fast Advanced And Cheapest",
        "description": "🚀 Soundcloud Email Scraper Fast Advanced & Cheapest extracts verified email contacts from SoundCloud profiles quickly. 🔥 Perfect for outreach, B2B lead gen & marketing lists. ✅ Affordable, efficient, and easy to use. 📩 Get leads fast!",
        "version": "1.0",
        "x-build-id": "eTNE9gfLdy2shRFUq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~soundcloud-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-soundcloud-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~soundcloud-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-soundcloud-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~soundcloud-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-soundcloud-email-scraper-fast-advanced-and-cheapest",
                "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 or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
