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

📧 Crunchbase Email Scraper extracts verified business emails from Crunchbase profiles for faster lead generation. 🏢 Perfect for B2B sales, outreach, and market research—save time, enrich data, and boost conversions.

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

## Pricing

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

### crunchbase Email Scraper ⚡

Manually visiting hundreds of company profiles to collect emails wastes hours you don’t have. **crunchbase Email Scraper** automatically scrapes emails from Crunchbase profiles using your **keywords** and **custom email-domain filters**. This Crunchbase email scraper is ideal for marketers, recruiters, and growth teams who need fresh leads fast—collecting thousands of potential email contacts in a single run with controlled limits.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Crunchbase.com",
  "keyword": "founder",
  "title": "Acme Ventures",
  "description": "Acme Ventures — email us at hello@gmail.com for partnership inquiries.",
  "url": "https://example.com/profile/acme-ventures",
  "email": "hello@gmail.com",
  "proxyGroups": [
    "cost-effective"
  ]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network used for the extracted contact data. |
| `keyword` | string | Which keyword found this email, so you can understand the context behind the lead. |
| `title` | string | The page result title tied to the extracted email (useful for sorting and review). |
| `description` | string | The text snippet where the email was found—helps validate relevance quickly. |
| `url` | string | The related URL associated with the result you extracted the email from. |
| `email` | string | The extracted contact email address. |
| `proxyGroups` | array | The proxy configuration used for the scraping session (helpful for debugging consistency). |
| *(failure state handling)* | — | The actor stops when `maxEmails` is reached, and results are written as they’re found via dataset pushes. |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why crunchbase Email Scraper?

There are a lot of ways to pull data from Crunchbase — here’s what sets **crunchbase Email Scraper** apart.

#### Keyword and domain targeting that actually fits lead gen

crunchbase Email Scraper finds emails from Crunchbase bios and posts related to your `keywords`. You can also narrow results by using `customDomains` (for example, domains like `@gmail.com`) to get a more targeted Crunchbase contact email scraper output—useful for prospecting emails from the right audience.

#### Controlled scale with a hard cap on collection

You set `maxEmails` to control how many emails you want to collect in a run. This helps keep scraping time predictable, so your Crunchbase email extraction software workflow stays budget-friendly even on large searches.

#### Resilience for real-world web variability

The actor includes retries and fallbacks designed to keep the run moving when pages return empty or blocked responses. If results seem low, you’re also prompted (in the actor input guidance) to broaden keywords and domains and re-run.

#### Deduplication to keep your list clean

Emails are tracked so duplicates are skipped. This makes your exported Crunchbase email list builder output cleaner for importing into CRMs or enrichment workflows.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "United States",
  "platform": "Crunchbase",
  "customDomains": [
    "@gmail.com",
    "@company.com"
  ],
  "maxEmails": 50,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of keywords to search for. The scraper finds emails from Crunchbase bios and posts that are related to these keywords. |
| `location` | ⬜ | Location to filter search results (leave empty for no location filtering). |
| `platform` | ⬜ | Select platform. The only available option in this actor is `Crunchbase`. |
| `customDomains` | ⬜ | List of custom email domains to target (for example, `@gmail.com`). Uses these domains to focus the Crunchbase leads email extraction. |
| `maxEmails` | ⬜ | Maximum number of emails to collect. Stops once this limit is reached (higher values can take longer and don’t guarantee the exact count). |
| `engine` | ⬜ | Choose scraping engine. `cost-effective` is labeled as Cost Effective (New), and `legacy` is labeled as Legacy. |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor. Use Apify’s proxy editor to set it up. |

***

### Core Capabilities

#### Email extraction from Crunchbase bios and posts

crunchbase Email Scraper is built to extract emails found in Crunchbase bios and posts that relate to your chosen `keywords`. This makes it a focused B2B email scraper for Crunchbase rather than a general web crawler.

#### Flexible targeting with keywords + custom domains

You control relevance using `keywords` and precision using `customDomains` (like `@gmail.com`). If you’re doing Crunchbase email finder tool research for specific audiences, this reduces irrelevant addresses right away.

#### Output written as results are found

Each discovered email is pushed to the output dataset immediately, so you can monitor progress and export results when the run completes. This is especially useful for automated email scraping from Crunchbase when you want quick turnaround.

#### Pagination with stop conditions you can trust

The actor paginates through results while respecting your `maxEmails` limit. That means your Crunchbase email extraction software runs remain predictable for lead generation and email enrichment from Crunchbase leads.

#### Robust runs with retries and fallbacks

When pages return empty or blocked responses, the actor uses retries and fallbacks to improve resilience. If you’re building a Crunchbase email list builder and hit low yield, re-running with broader terms is recommended in the actor guidance.

***

### Who Gets the Most Out of This

Here’s how different teams put **crunchbase Email Scraper** to work:

**Sales Development Representatives** — Use it to find company emails tied to relevant keywords, building a prospecting email list faster than manual review. With `maxEmails`, they can run targeted tests before committing to larger batches.

**Growth and Demand Gen Marketers** — Turn Crunchbase email lookup into segmented leads by using `customDomains` (for example, targeting personal domains vs. company domains). The keyword context helps prioritize outreach categories.

**Recruiters and Talent Sourcers** — Scrape Crunchbase prospecting email extraction around roles and relevant signals, then export to your workflow for faster candidate-contact sequencing.

**Data Analysts and Researchers** — Build repeatable datasets by running the same keyword/domain setup and exporting results for further cleaning and enrichment. The structured output fields make it easier to validate and filter downstream.

**Automation and Integration Developers** — Pull results from Apify runs programmatically via the Apify API and push them into your pipeline. This helps automate Crunchbase data mining email addresses workflows without manual steps.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run **crunchbase Email Scraper** from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find *crunchbase Email Scraper*.
2. **Enter your inputs** — set `keywords` (required) and optionally `location`, `customDomains`, and `maxEmails`.
3. **Choose your engine** — pick `engine` as `legacy` or `cost-effective` depending on your preference for reliability vs. cost-effective execution.
4. **Configure proxy settings** — set `proxyConfiguration` in the run options if you want proxy support for your scraping needs.
5. **Hit Run and watch the live log** — monitor progress and any retry/fallback messages.
6. **View results in the dataset tab** — email records are pushed to the dataset as they’re found.
7. **Export as JSON, CSV, or Excel** — download the dataset in the format that fits your team’s workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **crunchbase Email Scraper** plugs directly into your existing workflow.

You can download your dataset from the Apify dashboard in **JSON, CSV, or Excel** formats, depending on what your team uses for analysis or list building. This makes it easy to take Crunchbase contact email scraper results straight into spreadsheets and CRM imports.

For automation, you can connect the actor to your stack using **Apify API access**, **webhooks**, **Zapier / Make**, or **scheduled runs**. For full details on endpoints and integrations, see the Apify documentation at https://apify.com/docs/api.

***

### Pricing & Free Trial

**crunchbase Email Scraper** runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

You can use the free tier credits for several test runs, then scale with Apify’s pay-as-you-go compute model. For the most accurate, up-to-date pricing and plan details, check the Apify pricing page at https://apify.com/pricing.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Proxy support | You can configure proxies using `proxyConfiguration` in the actor run. |
| Retry resilience | Built-in retries and fallbacks help improve success rates when pages are empty or blocked. |
| Controlled scraping volume | `maxEmails` stops collection once your target is reached, helping prevent runaway runtimes. |
| Output progress persistence | Progress is saved during execution so the run can continue without losing previously seen emails. |
| Deduplication | The actor tracks `seen_emails` so repeated addresses aren’t pushed again. |

**Limitations:** Results depend on what emails are publicly present in Crunchbase bios and posts related to your `keywords`. If you need higher yield, the actor guidance recommends re-running with broader keywords and more related terms or more domains.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify provides a free tier so you can run test jobs before committing to larger scraping tasks.

#### Do I need to log in to Crunchbase to use this?

No. The actor is designed to scrape publicly available data from Crunchbase profiles.

#### How accurate is the data?

Accuracy depends on what the email addresses are publicly shown in Crunchbase bios and posts. The actor extracts emails using your `customDomains` filtering and skips duplicates for cleaner output.

#### How many results can I get per run?

You control the maximum number of emails collected using `maxEmails`. The actor stops once that limit is reached, but larger limits can take longer and don’t guarantee you’ll hit the exact number.

#### How often is the data updated / how fresh is it?

The dataset reflects what’s available at the time you run the actor. If Crunchbase profile text changes, a new run can produce different results.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor works with **publicly available data**, but compliance depends on how you store, process, and use the results. You’re responsible for ensuring your usage complies with GDPR, CCPA, platform Terms of Service, and local regulations.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dataset tab, and then import into Google Sheets or Excel using your preferred workflow.

#### Can I run this on a schedule automatically?

Yes. You can set up scheduled runs on Apify to automate recurring Crunchbase email extraction tasks.

#### Can I access this via API?

Yes. You can pull results programmatically using the Apify API. See https://apify.com/docs/api for details.

#### What happens if the actor hits an error?

If scraping pages fail or return empty results, the actor uses retries and fallbacks. The run continues where possible, and it also tracks already seen emails to avoid duplicates.

***

### Need Help or Have a Request?

Got a question about **crunchbase Email Scraper** or want a new feature added? Reach out at <dataforleads@gmail.com>. Share what you’re trying to build—team-level email discovery, better domain filtering, or a webhook on completion—and we’ll help you get the most out of the Crunchbase contact email scraper workflow.

***

### Disclaimer & Responsible Use

*crunchbase Email Scraper is the fastest, most reliable way to build Crunchbase prospecting email lists — start your free run today.*

This actor collects **publicly available data** from Crunchbase and extracts emails from publicly available sources. It does not access private/protected profiles, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using the results.

For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords to search for.

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

Location to filter search results.

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

Select platform.

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

List of custom email domains

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

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## `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`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Crunchbase",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

# 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": [
        "founder",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/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": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/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": [
    "founder",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scraperoka/crunchbase-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/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 business emails from Crunchbase profiles for faster lead generation. 🏢 Perfect for B2B sales, outreach, and market research—save time, enrich data, and boost conversions.",
        "version": "0.0",
        "x-build-id": "CTxmvhp7WfDNGwXlm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~crunchbase-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-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/scraperoka~crunchbase-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-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/scraperoka~crunchbase-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-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": "A list of keywords to search for.",
                        "default": [
                            "founder",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Crunchbase"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Crunchbase"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "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": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
