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

🔎 Crunchbase Email Scraper extracts verified email contacts from Crunchbase profiles to power B2B prospecting and lead generation. 🚀 Fast, targeted, and SEO-friendly for sales, recruiting, and market research. 💼📧

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

## Pricing

from $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

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

Crunchbase Email Scraper enables users to **extract** a wide range of **data** from Crunchbase profiles. This includes email addresses, company names, industries, and other key business details.

The tool is designed to gather accurate and comprehensive information to support lead generation and business outreach efforts. Users can rely on this software to retrieve verified **contact** **data** efficiently.

Additionally, the scraper ensures **data** is organized and ready for integration into CRM systems or marketing tools. With its advanced capabilities, the Crunchbase Email Scraper is a valuable asset for professionals seeking to streamline their **data** **extract**ion processes.

Crunchbase Email Scraper is a powerful tool designed to extract business contact information efficiently. It simplifies the process of gathering emails and other relevant data from Crunchbase for lead generation purposes.

With this email scraping software, users can automate the extraction of valuable data, saving time and effort. It integrates seamlessly with the Crunchbase API to ensure accurate and reliable data retrieval.

This business contact scraper is ideal for professionals seeking to build targeted email lists for marketing campaigns. It provides a streamlined solution for accessing verified contact information from Crunchbase profiles.

### 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 Addresses | Extract verified email addresses of businesses and professionals listed on Crunchbase. |
| Company Names | Retrieve the names of companies associated with the extracted email addresses. |
| Industries | Identify the industries of the companies for targeted outreach. |
| Contact Names | Extract the names of key contacts linked to the email addresses. |
| Company Locations | Gather location details such as city and country of the businesses. |
| Website URLs | Retrieve the official websites of the companies for additional information. |
| Funding Details | Access funding information associated with the companies. |
| LinkedIn Profiles | Extract LinkedIn profile links for further professional connections. |

### 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** data extraction from Crunchbase profiles to save time and effort
- ⭐ Seamless integration with Crunchbase API for accurate and reliable results
- ⭐ User-friendly interface designed for both beginners and advanced users
- ⭐ Ability to extract multiple data types including emails company names and industries
- ⭐ **Customizable** scraping options to target specific data fields
- ⭐ Export data in various formats such as CSV or JSON for easy integration
- ⭐ Built-in error handling to ensure smooth and uninterrupted scraping
- ⭐ **Advanced** filtering options to refine and focus data collection
- ⭐ Scalable solution capable of handling large datasets efficiently
- ⭐ **Regular** updates to ensure compatibility with Crunchbases latest features
- ⭐ **Secure** and compliant data extraction to protect user privacy
- ⭐ **Comprehensive** documentation and support for seamless user experience

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

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

1. ✅ **Sign up** for an account on the Crunchbase Email Scraper platform
2. ✅ Log in to the dashboard and navigate to the scraping tool section
3. ✅ Enter your Crunchbase API key to enable data extraction capabilities
4. ✅ **Select** the data fields you wish to extract such as emails or company names
5. ✅ Specify any filters or criteria to refine your data collection process
6. ✅ **Start** the scraper and monitor the progress through the dashboard
7. ✅ Once the scraping process is complete review the extracted data
8. ✅ **Export** the data in your preferred format such as CSV or JSON
9. ✅ **Integrate** the exported data into your CRM or marketing tools
10. ✅ Repeat the process as needed for additional data extraction tasks
11. ✅ Access the support section for troubleshooting or additional guidance
12. ✅ Log out securely after completing your session

### Use Cases 🎯

Lead Generation
🎯 Build targeted email lists for marketing campaigns
🎯 **Identify** potential clients or partners through extracted data

Market Research
🎯 **Analyze** industry trends using extracted company and funding data
🎯 Gather insights into competitors and market leaders

Business Development
🎯 Expand professional networks with LinkedIn profile links
🎯 Discover new business opportunities through detailed contact data

CRM Integration
🎯 Streamline data imports into CRM systems for better organization
🎯 Enhance customer relationship management with accurate contact details

Email Campaigns
🎯 Create personalized email campaigns using verified email addresses
🎯 Improve outreach efforts with targeted and segmented lists

### Why choose us? 💎

Crunchbase Email Scraper is a **reliable** and efficient tool for extracting business contact information. Its seamless integration with the Crunchbase API ensures accurate and up-to-date data retrieval.

The tool is designed to save time and effort by automating the data extraction process. Users can customize their scraping preferences to focus on specific data fields or industries.

This flexibility makes it suitable for businesses of all sizes and industries. Additionally, the software offers **advanced** features such as filtering and error handling to enhance the user experience.

With **regular** updates and comprehensive support, Crunchbase Email Scraper stays compatible with the latest Crunchbase features. Its secure and compliant design ensures user privacy and data protection.

By choosing this tool, users gain access to a powerful solution for lead generation and business growth.

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

Crunchbase Email Scraper is built to handle data extraction tasks of any scale. Whether you need to scrape a few profiles or thousands, the tool adapts to your requirements.

Its robust infrastructure ensures smooth performance even with large datasets. Users can rely on its **advanced** filtering options to refine results for specific needs.

The tool is designed to process data **efficient**ly, minimizing downtime and maximizing productivity. With its scalable features, businesses can expand their data collection efforts as they grow.

This makes it an ideal solution for startups, SMEs, and large enterprises alike. The scraper's ability to handle high volumes of data ensures it remains a valuable asset for professionals in any industry.

### **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 tool to extract data for malicious or unethical purposes
⚖️ **Obtain** proper authorization if accessing restricted or private data
⚖️ Respect data privacy laws and regulations such as GDPR and CCPA
⚖️ **Avoid** overloading Crunchbase servers with excessive scraping requests
⚖️ **Use** the scraper responsibly to maintain ethical business practices
⚖️ **Ensure** that extracted data is used only for legitimate business purposes
⚖️ Regularly review legal and compliance updates related to data scraping

### 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 business contact information from Crunchbase profiles efficiently.

#### How does the scraper integrate with Crunchbase?

The scraper integrates with the Crunchbase API to ensure accurate and reliable data extraction.

#### What data can I **extract** using this tool?

You can extract **emails**, company names, industries, contact names, locations, website URLs, funding details, and LinkedIn profiles.

#### Is the tool suitable for **large-scale** data **extract**ion?

**Yes**, the tool is scalable and can handle large datasets efficiently.

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

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

#### Is the scraper compliant with data privacy laws?

**Yes**, the scraper is designed to comply with data privacy regulations like GDPR and CCPA.

#### What are the customization options available?

You can customize scraping preferences by selecting specific data fields and applying filters.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with Crunchbase's latest features.

#### What support is available for users?

Comprehensive documentation and customer support are available to assist users.

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

**Yes**, the tool is ideal for building targeted email lists for marketing campaigns.

#### Is the tool beginner-friendly?

**Yes**, the **user-friendly** interface makes it accessible for beginners and advanced users alike.

#### What are the **legal** restrictions for using the scraper?

Users must comply with Crunchbase's terms of service and data privacy laws when using the scraper.

#### Can I scrape **private** or restricted data?

**No**, proper authorization is required to access restricted or private data.

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

The tool ensures **secure** and compliant data extraction to protect user privacy.

#### What industries can benefit from this tool?

The tool is suitable for various industries, including marketing, sales, and business development.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crunchbase Email Scraper",
        "description": "🔎 Crunchbase Email Scraper extracts verified email contacts from Crunchbase profiles to power B2B prospecting and lead generation. 🚀 Fast, targeted, and SEO-friendly for sales, recruiting, and market research. 💼📧",
        "version": "0.1",
        "x-build-id": "nC0oZdcEStrNUp6TP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~crunchbase-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-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/scrapepilotapi~crunchbase-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-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/scrapepilotapi~crunchbase-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```