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

🎓 College Coach Email Scraper extracts verified college coach emails fast using targeted filters—boost your outreach, partnerships & recruitment campaigns. 🚀 Ideal for agencies, sales teams & educators seeking qualified leads instantly. 📩

- **URL**: https://apify.com/solid-scraper/college-coach-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (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

### College Coach Email Scraper 📬

**College Coach Email Scraper** is a purpose-built tool that helps you find college sports coach contact details and then scrape emails (plus supporting phone and social links) from the businesses’ publicly available pages. Whether you’re running outreach, building a **college coaches email list**, or doing research for **college recruiting contact database** projects, this actor automates the heavy lifting—saving you hours of manual work.

You can use it with a **college recruiting email scraper** workflow to scale lead generation across locations, using your search term and limits to control how many results you collect.

---

### Why choose College Coach Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one lead finding + website email extraction** | Extracts websites first, then scrapes **emails**, plus **phone numbers** and **social media profiles** when available |
| ✅ **Reliability with built-in resilience** | Includes fallback and resilience so runs can complete even when some targets are missing or hard to access |
| ✅ **Structured dataset output** | Saves results in a consistent dataset schema so you can filter and export fast for a **coach email finder tool** use case |
| ✅ **Configurable limits for scale** | Control how many businesses you scrape (and stop when you hit your target) for predictable **college coach lead generation tool** results |
| ✅ **Proxy support for web scraping** | Lets you configure proxy settings for large-scale runs where request reliability matters |
| ✅ **Automated processing with immediate saving** | Pushes scraped results to the Apify dataset as it goes, reducing the risk of losing progress |

---

### Key features

- 🎯 **Keyword + location targeting**: Use a search term and one or more locations to focus results on college coach-related business profiles.
- 🌐 **Website discovery first**: Collects business website information so email scraping can be performed against actual domains.
- 📧 **Email extraction from websites**: Scrapes email addresses from each website and records how many were found.
- 📞 **Phone extraction support**: Extracts phone numbers when available and saves them alongside emails.
- 🔗 **Social profile extraction support**: Extracts social links when available and saves them alongside other contact info.
- 🛡️ **Proxy configuration for scraping**: Includes built-in proxy configuration support to improve reliability.
- 💾 **Real-time dataset saving**: Each processed business (and email rows when emails are found) is pushed into the dataset immediately.
- ✅ **Controlled output volume**: Stops once your max targets are reached (including optional per-location behavior).

---

### Input

Provide input via an `input.json` file. Example structure:

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `googleMapsSearchTerm` | Yes | The business type or niche to search for (prefilled with `College Coach`). |
| `googleMapsLocation` | Yes | Target geographic location(s) for the search (for example, `New York`). Provide one or more locations. |
| `maxBusinesses` | No | Maximum number of businesses to find with emails (allowed range: 1–1000). The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | If enabled, it collects up to `maxBusinesses` results per location. If disabled, it combines all locations into a single total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping. Recommended for larger-scale runs. |
| `proxyConfiguration.proxy support` | No | Enable Apify Proxy by default (prefilled as `true` in the UI). |

***

### Output

The actor saves results in the Apify dataset as flattened JSON records. When emails are found, it pushes **one row per email** (with the same business context repeated).

Example output record:

```json
{
  "street_address": "123 Main St",
  "city": "New York",
  "zip": "10001",
  "state": "NY",
  "country_code": "US",
  "full_address": "123 Main St New York NY 10001 US",
  "website": "https://example.com",
  "avg_rating": 4.2,
  "total_reviews": 128,
  "name": "Example College Coach",
  "place_id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
  "phone": "+1 555 123 4567",
  "lat": 40.7128,
  "long": -74.0060,
  "scraped_emails": [],
  "scraped_phones": [],
  "scraped_social_media": [],
  "emails_found": 0,
  "pages_scraped": 0,
  "scrape_status": "success",
  "email_found": "coach@example.com"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business name for the coach/business profile. |
| `website` | string | Website URL discovered for the business. |
| `phone` | string | Phone number as captured for the business profile (if present). |
| `full_address` | string | Full address assembled from the scraped address components. |
| `city` | string | City of the business. |
| `state` | string | State/region of the business. |
| `zip` | string | Postal/ZIP code. |
| `country_code` | string | Country code. |
| `scraped_emails` | array | List of scraped email addresses (in the business object before flattening). |
| `scraped_phones` | array | List of scraped phone numbers from the website. |
| `scraped_social_media` | array | List of scraped social media profiles from the website. |
| `emails_found` | number | Count of emails found on the website for this business. |
| `pages_scraped` | number | Number of pages processed during website scraping. |
| `avg_rating` | number | Average rating captured for the business profile. |
| `total_reviews` | number | Total reviews captured for the business profile. |
| `lat` | number | Latitude for the business location. |
| `long` | number | Longitude for the business location. |
| `place_id` | string | Place identifier for the business profile. |
| `scrape_status` | string | Scraping status (for example: `success`, `failed`, `no_website`, `error`). |

Note: the actor also pushes an `email_found` field when emails are available (one output row per discovered email), and it may push businesses without websites depending on the run configuration.

***

### How to use College Coach Email Scraper (via Apify Console)

1. **Open Apify Console**
   Log in at https://console.apify.com and navigate to the **Actors** section.

2. **Find the actor**
   Search for **College Coach Email Scraper** and open the actor page.

3. **Configure INPUT**
   In the input form, set:
   `googleMapsSearchTerm` (defaults to `College Coach`) and add at least one value in `googleMapsLocation`.

4. **Set your limits**
   Adjust `maxBusinesses` to control how many business contacts you want.
   Toggle `scrapeMaxBusinessesPerLocation` if you want `maxBusinesses` applied per location rather than as a single combined total limit.

5. **Optional: set Proxy Configuration**
   Use the `proxyConfiguration` settings if you need better reliability for larger scraping runs.

6. **Run the actor**
   Click **Run**. Watch the logs in the console to see progress as it processes each location and then scrapes websites for contact emails.

7. **Open the dataset**
   After the run finishes, go to the **OUTPUT** tab and open the dataset view titled **Business Contact Data**.

8. **Export your results**
   Export from the dataset in your preferred format (the dataset is structured for easy filtering and downstream use in tools that ingest JSON/CSV).

No coding required — get accurate results in minutes with this **college coach email scraper** workflow.

***

### Advanced features & SEO optimization

- 📌 **Designed for “coach email finder tool” workflows**: It supports a **college recruiting email scraper** approach by targeting a niche term (like `College Coach`) plus specific geographic locations.
- 🌐 **Website-first contact enrichment**: It scrapes websites and then extracts contact info from those domains, improving the usefulness of the resulting **college coaches email list**.
- 🛡️ **ProxyConfiguration support**: When you scale, configure proxy settings to help reduce the chance of interruptions.
- 💾 **Immediate dataset pushing**: Results are written as the actor discovers them, which is ideal for long runs and iterative lead generation.

***

### Best use cases

- 📈 **Lead generation for college recruiting**: Build a **college coach lead generation tool** pipeline by extracting coach contact emails at scale across multiple cities.
- 🎓 **Market research by location**: Compare outreach targets across regions using structured fields like `city`, `state`, and `full_address`.
- 🗂️ **Athletic director email outreach**: Assemble a **college staff email scraper** dataset to support recruiting campaigns and stakeholder communications.
- 🔎 **Email list building for marketers**: Create a **college coaches email list** quickly without manually checking each site.
- 💻 **Data enrichment for CRM workflows**: Feed scraped emails, phone details, and social links into your CRM for follow-up automation.
- 🧪 **Research & analysis projects**: Use scraped metadata (like `avg_rating`, `total_reviews`, `lat`, `long`) alongside contact fields for reporting.
- 📣 **Recruiting contact database creation**: Standardize outputs from a **college recruiting contact database**-style dataset for downstream outreach tooling.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `googleMapsSearchTerm` (string)
  - ✅ `googleMapsLocation` (array of strings)
  - ✅ `proxyConfiguration` (object, with `proxy support`)

- **Proxy Support**
  - ✅ `proxyConfiguration` is supported (recommended for larger-scale scraping runs)

- **Retry Mechanism**
  - ✅ Includes resilience and retry/fallback behavior (high level) for more reliable runs

- **Dataset Structure**
  - ✅ **Business Contact Data** dataset view with these fields:
    `name`, `website`, `phone`, `full_address`, `city`, `state`, `zip`, `country_code`, `scraped_emails`, `scraped_phones`, `scraped_social_media`, `emails_found`, `pages_scraped`, `avg_rating`, `total_reviews`, `lat`, `long`, `place_id`, `scrape_status`

- **Rate Limits & Performance**
  - ✅ Tuned for controlled batching using `maxBusinesses` and (optionally) per-location limits

- **Limitations**
  - ❌ No guaranteed email on every scraped website: output may show `scrape_status` like `no_website`, `failed`, or `error` depending on what’s accessible.
  - ❌ If a business has no website or the website doesn’t expose contact emails, `emails_found` may be `0`.

***

### FAQ

#### What does College Coach Email Scraper extract?

✅ It extracts business profile data (like `name`, `website`, `phone`, and address fields), then scrapes each website to collect `scraped_emails`, along with `scraped_phones` and `scraped_social_media` when available.

#### Does College Coach Email Scraper save results to the dataset while it runs?

✅ Yes. It pushes results immediately to the Apify dataset as it processes each business, so you can monitor progress and avoid losing everything if a run is interrupted.

#### How do I control how many results I get?

You can set `maxBusinesses` (1–1000). If you enable `scrapeMaxBusinessesPerLocation`, the actor collects up to `maxBusinesses` results per location; otherwise it uses a combined total limit across all locations.

#### Can I run this for multiple cities at once?

✅ Yes. Provide multiple entries in `googleMapsLocation` and the actor will process each location according to your limits and `scrapeMaxBusinessesPerLocation` setting.

#### Is email validation enabled by default?

✅ Email validation is controlled by an input you can pass via `validateEmails` (the schema for the UI inputs doesn’t expose it as a top-level field, but the actor reads it if present in input). If validation is enabled, the website scraping step uses that configuration.

#### Do I need proxyConfiguration to run?

❌ No. `proxyConfiguration` is optional, but it’s recommended for larger-scale scraping runs where reliability matters.

#### Can I use the output for outreach campaigns?

✅ You can use the dataset for legitimate outreach and lead generation workflows. The actor collects information from publicly available sources, and it’s your responsibility to comply with applicable laws and policies.

#### Where can I request help or report issues?

For support or feedback, email <dataforleads@gmail.com>.

***

### Support & feature requests

Want to improve your College Coach Email Scraper workflow? We’d love your feedback. 🚀

- 💡 **Feature Requests**: For example, enhancements like additional export formats, custom filtering options, or more control over the dataset shape could make this an even stronger **college coach email scraper** for your recruiting pipelines.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your input helps shape future improvements to this **college coach lead generation tool**.

***

*This is the most comprehensive, SEO-optimized College Coach Email Scraper for structured coach contact data—built for scale and speed.*\
Use it to turn **college coaches email list** ideas into actionable outreach-ready results.

***

### Disclaimer

**This tool accesses publicly available sources** to collect business contact information. It does not access private profiles, authenticated data, or password-protected pages.

You are responsible for ensuring your use complies with applicable laws and regulations (including GDPR and CCPA where relevant), spam and email outreach rules, and the terms of service of the websites being scraped.

For data removal requests, contact <dataforleads@gmail.com>. Please use this tool responsibly, ethically, and for legitimate purposes only.

# 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("solid-scraper/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("solid-scraper/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 solid-scraper/college-coach-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solid-scraper/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 emails fast using targeted filters—boost your outreach, partnerships & recruitment campaigns. 🚀 Ideal for agencies, sales teams & educators seeking qualified leads instantly. 📩",
        "version": "1.0",
        "x-build-id": "2XpJizWvv6RP50pI7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~college-coach-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-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/solid-scraper~college-coach-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-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/solid-scraper~college-coach-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
