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

🔎 Spotify Email Scraper extracts business emails from Spotify profiles with keyword, country & niche filtering. 📩 Build targeted lists fast for outreach, sales, and marketing—boost conversions with accurate leads in minutes.

- **URL**: https://apify.com/solid-scraper/spotify-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 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

### Spotify Email Scraper 🔍

**Spotify Email Scraper** is an Apify actor that scrapes contact emails from **Spotify profiles** using your chosen **keywords** and **custom email-domain filters**. If you’re looking for a **Spotify email scraper** to find business outreach contacts, this tool helps you automate the time-consuming step of building a **Spotify email list**. Whether you’re a marketer, recruiter, researcher, or data enthusiast, it’s built to help you surface relevant emails from **public Spotify bios and posts related to your keywords**—at scale, so you can keep momentum instead of manual searching.

---

### Why choose Spotify Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **Keyword-based email discovery** | Uses your keywords to locate email addresses tied to Spotify bios/posts |
| ✅ **Custom email-domain targeting** | Filters results using your `customDomains` (for example `@gmail.com`) to focus on the right contacts |
| ✅ **Reliability-focused engine choice** | Lets you pick `engine` as `legacy` or `cost-effective` depending on your needs |
| ✅ **Resilience with retries** | Includes retry logic and pagination stopping rules to keep runs effective over time |
| ✅ **Structured, ready-to-use output** | Pushes consistent JSON records (including `email`, `url`, and context fields) into your dataset |
| ✅ **Scale-friendly limits** | Uses `maxEmails` to control collection size and stop once your target is reached |

---

### Key features

- 🔍 **Accurate Spotify email extraction:** Extracts email addresses from publicly available Spotify profile-related text
- 🧰 **Flexible keyword input:** Provide a list of `keywords` to guide what the actor looks for
- 🌐 **Domain-filtered harvesting:** Uses `customDomains` to focus email harvesting on the domains you care about
- 🛡️ **Engine selection for different performance needs:** Choose between `legacy` and `cost-effective` scraping engines
- 🔄 **Pagination + stopping logic:** Collects results page-by-page and stops after reaching your `maxEmails` or after internal end-of-results checks
- 💾 **Real-time dataset saving:** Each found email is pushed immediately to the dataset during the run
- 📊 **De-duplicated emails:** Avoids collecting the same email address more than once per run
- 🧾 **Rich output context for analysis:** Each output row includes the originating `title`, `description`, and `url` for auditability

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["founder", "marketing"],
  "location": "",
  "platform": "Spotify",
  "customDomains": ["@gmail.com"],
  "maxEmails": 20,
  "engine": "Legacy",
  "proxyConfiguration": {}
}
````

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | ✅ | A list of keywords to search for. The scraper uses these keywords to find relevant Spotify bios and posts that may contain emails. |
| `location` | ❌ | Location to filter search results. Leave empty to skip location filtering. |
| `platform` | ❌ | Select platform. This actor supports `Spotify` (default: `Spotify`). |
| `customDomains` | ❌ | List of custom email domains to target (e.g., `@gmail.com`). This helps you focus your Spotify email scraper output on the kinds of contacts you want. |
| `maxEmails` | ❌ | Maximum number of emails to collect. The scraper stops once this limit is reached (default: `20`). Higher values may take longer and do not guarantee that many emails will be found. |
| `engine` | ❌ | Choose scraping engine. Options: `cost-effective` (“Cost Effective (New)”) or `legacy` (“Legacy”). Default is `Legacy`. |
| `proxyConfiguration` | ❌ | Proxy configuration for this Actor. Use this if you want to control how scraping traffic is routed. |

> Note: The actor description indicates that large searches or high email limits may take longer, and you can increase the timeout in Run Options (default: `3600 s / 1 hr`).

***

### Output

The actor saves each discovered email as a JSON row in the default output dataset.

Example output row:

```json
{
  "network": "Spotify.com",
  "keyword": "founder",
  "title": "No title",
  "description": "No data",
  "url": "https://example.com",
  "email": "person@example.com",
  "proxyGroups": ["GOOGLE_SERP"]
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `network` | string | The source network label used by the actor (`Spotify.com`). |
| `keyword` | string | The keyword currently being used for the email discovery run. |
| `title` | string | Title text associated with the result where the email was found. |
| `description` | string | Description/snippet text associated with the result (the text the actor extracts emails from). |
| `url` | string | URL associated with the result where the email was found. |
| `email` | string | The extracted email address. |
| `proxyGroups` | array | Proxy groups list used during that push (as passed from the actor run). |

You can export the dataset from Apify Console to JSON or CSV using the platform’s built-in export tools.

***

### How to use Spotify Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and log in.

2. **Find the actor**\
   Search for **Spotify Email Scraper** and open the actor details page.

3. **Add your input**\
   In the **INPUT** section, use the form or paste an `input.json` that includes at least `keywords`.\
   Optionally add `customDomains`, `maxEmails`, and `location` to tighten targeting.

4. **Choose your engine (optional)**\
   If you need different performance characteristics, set `engine` to `legacy` or `cost-effective`.

5. **Configure proxies (optional)**\
   If needed, adjust `proxyConfiguration` to match your scraping environment.

6. **Run the actor**\
   Click **Run**. During execution, you’ll see logs as pages are fetched and emails are extracted and pushed into the dataset.

7. **Review results in the dataset**\
   After the run completes, open the **OUTPUT** dataset to view and filter your collected Spotify emails (including `title`, `description`, and `url` context).

8. **Export for your workflow**\
   Export the dataset to **JSON or CSV** so you can load it into your CRM, spreadsheets, or analysis pipeline.

No coding required—get accurate Spotify email scraping results in minutes with this SEO-optimized **Spotify email harvesting tool**.

***

### Advanced features & SEO optimization

- 🧠 **Engineered for Spotify contact discovery:** Built specifically as a **Spotify email scraper** for uncovering outreach emails tied to Spotify profile bios and keyword-relevant posts.
- 🎯 **Better targeting with domain filters:** By using your `customDomains` (like `@gmail.com`), this Spotify contact email finder can focus on the types of addresses you actually want.
- 🧾 **Structured dataset rows for lead research:** Every push includes context fields (`title`, `description`, `url`) so Spotify artist email scraper outputs are easier to verify and analyze.
- 💬 **Run robustness for long collections:** The actor includes pagination and end-of-results stopping logic, plus retries/fallback behavior to keep results coming when possible.
- 🔄 **Automation-ready for Spotify leads:** It’s designed for automation workflows—ideal for building a Spotify email address finder list from public web data at scale.

***

### Best use cases

- 📈 **Growth marketers building outreach lists:** Quickly enrich campaigns with emails relevant to Spotify brands, teams, or creators
- 🎓 **Researchers collecting contact data for analysis:** Analyze how keywords correlate with email domains and outreach patterns
- ✉️ **Email marketing teams sourcing prospects:** Generate a Spotify email list to fuel newsletters, cold-email outreach, and lead nurturing
- 🧑‍💼 **Recruiters and talent scouts:** Find Spotify business email contacts for hiring, partnerships, or talent outreach
- 🎙️ **Podcast and media outreach:** Discover Spotify podcast email scraper contacts for show promotion and sponsorship conversations
- 🏢 **Companies seeking partnerships:** Use the Spotify company email scraper workflow to build lists around specific niches and roles
- 💻 **Developers integrating lead data pipelines:** Automate Spotify email scraping automation into ETL jobs and CRM imports

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of strings (required)
  - ✅ `customDomains` as an array of strings
  - ✅ Optional `location`, `platform` (`Spotify`), `maxEmails`, `engine`, and `proxyConfiguration`

- **Proxy Support**
  - ✅ `proxyConfiguration` is supported (Apify proxy configuration)
  - ✅ Engine choice supports different operational modes (`legacy` vs `cost-effective`)

- **Retry Mechanism**
  - ✅ Includes retry logic and pagination stopping behavior to handle blocks and low-results situations over time

- **Dataset Structure**
  - ✅ Each found email is pushed as a dataset row containing: `network`, `keyword`, `title`, `description`, `url`, `email`, `proxyGroups`

- **Rate Limits & Performance**
  - ⚠️ Processing time depends on run size and limits (for example `maxEmails` and large searches may take longer)
  - ✅ You can adjust run timeout in **Run Options** (default mentioned: `3600 s / 1 hr`)

- **Limitations**
  - ❌ No guarantee that `maxEmails` will be reached (the actor stops when it hits the limit, but availability of emails varies)
  - ❌ Emails are only extracted when present in publicly available Spotify profile-related content as described by the actor

***

### FAQ

#### Is Spotify Email Scraper extracting emails only from Spotify?

✅ Yes. The actor description states that it finds emails from Spotify bios and posts related to your keywords, and the dataset rows are labeled with `network: "Spotify.com"`.

#### What do `keywords` do in Spotify Email Scraper?

`keywords` are the terms you provide to guide discovery. The actor uses them to find relevant Spotify profile-related pages where emails may appear.

#### How do `customDomains` help with results?

`customDomains` are used to target specific email domains. For example, if you want only Gmail-based contacts, set `customDomains` to `["@gmail.com"]` so the Spotify email scraper focuses on those domains.

#### What does `maxEmails` control?

`maxEmails` is the maximum number of emails the scraper will collect. Once that number is reached, the actor stops. Higher values can take longer and still may not reach the target if fewer matching emails exist.

#### Which engine should I choose: `legacy` or `cost-effective`?

Use `engine` to match your needs. The input description explains that `cost-effective` is intended to be faster/cheaper with residential proxy support, while `legacy` is described as more reliable but slower and more expensive.

#### Do I need any special setup to use proxies?

No. You can run with defaults, or set `proxyConfiguration` if you want to control how requests are routed. This is especially useful for large batches or stricter scraping environments.

#### Can I use the output for lead generation or outreach?

✅ In general, this can support outreach use cases like building a Spotify email list. However, you must follow applicable laws and platform rules. The actor collects information from publicly available sources, and it’s your responsibility to ensure compliant use.

#### Where can I request changes or report issues?

For custom solutions or feature requests, contact the team at <dataforleads@gmail.com>.

***

### Support & feature requests

If you’re using Spotify Email Scraper and want improvements (for example, better lead coverage for specific niches, or changes to output formatting), tell us what you need.

- 💡 **Feature Requests:** Examples include enhanced CSV/JSON export options, additional filtering controls for Spotify email scraping, or workflow improvements for Spotify leads email scraper use cases.
- 📧 **Contact:** Email <dataforleads@gmail.com>

Your feedback helps shape the roadmap for the Spotify email harvesting tool experience.

***

### *Spotify Email Scraper* — get your outreach-ready *Spotify email list* faster

*This is a comprehensive, SEO-optimized Spotify email harvesting tool designed for marketers, analysts, and researchers who need results at scale.*

***

### Disclaimer

**This actor only accesses publicly accessible sources** to extract emails. It does not access private profiles, authenticated data, or password-protected pages.

Compliance with applicable laws (including GDPR/CCPA where relevant), spam regulations, and platform terms is your responsibility.

For data removal requests, contact <dataforleads@gmail.com>.

Use Spotify Email Scraper responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

A list of keywords to search for.

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

Location to filter search results.

## `platform` (type: `string`):

Select platform.

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

## `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`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Spotify",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "Legacy"
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/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": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solid-scraper/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 business emails from Spotify profiles with keyword, country & niche filtering. 📩 Build targeted lists fast for outreach, sales, and marketing—boost conversions with accurate leads in minutes.",
        "version": "0.0",
        "x-build-id": "t7XEzxIIg1IGHbTLH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~spotify-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-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/solid-scraper~spotify-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-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/solid-scraper~spotify-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-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": "A list of keywords to search for.",
                        "default": [
                            "founder",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Spotify"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Spotify"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "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
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "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": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
