# 🚀 Kickstarter B2B Email Scraper (`api-empire/kickstarter-b2b-emails-scraper`) Actor

🚀 Kickstarter B2B Email Scraper extracts business contact emails from Kickstarter campaigns—fast and accurate. Perfect for lead gen, outreach, and market research. Save time, build lists, and boost your pipeline with confidence. 📧📈

- **URL**: https://apify.com/api-empire/kickstarter-b2b-emails-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (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 $4.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 B2B Email Scraper

**Automatically discover verified business emails from Kickstarter social media profiles, posts, and bios** using intelligent Google SERP search patterns — no Kickstarter login required, no API keys needed.

> 📊 **Tier Rating:** TIER 1 — Excellent

---

### 🚀 Why Choose This Actor?

- ⚡ **Fast & Efficient** — Uses browser impersonation (not a full headless browser) for maximum speed with minimal resource usage
- 🎯 **B2B Focused** — 29 pre-built search patterns specifically engineered to find corporate emails (not Gmail/Yahoo noise)
- 🔒 **Smart Proxy Fallback** — Auto-escalates from direct → datacenter → residential proxy if blocked
- 📊 **Live Results** — Each email is saved to your dataset in real time as it's discovered
- 🌍 **Location Targeting** — Filter results by city, region, or country for hyper-local prospecting
- 🔑 **Multi-Keyword** — Process dozens of industries/niches in a single run

---

### ✨ Key Features

- 🏢 **B2B Mode** — Corporate email discovery (contact@, info@, team@, domain-specific)
- 👤 **Personal Mode** — Broader discovery including all email types
- 🎨 **29 Pattern Templates** — From booking emails to sponsorship inquiries
- 🔄 **Smart Deduplication** — Each email address appears only once in your results
- 📍 **Geographic Filtering** — Target specific cities or regions
- 🌐 **Platform Locked to Kickstarter** — Optimized search queries for Kickstarter.com
- ⚡ **Jitter Delays** — Human-like request timing to avoid detection
- 📈 **Real-Time Progress** — Live status updates and per-result logging

---

### 📥 Input Configuration

```json
{
  "keywords": ["marketing", "restaurants", "fitness"],
  "platform": "Kickstarter.com",
  "location": "London",
  "mode": "b2b",
  "maxEmails": 50,
  "maxEmailsPerPattern": 15,
  "selectedPatterns": ["email_for_bookings", "bio_email_basic", "contact_at_domain"],
  "proxyConfiguration": { "useApifyProxy": false }
}
````

| Field | Type | Description |
|-------|------|-------------|
| `keywords` | `array` | 🔑 Industries/niches to search (required) |
| `platform` | `string` | 🌐 Platform domain (default: `Kickstarter.com`) |
| `location` | `string` | 📍 City/region filter (optional, leave empty for global) |
| `mode` | `string` | 🎯 `b2b` (corporate emails) or `personal` (all types) |
| `maxEmails` | `integer` | 📊 Total email cap (1–50000, default: 10) |
| `maxEmailsPerPattern` | `integer` | 🔢 Per-pattern cap in B2B mode (default: 15) |
| `selectedPatterns` | `array` | 🎨 Specific patterns (empty = all 29 patterns) |
| `proxyConfiguration` | `object` | 🔒 Proxy settings (default: GOOGLE\_SERP proxy) |

***

### 📤 Output Format

Each discovered email is saved as a row in the Apify dataset:

```json
{
  "email": "info@example-business.com",
  "leadType": "b2b",
  "pattern": "email_for_bookings",
  "keyword": "marketing",
  "location": "London",
  "network": "Kickstarter.com",
  "title": "For bookings email info@example-business.com",
  "description": "Professional marketing agency serving London businesses...",
  "url": "https://www.kickstarter.com/...",
  "scraped_at": "2026-05-25T15:00:00Z"
}
```

| Field | Description |
|-------|-------------|
| `email` | ✅ The discovered business email address |
| `leadType` | 🏷️ `b2b` or `personal` |
| `pattern` | 🎨 B2B search pattern that found this email |
| `keyword` | 🔑 Keyword used in the search |
| `location` | 📍 Location filter applied |
| `network` | 🌐 Platform (e.g., Kickstarter.com) |
| `title` | 📋 Google result title containing the email |
| `description` | 📝 Snippet text from Google result |
| `url` | 🔗 Source Kickstarter page URL |
| `scraped_at` | ⏰ UTC timestamp when the email was found |

***

### 🎨 Available B2B Patterns

| Pattern | What It Finds |
|---------|--------------|
| `email_for_bookings` | 📅 Booking & reservation emails |
| `bio_email_basic` | 📧 Bio email mentions with emoji |
| `job_applications` | 💼 Hiring & careers emails |
| `email_direct_mention` | 📬 Direct "email us at" posts |
| `contact_at_domain` | 🏢 `info@`, `contact@`, `hello@`, etc. |
| `business_development` | 🤝 B2B & partnership emails |
| `careers_hiring` | 👥 Recruitment contacts |
| `hr_recruitment` | 🏭 HR department emails |
| `customer_service` | 🎧 Support & help desk emails |
| `sponsor_me` | 💰 Sponsorship opportunity emails |
| `professional_services` | 🔧 Agency & consulting contacts |
| `bio_email_emoji_extended` | 💌 📩 📮 Emoji email mentions |
| `dm_or_email` | 💬 DM or email CTA posts |
| + 16 more | ... |

***

### 🚀 How to Use (Apify Console)

1. 🔐 Log in at [console.apify.com](https://console.apify.com) → **Actors**
2. 🔍 Find **Kickstarter B2B Email Scraper** and click it
3. ⚙️ Configure your inputs:
   - Add your target keywords (e.g., `marketing`, `restaurants`)
   - Set your location (e.g., `London`, `New York`)
   - Choose mode: `B2B` for corporate emails
   - Set max emails (e.g., `100`)
4. ▶️ Click **Start**
5. 📊 Watch real-time logs as emails are discovered
6. 📋 Open the **Output** tab to see your results table
7. 📁 Export to **JSON / CSV / Excel**

***

### 🔒 Proxy Behavior

The actor uses a smart **3-tier proxy escalation system**:

```
1️⃣ Direct (no proxy)  →  impit browser impersonation
        ↓ If blocked
2️⃣ GOOGLE_SERP Datacenter  →  Apify's Google-optimized proxy
        ↓ If blocked
3️⃣ Residential Proxy  →  3 retry attempts
        ↓ If all fail
❌ Skip this request, continue with next query
```

Once escalated to residential, **all remaining requests use residential proxy** to maintain consistency.

***

### 🎯 Best Use Cases

- 🏢 **B2B Sales Outreach** — Find corporate emails of businesses in your niche
- 📍 **Local Business Prospecting** — Target businesses in specific cities
- 🤝 **Partnership Discovery** — Find influencer/brand partnership contact emails
- 📧 **Email List Building** — Build verified, corporate email lists for campaigns
- 🔍 **Market Research** — Understand which businesses are active in your niche

***

### ⚠️ Legal & Ethical Notice

- This actor only collects data from **publicly available** Google search results
- Only emails that appear in **public Kickstarter content** are collected.
- Users are responsible for compliance with **GDPR, CAN-SPAM, CCPA**, and applicable laws
- Do not use collected emails for spam or unsolicited bulk messaging
- Review Kickstarter's and Google's Terms of Service before use

***

### ❓ Frequently Asked Questions

**Q: Does this need a Kickstarter account?**
A: No — it searches Google for public Kickstarter content.

**Q: Will it find private account emails?**
A: No — only publicly indexed Kickstarter content is searched.

**Q: How many emails can I collect per run?**
A: Up to 50,000 per run. Run multiple times for larger lists.

**Q: What makes B2B mode different?**
A: B2B mode filters out Gmail, Yahoo, Outlook, and other personal email domains, returning only corporate/domain-specific emails.

**Q: Do I need Apify proxies?**
A: The default uses GOOGLE\_SERP datacenter proxy. Residential proxies are only escalated to if Google blocks requests.

***

### 📞 Support & Feedback

- 🐛 Report issues in the **Issues** tab
- 💡 Feature requests welcome
- ⭐ If this actor saves you time, please leave a review!

# Actor input Schema

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

🔎 Search terms for Kickstarter via Google (e.g. marketing, fitness, real estate). ✨ Add one or many keywords.

## `mode` (type: `string`):

👤 personal = Gmail/Outlook discovery | 🏢 b2b = corporate email patterns

## `customDomains` (type: `array`):

👤 Personal mode: filter results to these domains (e.g. @gmail.com, @outlook.com). ⏭️ Ignored in B2B mode.

## `patterns` (type: `array`):

🏢 B2B only: 📂 empty list runs all patterns; or name specific keys from b2b\_patterns.py (e.g. email\_for\_bookings, bio\_email\_basic).

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

📱 Target platform for email discovery (locked to Kickstarter).

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

🗺️ Geographic filter added to search queries (e.g. London, New York). 🌍 Leave empty for global results.

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

🎯 Maximum number of emails to collect across all keywords and patterns.

## `maxEmailsPerPattern` (type: `integer`):

📈 Cap emails collected per B2B search pattern (🏢 B2B mode only).

## `useProxy` (type: `boolean`):

✅ Enable proxy for Google Search requests. ⭐ Recommended: on for best results.

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

🔧 Optional proxy override when 🛡️ Use Apify Proxy is enabled. 🎯 Leave as default for best performance.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "mode": "b2b",
  "customDomains": [
    "@outlook.com",
    "@gmail.com"
  ],
  "patterns": [
    "email_for_bookings",
    "bio_email_basic",
    "contact_at_domain",
    "business_development"
  ],
  "platform": "Kickstarter.com",
  "location": "",
  "maxEmails": 10,
  "maxEmailsPerPattern": 15,
  "useProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# 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"
    ],
    "customDomains": [
        "@outlook.com",
        "@gmail.com"
    ],
    "patterns": [
        "email_for_bookings",
        "bio_email_basic",
        "contact_at_domain",
        "business_development"
    ],
    "location": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/kickstarter-b2b-emails-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"],
    "customDomains": [
        "@outlook.com",
        "@gmail.com",
    ],
    "patterns": [
        "email_for_bookings",
        "bio_email_basic",
        "contact_at_domain",
        "business_development",
    ],
    "location": "",
}

# Run the Actor and wait for it to finish
run = client.actor("api-empire/kickstarter-b2b-emails-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"
  ],
  "customDomains": [
    "@outlook.com",
    "@gmail.com"
  ],
  "patterns": [
    "email_for_bookings",
    "bio_email_basic",
    "contact_at_domain",
    "business_development"
  ],
  "location": ""
}' |
apify call api-empire/kickstarter-b2b-emails-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🚀 Kickstarter B2B Email Scraper",
        "description": "🚀 Kickstarter B2B Email Scraper extracts business contact emails from Kickstarter campaigns—fast and accurate. Perfect for lead gen, outreach, and market research. Save time, build lists, and boost your pipeline with confidence. 📧📈",
        "version": "1.0",
        "x-build-id": "wy6G3QZqiJHEMXFwM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~kickstarter-b2b-emails-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-kickstarter-b2b-emails-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/api-empire~kickstarter-b2b-emails-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-kickstarter-b2b-emails-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/api-empire~kickstarter-b2b-emails-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-kickstarter-b2b-emails-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": "🔎 Search terms for Kickstarter via Google (e.g. marketing, fitness, real estate). ✨ Add one or many keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "🎯 Extraction Mode",
                        "enum": [
                            "b2b",
                            "personal"
                        ],
                        "type": "string",
                        "description": "👤 personal = Gmail/Outlook discovery | 🏢 b2b = corporate email patterns",
                        "default": "b2b"
                    },
                    "customDomains": {
                        "title": "📬 Custom Email Domains",
                        "type": "array",
                        "description": "👤 Personal mode: filter results to these domains (e.g. @gmail.com, @outlook.com). ⏭️ Ignored in B2B mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "patterns": {
                        "title": "🔎 B2B Search Patterns",
                        "type": "array",
                        "description": "🏢 B2B only: 📂 empty list runs all patterns; or name specific keys from b2b_patterns.py (e.g. email_for_bookings, bio_email_basic).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "🌐 Platform",
                        "enum": [
                            "Kickstarter.com"
                        ],
                        "type": "string",
                        "description": "📱 Target platform for email discovery (locked to Kickstarter).",
                        "default": "Kickstarter.com"
                    },
                    "location": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "🗺️ Geographic filter added to search queries (e.g. London, New York). 🌍 Leave empty for global results.",
                        "default": ""
                    },
                    "maxEmails": {
                        "title": "📊 Maximum Total Emails",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "🎯 Maximum number of emails to collect across all keywords and patterns.",
                        "default": 10
                    },
                    "maxEmailsPerPattern": {
                        "title": "🧩 Max Emails Per B2B Pattern",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "📈 Cap emails collected per B2B search pattern (🏢 B2B mode only).",
                        "default": 15
                    },
                    "useProxy": {
                        "title": "🛡️ Use Apify Proxy",
                        "type": "boolean",
                        "description": "✅ Enable proxy for Google Search requests. ⭐ Recommended: on for best results.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "⚙️ Advanced Proxy Settings",
                        "type": "object",
                        "description": "🔧 Optional proxy override when 🛡️ Use Apify Proxy is enabled. 🎯 Leave as default for best performance.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "GOOGLE_SERP"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```