# College S Email Scraper (`solid-scraper/college-s-email-scraper`) Actor

📧 College S Email Scraper extracts verified college student/prospect emails from College sites fast—ideal for outreach, lead gen, and marketing teams. 🇺🇸⚡ Target, capture, and grow your list with confidence.

- **URL**: https://apify.com/solid-scraper/college-s-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 S Email Scraper 📬

**College S Email Scraper** is a lead-generation tool that searches “College S” business listings for universities, departments, and campus-related businesses, then extracts contact information—especially email addresses—along with supporting details like phone numbers and social media profiles. Whether you’re a marketer, a researcher, or a data analyst, this college email scraper helps solve the core problem of turning campus contact pages and publicly available information into usable outreach-ready datasets—saving you hours of manual work.

---

### Why choose College S Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **College email scraper workflow (business + website contact extraction)** | Extracts emails, phone numbers, and social media profiles from business websites in one run |
| ✅ **Built-in proxy support for reliable scraping** | Helps reduce rate-limit and IP-block issues when scaling bulk email scraping for colleges |
| ✅ **Reliability-oriented scraping flow** | Includes resiliency mechanisms such as fallbacks so you can keep runs moving at scale |
| ✅ **Structured, dataset-ready output** | Saves consistent fields like full address, phone, and scraped contact lists for easy import |
| ✅ **Scale-oriented limits & stop conditions** | Targets a max number of businesses and stops when quotas are reached |
| ✅ **Apify-ready dataset saving** | Pushes results during execution so you don’t lose progress if something interrupts |

---

### Key features

- 🔎 **College contact email extraction:** Finds businesses based on your search term and extracts emails from their websites (a college leads email scraper workflow).
- 🌐 **Website-driven email discovery:** Collects scraped contact info using each business’s website as the primary source.
- 📞 **Phone numbers + social profiles included:** Captures `scraped_phones` and `scraped_social_media` alongside emails to improve lead coverage.
- 🛡️ **Proxy configuration support:** Works with proxy settings you provide (recommended for large-scale scraping).
- ⏱️ **Controlled scaling:** Uses your `maxBusinesses` and location settings to limit results and stop once the target is met.
- 💾 **Real-time dataset saving:** Pushes flattened rows to the Apify dataset as emails are found (progress is captured continuously).
- ✅ **Resilience for incomplete data:** If a business has no website, it’s handled gracefully and marked with a clear scrape status in the output.

---

### Input

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

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `googleMapsSearchTerm` | Yes | Enter the business type or niche for email scraper (example given: `'coffee shops'`, `'dentists'`). In this actor UI it’s prefilled with `College S`. |
| `googleMapsLocation` | Yes | Target geographic location(s) to search. Provide a list like `["Miami, Florida"]` or a single location string (schema expects an array). |
| `maxBusinesses` | No | Maximum businesses with emails to find (range `1-1000`). The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | If enabled, the scraper collects up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping. Proxy support is recommended for larger runs. When present, the input includes `proxy support` (prefilled to `true`). |

***

### Output

The actor saves your results to the **Business Contact Data** dataset in a flattened JSON structure (including one row per extracted email when emails are found).

Example output row:

```json
{
  "street_address": "123 Example St",
  "city": "New York",
  "zip": "10001",
  "state": "NY",
  "country_code": "US",
  "full_address": "123 Example St New York NY 10001 US",
  "website": "https://example.edu",
  "avg_rating": 4.3,
  "total_reviews": 120,
  "name": "Example University Department",
  "place_id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
  "phone": "+1 555-123-4567",
  "lat": 40.7128,
  "long": -74.006,
  "scraped_phones": ["+1 555-111-2222"],
  "scraped_social_media": ["https://www.linkedin.com/company/example"],
  "emails_found": 2,
  "pages_scraped": 5,
  "scrape_status": "success",
  "email_found": "contact@example.edu"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business name |
| `website` | string | Business website |
| `phone` | string | Business phone number (from listing data) |
| `full_address` | string | Full concatenated address string |
| `city` | string | City |
| `state` | string | State |
| `zip` | string | Zip/postal code |
| `country_code` | string | Country code |
| `scraped_emails` | array | Emails found (list). Note: when the actor pushes flattened rows per email, it deletes this field in the flattened copy. |
| `scraped_phones` | array | Phone numbers extracted from the business website |
| `scraped_social_media` | array | Social media profile links extracted from the business website |
| `emails_found` | number | Count of emails found for the business |
| `pages_scraped` | number | Number of processed URLs/pages during website scraping |
| `avg_rating` | number | Average rating from the listing data |
| `total_reviews` | number | Total reviews from the listing data |
| `scrape_status` | string | Scrape status (e.g. `success`, `failed`, `no_website`, `error`) |

**Export note:** The dataset can be exported by Apify in common formats like JSON/CSV from the Apify Console (exact export formats depend on your workspace settings).

***

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

1. **Open Apify Console**: Sign in at https://console.apify.com and open the **Actors** tab.
2. **Find the actor**: Search for **College S Email Scraper** and open its actor page.
3. **Configure input**: In the **INPUT** section, set:
   **`googleMapsSearchTerm`** to your niche keyword (prefilled with `College S`), and
   **`googleMapsLocation`** to one or more target locations.
4. **Set limits (optional but recommended)**: Adjust **Maximum Businesses With Emails (`maxBusinesses`)**. If you have multiple locations, decide whether to use **Scrape Max Businesses Per Location (`scrapeMaxBusinessesPerLocation`)**.
5. **Choose proxy settings (optional)**: In **Proxy Configuration**, enable and configure proxy settings as needed (the form prefill uses `proxy support: true`).
6. **Run the actor**: Click **Run**. Watch logs for progress and see results being saved as the run proceeds.
7. **Review results**: After completion, open the **Business Contact Data** dataset and export/filter the scraped leads.

No coding required — get college contact email data in minutes with this education email harvesting software tool.

***

### Advanced features & SEO optimization

- 🚦 **Email-only friendly behavior:** When email extraction can’t happen (e.g., no website found), the actor can mark records with `scrape_status` such as `no_website`, while still keeping dataset structure consistent for downstream processing—useful for a student email finder tool workflow.
- 🧰 **Targeted “email extraction” pipeline:** Designed as a college contact email extractor that couples listing-level business info with website-level contact discovery, improving the odds of finding working emails.
- 🔁 **Scalable execution controls:** The actor uses `maxBusinesses` and location handling to keep bulk email scraping for colleges bounded and predictable.
- 📄 **Consistent structured output:** Output fields like `full_address`, `avg_rating`, `total_reviews`, plus scraped contact lists make it easy to build a college contact email database for campaigns and research.

***

### Best use cases

- 🎯 **Admissions teams building outreach lists:** Compile department email lists for college admissions email outreach and event promotion.
- 📞 **University marketing teams sourcing contact leads:** Export verified-feeling outreach data with phone and social media enrichment alongside emails.
- 🧑‍🔬 **Researchers analyzing campus contact patterns:** Study how many departments have publicly listed contact emails across regions.
- 🗂️ **Sales ops teams automating lead enrichment:** Pipe dataset rows into CRM workflows for faster follow-up and segmentation.
- 🧾 **Data analysts validating contact coverage:** Compare `emails_found`, `pages_scraped`, and `scrape_status` to measure extraction yield per location.
- 💼 **Partnership managers targeting campus departments:** Build a structured contact email database for co-marketing or sponsorship proposals.
- 💻 **Developers integrating into pipelines:** Use the Apify dataset output fields to automate outreach list generation and quality checks.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `googleMapsLocation` as an array of locations
  - ✅ `googleMapsSearchTerm` as a string
  - ✅ Optional limits: `maxBusinesses`, `scrapeMaxBusinessesPerLocation`
  - ✅ Optional proxy input via `proxyConfiguration`

- **Proxy Support**
  - ✅ Proxy configuration via `proxyConfiguration` (example uses `proxy support`)

- **Retry Mechanism**
  - ✅ Resilience is built into the scraping approach (exact retry counts and delays are handled internally)

- **Dataset Structure**
  - ✅ Stored in the Apify dataset: **Business Contact Data**
  - ✅ Flattened rows are pushed during execution (one row per extracted email when emails are found)

- **Rate Limits & Performance**
  - ✅ High-level throttling and controlled concurrency are used to support stable runs

- **Limitations**
  - ❌ If a business has no website, emails cannot be extracted (records are marked with `scrape_status` like `no_website`)
  - ❌ Results depend on the availability of publicly accessible contact information on the websites discovered during the run

***

### FAQ

#### Does College S Email Scraper extract emails only from college websites?

✅ Yes. The actor extracts contact information from business websites it discovers and then saves emails (along with phones and social links when available) into the dataset structure.

#### What does `scrapeMaxBusinessesPerLocation` change?

✅ If `scrapeMaxBusinessesPerLocation` is enabled, the actor targets up to `maxBusinesses` results per location. If disabled, it combines all locations into a single total cap based on `maxBusinesses`.

#### Will it return results when no emails are found?

✅ The actor handles “no website” and failure scenarios using `scrape_status`. It also tracks `emails_found` and `pages_scraped` so you can filter low-yield entries in your analysis.

#### Can I use proxy settings for large runs?

✅ Yes. Use the `proxyConfiguration` input to configure proxy support. This is recommended for bulk email scraping for colleges and other large-scale tasks.

#### How is the output saved?

✅ Results are pushed to the Apify dataset during execution. When emails are found, the actor pushes flattened rows per extracted email (so each dataset row includes `email_found` and business context).

#### Can I validate emails?

✅ The actor has an internal `validate_emails` configuration controlled by the input value `validateEmails` in code (though it is not exposed in the provided input schema). If you set validation in your run environment, it will influence email validation behavior.

#### Do I need to log in to use Apify Console?

✅ Yes. You need access to Apify Console to run actors and view the resulting dataset in the Output tab.

#### Is it legal to use the scraped emails for outreach?

✅ You’re responsible for compliance. The actor collects information from publicly accessible sources, but you must follow applicable privacy laws (including GDPR/CCPA where relevant), spam regulations, and the terms of service of the sources.

***

### Support & feature requests

Have an idea to improve College S Email Scraper? We’d love your feedback. 💡

- 💡 **Feature Requests:** For example, CSV-first exports, additional output columns for better CRM mapping, or more granular filters for college contact leads email scraper workflows.
- 📧 **Contact:** Email us at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this college email scraper.

***

### Closing CTA / Final thoughts

*If you’re looking for a fast, SEO-friendly way to build a college leads email scraper dataset, **College S Email Scraper** is ready for scale.*\
*Run it once, export structured leads, and save hours of manual collection.*

***

### Disclaimer

**This tool only accesses publicly accessible sources.** It does not access private profiles, authenticated data, or password-protected pages. You are responsible for complying with applicable laws (including GDPR/CCPA where relevant), spam regulations, and the terms of service of each website.

For data removal requests, contact <dataforleads@gmail.com>. 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 S",
  "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 S",
    "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-s-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 S",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "College S Email Scraper",
        "description": "📧 College S Email Scraper extracts verified college student/prospect emails from College sites fast—ideal for outreach, lead gen, and marketing teams. 🇺🇸⚡ Target, capture, and grow your list with confidence.",
        "version": "1.0",
        "x-build-id": "Tn3UgZSNX7eXF8jVI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~college-s-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-college-s-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-s-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-college-s-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-s-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-college-s-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 S"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
