# GreatSchools Scraper (`solidcode/greatschools-scraper`) Actor

\[💰 $10 / 1K] Extract US K-12 school data from GreatSchools.org: 1-to-10 ratings, principal and contact details, test scores, demographics, and enrollment. Search by city, state, or ZIP, or paste GreatSchools URLs. Covers public, charter, and private schools across all 50 states.

- **URL**: https://apify.com/solidcode/greatschools-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## GreatSchools Scraper

Pull US K-12 school data from GreatSchools.org at scale — 1-to-10 ratings, test scores by subject, student demographics, enrollment, and principal contacts for public, charter, and private schools across all 50 states. Search by city, state, or ZIP, or paste any GreatSchools URL. Built for real estate and relocation services, EdTech teams, and market researchers who need verified, structured school data without manually opening one profile page at a time.

### Why This Scraper?

- **All 50 US states plus D.C.** — search any city, state, or ZIP code, or paste a GreatSchools listing or profile URL. Mix locations and URLs in a single run.
- **The 1-to-10 GreatSchools rating, fully broken out** — every school's overall summary rating plus three sub-ratings: test-score rating, student-progress rating, and equity rating.
- **Test scores by subject** — per-subject proficiency percentages (math, reading/ELA, science, and more), not just a single blurred average.
- **Student demographics on every school** — race/ethnicity breakdown percentages plus the low-income student percentage, ready for equity and access analysis.
- **Principal name and email when listed** — go straight to the decision-maker on claimed profiles, with the school's phone, website, and Facebook page included.
- **4 school levels and 3 school types** — filter to preschool, elementary, middle, or high, and to public, charter, or private, in any combination.
- **Enrollment, student-teacher ratio, district, and exact coordinates** — total enrollment, a clean `16:1`-style ratio, district name and city, plus latitude/longitude on every row.
- **Fast listing mode or full enrichment** — flip `includeDetails` off for quick name/rating/address rows, or on for the complete 30+ field profile.

### Use Cases

**Real Estate & Relocation**
- Attach school ratings and test scores to property listings in a target ZIP
- Build relocation guides comparing schools across candidate neighborhoods
- Rank neighborhoods by the strength of their assigned schools
- Answer buyer questions about district quality with sourced numbers

**Market Research**
- Map school quality, type, and enrollment across a metro or state
- Compare public, charter, and private options in the same area
- Track demographic and low-income mix across districts
- Benchmark test-score proficiency between competing districts

**EdTech & Data Products**
- Power school-search and comparison tools with structured records
- Enrich an existing school database with ratings and demographics
- Feed dashboards that monitor district and school-level performance
- Build alerting on enrollment, rating, or demographic shifts

**Parent & Family Research**
- Shortlist schools by level, type, and rating before touring
- Compare test scores and student-teacher ratios side by side
- Weigh demographics and low-income mix for schools on a shortlist
- Pull principal contact details to reach out with questions

**Lead Generation**
- Build principal and school contact lists (name, email, phone) by area
- Target schools by type and level for education-focused outreach
- Segment outreach by district, enrollment size, or rating band

### Getting Started

#### Search by City

The simplest way to start — one city and state:

```json
{
    "searchLocations": ["Austin, TX"],
    "maxResults": 50
}
````

#### Search by ZIP with Filters

Pull only public and charter elementary and middle schools in three ZIP codes:

```json
{
    "searchLocations": ["78701", "78702", "78703"],
    "schoolLevels": ["elementary", "middle"],
    "schoolTypes": ["public", "charter"],
    "maxResults": 200
}
```

#### Full Detail Run

Mix locations and a URL, pull every enriched field, and collect everything found:

```json
{
    "searchLocations": ["Denver, CO", "80206"],
    "startUrls": ["https://www.greatschools.org/colorado/denver/schools/"],
    "schoolLevels": ["high"],
    "schoolTypes": ["public"],
    "includeDetails": true,
    "maxResults": 0
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchLocations` | array | `["Austin, TX"]` | Cities (e.g. `Austin, TX`) or ZIP codes (e.g. `78701`) to search. Add as many as you like — no URLs to build. |
| `startUrls` | array | `[]` | Any GreatSchools.org search or school-profile URL. Filters already in the URL are applied automatically. |

#### Search Filters

These filters apply only to `searchLocations`. URLs carry their own filters.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `schoolLevels` | array | `[]` (all) | Limit to grade levels: `Preschool / Pre-K`, `Elementary`, `Middle`, `High School`. |
| `schoolTypes` | array | `[]` (all) | Limit to school types: `Public`, `Charter`, `Private`. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Exact maximum schools to return across all locations and URLs. Set to `0` for unlimited. |
| `includeDetails` | boolean | `true` | Open each profile for the full record — ratings breakdown, test scores, demographics, and principal contact. Off returns fast name/rating/address/URL rows. Very large single-location runs (200+) with details on take several minutes; lower `maxResults` or split into multiple ZIP/city runs for faster turnaround. |

### Output

Each result is one flat row per school. With `includeDetails` on, the profile fields below are populated; with it off, you get the core listing fields.

```json
{
    "id": "18850",
    "name": "Lee Elementary School",
    "url": "https://www.greatschools.org/texas/austin/18850-Lee-Elementary-School/",
    "schoolType": "public",
    "level": "Elementary",
    "gradesServed": "PK-5",
    "latitude": 30.2849,
    "longitude": -97.7341,
    "addressStreet": "3308 Hampton Rd",
    "addressCity": "Austin",
    "addressState": "TX",
    "addressZip": "78705",
    "phone": "(512) 414-2236",
    "website": "https://example.austinisd.org",
    "facebook": "https://www.facebook.com/example",
    "principalName": "Jane Doe",
    "principalEmail": "jane.doe@austinisd.org",
    "overallRating": 9,
    "ratingScaleLabel": "Above average",
    "testScoresRating": 9,
    "studentProgressRating": 8,
    "equityRating": 7,
    "reviewsCount": 24,
    "reviewsAverageRating": 4.5,
    "testScores": [
        { "subject": "Math", "proficiencyPercentage": 72 },
        { "subject": "Reading", "proficiencyPercentage": 78 }
    ],
    "enrollmentTotal": 412,
    "studentTeacherRatio": "15:1",
    "demographics": [
        { "group": "White", "percentage": 58 },
        { "group": "Hispanic", "percentage": 26 }
    ],
    "lowIncomePercentage": 18,
    "districtId": "1234",
    "districtName": "Austin Independent School District",
    "districtCity": "Austin",
    "scrapedAt": "2026-06-27T12:00:00.000Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | GreatSchools universal school ID |
| `name` | string | School name |
| `url` | string | GreatSchools profile URL |
| `schoolType` | string | `public`, `charter`, or `private` |
| `level` | string | Grade band (Preschool / Elementary / Middle / High) |
| `gradesServed` | string | Grades offered, e.g. `K-5`, `9-12` |
| `enrollmentTotal` | integer | Total students enrolled |
| `studentTeacherRatio` | string | Students per teacher, e.g. `15:1` |
| `scrapedAt` | string | ISO timestamp of capture |

#### Ratings & Reviews

| Field | Type | Description |
|-------|------|-------------|
| `overallRating` | number | GreatSchools summary rating (1-10) |
| `ratingScaleLabel` | string | Plain-language rating band, e.g. `Above average` |
| `testScoresRating` | number | Test-scores sub-rating (1-10) |
| `studentProgressRating` | number | Student-progress sub-rating (1-10) |
| `equityRating` | number | Equity sub-rating (1-10) |
| `reviewsCount` | integer | Number of parent reviews |
| `reviewsAverageRating` | number | Average parent review rating |
| `testScores` | object\[] | Per-subject proficiency: `{ subject, proficiencyPercentage }` |

#### Address & Contact

| Field | Type | Description |
|-------|------|-------------|
| `addressStreet` | string | Street address |
| `addressCity` | string | City |
| `addressState` | string | State code |
| `addressZip` | string | ZIP code |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |
| `phone` | string | School phone number |
| `website` | string | School website |
| `facebook` | string | School Facebook page |
| `principalName` | string | Principal name (claimed profiles) |
| `principalEmail` | string | Principal email (claimed profiles) |

#### Demographics & District

| Field | Type | Description |
|-------|------|-------------|
| `demographics` | object\[] | Race/ethnicity breakdown: `{ group, percentage }` |
| `lowIncomePercentage` | number | Percent of low-income students |
| `districtId` | string | District ID |
| `districtName` | string | District name |
| `districtCity` | string | District city |

### Tips for Best Results

- **Start small, then scale** — set `maxResults` to 10-50 on your first run to confirm the data matches your needs before pulling thousands.
- **Turn off `includeDetails` for fast bulk listings** — when you only need name, rating, address, and URL, this collects far more schools per run; turn it back on for test scores, demographics, and principal contacts.
- **Large detail runs take longer** — pulling 200+ schools from a single city or ZIP with `includeDetails` on can run several minutes, since each profile is opened individually. For faster turnaround, lower `maxResults` or split a big city into several smaller ZIP or city runs.
- **Match GreatSchools' own city spelling** — type the city exactly as GreatSchools writes it (e.g. `Saint Louis, MO`, not `St. Louis, MO`); an unrecognized spelling returns no results rather than an error.
- **Use ZIP codes for precise neighborhood targeting** — a ZIP search pins results to a specific area, while a city search returns the whole city.
- **Remember filters apply only to `searchLocations`** — `schoolLevels` and `schoolTypes` do not change results coming from `startUrls`, which carry their own filters.
- **Combine inputs in one run** — mix multiple cities, ZIP codes, and URLs together; results are deduplicated so overlapping areas never double-count a school.
- **Principal email is best-effort** — it appears on claimed profiles; expect it on a subset of schools rather than every row.

### Pricing

**From $10 per 1,000 results** — a flat, predictable rate for verified US school data. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $1.20 | $1.13 | $1.07 | $1.00 |
| 1,000 | $12.00 | $11.30 | $10.70 | $10.00 |
| 10,000 | $120.00 | $113.00 | $107.00 | $100.00 |
| 100,000 | $1,200.00 | $1,130.00 | $1,070.00 | $1,000.00 |

No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. A "result" is any school row in the output dataset.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate education research, real estate and relocation analysis, and market intelligence. Users are responsible for complying with applicable laws and GreatSchools.org's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any contact details responsibly and in line with applicable privacy regulations. </content> </invoke>

# Actor input Schema

## `searchLocations` (type: `array`):

Find schools by typing a city and state (e.g. 'Austin, TX') or a ZIP code (e.g. '78701'). Add as many as you like — no need to build URLs.

## `startUrls` (type: `array`):

Paste any GreatSchools.org search or school-profile URL. Any filters already in the URL are applied automatically. The Search Filters below only apply to Search Locations, not to URLs.

## `schoolLevels` (type: `array`):

Limit results to specific grade levels. Leave empty to include all levels.

## `schoolTypes` (type: `array`):

Limit results to specific school types. Leave empty to include all types.

## `maxResults` (type: `integer`):

Exact maximum number of schools to return across all locations and URLs — you are never charged for more than this. Set to 0 for unlimited. Tip: start with 10-50 to test, then increase. Very large single-location runs (200+) with full details enabled take several minutes; lower this or split into multiple ZIP/city runs for faster turnaround.

## `includeDetails` (type: `boolean`):

Open each school's profile to pull the full record — ratings breakdown, test scores, demographics, enrollment, principal contact, and district info. Slower but much richer (very large single-location runs take several minutes). When off, only basic listing data (name, rating, address, URL) is returned.

## Actor input object example

```json
{
  "searchLocations": [
    "Austin, TX"
  ],
  "startUrls": [],
  "schoolLevels": [],
  "schoolTypes": [],
  "maxResults": 100,
  "includeDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped schools with key fields.

# 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 = {
    "searchLocations": [
        "Austin, TX"
    ],
    "startUrls": [],
    "schoolLevels": [],
    "schoolTypes": [],
    "maxResults": 100,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/greatschools-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 = {
    "searchLocations": ["Austin, TX"],
    "startUrls": [],
    "schoolLevels": [],
    "schoolTypes": [],
    "maxResults": 100,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/greatschools-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 '{
  "searchLocations": [
    "Austin, TX"
  ],
  "startUrls": [],
  "schoolLevels": [],
  "schoolTypes": [],
  "maxResults": 100,
  "includeDetails": true
}' |
apify call solidcode/greatschools-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GreatSchools Scraper",
        "description": "[💰 $10 / 1K] Extract US K-12 school data from GreatSchools.org: 1-to-10 ratings, principal and contact details, test scores, demographics, and enrollment. Search by city, state, or ZIP, or paste GreatSchools URLs. Covers public, charter, and private schools across all 50 states.",
        "version": "1.0",
        "x-build-id": "VEHowOumHxeeXQEjS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~greatschools-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-greatschools-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/solidcode~greatschools-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-greatschools-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/solidcode~greatschools-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-greatschools-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",
                "properties": {
                    "searchLocations": {
                        "title": "Search Locations",
                        "type": "array",
                        "description": "Find schools by typing a city and state (e.g. 'Austin, TX') or a ZIP code (e.g. '78701'). Add as many as you like — no need to build URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "GreatSchools URLs",
                        "type": "array",
                        "description": "Paste any GreatSchools.org search or school-profile URL. Any filters already in the URL are applied automatically. The Search Filters below only apply to Search Locations, not to URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "schoolLevels": {
                        "title": "School Levels",
                        "type": "array",
                        "description": "Limit results to specific grade levels. Leave empty to include all levels.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "preschool",
                                "elementary",
                                "middle",
                                "high"
                            ],
                            "enumTitles": [
                                "Preschool / Pre-K",
                                "Elementary",
                                "Middle",
                                "High School"
                            ]
                        }
                    },
                    "schoolTypes": {
                        "title": "School Types",
                        "type": "array",
                        "description": "Limit results to specific school types. Leave empty to include all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "public",
                                "charter",
                                "private"
                            ],
                            "enumTitles": [
                                "Public",
                                "Charter",
                                "Private"
                            ]
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Exact maximum number of schools to return across all locations and URLs — you are never charged for more than this. Set to 0 for unlimited. Tip: start with 10-50 to test, then increase. Very large single-location runs (200+) with full details enabled take several minutes; lower this or split into multiple ZIP/city runs for faster turnaround.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include Full School Details",
                        "type": "boolean",
                        "description": "Open each school's profile to pull the full record — ratings breakdown, test scores, demographics, enrollment, principal contact, and district info. Slower but much richer (very large single-location runs take several minutes). When off, only basic listing data (name, rating, address, URL) is returned.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
