# Schools Email Scraper (`solid-scraper/schools-email-scraper`) Actor

🎓 Schools Email Scraper extracts verified school contact emails by country, niche, and keywords—fast and accurate. Ideal for lead gen, outreach, and marketing teams seeking targeted education prospects. 🚀

- **URL**: https://apify.com/solid-scraper/schools-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

### Schools Email Scraper 📬

**Schools Email Scraper** helps you find and extract contact emails for schools by combining business discovery with website email extraction. If you’re looking for a **school email scraper**, this actor automates email scraping from publicly available data, making it easier to build a **school district email list** or grow an **education email list building** workflow at scale—saving you hours of manual work.

Whether you’re a marketer, researcher, or data analyst, **Schools Email Scraper** supports bulk collection by searching for schools across one or more locations, then scraping emails, phone numbers, and social links from the associated websites.

---

### Why choose Schools Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one email + contact extraction** | Extracts emails, phone numbers, and social media profiles from school websites in one run |
| ✅ **Structured output for easy analysis** | Saves consistent fields to the dataset so you can map results to your CRM or spreadsheet |
| ✅ **Reliability-focused scraping workflow** | Includes resilience and fallback behaviors so scraping keeps moving when some pages fail |
| ✅ **Built-in proxy support for reliable scraping** | Helps improve stability during large-scale collection runs |
| ✅ **Designed for bulk scale** | Uses limits (like `maxBusinesses`) to control how many school results you collect |
| ✅ **Automated dataset saving** | Pushes results during execution so you don’t lose progress on interruptions |

---

### Key features

- ✅ **School email discovery workflow**: Finds relevant school businesses for each location using your search term
- 🌐 **Website-first contact harvesting**: Scrapes contact information from the school’s website when available
- 📧 **Email extraction for outreach**: Collects `scraped_emails` per business and saves results in a structured format
- 📞 **Phone and social media extraction**: Also captures `scraped_phones` and `scraped_social_media` when present
- 🧾 **Detailed per-business progress fields**: Includes `pages_scraped`, `emails_found`, and `scrape_status` for transparency
- 🛡️ **Resilience and fallback logic**: Includes handling for missing websites and failure states
- 💾 **Real-time dataset saving**: Pushes data immediately as it’s scraped, including “no website” rows when applicable
- 🔍 **Optional limits for controlled collection**: Use `maxBusinesses` and `scrapeMaxBusinessesPerLocation` to manage volume

---

### Input

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

```json
{
  "googleMapsSearchTerm": "Schools",
  "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 email scraping (prefilled with `Schools`). |
| `googleMapsLocation` | Yes | A list of target geographic locations to search (for example: `["Miami, Florida"]` or `["New York"]`). |
| `maxBusinesses` | No | The target number of businesses to find **with emails** (allowed range: 1–1000). The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | If enabled, collects up to `maxBusinesses` results per location. If disabled, it combines locations into one total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping (recommended for larger-scale runs). |
| `proxyConfiguration.proxy support` | No | Enables the default Apify proxy setting for scraping. |

***

### Output

The actor saves results to the **Business Contact Data** dataset in JSON format (table view is configured, and results are pushed as records during execution).

Example output record shape (one dataset row):

```json
{
  "name": "Unknown",
  "website": "https://example.org",
  "phone": "",
  "full_address": "123 Main St New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "scraped_emails": [],
  "scraped_phones": [],
  "scraped_social_media": [],
  "emails_found": 0,
  "pages_scraped": 0,
  "avg_rating": null,
  "total_reviews": null,
  "lat": null,
  "long": null,
  "place_id": null,
  "scrape_status": "no_website"
}
```

> Note: When emails are found, the actor pushes a **flattened row per email** by copying the business data and adding `email_found` (the dataset transformation keeps the listed fields; phone/social/email arrays are produced by the flattening workflow).

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | School/business name. |
| `website` | string | Website URL discovered for the business. |
| `phone` | string | Phone number associated with the discovered business (if present). |
| `full_address` | string | Combined address string built from street/city/state/zip/country code. |
| `city` | string | City extracted from the business location data. |
| `state` | string | State extracted from the business location data. |
| `zip` | string | Postal code extracted from the business location data. |
| `country_code` | string | Country code extracted from the business location data. |
| `scraped_emails` | array | Array of scraped email addresses found on the website (empty if none). |
| `scraped_phones` | array | Array of scraped phone numbers found on the website (empty if none). |
| `scraped_social_media` | array | Array of scraped social media links found on the website (empty if none). |
| `emails_found` | number | Count of emails found for this business. |
| `pages_scraped` | number | Number of processed URLs/steps during scraping for the business. |
| `avg_rating` | number | Average rating from the discovered business data (if present). |
| `total_reviews` | number | Total reviews from the discovered business data (if present). |
| `lat` | number | Latitude from business location data (if present). |
| `long` | number | Longitude from business location data (if present). |
| `place_id` | string | Place identifier from the discovered business record (used for de-duplication). |
| `scrape_status` | string | Scraping outcome status (e.g., `success`, `failed`, `error`, `no_website`). |

***

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

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

2. **Find Schools Email Scraper**\
   Search for **Schools Email Scraper** and open the actor details page.

3. **Configure your INPUT**\
   In the **Input** panel, set:
   - `googleMapsSearchTerm` (defaults to `Schools`)
   - `googleMapsLocation` (one or more locations)

4. **Set collection limits (optional)**\
   Choose `maxBusinesses` to control how many businesses with emails you want.\
   If you want limits per location instead of one combined total, enable `scrapeMaxBusinessesPerLocation`.

5. **(Optional) Enable proxy support**\
   Configure `proxyConfiguration` and set `proxyConfiguration.proxy support` to `true` for proxy-enabled scraping stability on larger runs.

6. **Run the actor**\
   Click **Run**. Watch logs for progress updates and scraping outcomes.

7. **Review results in the dataset**\
   After completion, open the actor **dataset** titled **Business Contact Data** to see your structured output fields.

8. **Export your data**\
   Export from the dataset view to JSON/CSV for your workflow (CRM import, analysis, or outreach lists).

No coding required—get accurate school email extraction results in minutes with **Schools Email Scraper**. ✅

***

### Advanced features & SEO optimization

- 🎯 **Engineered for “school email scraper” workflows**: Designed specifically for extracting education institution email contacts by pairing discovery with website harvesting, making it a practical **find school emails** solution.
- 🔄 **Scales with clear stop conditions**: Uses your `maxBusinesses` target and can apply limits per location via `scrapeMaxBusinessesPerLocation`.
- 🧠 **Built for email-oriented list building**: Works well for **school directory email scraper** and **bulk school email collection** use cases where you need many school contacts fast.
- 🗃️ **Structured education data output**: Produces consistent fields for **school district email list** style datasets, including phones and social links for better enrichment.
- 🛡️ **Proxy-ready scraping runs**: Includes proxy support to help maintain stability during larger scraping batches.

***

### Best use cases

- 📈 **Lead generation for school programs**: Quickly assemble a **school contact email extractor** dataset for outreach campaigns.
- 🎓 **College and university pipeline research**: Build a **college email scraper** workflow for education email list building across regions.
- 🏫 **School district directory enrichment**: Create a **school district email list** enriched with phone numbers and social media links.
- 🧪 **Education marketing analytics**: Analyze email availability (`emails_found`, `pages_scraped`) alongside business rating/reviews for quality scoring.
- 💼 **Recruitment and communications teams**: Use extracted contacts to streamline internal marketing and communications planning.
- 🧰 **Data analysts & researchers**: Combine geo, address, and email extraction results for structured dataset analysis.
- ✉️ **Bulk outreach operations**: Use as a **bulk school email collection** tool to move faster from discovery to campaign-ready lists.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `googleMapsSearchTerm`: string (business niche; default prefill: `Schools`)
  - ✅ `googleMapsLocation`: array of strings (locations)

- **Proxy Support**
  - ✅ `proxyConfiguration` (with `proxyConfiguration.proxy support` supported)
  - Recommended for larger scraping runs

- **Retry Mechanism**
  - ✅ Includes retries and fallbacks for resilience (high-level behavior)
  - Exact retry counts/delays are controlled internally by the scraping components

- **Dataset Structure**
  - ✅ Dataset: **Business Contact Data**
  - ✅ Dataset rows include fields like `name`, `website`, `scraped_emails`, `emails_found`, `scrape_status`, and more

- **Rate Limits & Performance**
  - ⚙️ Designed for batch scraping with concurrency and controlled limits via `maxBusinesses`

- **Limitations**
  - ⚠️ If a business has **no website** available, scraping cannot extract emails from the site and the row is pushed with a `scrape_status` such as `no_website`.
  - ⚠️ Results depend on the availability of publicly accessible contact details.

***

### FAQ

#### How do I find school emails with Schools Email Scraper?

Schools Email Scraper first discovers relevant school businesses using your `googleMapsSearchTerm` and `googleMapsLocation`, then scrapes the business website to extract emails and related contact details. This makes it practical for “find school emails” and “school email scraper” workflows.

#### What does the actor save to the dataset?

It saves fields configured under **Business Contact Data**, including business identity and contact details like `website`, `scraped_emails`, `scraped_phones`, `scraped_social_media`, plus metrics such as `emails_found`, `pages_scraped`, and `scrape_status`.

#### Can I control how many schools are collected?

Yes. Use `maxBusinesses` to set the target number of businesses with emails. If you enable `scrapeMaxBusinessesPerLocation`, the actor will aim for up to `maxBusinesses` results per location; otherwise it uses a single combined total limit.

#### Do I need a proxy?

You don’t have to, but proxy configuration is available via `proxyConfiguration`. Proxy support is recommended for larger-scale scraping runs to help improve stability.

#### Does it extract phone numbers and social media too?

Yes. Along with `scraped_emails`, the actor also attempts to extract `scraped_phones` and `scraped_social_media` from the school website when available.

#### Will it save results when no website is found?

Yes. For businesses without a website, it pushes a dataset row with empty `scraped_emails` / `scraped_phones` / `scraped_social_media`, `emails_found` set to `0`, `pages_scraped` set to `0`, and a `scrape_status` such as `no_website` (unless email-only behavior prevents saving, depending on the run mode).

#### Is this suitable for bulk school email collection?

✅ Yes. The actor is built for batch runs with dataset saving during execution, and it’s designed for workflows like **school directory email scraper** and **education email list building**.

***

### Support & feature requests

Have feedback on **Schools Email Scraper** or want improvements for your **school email scraper** workflow? 💡

- 💡 **Feature Requests**: For example, you can request CSV export options, custom email handling rules, or tighter enrichment output for education institution email scraper use cases.
- 📧 **Contact**: Send us a message at <dataforleads@gmail.com>

Your input helps shape the roadmap for future versions of **Schools Email Scraper**. 🚀

***

*If you’re after the most comprehensive, SEO-friendly “schools email scraper” workflow for education lead generation, start a run with Schools Email Scraper today—engineered to help you collect school contact emails at scale.*

***

### Disclaimer

**This tool accesses publicly accessible sources only.** It does not access private profiles, authenticated content, password-protected pages, or other restricted data.

You are responsible for complying with applicable laws (including GDPR/CCPA where relevant), spam regulations, and each website’s terms of service. For data-removal requests, contact <dataforleads@gmail.com>.

Please use **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": "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": "Schools",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Schools Email Scraper",
        "description": "🎓 Schools Email Scraper extracts verified school contact emails by country, niche, and keywords—fast and accurate. Ideal for lead gen, outreach, and marketing teams seeking targeted education prospects. 🚀",
        "version": "1.0",
        "x-build-id": "2MtlnMyOr6OsXv1uk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~schools-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-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/solid-scraper~schools-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-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/solid-scraper~schools-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-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": "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
