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

🚀 Mass Kickstarter Email Scraper extracts emails from Kickstarter campaigns in bulk. ⚡ Speed up lead gen, outreach, and market research with clean, targeted data. 📈 Perfect for startups, agencies & marketers.

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

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### **Kickstarter** Email Scraper 📱

The Mass **Kickstarter** Email Scraper allows users to **extract** key **data** points from **Kickstarter** campaigns with precision. This **data** includes **contact** **emails**, campaign titles, creator names, and more, enabling users to build a robust email **data**base for outreach.

By leveraging this tool, users can gather information on active and past campaigns, making it easier to identify potential leads. The scraper also provides insights into campaign categories and funding goals, offering a deeper understanding of each project.

With its ability to **extract** bulk **data**, this tool is perfect for businesses, marketers, and researchers looking to streamline their **Kickstarter** outreach efforts. The **extract**ed **data** is organized and exportable, ensuring seamless integration into your existing workflows.

Whether you're building a **Kickstarter** email list or conducting market analysis, this scraper provides the **data** you need efficiently and accurately.

Mass Kickstarter Email Scraper is a powerful tool designed to help users extract email data from Kickstarter campaigns efficiently. It simplifies the process of gathering contact information for crowdfunding projects.

Kickstarter email scraping enables businesses and individuals to connect with campaign creators for networking, partnerships, or promotional purposes. By automating this process, users save time and effort in building outreach lists.

With the Mass Kickstarter Email Scraper, you can access a wealth of contact data to enhance your marketing and outreach strategies. This tool is ideal for those looking to engage with Kickstarter project creators at scale.

### 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 | Extracts the contact email of Kickstarter campaign creators. |
| Campaign Title | Retrieves the title of the Kickstarter project for easy identification. |
| Creator Name | Captures the name of the individual or organization behind the campaign. |
| Campaign URL | Provides the direct link to the Kickstarter campaign page. |
| Category | Identifies the category under which the campaign is listed. |
| Funding Goal | Extracts the funding goal set by the campaign creator. |
| Backer Count | Retrieves the number of backers supporting the campaign. |
| Funding Status | Indicates whether the campaign is active, successful, or failed. |

### 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** scraping of **Kickstarter** campaign emails for efficient data collection
- ⭐ Supports bulk data extraction to build large email lists quickly
- ⭐ Provides detailed campaign information including titles categories and funding goals
- ⭐ User-friendly interface for seamless operation without technical expertise
- ⭐ **Customizable** scraping settings to target specific campaigns or categories
- ⭐ Exportable data in multiple formats including CSV and JSON for easy integration
- ⭐ **High** accuracy in data extraction to ensure reliable results
- ⭐ **Regular** updates to maintain compatibility with **Kickstarter**s platform
- ⭐ **Secure** and compliant scraping practices to protect user data
- ⭐ Scalable solution for both small-scale and large-scale data extraction needs
- ⭐ Detailed logs and reports for monitoring scraping activities
- ⭐ 247 customer support to assist with any technical issues or queries

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

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

1. ✅ **Sign up** for an account on the platform hosting the Mass **Kickstarter** Email Scraper
2. ✅ Log in to the dashboard and navigate to the **Kickstarter** scraping tool
3. ✅ Enter the desired keywords or campaign URLs to target specific projects
4. ✅ Customize the scraping settings such as categories or funding goals if needed
5. ✅ **Start** the scraping process and monitor progress in real-time on the dashboard
6. ✅ Once completed review the extracted data for accuracy and completeness
7. ✅ **Export** the data in your preferred format such as CSV or JSON
8. ✅ Use the extracted data for outreach marketing or analysis purposes

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for **Kickstarter** campaign creators
🎯 Promote your products or services to crowdfunding project owners

Networking and Partnerships
🎯 Connect with **Kickstarter** creators for collaboration opportunities
🎯 **Identify** potential partners in niche crowdfunding categories

Market Research
🎯 **Analyze** trends in **Kickstarter** campaigns across various categories
🎯 Gather data on successful campaigns for competitive insights

Lead Generation
🎯 Generate high-quality leads from active **Kickstarter** campaigns
🎯 Expand your outreach database with verified contact information

### Why choose us? 💎

The Mass **Kickstarter** Email Scraper is a **reliable** and efficient tool for extracting email data from **Kickstarter** campaigns. It is designed to meet the needs of marketers, researchers, and businesses looking to streamline their outreach efforts.

By automating the data extraction process, this tool saves you time and ensures accuracy in building your email lists. Our scraper is equipped with **advanced** features, including customizable settings and exportable data formats, to provide a seamless user experience.

We prioritize data security and compliance, ensuring that your scraping activities adhere to legal and ethical guidelines. With **regular** updates and dedicated customer support, we ensure that our tool remains compatible with **Kickstarter**'s platform.

Whether you're targeting a specific niche or conducting large-scale data extraction, the Mass **Kickstarter** Email Scraper is your go-to solution. Choose us for a **reliable**, **scalable**, and **user-friendly** email scraping experience.

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

The Mass **Kickstarter** Email Scraper is built to handle data extraction tasks of any size. Whether you're targeting a handful of campaigns or thousands, our tool is designed to scale with your needs.

It supports bulk data extraction, allowing you to gather large volumes of information **efficient**ly. The tool's robust infrastructure ensures consistent performance, even during high-demand operations.

With **customizable** settings, you can focus on specific categories or campaigns without compromising speed or accuracy. Our exportable data formats make it easy to integrate the extracted information into your existing workflows.

Whether you're a small business or a large enterprise, the Mass **Kickstarter** Email Scraper adapts to your requirements **seamless**ly. Experience unparalleled scalability and efficiency with our powerful scraping solution.

### **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 when using the scraper
⚖️ **Do not** use the extracted data for spamming or unsolicited marketing activities
⚖️ Respect the privacy of **Kickstarter** campaign creators and their contact information
⚖️ **Use** the tool only for lawful purposes such as research or legitimate outreach
⚖️ **Avoid** scraping excessive data that may overload **Kickstarter**s servers
⚖️ Regularly review and adhere to local data protection and privacy laws
⚖️ Provide an opt-out option when contacting individuals using the extracted data
⚖️ Consult legal counsel if unsure about the legality of your scraping activities

### 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 and other campaign data from Kickstarter efficiently.

#### Can I use this scraper for bulk email **extract**ion?

**Yes**, the tool supports bulk data extraction to help you build large email lists quickly.

#### Is the **extract**ed data accurate?

The scraper is designed to provide high accuracy in data extraction, ensuring reliable results.

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

You can export the data in multiple formats, including **CSV** and **JSON**, for easy integration.

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

**Yes**, we prioritize **compliance** with data protection and privacy regulations to ensure legal use.

#### Can I customize the scraping settings?

**Yes**, the tool allows you to customize settings such as categories and keywords for targeted scraping.

#### Does the scraper work for all Kickstarter campaigns?

The tool is designed to extract data from a wide range of Kickstarter campaigns, including active and past projects.

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

**No**, the tool features a **user-friendly** interface that makes it easy to use without technical skills.

#### How often is the tool updated?

We provide **regular updates** to ensure compatibility with Kickstarter's platform and maintain performance.

#### What support options are available?

We offer 24/7 customer support to assist with any technical issues or queries you may have.

#### Can I scrape data from **specific** Kickstarter categories?

**Yes**, you can target specific categories or campaigns using the customization options.

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

The tool is scalable and can handle data extraction for a large number of campaigns efficiently.

#### What precautions should I take when using the scraper?

Ensure **compliance** with legal and ethical guidelines, including Kickstarter's terms of service.

#### Can I use the data for marketing purposes?

**Yes**, but you must adhere to anti-spam laws and provide an opt-out option for recipients.

#### Is the tool **secure** to use?

**Yes**, we prioritize data security and ensure that your scraping activities are protected.

# 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("scrapepilotapi/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("scrapepilotapi/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 scrapepilotapi/mass-kickstarter-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapepilotapi/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 emails from Kickstarter campaigns in bulk. ⚡ Speed up lead gen, outreach, and market research with clean, targeted data. 📈 Perfect for startups, agencies & marketers.",
        "version": "0.1",
        "x-build-id": "pqXfwH03okV34GpOz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~mass-kickstarter-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-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/scrapepilotapi~mass-kickstarter-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-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/scrapepilotapi~mass-kickstarter-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```