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

🔍 Spotify Email Scraper Fast Advanced & Cheapest extracts verified email contacts from Spotify to power outreach. ⚡️ Fast, advanced filtering, and budget-friendly pricing. 🚀 Ideal for lead gen, marketing, and sales teams.

- **URL**: https://apify.com/scraperoka/spotify-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Social media
- **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 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/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

### Spotify Email Scraper - Fast, Advanced and Cheapest 🎯

Manually hunting for contact emails across Spotify profiles wastes hours you don’t have. **Spotify Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from Spotify using the keywords and filters you choose. It’s built for anyone searching for a Spotify email scraper, Spotify lead scraper, or advanced Spotify email extractor tool—ideal for marketers, recruiters, and growth teams. In one run, you can collect thousands of potential contacts and export the results instantly.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "network": "Spotify.com",
  "keyword": "manager",
  "title": "Marketing Manager — Spotify",
  "description": "Marketing role | Contact: person@example.com | Follow updates",
  "url": "https://open.spotify.com/artist/example",
  "email": "person@example.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Shows the source network the lead was pulled from (Spotify.com). |
| `keyword` | string | Which keyword triggered the discovery so you can track your results by search intent. |
| `title` | string | The result title captured alongside the email for easier lead context. |
| `description` | string | The extracted text around the contact info, useful for quick validation. |
| `url` | string | The page link where the contact information was found. |
| `email` | string | The email address extracted from publicly available data. |

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

***

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

There are a lot of ways to pull data from Spotify — here’s what sets **Spotify Email Scraper - Fast, Advanced and Cheapest** apart.

#### Built for fast lead collection

Spotify Email Scraper - Fast, Advanced and Cheapest is designed to work through your keyword and email-domain inputs efficiently, collecting emails until it hits your limit or results end. You can broaden coverage with more keywords and more domains when you need more volume.

#### Flexible targeting with keywords and email domains

You control what the scraper looks for using `keywords` and `customDomains` (like `@gmail.com` or `@yahoo.com`). This makes it easy to run a Spotify email harvesting software workflow tailored to your ICP and outreach strategy.

#### Output designed for direct outreach workflows

Each record includes `keyword`, `title`, `description`, `url`, and the extracted `email`. That structure makes Spotify contact email finder outputs easier to review, deduplicate in your pipeline, and import into tools for outreach.

#### Resilience and run recovery for large jobs

The actor saves progress and deduplicates results via `seen_emails`, so reruns can resume where they left off and avoid re-collecting the same email addresses. It also supports retries and stop conditions to keep runs practical at scale.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords or queries used to find relevant Spotify leads and extract matching emails. |
| `location` | ⬜ | Optional location filter to help narrow down results. |
| `customDomains` | ⬜ | List of email domains the scraper will extract emails for (for example `@gmail.com`, `@yahoo.com`). |
| `maxEmails` | ⬜ | Caps the maximum number of emails to collect; stops the run once the limit is reached to control time and cost. |

***

### Core Capabilities

#### Email extraction from Spotify-based leads

Spotify Email Scraper - Fast, Advanced and Cheapest extracts email addresses from Spotify using the keyword inputs and domain filters you provide. The actor captures the lead context (title and description) so the output isn’t just raw emails.

#### Input flexibility for different outreach strategies

Use `keywords` to target roles, intents, or search themes, and `customDomains` to focus on specific email providers or B2B-style domains. If you’re building a Spotify email database scraper for outreach, this helps you tune results rather than accept everything.

#### Deduplication and progress persistence

The actor maintains a `seen_emails` set and saves progress, so you don’t keep collecting the same email again and again. This is especially useful for Spotify email extraction tool use cases where you run the job in batches.

#### Practical stopping rules for cost control

It respects `maxEmails` as a hard stop for collection volume, and it includes stop conditions for when new emails stop appearing. That means your advanced Spotify email scraper run can end cleanly instead of dragging on indefinitely.

#### Structured dataset output for easy importing

Results are written incrementally to the Apify dataset so you can start reviewing as the run proceeds. The dataset view is configured as a table with `keyword`, `title`, `description`, `url`, and `email`, making it straightforward to validate leads fast.

***

### Who Gets the Most Out of This

Here's how different teams put Spotify Email Scraper - Fast, Advanced and Cheapest to work:

**Marketing managers** can generate a targeted list of Spotify business email scraper leads by running role-focused keywords (like “manager” and “founder”) combined with specific email domains, then exporting the dataset directly for outreach.

**Recruiters and talent sourcers** can use the Spotify contact email finder output to speed up first-touch campaigns—emails come bundled with `title`, `description`, and `url` for quick verification before contacting.

**Influencer outreach specialists** can treat this as a Spotify influencer email scraper workflow: run multiple keywords, restrict to the domains your candidates usually use, and build a ready-to-import list of contacts for campaigns.

**Freelance researchers and analysts** can use the consistent structured output to compare coverage across keyword sets and domains, then iterate until they reach the desired email volume.

**Automation specialists (technical users)** can integrate the actor into pipelines by triggering runs with specific inputs, processing the dataset programmatically, and storing leads in their systems for further enrichment and deduplication.

***

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

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

1. **Open the actor on Apify** — start from the actor page on [console.apify.com](https://console.apify.com).
2. **Enter your inputs** — set `keywords` (required), and optionally `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — use your preferred proxy approach for reliable scraping on larger runs.
4. **Hit Run and watch the live log** — follow progress as results are pushed to the dataset.
5. **View results in the dataset tab** — review `keyword`, `title`, `description`, `url`, and `email` as they appear.
6. **Export as JSON, CSV, or Excel** — download in your preferred format directly from the Apify dataset.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Spotify Email Scraper - Fast, Advanced and Cheapest plugs directly into your existing workflow. You can export results in **JSON**, **CSV**, or **Excel** from the Apify dataset tab for easy use in spreadsheets, CRMs, and internal databases.

For automation and distribution, you can connect the actor to your stack using **Apify API access**, **webhooks** for downstream actions when runs complete, and **no-code automation** tools like Zapier or Make. For full details on programmatic access and automation patterns, refer to the Apify documentation at [apify.com/docs/api](https://apify.com/docs/api).

***

### Pricing & Free Trial

Spotify Email Scraper - Fast, Advanced and Cheapest runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can run small tests to validate your Spotify email scraper targeting before scaling up.

For larger jobs, the run cost is based on Apify compute usage. Exact pricing depends on your plan and run configuration, so check the Apify pricing page for the latest details. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Resumable scraping | Saves progress and keeps track of already found emails so reruns can continue without starting from zero. |
| Result deduplication | Avoids pushing the same email multiple times using `seen_emails`. |
| Practical run limits | Stops when `maxEmails` is reached and uses internal stop conditions when new emails stop appearing. |
| Dataset writing | Pushes results incrementally so you can export even if the run stops early. |

Limitations: the actor works with **publicly available data** and depends on what emails are present in accessible sources. If there are few matching emails for your keyword and domain filters, results may be lower than your requested cap.

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 so you can test Spotify Email Scraper - Fast, Advanced and Cheapest with smaller runs before scaling. Availability and limits depend on your Apify account setup.

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

No. This actor extracts emails from publicly available sources, so it doesn’t require Spotify account access or login-gated viewing.

#### How accurate is the data?

Accuracy depends on what’s present in the publicly available content the actor extracts. It pulls email addresses that match the domains provided in `customDomains` and associates them with the surrounding `title`, `description`, and `url`.

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

You can control the maximum volume using `maxEmails`. If you request more than the free-tier cap while on a free plan, the actor applies a maximum of 100 emails.

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

The actor scrapes at run time, so freshness corresponds to when you execute the run. If you need the most up-to-date leads, schedule recurring runs and export the newest dataset each time.

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

The actor uses **publicly available data**, but compliance is ultimately your responsibility. Ensure you handle the collected emails in line with GDPR, CCPA, platform ToS, and any local regulations.

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

Yes. You can export the Apify dataset as JSON, CSV, or Excel directly from the dashboard. From there, you can import into Google Sheets or other tools.

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

Yes, you can schedule actor runs using Apify’s scheduling capabilities. This is helpful for keeping your Spotify email database fresh with minimal effort.

#### Can I access this via API?

Yes. You can access run results programmatically via the Apify API. Check the Apify developer docs for how to trigger runs and retrieve dataset outputs.

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

Results already collected are pushed incrementally to the dataset, and progress is saved. If a run ends early, you can rerun the actor to resume without re-collecting the same emails.

***

### Need Help or Have a Request?

Got a question about Spotify Email Scraper - Fast, Advanced and Cheapest or want a new feature added? Reach out at <dataforleads@gmail.com> and we’ll help. We’re happy to take feedback on improvements for Spotify email scraper workflows, including ideas like webhook notifications on completion and tailored input presets for different outreach niches.

***

### Disclaimer & Responsible Use

*Spotify Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to build a Spotify outreach contact list — start your free run today.*

This actor collects **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for using the collected data in compliance with GDPR, CCPA, platform ToS, and other applicable laws. 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/spotify-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/spotify-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/spotify-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/spotify-email-scraper-fast-advanced-and-cheapest",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Email Scraper Fast Advanced And Cheapest",
        "description": "🔍 Spotify Email Scraper Fast Advanced & Cheapest extracts verified email contacts from Spotify to power outreach. ⚡️ Fast, advanced filtering, and budget-friendly pricing. 🚀 Ideal for lead gen, marketing, and sales teams.",
        "version": "1.0",
        "x-build-id": "g8mlghTgVFcU9PPhg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~spotify-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-spotify-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~spotify-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-spotify-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~spotify-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-spotify-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
