# Substack Email Scraper Fast Advanced And Cheapest (`scrapers-hub/substack-email-scraper-fast-advanced-and-cheapest`) Actor

📧 Substack Email Scraper Fast Advanced & Cheapest extracts verified subscriber emails from Substack quickly and affordably. 🚀 Perfect for B2B lead gen, sales, and outreach—save time, target smarter, and scale faster.

- **URL**: https://apify.com/scrapers-hub/substack-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Automation, Other
- **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

### Substack Email Scraper - Fast, Advanced and Cheapest 📬

**Substack Email Scraper - Fast, Advanced and Cheapest** is an Apify actor built to extract email addresses from Substack using the keywords and email-domain filters you choose. If you’re looking for a **Substack email scraper**, a **Substack contact email extractor**, or a **Substack subscriber email list** to speed up outreach, this tool helps you turn publicly available Substack leads into actionable contact data—saving you hours of manual work.

Whether you’re a marketer, lead generator, researcher, or data analyst, you can use targeted terms and domains (for example `@gmail.com`) to find relevant contacts faster and build a **Substack email database builder** at scale.

---

### 🚀 Why choose Substack Email Scraper - Fast, Advanced and Cheapest?

| Feature | Benefit |
| --- | --- |
| ✅ **Keyword-based Substack email extraction** | Extract emails from Substack based on the keywords you provide |
| ✅ **Custom email-domain filtering** | Focus results on the domains you care about (e.g. `@gmail.com`) |
| ✅ **Reliability with retries & fallbacks** | Includes resilience to keep runs moving even when results are sparse |
| ✅ **Structured dataset output** | Saves consistent lead records to a dataset for easy export and cleanup |
| ✅ **Scales with batching via multiple keywords/domains** | Run broad **Substack bulk email scraping** projects by combining inputs |
| ✅ **Incremental saving** | Pushes results to the dataset as it finds them so you don’t lose progress |

---

### 🔎 Key features

- 📌 **Accurate email extraction from public Substack pages**: Extracts email addresses found in publicly available sources and stores them in a structured dataset  
- 🧩 **Flexible input for lead discovery**: Uses your `keywords` list, optional `location`, and `customDomains` filters to target the right contacts  
- 🛡️ **Resilient scraping with stop conditions**: Includes logic to stop when there’s no further yield (and to respect your max email limit)  
- 🔄 **Progress resume support**: Saves cursor progress and already-seen emails so re-runs can continue from where the actor left off  
- 💾 **Real-time dataset pushing**: Each discovered email is pushed immediately to the dataset with the related keyword and page details  
- 🌐 **Clear lead record structure for analysis**: Outputs fields like `keyword`, `title`, `description`, `url`, and `email` so you can quickly build a **Substack lead generation tool** workflow  
- ⚙️ **Cost/limit control**: Lets you cap work using `maxEmails`, which helps control run time and avoids unnecessary scraping  

---

### 📝 Input

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

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

#### Input Fields

| Key | Required | Description |
| --- | --- | --- |
| `keywords` | Yes | A list of keywords (or queries) used to find relevant Substack leads for email extraction |
| `location` | No | Optional location filter to narrow results; leave empty for no location filtering |
| `customDomains` | No | List of email domains to target (examples: `@gmail.com`, `@yahoo.com`) |
| `maxEmails` | No | Maximum number of emails to collect. The actor stops once this limit is reached (higher values can take longer). Default is `20`. Must be between `1` and `10000`. |

***

### 📦 Output

The actor saves each lead record into the **Substack Emails Dataset** in JSON format as it finds emails.

Example JSON rows pushed to the dataset:

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

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `network` | string | The source network label (always `Substack.com`) |
| `keyword` | string | The keyword used for this extraction run |
| `title` | string | The title associated with the found result (or `No title` if missing) |
| `description` | string | Extracted text used for email matching (or `No data` if missing) |
| `url` | string | The result URL (or `No URL` if missing) |
| `email` | string | The extracted email address |
| `error` | string | Not provided by the actor in the dataset row schema (no `error_message` field is pushed) |

**Export note:** After the run, you can export the dataset in the format supported by Apify (commonly JSON/CSV) for your CRM, spreadsheets, or further analysis.

***

### 🧭 How to use Substack Email Scraper - Fast, Advanced and Cheapest (via Apify Console)

1. **Open Apify Console**\
   Log in at [console.apify.com](https://console.apify.com) and open the actor page for **Substack Email Scraper - Fast, Advanced and Cheapest**.

2. **Go to the Input section**\
   You’ll see the built-in form mapped to the actor’s input fields: `keywords`, `location`, `customDomains`, and `maxEmails`.

3. **Set your `keywords`**\
   Enter job-style or audience terms you want to target (for example `manager`, `founder`). These are used to drive the email harvesting for a **Substack email scraper** workflow.

4. **Optionally set `location`**\
   Add a location if you want to narrow results; otherwise leave it blank for broader coverage.

5. **Set `customDomains` to filter emails**\
   Add domains like `@gmail.com` or `@yahoo.com` to focus on the **Substack contact email extractor** output you actually want.

6. **Choose `maxEmails` for cost & speed control**\
   The actor will stop once the maximum number of collected emails is reached. Default is `20`.

7. **Run the actor and watch logs**\
   During the run, you’ll see progress/resume messages and per-page status updates. Results are pushed incrementally to the dataset as emails are found.

8. **Open the dataset and export**\
   When the run finishes, open **Scraped Leads** (the dataset view `Scraped Leads`) and export the data to JSON/CSV for your next steps in lead generation or research.

No coding required—get accurate results in minutes with **Substack Email Scraper - Fast, Advanced and Cheapest**. ✅

***

### ⚙️ Advanced features & SEO optimization

- 🔄 **Resume-friendly progress saving**: If your run is interrupted, the actor can resume using saved cursor progress and previously seen emails—great for long, **advanced Substack email scraper** sessions.
- 🧠 **Input normalization for better results**: Supports flexible keyword input types so you can run smaller or broader searches without changing your workflow.
- 📊 **Built-in domain strategy for lead quality**: Uses your `customDomains` list to extract emails that match your preferred email extensions—useful for building a **Substack email database builder** that’s already filtered.
- 🧾 **Structured output for fast downstream processing**: Every row includes `keyword`, `title`, `description`, `url`, and `email`, making it easier to clean and enrich later.
- 🛡️ **Resilient scraping with stop conditions**: Includes resilience logic and stops when it’s no longer finding new emails, helping keep large **Substack bulk email scraping** jobs practical.

***

### 🎯 Best use cases

- 📈 **Lead generation for newsletters & creators**: Build a targeted **Substack subscriber email list** for outreach by combining role keywords with email-domain filters
- 💼 **B2B prospecting from publication teams**: Find contacts tied to leadership titles (like manager/founder) and export a ready-to-use **Substack email harvesting tool** dataset
- 🔎 **Audience email discovery for research**: Extract emails from Substack publications to study contact patterns by niche or role
- ✉️ **Email database building for marketing ops**: Turn public web data into a structured list for segmentation, validation, and follow-up sequences
- 🧑‍💻 **CRM pipeline automation**: Feed the dataset fields (`keyword`, `url`, `email`) into your automation stack to enrich records at scale
- 📊 **Data analysis & deduping workflows**: Use the incremental dataset pushes to analyze coverage by keyword and email domain before exporting final results

***

### 🛠️ Technical specifications

**Supported Input Formats**

- ✅ `keywords` (array of strings)
- ✅ `location` (string, optional)
- ✅ `customDomains` (array of strings, optional)
- ✅ `maxEmails` (integer, optional; default `20`; min `1`; max `10000`)

**Proxy Support**

- ✅ Built-in proxy support for reliable scraping (resilience-focused)

**Retry Mechanism**

- ✅ Includes retries and fallbacks for resilience when results are limited or blocked

**Dataset Structure**

- ✅ Dataset: **Substack Emails Dataset**
- ✅ View: **Scraped Leads**
- ✅ Output fields pushed: `keyword`, `title`, `description`, `url`, `email` (plus `network` in the pushed row)

**Rate Limits & Performance**

- ✅ Supports large batches through multiple keyword/domain combinations
- ✅ Processing time varies with search coverage and limits

**Limitations**

- ❌ No guarantee that the actor will reach your exact `maxEmails` target (it stops when results run out)
- ❌ If there are fewer matching public contacts than expected, you may see fewer than the requested number of emails

***

### ❓ FAQ

#### Is this a Substack email scraper that extracts emails only?

✅ Yes. **Substack Email Scraper - Fast, Advanced and Cheapest** extracts email addresses and stores them in the dataset along with related fields such as `keyword`, `title`, `description`, and `url`.

#### What inputs work best for a fast Substack email scraper workflow?

For best results, use targeted `keywords` and add relevant `customDomains` (for example `@gmail.com`). If you need more coverage, broaden your keywords and expand the set of domains.

#### Why might I get fewer emails than `maxEmails`?

The actor stops when it no longer finds new emails in the available public results. Even with a higher `maxEmails`, results may be limited by what matches your `keywords`, optional `location`, and `customDomains`.

#### Does it resume if the run stops early?

✅ Yes. It saves progress (cursor state) and tracks already-seen emails so you can continue without starting from scratch.

#### Can I export results for a Substack subscriber email list?

Yes. The actor pushes structured rows into the **Substack Emails Dataset** view **Scraped Leads**, which you can export in the dataset formats available in Apify (e.g., JSON/CSV).

#### Do I need coding or an API integration?

❌ No coding required to use it in Apify Console. For API-style workflows, you can still consume the dataset output, but the actor itself is designed to run from Apify with structured inputs.

#### Is this compliant with privacy rules?

✅ The actor is designed to collect information only from **publicly available sources**. It’s still your responsibility to comply with applicable laws (including GDPR/CCPA where relevant), spam regulations, and each platform’s terms.

#### How do I request data removal?

If you need data removal for scraped information, contact <dataforleads@gmail.com>.

***

### 🤝 Support & feature requests

Want to improve **Substack Email Scraper - Fast, Advanced and Cheapest** or build something better with this Substack email harvesting tool?

- 💡 **Feature Requests**: Share ideas like additional export options (CSV-first), configurable matching rules, or CRM-focused output shaping.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for future versions of this Substack email extractor.

***

*Built for marketers and analysts who want the most comprehensive **Substack Email Scraper - Fast, Advanced and Cheapest** experience—fast, structured, and ready to export.*

# 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("scrapers-hub/substack-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("scrapers-hub/substack-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 scrapers-hub/substack-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=scrapers-hub/substack-email-scraper-fast-advanced-and-cheapest",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Substack Email Scraper Fast Advanced And Cheapest",
        "description": "📧 Substack Email Scraper Fast Advanced & Cheapest extracts verified subscriber emails from Substack quickly and affordably. 🚀 Perfect for B2B lead gen, sales, and outreach—save time, target smarter, and scale faster.",
        "version": "1.0",
        "x-build-id": "kZ3XXcjslgY9bwV2Y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~substack-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-substack-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/scrapers-hub~substack-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-substack-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/scrapers-hub~substack-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-substack-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
