# K12 Schools Email Scraper (`scraperoka/k12-schools-email-scraper`) Actor

📧 K12 Schools Email Scraper extracts verified email addresses from K-12 school websites—great for targeted outreach, sales, and lead research. ⚡ Fast, accurate data collection. 🚀 Perfect for B2B prospecting and marketing campaigns.

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

## Pricing

from $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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### K12 Schools Email Scraper 📬

**K12 Schools Email Scraper** is an Apify actor that helps you find K12 schools in targeted locations and extract contact information—especially email addresses—from publicly available sources. If you’re looking for a **K12 schools email scraper**, a **school district email scraping tool**, or a **K-12 school contact email extractor**, this actor is built to save you time by turning school and district listings into usable email and phone contact data. Whether you’re a marketer, recruiter, researcher, or data analyst, you can use K12 leads email scraper workflows to build outreach-ready contact lists at scale—without manually digging through directories.

---

### 🚀 Why choose K12 Schools Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ **Email-first website contact scraping** | Extracts emails (and also phones + social links) from the school/district websites found in your results |
| ✅ **Proxy support** | Helps improve reliability for large-scale scraping by reducing the chance of IP blocks and rate limits |
| ✅ **Resilience for real-world pages** | Includes fallbacks so the run can keep going even when some sites are incomplete or unavailable |
| ✅ **Structured, dataset-ready output** | Saves consistent fields like `name`, `website`, `scraped_emails`, and `scrape_status` for easy import into CRMs and analysis |
| ✅ **Scales across multiple locations** | Lets you search multiple `googleMapsLocation` values and collect up to your defined limits |
| ✅ **Progress-aware limits** | Stops when the target number of results is reached, so you control how much data you collect |

---

### 🔑 Key features

- 🎯 **Location-driven K12 contact discovery**: Uses your `googleMapsLocation` list and `googleMapsSearchTerm` to focus on K12 school listings.
- 📄 **Website email harvesting**: Scrapes school or district websites to extract `scraped_emails`, and can also extract `scraped_phones` and `scraped_social_media`.
- 🧾 **Accurate dataset structure**: Outputs consistent dataset columns for downstream processing (including per-email rows via `email_found`).
- 🛡️ **Built-in proxy support**: Works with your `proxyConfiguration` (recommended for larger batches).
- 🔄 **Control your volume**: Use `maxBusinesses` and `scrapeMaxBusinessesPerLocation` to manage totals per location vs globally.
- 💾 **Real-time data saving**: Pushes results to the Apify dataset immediately during execution (so you don’t lose work on interruptions).
- 📞 **Phone and social enrichment included**: Alongside emails, it also stores phone numbers and social links when available.
- ✅ **Optional email validation**: Through `validateEmails`, it can validate emails for higher-confidence outreach lists.

---

### 📝 Input

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

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

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `googleMapsSearchTerm` | ❌ | Search term describing the business type or niche to target (prefilled with `K12 Schools`). |
| `googleMapsLocation` | ✅ | One or more geographic locations to search (example format: `New York`). |
| `maxBusinesses` | ❌ | Target number of businesses to find with emails. Allowed range is `1-1000` (default: `5`). |
| `scrapeMaxBusinessesPerLocation` | ❌ | Controls how `maxBusinesses` is applied: when enabled, it collects up to `maxBusinesses` per location; when disabled, it combines all locations up to a single total limit. |
| `proxyConfiguration` | ❌ | Proxy settings for scraping. Includes `proxy support` (prefilled to `true`). |

***

### 📦 Output

After execution, the actor saves the results to the **Business Contact Data** dataset view. The dataset transformation includes the following 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`.

```json
[
  {
    "name": "Sample School District",
    "website": "https://example.edu",
    "phone": "+1 555 123 4567",
    "full_address": "123 Main St City ST 12345 US",
    "city": "City",
    "state": "ST",
    "zip": "12345",
    "country_code": "US",
    "scraped_emails": ["info@example.edu"],
    "scraped_phones": ["+1 555 987 6543"],
    "scraped_social_media": ["https://www.facebook.com/example"],
    "emails_found": 1,
    "pages_scraped": 12,
    "avg_rating": 4.2,
    "total_reviews": 38,
    "lat": 40.7128,
    "long": -74.006,
    "place_id": "ChIJ...",
    "scrape_status": "success"
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `name` | string | Business/school name. |
| `website` | string | Website URL for the business/school. |
| `phone` | string | Phone value from the initial business listing (when present). |
| `full_address` | string | Combined address string built from address parts. |
| `city` | string | City from the business listing. |
| `state` | string | State from the business listing. |
| `zip` | string | ZIP/postal code from the business listing. |
| `country_code` | string | Country code from the business listing. |
| `scraped_emails` | array | Extracted emails found on the website. |
| `scraped_phones` | array | Extracted phone numbers found on the website. |
| `scraped_social_media` | array | Extracted social media links found on the website. |
| `emails_found` | number | Count of emails found for that business. |
| `pages_scraped` | number | Number of processed URLs/pages during website scraping (`job.progress.processed_urls`). |
| `avg_rating` | number | Average rating value from the business listing. |
| `total_reviews` | number | Total reviews count from the business listing. |
| `lat` | number | Latitude coordinate. |
| `long` | number | Longitude coordinate. |
| `place_id` | string | Place identifier from the initial listing. |
| `scrape_status` | string | Status of the scrape (e.g. `success`, `failed`, `no_website`, `error`). |

Note: during execution, results are also pushed in a flattened way per extracted email using `email_found`. However, the dataset view transformation focuses on the fields listed above for table display and analysis.

***

### How to use K12 Schools Email Scraper (via Apify Console)

1. **Open Apify Console**
   Go to [console.apify.com](https://console.apify.com) and sign in.

2. **Find the actor**
   Search for **K12 Schools Email Scraper** in the Actors marketplace.

3. **Add your input**
   In the **INPUT** panel, set:
   - `googleMapsSearchTerm` (default `K12 Schools`)
   - `googleMapsLocation` (add one or more locations)

4. **Set your limits**
   Choose:
   - `maxBusinesses` (how many business contacts you want to collect)
   - `scrapeMaxBusinessesPerLocation` (per-location cap vs one global cap)

5. **Configure proxies (recommended)**
   In **Proxy configuration**, use `proxyConfiguration` and keep `proxy support` enabled for more reliable runs at scale.

6. **Run the actor**
   Click **Run**. While it runs, you’ll see progress in the logs as it processes each location and scrapes websites.

7. **Review your dataset**
   When finished, open the dataset named **Business Contact Data** (default dataset view: *Businesses with Contact Information*), then export the results (JSON/CSV) for your outreach pipeline.

No coding required—get K12 school contact email lists in minutes with this K12 schools email scraper.

***

### 🧠 Advanced features & SEO optimization

- 🔍 **Engineered for K12 outreach lists**: Built specifically for the **K12 Schools Email Scraper** use case—extracting emails plus additional contact details like phones and social links.
- 🌍 **Location-aware scaling**: Use `scrapeMaxBusinessesPerLocation` to decide whether you want a per-city quota or one combined global quota across all `googleMapsLocation` entries.
- 🛡️ **Proxy-ready for reliability**: Includes proxy configuration support to help keep scraping stable when you collect large numbers of contacts.
- 📬 **Optimized for email lead building**: Works well as a **school district email scraping tool** when you need consistent structured fields for bulk analysis and CRM import.
- 📊 **Dataset-first workflow**: Results are pushed to the dataset during the run, so you can start exporting even before you finish experimenting with parameters.

***

### 🎯 Best use cases

- 📈 **Marketers building K12 school contact email lists**: Gather district and school emails for campaigns while enriching with phones and social links.
- 🏫 **School staffing researchers**: Compile school staff email discovery lists from public web information for outreach and analysis.
- 🧾 **Data analysts running contact coverage studies**: Quantify how many schools include email contact details and track scrape outcomes with `scrape_status`.
- 🛠️ **CRM operations and sales development teams**: Feed a bulk school emails scraper output into pipelines for follow-ups and segmentation by location.
- 💼 **Education program coordinators**: Find campus email scraping leads quickly for event invitations, partnerships, and applications.
- 💻 **API/data automation workflows**: Use this **K12 domain email scraper** output as structured inputs for ETL jobs and automated enrichment.

***

### 🔧 Technical specifications

#### Supported Input Formats

✅ `googleMapsSearchTerm` (string)\
✅ `googleMapsLocation` (array of strings)\
✅ `maxBusinesses` (integer)\
✅ `scrapeMaxBusinessesPerLocation` (boolean)\
✅ `proxyConfiguration` (object with `proxy support`)

#### Proxy Support

✅ `proxyConfiguration` support via `proxy support` (Apify Proxy)

#### Retry Mechanism

✅ Includes retries and fallbacks for resilience (high level behavior)

#### Dataset Structure

✅ Dataset view fields include:
`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

- Designed for practical bulk runs using controlled concurrency during website scraping.
- The total amount of work is bounded by `maxBusinesses` and `scrapeMaxBusinessesPerLocation`.

#### Limitations

- ❌ Some listings may not have a `website`, resulting in `scrape_status` like `no_website` and empty `scraped_emails`.
- ❌ Some websites may not expose emails in publicly accessible pages, producing `scrape_status` like `failed` or `success` with `emails_found` of 0.

***

### ❓ FAQ

#### How many emails can I scrape with K12 Schools Email Scraper?

It’s controlled primarily by `maxBusinesses`, which sets the target number of businesses to find with emails. If `scrapeMaxBusinessesPerLocation` is enabled, the actor aims for up to `maxBusinesses` per location; otherwise it uses a combined global limit across locations.

#### What locations can I use for the search?

Use `googleMapsLocation` as an array of location strings (for example, `["New York"]`). Add multiple locations to expand your reach and generate a larger K12 school contact email list.

#### Does it extract phones and social media links too?

✅ Yes. The dataset includes `scraped_phones` and `scraped_social_media` alongside `scraped_emails` when a website is available and public contact details can be extracted.

#### Will it validate emails?

It can validate emails if you enable `validateEmails` in the actor input (the code reads `validateEmails` from actor input). When enabled, emails are validated during the website scraping step.

#### What happens if a school listing has no website?

If no `website` is available, the actor sets `scraped_emails` to an empty array, sets `emails_found` to `0`, and uses `scrape_status` such as `no_website`. In email-only mode behavior, it may skip saving those rows depending on the run settings.

#### Can I run this at scale for bulk school emails scraping?

✅ Yes—use `proxyConfiguration` (recommended) and set `maxBusinesses` appropriately. The actor also pushes results during processing, so you can manage large jobs without losing completed work.

#### How do I integrate the output into my workflow?

You can export from the Apify dataset (JSON/CSV options depend on the console). The **Business Contact Data** dataset includes fields like `scraped_emails`, `emails_found`, `pages_scraped`, and `scrape_status`, which are convenient for importing into CRMs and analytics tools.

#### Is this legal to use for outreach?

✅ The actor collects information only from **publicly accessible sources**. It’s your responsibility to comply with GDPR, CCPA, anti-spam laws, and platform terms when using the output for outreach.

***

### 🤝 Support & feature requests

Want to improve the **K12 Schools Email Scraper** output for your K12 leads email scraper workflows? 💡

- 💡 **Feature Requests**: Ask for enhancements like richer exports (CSV), additional dataset fields, or custom filtering logic for email domains and roles.
- 📧 **Contact**: Email us at <dataforleads@gmail.com> with your request or feedback.

Your feedback helps shape what we build next for this K12 schools email scraper.

***

### *Final thoughts on K12 Schools Email Scraper*

*If you need a reliable way to extract K12 school contact email lists with structured output, **K12 Schools Email Scraper** is a strong choice for scaling your outreach data.*\
*Get started today and let this SEO-optimized K12 schools email scraper do the heavy lifting.*

***

### Disclaimer

**This tool only accesses publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected pages. You are responsible for ensuring your use complies with applicable laws (including GDPR/CCPA), anti-spam regulations, and relevant platform terms of service.

If you need data removal, contact <dataforleads@gmail.com>. Please use K12 Schools Email Scraper responsibly, ethically, and only for legitimate 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": "K12 Schools",
  "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": "K12 Schools",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "K12 Schools Email Scraper",
        "description": "📧 K12 Schools Email Scraper extracts verified email addresses from K-12 school websites—great for targeted outreach, sales, and lead research. ⚡ Fast, accurate data collection. 🚀 Perfect for B2B prospecting and marketing campaigns.",
        "version": "1.0",
        "x-build-id": "cFYuQcfNaf4cBI0V3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~k12-schools-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-k12-schools-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~k12-schools-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-k12-schools-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~k12-schools-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-k12-schools-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": "K12 Schools"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
