# Crunchbase Email Scraper (`api-empire/crunchbase-email-scraper`) Actor

Automate email extraction from Crunchbase with Crunchbase Email Scraper. The actor scans company profiles and linked sources to pull available contact emails into structured datasets for CRM enrichment.

- **URL**: https://apify.com/api-empire/crunchbase-email-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

$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

### **Social Media** Email Scraper 📱

Crunchbase Email Scraper enables users to **extract** a wide range of **data** from Crunchbase profiles with precision. It is designed to gather essential **contact** details, such as email addresses, phone numbers, and social media links.

This tool also captures profile information like company names, industries, and locations, making it a comprehensive **data** **extract**ion solution. With its automated capabilities, users can collect **data** in bulk, saving time and effort.

The scraper ensures that all **extract**ed **data** is well-organized and ready for use in lead generation, marketing campaigns, or research projects. Its ability to handle large-scale **data** **extract**ion makes it a reliable tool for businesses of all sizes.

Crunchbase Email Scraper is a powerful tool designed to extract email addresses and other contact information from Crunchbase profiles efficiently. It simplifies the process of gathering leads and contact details for businesses and professionals.

With the increasing demand for accurate and reliable contact data, using an automated email scraper for Crunchbase ensures you save time and resources. This tool is ideal for lead generation, market research, and business outreach.

Crunchbase data extraction software allows users to collect structured data from profiles, providing a seamless way to access valuable information. It eliminates the need for manual data entry, ensuring accuracy and consistency.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract verified email addresses from Crunchbase profiles for direct communication. |
| Phone numbers | Retrieve contact phone numbers listed on Crunchbase profiles. |
| Social media links | Collect links to social media accounts associated with profiles. |
| Company names | Extract the names of companies listed on Crunchbase. |
| Industries | Identify the industries associated with each profile for targeted outreach. |
| Locations | Capture location details such as city, state, and country from profiles. |
| Funding information | Gather data about funding rounds and investments listed on profiles. |
| Website URLs | Extract official website links from Crunchbase profiles for additional research. |

### Key Features of **Social Media** Email Scraper

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

- ⭐ **Automated** extraction of email addresses and contact details from Crunchbase profiles
- ⭐ User-friendly interface for easy setup and operation without technical expertise
- ⭐ Supports bulk data extraction to save time and improve efficiency
- ⭐ **Customizable** filters to target specific industries locations or funding stages
- ⭐ **Accurate** and reliable data extraction with minimal errors
- ⭐ Export data in multiple formats such as CSV or JSON for seamless integration
- ⭐ **Regular** updates to ensure compatibility with Crunchbases platform changes
- ⭐ Built-in compliance features to adhere to legal and ethical data usage guidelines
- ⭐ **High**-speed scraping capabilities for handling large datasets quickly
- ⭐ 247 customer support to assist with any issues or queries

### How to use **Social Media** Email Scraper 🚀

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

1. ✅ **Sign up** or **log in** to your account on the Crunchbase Email Scraper platform
2. ✅ Navigate to the scraper dashboard and select the Crunchbase scraping option
3. ✅ Enter your target keywords industries or profile URLs to define your scraping parameters
4. ✅ **Configure** additional filters such as location funding stage or company size if needed
5. ✅ **Start** the scraping process and monitor the progress in real-time on the dashboard
6. ✅ Once completed review the extracted data for accuracy and completeness
7. ✅ **Export** the scraped data to your preferred format such as CSV or JSON
8. ✅ Use the exported data for lead generation marketing or research purposes

### Use Cases 🎯

Lead Generation
🎯 Extract contact details of potential clients or partners from Crunchbase profiles
🎯 **Identify** businesses in specific industries or locations for targeted outreach

Market Research
🎯 Gather data on companies industries and funding trends for analysis
🎯 **Identify** key players and emerging startups in your target market

Business Outreach
🎯 Build a database of verified email addresses for email marketing campaigns
🎯 Connect with decision-makers and stakeholders using accurate contact information

Competitor Analysis
🎯 **Analyze** competitors profiles to understand their funding and growth strategies
🎯 **Identify** potential partnerships or acquisition opportunities

### Why choose us? 💎

Crunchbase Email Scraper is the **best** solution for extracting contact details and other data from Crunchbase profiles. Our tool is designed to save you time and ensure accuracy, making it an essential resource for businesses and professionals.

With features like bulk data extraction and customizable filters, you can tailor the scraping process to your specific needs. We prioritize compliance with legal and ethical guidelines, ensuring that all data is collected responsibly.

Our **user-friendly** interface and 24/7 customer support make it easy for anyone to use the scraper effectively. Whether you need an automated email scraper for Crunchbase or a comprehensive data extraction solution, our tool is built to deliver exceptional results.

### **Social Media** Email Scraper Scalability 📈

Crunchbase Email Scraper is designed to handle **large-scale** data extraction with ease. Whether you need to extract data from a few profiles or thousands, our tool ensures consistent performance and accuracy.

Its high-speed scraping capabilities allow you to process vast amounts of data quickly, saving you valuable time. The tool is also equipped with features to manage and organize large datasets **efficient**ly, making it suitable for businesses of all sizes.

With regular updates and robust infrastructure, our scraper can adapt to your growing data needs without compromising on quality. This scalability makes it an ideal choice for companies looking to expand their lead generation or research efforts.

### **Social Media** Email Scraper Legal Guidelines ⚖️

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with Crunchbases terms of service when using the scraper
⚖️ **Do not** use the extracted data for spamming or unsolicited marketing activities
⚖️ Verify the accuracy of the data before using it for business purposes
⚖️ Respect the privacy of individuals and avoid extracting sensitive personal information
⚖️ **Use** the scraper only for lawful purposes in accordance with applicable regulations
⚖️ **Obtain** proper consent if required before contacting individuals using the extracted data
⚖️ **Avoid** scraping data that is explicitly restricted or protected by Crunchbase
⚖️ Regularly review and adhere to changes in data privacy laws and guidelines

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Crunchbase Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Social Media",
  "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 (Social Media) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Social Media",
    "keyword": "Crunchbase 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 Social Media as the source |
| keyword | Keyword that triggered the result (Crunchbase Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Social Media profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Crunchbase **Email Scraper**?

Crunchbase Email Scraper is a tool designed to extract email addresses and other contact details from Crunchbase profiles efficiently.

#### Can I use this tool for bulk data **extract**ion?

**Yes**, the scraper supports bulk data extraction, allowing you to process multiple profiles at once.

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

**Yes**, the tool automates the data extraction process to save time and improve accuracy.

#### What types of data can I **extract**?

You can extract email addresses, phone numbers, social media links, company names, industries, locations, and more.

#### Is the scraper compliant with **legal** guidelines?

**Yes**, the scraper is designed to adhere to legal and ethical data usage guidelines.

#### Can I **export** the **extract**ed data?

**Yes**, you can export the data in formats such as **CSV** or **JSON** for easy integration.

#### Do I need technical expertise to use the scraper?

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

#### How frequently is the scraper updated?

The scraper is regularly updated to ensure compatibility with Crunchbase's platform changes.

#### What support options are available?

We offer 24/7 customer support to assist with any issues or queries.

#### Can I customize the scraping parameters?

**Yes**, you can configure filters such as industry, location, and funding stage to target specific profiles.

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

The tool is scalable and can handle large datasets, but usage limits may depend on your subscription plan.

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

**Yes**, but ensure **compliance** with email marketing laws and obtain proper consent where required.

#### Is the scraper compatible with all Crunchbase profiles?

The scraper works with most profiles, but certain restricted or protected data may not be accessible.

#### How **secure** is the data **extract**ion process?

The tool uses **secure** methods to ensure the safety and privacy of extracted data.

#### What payment options are available?

We offer flexible subscription plans with various payment options to suit your needs.

# Actor input Schema

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

List of keywords to search for on Crunchbase (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Crunchbase 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": "Crunchbase",
  "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("api-empire/crunchbase-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("api-empire/crunchbase-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 api-empire/crunchbase-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crunchbase Email Scraper",
        "description": "Automate email extraction from Crunchbase with Crunchbase Email Scraper. The actor scans company profiles and linked sources to pull available contact emails into structured datasets for CRM enrichment.",
        "version": "0.1",
        "x-build-id": "9C3QtQkT9a20TnZYS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~crunchbase-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-crunchbase-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/api-empire~crunchbase-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-crunchbase-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/api-empire~crunchbase-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-crunchbase-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 Crunchbase (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Crunchbase profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Crunchbase"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Crunchbase"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```