# College Coach Email Scraper (`scraperoka/college-coach-email-scraper`) Actor

📧 College Coach Email Scraper extracts verified college coach email contacts for faster outreach. ✅ Helps sales teams and recruiters build targeted lists quickly—no manual searching. Ideal for B2B prospecting, partnerships & recruiting.

- **URL**: https://apify.com/scraperoka/college-coach-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Jobs
- **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

### College Coach Email Scraper 🚀 — Find Coach Contact Emails Fast (From Public Web Data)

Manually hunting for college coach contact emails by searching websites one by one wastes hours you don’t have. **College Coach Email Scraper** is a focused email scraping tool that pulls coach business contact details (emails, phone numbers, and social links) from publicly available sources, ideal for marketers, recruiters, and growth teams. It’s built specifically as a **college coach email scraper** and **college recruiting email scraper** to help you build outreach-ready lists quickly—often reaching hundreds of contacts in a single run.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "name": "University Athletics - Men's Basketball",
  "website": "https://www.universityathletics.edu",
  "phone": "+1 (212) 555-0199",
  "full_address": "123 College Ave New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "scraped_emails": ["coach.recruiting@universityathletics.edu"],
  "scraped_phones": ["+1 (212) 555-0199"],
  "scraped_social_media": ["https://www.linkedin.com/company/universityathletics/"],
  "emails_found": 1,
  "pages_scraped": 6,
  "avg_rating": 4.6,
  "total_reviews": 128,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
  "scrape_status": "success",
  "email_found": "coach.recruiting@universityathletics.edu"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `name` | string | The business name for your outreach list (the coach org context). |
| `website` | string | The coach org website the actor scanned for contact details. |
| `phone` | string | Primary phone field captured alongside the listing info. |
| `full_address` | string | A consolidated address string you can use for enrichment or verification. |
| `city` | string | City to help with geography filtering for recruiting coach outreach. |
| `state` | string | State/region for segmentation. |
| `zip` | string | ZIP/postal code for record matching and dedupe. |
| `country_code` | string | Country code to keep your dataset consistent internationally. |
| `scraped_emails` | array | All emails found on the business website pages. |
| `scraped_phones` | array | Phone numbers extracted from the website content. |
| `scraped_social_media` | array | Social media profile links extracted from the website. |
| `emails_found` | number | How many emails were found for this business website. |
| `pages_scraped` | number | How many URLs/pages were processed while extracting contacts. |
| `avg_rating` | number | Listing rating metadata that can help you prioritize targets. |
| `total_reviews` | number | Number of reviews for listing context. |
| `scrape_status` | string | Run status for the business record (example values include `success`, `failed`, `no_website`, `error`). |

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

***

### Why College Coach Email Scraper?

There are a lot of ways to pull data from public web sources — here’s what sets **College Coach Email Scraper** (and other coach contact email scraper workflows) apart.

#### Built for coach outreach data collection

The actor focuses on extracting coach-adjacent business contact information such as emails, phone numbers, and social media profiles, designed to feed directly into recruiting coach email outreach and sales development pipelines.

#### Clean, structured dataset fields

Your output is written into the Apify dataset using consistent, analyst-friendly fields (like `scraped_emails`, `scraped_phones`, `scraped_social_media`, and `scrape_status`) so you can filter, deduplicate, and merge records without heavy reformatting.

#### Email-focused scraping with resilience

The workflow is designed to keep going and still deliver results even when some websites don’t cooperate (for example, missing websites). It also supports optional email validation, which is useful when you’re building a **college coach contact email scraper** list you’ll actually use for outreach.

#### Deduplication by listing identity

For the business discovery portion, the actor tracks unique listings to avoid inserting the same target repeatedly, helping you generate a more reliable **college coach email list scraper** output.

***

### Configuring Your Run

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

```json
{
  "googleMapsSearchTerm": "College Coach",
  "googleMapsLocation": ["New York"],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `googleMapsSearchTerm` | ✅ | The business type or niche you want to search for (prefilled with `College Coach`). |
| `googleMapsLocation` | ✅ | One or more target geographic locations (for example, `"New York"`). |
| `maxBusinesses` | ⬜ | Maximum number of businesses to find (range `1-1000`). The actor stops when it reaches this target. |
| `scrapeMaxBusinessesPerLocation` | ⬜ | If enabled, the actor aims for up to `maxBusinesses` results per location; if disabled, it combines all locations into a single total limit. |
| `proxyConfiguration` | ⬜ | Proxy settings for scraping. Recommended for larger runs. |
| `proxyConfiguration ↳ proxy support` | ⬜ | When set, routes traffic through Apify Proxy for better reliability. |

***

### Core Capabilities

#### Targeted college coach discovery by niche and location

You provide a coach-related search term and one or more locations, and the actor collects business listing details that are then used for website contact extraction—useful for building a **college recruiting email scraper** list segmented by region.

#### Website contact extraction (emails, phones, social links)

For each discovered business that has a website, the actor extracts `scraped_emails`, `scraped_phones`, and `scraped_social_media`, plus supporting metadata like `pages_scraped` and `scrape_status`.

#### Optional email validation to improve outreach quality

Email validation can be enabled via input (`validateEmails`) even though it’s not exposed as a visible field in the provided input schema. When enabled, it helps you reduce risky addresses in your **NCAA coach email scraper** or assistant coach outreach datasets.

#### Output completeness with explicit status handling

If a listing has no website, the actor still records a structured entry with `scrape_status` set to `no_website` and empty contact arrays, so your downstream cleanup logic is straightforward.

#### Proxy support for stable large-scale runs

The actor supports proxy configuration to help scraping stay reliable at scale, which is helpful when you’re building a **coach contact list scraper** across many runs.

***

### Who Gets the Most Out of This

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

**Recruiting marketing teams** use it to build a region-based outreach list for recruiters and sports marketers, collecting `scraped_emails` plus phone and social links so they can run multi-channel campaigns with fewer manual steps.

**Sales development reps** use it to generate a repeatable pipeline for **college coach outreach email scraper** workflows—discover targets by location, extract contact emails from websites, then enrich with phone and social profiles for faster first-touch personalization.

**College sports analysts and researchers** use it to assemble datasets of athletic program and coaching contact points for outreach studies, using fields like `avg_rating`, `total_reviews`, and `place_id` to compare and deduplicate targets.

**Automation specialists and data engineers** can integrate the results into their ETL flow using the actor’s dataset output fields and run controls, turning it into a dependable upstream for dashboards and lead scoring systems.

***

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

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

1. **Open** the actor on Apify — go to [console.apify.com](https://console.apify.com) and find the actor page.
2. **Enter** your inputs using the fields from the configuration section (like `googleMapsSearchTerm`, `googleMapsLocation`, and your `maxBusinesses` target).
3. **Configure** proxy settings (optional, but recommended for larger scraping jobs).
4. **Hit Run** and watch the live log for progress and any status messages.
5. **View** results in the dataset tab (each business record includes contact arrays and status fields).
6. **Export** as JSON, CSV, or Excel from the dataset tab.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

You can export results from the Apify dataset tab in common formats like **JSON**, **CSV**, and **Excel**, making it easy to use with spreadsheets, CRMs, and analytics tooling.

For automation and ingestion, you can connect exports to tools using Apify-native integrations or no-code automation (such as Zapier/Make), and you can also pull results programmatically via the Apify API (see [apify.com/docs/api](https://apify.com/docs/api) for details).

***

### Pricing & Free Trial

**College Coach Email Scraper** runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You’ll typically get several test runs with the free platform credits, and then continue pay-as-you-go based on usage.

Apify compute is billed per platform usage, and you can scale up using Apify’s subscription plans if you’re running frequent or high-volume scraping jobs. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit resilience | Uses proxy support and built-in scraping safeguards to improve stability. |
| Proxy reliability | Proxy configuration is supported to help reduce blocking and throttling. |
| Missing or incomplete websites | If a website is missing, records are still pushed with empty contact fields and `scrape_status` set accordingly. |
| Output consistency | Results are saved with consistent dataset fields for downstream processing. |
| Controlled scale | `maxBusinesses` and the per-location logic help keep runs within your target size. |

**Limitations:** This actor relies on publicly available data and the presence of website contact information. If a target doesn’t publish email addresses (or uses obfuscation/anti-scraping measures), you may see fewer emails in `scraped_emails` for that business. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

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

Yes. Apify offers a free tier (platform credits) to help you test **college coach email scraper** output before scaling up.

#### Do I need to log in to College Coach Email Scraper to use this?

No. You use the actor through Apify, providing inputs like `googleMapsSearchTerm` and `googleMapsLocation`.

#### How accurate is the data?

Accuracy depends on what the target business publishes on its website. The actor extracts emails, phone numbers, and social links into structured fields such as `scraped_emails` and `scraped_social_media`.

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

You control volume with `maxBusinesses` (range `1-1000`). If you enable `scrapeMaxBusinessesPerLocation`, the actor aims for that cap per location; otherwise, it uses a combined total limit.

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

The dataset reflects what the actor finds during the time of your run. If you need fresher outreach lists, schedule regular runs based on your campaign cadence.

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

The actor works with **publicly available data** that can be accessed without using private credentials. You’re responsible for ensuring your use complies with GDPR, CCPA, platform Terms, and any applicable local regulations.

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

Yes. You can export the dataset from the Apify dashboard as JSON, CSV, or Excel, and then import into Google Sheets or your preferred spreadsheet/CRM workflow.

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

Yes. You can set up scheduled runs in Apify to automate recurring **college recruiting email scraper** list refreshes.

#### Can I access this via API?

Yes. You can retrieve results programmatically through the Apify API after the run completes (see [apify.com/docs/api](https://apify.com/docs/api)).

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

If a target can’t be processed (for example, no website is found or scraping fails), the dataset still contains structured fields including `scrape_status` so you can identify failures and rerun as needed.

***

### Need Help or Have a Request?

Got a question about **College Coach Email Scraper** or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with onboarding and we actively maintain the actor based on user feedback. If you’d like ideas like webhook notifications on completion or batch workflows for exporting outreach-ready lists, tell us what you’re building.

***

### Disclaimer & Responsible Use

*College Coach Email Scraper is the fastest, most reliable way to build a contact-ready college coach email dataset from public web data — start your free run today.*

This actor collects **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. You are responsible for compliance with GDPR, CCPA, platform Terms of Service, and any applicable laws when using or storing the extracted data. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').

## `googleMapsLocation` (type: `array`):

Target geographic location for the email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of businesses to find (1-1000). The scraper will stop when this target is reached.

## `scrapeMaxBusinessesPerLocation` (type: `boolean`):

If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.

## `proxyConfiguration` (type: `object`):

Proxy settings for scraping. Recommended for large-scale scraping.

## Actor input object example

```json
{
  "googleMapsSearchTerm": "College Coach",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "googleMapsSearchTerm": "College Coach",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/college-coach-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 = {
    "googleMapsSearchTerm": "College Coach",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/college-coach-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 '{
  "googleMapsSearchTerm": "College Coach",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scraperoka/college-coach-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "College Coach Email Scraper",
        "description": "📧 College Coach Email Scraper extracts verified college coach email contacts for faster outreach. ✅ Helps sales teams and recruiters build targeted lists quickly—no manual searching. Ideal for B2B prospecting, partnerships & recruiting.",
        "version": "1.0",
        "x-build-id": "z72JJct5p5XhTpK6y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~college-coach-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-college-coach-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~college-coach-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-college-coach-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~college-coach-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-college-coach-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": [
                    "googleMapsLocation",
                    "googleMapsSearchTerm"
                ],
                "properties": {
                    "googleMapsSearchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').",
                        "default": "College Coach"
                    },
                    "googleMapsLocation": {
                        "title": "Location",
                        "type": "array",
                        "description": "Target geographic location for the email scraper (e.g., 'Miami, Florida').",
                        "default": [
                            "New York"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxBusinesses": {
                        "title": "Maximum Businesses With Emails",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Target number of businesses to find (1-1000). The scraper will stop when this target is reached.",
                        "default": 5
                    },
                    "scrapeMaxBusinessesPerLocation": {
                        "title": "Scrape Max Businesses Per Location",
                        "type": "boolean",
                        "description": "If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Recommended for large-scale scraping."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
