# Mass Kickstarter Email Scraper (`scraper-engine/mass-kickstarter-email-scraper`) Actor

Mass Kickstarter Email Scraper extracts publicly available email addresses from Kickstarter creator profiles and campaign pages at scale. Build large contact lists for partnerships, PR, and campaign outreach efficiently.

- **URL**: https://apify.com/scraper-engine/mass-kickstarter-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

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

### **Kickstarter** Email Scraper 📱

The Mass **Kickstarter** Email Scraper allows you to **extract** a wide range of **data** from **Kickstarter** campaigns. This includes email addresses, campaign titles, creator names, and more.

By using this tool, you can gather valuable **contact** information from thousands of campaigns in a matter of minutes. The **extract**ed **data** is structured and ready to use for marketing, research, or networking purposes.

This **Kickstarter** email harvesting software ensures that you can focus on your outreach strategy without worrying about manual **data** collection. With its advanced algorithms, the scraper is capable of handling large **data**sets while ensuring accuracy and reliability.

Whether you are building an email list for marketing or researching crowdfunding trends, this tool provides all the **data** you need in one place.

Mass Kickstarter Email Scraper is a powerful tool designed to help you collect email addresses from Kickstarter campaigns efficiently. It enables businesses and individuals to connect with campaign creators for networking, marketing, or collaboration purposes.

Kickstarter is a leading crowdfunding platform with thousands of active campaigns, making it an ideal source for targeted email extraction. This tool simplifies the process of gathering contact information from Kickstarter projects, saving you time and effort.

With the Mass Kickstarter Email Scraper, you can generate bulk email lists from Kickstarter campaigns in just a few clicks. It is perfect for marketers, researchers, and businesses looking to reach out to campaign creators.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Address | Extract the email addresses of Kickstarter campaign creators for direct communication. |
| Campaign Title | Retrieve the titles of Kickstarter campaigns to identify relevant projects. |
| Creator Name | Collect the names of campaign creators for personalized outreach. |
| Campaign URL | Get direct links to Kickstarter campaigns for further exploration. |
| Campaign Category | Identify the category of each campaign to target specific niches. |
| Funding Goal | Extract the funding goals of campaigns to analyze project scale. |
| Location | Gather location details of campaign creators for geographic targeting. |
| Campaign Description | Retrieve brief descriptions of campaigns to understand their objectives. |

### Key Features of **Kickstarter** Email Scraper

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

- ⭐ **Automated** email extraction from **Kickstarter** campaigns for efficiency
- ⭐ Ability to scrape bulk email data quickly and accurately
- ⭐ User-friendly interface for seamless operation and navigation
- ⭐ **Customizable** filters to target specific campaign categories or locations
- ⭐ Export data in multiple formats such as CSV or Excel for convenience
- ⭐ Handles large-scale data scraping without compromising on speed or accuracy
- ⭐ Real-time data extraction to ensure up-to-date information
- ⭐ Integrated error handling to minimize data loss or inaccuracies
- ⭐ **Secure** and compliant with ethical scraping guidelines
- ⭐ Compatible with various operating systems and devices

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

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

1. ✅ **Sign up** or **log in** to your account on the Mass **Kickstarter** Email Scraper platform
2. ✅ Download and install the scraper software on your device
3. ✅ Open the tool and input your search criteria such as campaign category or location
4. ✅ Set any additional filters to refine your data extraction process
5. ✅ **Start** the scraping process and monitor the progress in real-time
6. ✅ Once the scraping is complete review the extracted data for accuracy
7. ✅ **Export** the data to your desired format such as CSV or Excel
8. ✅ Use the extracted data for your marketing research or outreach purposes

### Use Cases 🎯

Marketing and Outreach
🎯 Generate targeted email lists for **Kickstarter** campaigns
🎯 Reach out to campaign creators for collaboration opportunities
🎯 Promote your products or services to relevant audiences

Research and Analysis
🎯 **Study** crowdfunding trends using extracted campaign data
🎯 **Analyze** campaign success rates based on funding goals and categories
🎯 **Identify** popular niches and emerging markets on **Kickstarter**

Business Development
🎯 Build connections with **Kickstarter** campaign creators
🎯 Discover potential partners for joint ventures or investments
🎯 Expand your professional network within the crowdfunding industry

Content Creation
🎯 Gather inspiration from successful **Kickstarter** campaigns
🎯 Create case studies or reports based on campaign data
🎯 Develop content strategies targeting crowdfunding audiences

### Why choose us? 💎

The Mass **Kickstarter** Email Scraper is designed to provide you with a seamless and efficient email extraction experience. Our tool leverages **advanced** algorithms to ensure accurate and **reliable** data scraping from **Kickstarter** campaigns.

It is **user-friendly** and requires no technical expertise, making it accessible to everyone. We prioritize your data security and ensure compliance with ethical guidelines and legal standards.

Our **Kickstarter** email extraction tool is highly customizable, allowing you to tailor your searches to specific campaign categories, locations, or funding goals. We also offer excellent customer support to assist you with any issues or questions.

Whether you are a marketer, researcher, or entrepreneur, our tool is built to meet your unique needs. Choose the Mass **Kickstarter** Email Scraper to streamline your email collection process and achieve your outreach goals effectively.

### **Kickstarter** Email Scraper Scalability 📈

The Mass **Kickstarter** Email Scraper is built to handle **large-scale** data scraping with ease. Whether you need to extract data from a few campaigns or thousands, our tool is designed to scale according to your requirements.

It uses **advanced** technology to ensure fast and **efficient** data collection, even for **extensive** datasets. Our bulk email scraper for **Kickstarter** is optimized for performance, allowing you to extract data without any delays or interruptions.

With the ability to customize your search criteria, you can focus on the most relevant campaigns for your needs. This scalability makes our tool suitable for businesses of all sizes, from small startups to large enterprises.

Leverage the power of our **Kickstarter** email database builder to grow your outreach efforts without limitations.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Kickstarter**s terms of service while using the tool
⚖️ **Use** the Mass **Kickstarter** Email Scraper only for ethical and legal purposes
⚖️ **Do not** use the extracted data for spamming or unsolicited marketing
⚖️ **Obtain** consent from recipients before sending marketing emails
⚖️ Respect the privacy of campaign creators and their data
⚖️ **Adhere** to local and international data protection laws such as GDPR
⚖️ **Do not** resell or distribute the extracted data without proper authorization
⚖️ **Use** the tool responsibly to avoid any misuse or legal consequences

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Mass Kickstarter Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Kickstarter",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (Kickstarter) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Kickstarter",
    "keyword": "Mass Kickstarter Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Kickstarter as the source |
| keyword | Keyword that triggered the result (Mass Kickstarter Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Kickstarter profile link |
| email | Extracted email address |

### FAQ ❓

#### What is the Mass Kickstarter **Email Scraper**?

It is a tool designed to extract email addresses and other data from Kickstarter campaigns efficiently.

#### Can I use this tool for bulk email scraping?

**Yes**, the tool is optimized for bulk email scraping from Kickstarter campaigns.

#### Is the tool compliant with data protection laws?

**Yes**, the tool is designed to comply with GDPR and other data protection regulations.

#### What formats can I **export** the data in?

You can export the data in formats like **CSV** or Excel for easy use.

#### Is technical expertise required to use the tool?

**No**, the tool is **user-friendly** and does not require any technical expertise.

#### Can I customize my data **extract**ion criteria?

**Yes**, you can set filters for campaign categories, locations, and other criteria.

#### Is the data **extract**ion process automated?

**Yes**, the tool automates the data extraction process for efficiency.

#### How accurate is the **extract**ed data?

The tool uses advanced algorithms to ensure high accuracy in data extraction.

#### Can I use the tool for other crowdfunding platforms?

Currently, the tool is designed specifically for Kickstarter campaigns.

#### What support is available for users?

We offer comprehensive customer support to assist you with any issues or questions.

#### How do I ensure ethical use of the tool?

Follow our legal guidelines and obtain consent before using the extracted data for outreach.

#### Is there a **limit** to the number of campaigns I can scrape?

**No**, the tool is scalable and can handle large-scale data scraping.

#### Can I use the tool for competitor analysis?

**Yes**, you can analyze competitor campaigns to gain insights into their strategies.

#### Is there a free trial available?

Please check our website for information on free trials and pricing plans.

#### How do I get started with the tool?

Sign up on our platform, download the tool, and follow the step-by-step instructions to begin.

# Actor input Schema

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

List of keywords to search for on Kickstarter (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Kickstarter profiles/posts containing these keywords and extract email addresses.

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

Select platform.

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

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

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

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `proxyConfiguration` (type: `object`):

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Kickstarter",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/mass-kickstarter-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/mass-kickstarter-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/mass-kickstarter-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mass Kickstarter Email Scraper",
        "description": "Mass Kickstarter Email Scraper extracts publicly available email addresses from Kickstarter creator profiles and campaign pages at scale. Build large contact lists for partnerships, PR, and campaign outreach efficiently.",
        "version": "0.1",
        "x-build-id": "TZ7SaFfo1DhDUZ3jt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~mass-kickstarter-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-mass-kickstarter-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/scraper-engine~mass-kickstarter-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-mass-kickstarter-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/scraper-engine~mass-kickstarter-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-mass-kickstarter-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Kickstarter (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Kickstarter profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Kickstarter"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Kickstarter"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```