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

📊 Crunchbase B2B Email Scraper & email finder extracts company insights, decision-maker contacts & verified emails from Crunchbase profiles. 🔎 Filter by industry, size & funding; enrich domains; de-dupe; export CSV. 🚀 Ideal for lead gen, prospecting, sales & outreach.

- **URL**: https://apify.com/api-empire/crunchbase-b2b-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Automation, Lead generation, Social media
- **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 B2B Email Scraper enables users to **extract** a wide range of **data** from Crunchbase profiles. This includes essential **contact** information such as email addresses, phone numbers, and company details.

The tool is designed to provide structured and organized **data** that can be directly used for lead generation or marketing campaigns. Users can also gather industry-specific information to target their outreach efforts more effectively.

By automating the **data** **extract**ion process, this email scraper for Crunchbase ensures accuracy and saves valuable time. Its ability to **extract** comprehensive business details makes it an indispensable resource for building a robust B2B email **data**base.

Whether you're looking to connect with startups, established companies, or specific industries, this tool provides the **data** you need to succeed.

Crunchbase B2B Email Scraper is a powerful tool designed to extract business email addresses from Crunchbase efficiently. It helps businesses streamline their lead generation process by providing accurate and up-to-date contact information.

This B2B email extraction tool is ideal for companies looking to build targeted email lists for outreach campaigns. By automating the email scraping process, it saves time and effort while ensuring high-quality data collection.

With the Crunchbase email scraping software, users can access valuable contact details of decision-makers and professionals in various industries. This enables businesses to connect with potential clients and partners more effectively.

### 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 business email addresses from Crunchbase profiles. |
| Phone Numbers | Retrieve publicly available phone numbers associated with companies or professionals. |
| Company Names | Collect the names of businesses listed on Crunchbase. |
| Job Titles | Extract job titles of key decision-makers and professionals. |
| Industry Information | Identify the industry or sector associated with each company. |
| Company Locations | Gather geographic details such as city, state, and country. |
| Website URLs | Retrieve official website links for companies listed on Crunchbase. |
| Social Media Links | Extract links to social media profiles associated with businesses or individuals. |

### 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** email scraping for efficient data collection
- ⭐ **Accurate** extraction of verified business email addresses
- ⭐ **Customizable** filters to target specific industries or regions
- ⭐ User-friendly interface for easy operation and navigation
- ⭐ Supports bulk data extraction to save time and effort
- ⭐ Provides well-structured and organized data outputs
- ⭐ Seamless integration with CRM and marketing tools
- ⭐ **Regular** updates to ensure compliance with data scraping policies
- ⭐ **Advanced** algorithms for precise and reliable data extraction
- ⭐ **Secure** and encrypted data handling for user privacy

### 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 B2B Email Scraper platform
2. ✅ Navigate to the dashboard and select the data extraction option
3. ✅ Enter the specific keywords or filters to target your desired audience
4. ✅ Choose the data fields you want to extract such as email addresses or company names
5. ✅ Set the scraping parameters including the number of profiles to extract data from
6. ✅ Click on the **Start** Scraping button to initiate the process
7. ✅ Monitor the progress of the scraping task through the dashboard
8. ✅ Once completed download the extracted data in your preferred format
9. ✅ **Review** the data for accuracy and completeness before using it
10. ✅ **Integrate** the data into your CRM or marketing tools for further use

### Use Cases 🎯

B2B Lead Generation
🎯 Build targeted email lists for outreach campaigns
🎯 **Identify** potential clients and partners in specific industries
🎯 **Automate** the process of finding business contacts

Market Research
🎯 Gather data on competitors and industry trends
🎯 **Analyze** business profiles to identify market opportunities
🎯 Extract detailed information for strategic planning

Sales Prospecting
🎯 **Find** decision-makers and key contacts in target companies
🎯 Enhance your sales pipeline with verified contact details
🎯 Streamline the prospecting process with automated tools

CRM Integration
🎯 Import extracted data directly into your CRM system
🎯 Maintain an up-to-date database of business contacts
🎯 Improve the efficiency of your sales and marketing teams

### Why choose us? 💎

Crunchbase B2B Email Scraper is designed to meet the evolving needs of modern businesses. Our tool offers unparalleled accuracy and efficiency, ensuring that you get the most relevant contact details for your campaigns.

We prioritize user experience by providing a simple and intuitive interface that anyone can use. Our **advanced** algorithms ensure precise data extraction, minimizing errors and maximizing productivity.

With customizable filters, you can target specific industries, regions, or business types with ease. We are committed to data security and compliance, ensuring that all scraping activities adhere to legal and ethical standards.

Our tool is **regular**ly updated to keep up with changes in Crunchbase's platform and data policies. Choose Crunchbase B2B Email Scraper for a **reliable**, efficient, and secure data scraping solution that empowers your business to succeed.

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

Crunchbase B2B Email Scraper is built to handle data extraction tasks of any scale. Whether you need to scrape data from a few profiles or thousands, our tool can accommodate your requirements.

Its robust infrastructure ensures smooth performance even during **large-scale** operations. By automating the process, it eliminates the need for manual data collection, saving time and resources.

Our tool is optimized for speed and accuracy, ensuring that you get high-quality data regardless of the volume. With flexible pricing plans, businesses of all sizes can benefit from our solution.

Whether you're a startup or a large enterprise, Crunchbase B2B Email Scraper can scale with your needs.

### **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 personal or sensitive information
⚖️ **Only** scrape publicly available data to avoid privacy violations
⚖️ **Obtain** consent before using extracted email addresses for marketing purposes
⚖️ **Avoid** overloading Crunchbases servers with excessive scraping requests
⚖️ Regularly review and adhere to data protection regulations in your region
⚖️ **Use** the tool responsibly to maintain ethical business practices
⚖️ **Do not** resell or distribute extracted data without proper authorization

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Crunchbase B2B 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 B2B 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 B2B 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 B2B **Email Scraper**?

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

#### Can I use this tool for **lead generation**?

**Yes**, the tool is specifically designed to help **businesses** generate targeted leads by extracting relevant contact information.

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

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

#### Can I customize the data fields to **extract**?

**Yes**, you can select specific data fields such as email addresses, phone numbers, or company names.

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

**Yes**, Crunchbase B2B Email Scraper is designed to comply with data protection regulations and ethical standards.

#### How do I integrate the **extract**ed data into my **CRM**?

You can download the data in a compatible format and import it directly into your CRM system.

#### Does the tool support bulk data **extract**ion?

**Yes**, the tool is capable of extracting data from multiple profiles simultaneously.

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

The limit depends on your subscription plan and the parameters set for the scraping task.

#### Can I scrape data from **specific** industries?

**Yes**, you can use filters to target specific industries or business types.

#### Is the tool easy to use?

**Yes**, the tool features a **user-friendly** interface that simplifies the data scraping process.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with Crunchbase's platform and policies.

#### Is technical support available?

**Yes**, our support team is available to assist you with any issues or questions.

#### Can I **export** the data in different formats?

**Yes**, the tool allows you to export data in various formats such as **CSV** or Excel.

#### Is my data **secure** while using the tool?

**Yes**, we prioritize data security and use encryption to protect user information.

#### What happens if Crunchbase changes its platform?

Our team monitors changes to Crunchbase and updates the tool accordingly to ensure continued functionality.

# 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-b2b-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-b2b-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-b2b-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crunchbase B2b Email Scraper",
        "description": "📊 Crunchbase B2B Email Scraper & email finder extracts company insights, decision-maker contacts & verified emails from Crunchbase profiles. 🔎 Filter by industry, size & funding; enrich domains; de-dupe; export CSV. 🚀 Ideal for lead gen, prospecting, sales & outreach.",
        "version": "0.1",
        "x-build-id": "35Nvp38wJrbAQJlPN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~crunchbase-b2b-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-crunchbase-b2b-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-b2b-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-crunchbase-b2b-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-b2b-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-crunchbase-b2b-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```