# Crunchbase Email Scraper Fast Advanced And Cheapest (`scraperoka/crunchbase-email-scraper-fast-advanced-and-cheapest`) Actor

🚀 Crunchbase Email Scraper—Fast, Advanced & Cheapest! Extract verified emails and key company details from Crunchbase with precision. Perfect for B2B leads, outreach, sales & recruitment. ⚡ Save time, boost conversions—start today! 📩

- **URL**: https://apify.com/scraperoka/crunchbase-email-scraper-fast-advanced-and-cheapest.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 $2.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

### Crunchbase Email Scraper - Fast, Advanced and Cheapest 🎯

Manually collecting emails from Crunchbase leads wastes hours you don’t have. **Crunchbase Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from Crunchbase using your keywords and email-domain filters, making it ideal for marketers, recruiters, and growth teams. Get results fast with this Crunchbase email extractor and reach thousands of contacts in a single run—without the manual copy-paste.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "network": "Crunchbase.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "alex@example.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source as `Crunchbase.com` for easier dataset tracking |
| `keyword` | string | Which keyword matched this contact (helps you segment campaigns) |
| `title` | string | The page title associated with the result you extracted |
| `description` | string | The text content used to find the email (useful for context and verification) |
| `url` | string | The link connected to the extracted contact (handy for manual checks) |
| `email` | string | The extracted email address ready for outreach |

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

***

### Why Crunchbase Email Scraper - Fast, Advanced and Cheapest?

There are a lot of ways to pull data from Crunchbase — here’s what sets **Crunchbase Email Scraper - Fast, Advanced and Cheapest** apart.

#### Keyword and domain targeting for better lead quality

You choose `keywords` and `customDomains` (like `@gmail.com`) so the **Crunchbase email scraper** focuses on the contacts that fit your outreach rules instead of collecting everything blindly.

#### Designed for automation and bulk collection

Run it across multiple keywords and domains to build a **Crunchbase company email list** for prospecting workflows. This makes it a strong fit for a Crunchbase email extractor when you need scale.

#### Resumable progress for fewer “lost runs”

The actor saves progress and deduplicates emails using a `seen_emails` set, so you can keep running without repeating the same results unnecessarily.

#### Output ready for downstream workflows

Every extracted match is pushed incrementally into the Apify dataset with consistent fields (`network`, `keyword`, `title`, `description`, `url`, `email`)—perfect for analytics, enrichment, or CRM import.

***

### Configuring Your Run

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

```json
{
  "keywords": ["manager", "founder"],
  "location": "San Francisco, CA",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords or queries the actor uses to find relevant Crunchbase leads |
| `location` | ⬜ | Location filter to focus results on a specific geography |
| `customDomains` | ⬜ | Email domains to restrict output (for example `@gmail.com`, `@yahoo.com`) |
| `maxEmails` | ⬜ | Stops the scraper once it collects the maximum number of emails you request (helps control runtime and cost) |

***

### Core Capabilities

#### Email extraction from Crunchbase profiles and related public pages

**Crunchbase Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from Crunchbase using the keyword and domain constraints you provide. This makes it useful as a Crunchbase email scraper tool for lead generation and research.

#### Flexible input for targeted prospecting

You can run multiple `keywords` and multiple `customDomains` in the same job, letting you build **Crunchbase leads email scraper** outputs tailored to your market (including B2B-friendly filtering via company-like domains).

#### Resilient, resumable runs

The actor persists progress and tracks seen emails, so repeated runs are less likely to waste time on already collected contacts. This is especially helpful when you’re running larger searches.

#### Controlled output volume (cost-friendly)

By using `maxEmails`, you cap how many emails the actor tries to collect. This helps you run tests quickly and scale up only when the results are on target.

#### Structured dataset output for easy importing

Results are pushed to the dataset as rows containing `keyword`, `title`, `description`, `url`, and `email` (plus `network`). That structure makes it straightforward to use a Crunchbase prospecting email tool in spreadsheets and CRM pipelines.

***

### Who Gets the Most Out of This

Here’s how different teams put **Crunchbase Email Scraper - Fast, Advanced and Cheapest** to work:

**Sales Development Representatives**\
SDRs can turn role-based keywords like `manager` and `founder` plus domain filters into a ready-to-import email list, cutting prospecting time from hours to minutes.

**Growth Marketing Teams**\
Growth teams can build segmented outreach lists by pairing keywords with specific domains (like `@gmail.com`), helping campaigns stay focused while still running at scale.

**Recruiters and Talent Sourcers**\
Recruiters can use Crunchbase email scraping to identify and contact relevant people tied to leadership or role keywords, speeding up outreach for active searches.

**Data Analysts and Researchers**\
Analysts can collect structured email records from Crunchbase and analyze coverage by keyword and domain, producing datasets that are easy to deduplicate and audit.

**Automation & Integration Specialists**\
Developers can incorporate this Crunchbase contact email scraper into a larger workflow by pulling results programmatically via the Apify API and feeding them into enrichment, scoring, or CRM ingestion pipelines.

***

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

No coding needed. Here's how to run **Crunchbase Email Scraper - Fast, Advanced and Cheapest** from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open the actor page.
2. **Enter your inputs** — set `keywords` (required), and optionally `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — use the actor’s built-in proxy support from the run options for more reliable scraping.
4. **Hit Run and watch the live log** — monitor progress and see when it collects new emails.
5. **View results in the dataset tab** — each extracted record is pushed into the dataset incrementally.
6. **Export as JSON, CSV, or Excel** — download directly from the dataset tab in Apify.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Crunchbase Email Scraper - Fast, Advanced and Cheapest** plugs directly into your existing workflow.

Export formats available from the Apify dataset tab include JSON, CSV, and Excel—ideal for marketers who want to import into outreach tools, and analysts who want to model in spreadsheets.

For deeper automation, you can use Apify’s API access to pull results programmatically, connect the dataset to tools like Zapier/Make, or schedule runs for ongoing lead generation using Apify’s run scheduling features. If you need more advanced automation patterns, check Apify’s API documentation at [apify.com/docs/api](https://apify.com/docs/api).

***

### Pricing & Free Trial

**Crunchbase Email Scraper - Fast, Advanced and Cheapest** runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

You can begin with a small test run using the free tier credits, then scale when you’re ready. Apify uses pay-as-you-go compute billing (based on platform usage), so you don’t need a long-term commitment to run proof-of-value campaigns.

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

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limiting and unstable pages | Includes resilience and fallback behavior to keep runs moving |
| Reliability improvements for scraping | Built-in proxy support designed for steadier collection |
| Duplicate contacts | Deduplicates using a `seen_emails` approach |
| Run interruptions | Progress is saved so you can resume rather than restart from zero |
| Output correctness | Only stores extracted email matches tied to the row fields shown in the dataset |

**Limitations:** The actor only extracts emails from publicly available sources visible during scraping. If target emails aren’t present in the public content, results may be limited even with higher `maxEmails`.

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 to get started without a credit card, which is typically enough for smaller tests of this Crunchbase email extractor.

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

No. This actor is designed to work with publicly available data, so you don’t need to provide Crunchbase login credentials.

#### How accurate is the data?

Accuracy depends on what is actually published in the public content. The actor extracts email addresses found in the scraped text and returns them in the dataset as `email` with supporting fields like `url` and `description`.

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

You control volume using `maxEmails`. If you request more, the actor may still return fewer emails if the accessible public content doesn’t contain additional matches.

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

Freshness depends on when you run the actor. Each run scrapes publicly available data at that time, and the dataset reflects what was available during the run.

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

Use of scraped emails must follow applicable laws and policies. The actor works with **publicly available data**, but it’s your responsibility to ensure your usage (including storage and outreach) complies with GDPR, CCPA, platform rules, and local regulations.

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

Yes. You can export directly from the Apify dataset tab to JSON, CSV, or Excel, and then import into Google Sheets or your preferred system.

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

Yes. You can schedule actor runs using Apify’s scheduling features for ongoing lead generation with this Crunchbase email scraper tool.

#### Can I access this via API?

Yes. You can retrieve results programmatically using the Apify API. For details, see [apify.com/docs/api](https://apify.com/docs/api).

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

If an error occurs during result pushing, the actor logs the issue and continues the run. Progress is saved during execution so you can resume work without losing all previously collected data.

***

### Need Help or Have a Request?

Got a question about **Crunchbase Email Scraper - Fast, Advanced and Cheapest** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like webhook notifications on completion and batch CSV upload support—tell us what would make your Crunchbase email scraping workflow smoother.

***

### Disclaimer & Responsible Use

*Crunchbase Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to extract emails from publicly available sources — start your free run today.*

This actor collects **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. It’s your responsibility to comply with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using and storing 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 or queries to search for.

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

Location to filter search results.

## `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.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/crunchbase-email-scraper-fast-advanced-and-cheapest").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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crunchbase Email Scraper Fast Advanced And Cheapest",
        "description": "🚀 Crunchbase Email Scraper—Fast, Advanced & Cheapest! Extract verified emails and key company details from Crunchbase with precision. Perfect for B2B leads, outreach, sales & recruitment. ⚡ Save time, boost conversions—start today! 📩",
        "version": "1.0",
        "x-build-id": "i3ICxZPC9KUZ2Yghk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~crunchbase-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-crunchbase-email-scraper-fast-advanced-and-cheapest",
                "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-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-crunchbase-email-scraper-fast-advanced-and-cheapest",
                "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-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-crunchbase-email-scraper-fast-advanced-and-cheapest",
                "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 or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter 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
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
