# Skool Public Members Scraper (`automation-lab/skool-public-members-scraper`) Actor

Export public Skool community members with profile, activity, role, points, location, and social-link data—no login or cookies required.

- **URL**: https://apify.com/automation-lab/skool-public-members-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Skool Public Members Scraper

Export anonymously visible members from public Skool communities into a clean dataset—without login cookies, browser automation, or private-group access.

Give the Actor one or more public community URLs. It returns one row per visible member with identity, profile, role, activity, membership dates, points, level, location, avatars, website, and social links.

- 👥 Build public creator and community member lists
- 🔄 Refresh community-composition datasets on a schedule
- 🤝 Find partnership and audience-research signals
- 📊 Export to JSON, CSV, Excel, XML, RSS, or an API
- 🔒 Stay inside the anonymously visible public member surface

### What does Skool Public Members Scraper do?

Skool Public Members Scraper turns public Skool member directories into structured records.

Paste a URL such as `https://www.skool.com/educate` or `https://www.skool.com/educate/-/members`. The Actor normalizes the URL, reads Skool's public server-rendered data, removes duplicate members, and saves a flat dataset.

It does **not** log in, collect cookies, open private communities, download courses, or expose email addresses.

The HTTP-first design is fast and economical. Most runs need only 256 MB of memory and no proxy.

### Who is it for?

#### Creator-economy agencies

Build public prospect lists around communities relevant to a campaign, then enrich only the profiles that match your criteria.

#### Community operators

Create periodic snapshots to understand member mix, locations, activity signals, roles, and public interests.

#### Partnerships teams

Discover publicly identified creators, operators, and businesses that participate in a niche community.

#### Audience researchers

Compare public communities using repeatable, timestamped exports instead of manual copy-and-paste work.

#### Data and automation teams

Feed a stable member schema into a warehouse, CRM staging table, webhook, or scheduled monitoring workflow.

### Why use this Skool member scraper?

- ⚡ **HTTP-first:** no browser startup or page scrolling
- 🧩 **Structured:** stable flat fields for spreadsheets and databases
- 🪪 **Identity-aware:** user, member, group, and profile identifiers
- 📈 **Useful signals:** role, online status, activity, points, and level
- 🔗 **Public links:** website and social profile URLs when members publish them
- ♻️ **Deduplicated:** repeated pages and duplicate inputs do not duplicate rows
- 🛑 **Safe stopping:** limits, page caps, and repeated-page detection
- 🔐 **Public only:** no credentials, private content, or email extraction

### What Skool member data can you extract?

| Category | Fields |
|---|---|
| Identity | `userId`, `memberId`, `displayName`, `firstName`, `lastName`, `profileUrl` |
| Community | `groupId`, `communitySlug`, `communityName`, `communityUrl`, `membersUrl` |
| Profile | `bio`, `location`, `timeZone`, `avatarUrl`, `profileImageUrl` |
| Membership | `role`, `joinedAt`, `approvedAt` |
| Activity | `isOnline`, `activityStatus`, `lastActiveAt`, `profileUpdatedAt` |
| Progress | `points`, `level` |
| Public links | `websiteUrl`, `facebookUrl`, `instagramUrl`, `linkedinUrl`, `twitterUrl`, `youtubeUrl` |
| Provenance | `accountCreatedAt`, `scrapedAt` |

Optional public values remain empty when a member has not supplied them. The Actor never invents missing data.

### How much does it cost to scrape Skool members?

This Actor uses pay-per-event pricing:

- a **$0.005 Run started** charge per run
- an **Item extracted** charge per emitted dataset row
- automatic volume discounts: FREE $0.000044641, BRONZE $0.000038818, SILVER $0.000030278, GOLD $0.000023291, PLATINUM $0.000015527, and DIAMOND $0.000010869 per member

The input panel prefills 20 members for a small first run, while the default cap is 30. The live pricing panel in Apify Console shows the tier assigned to your account.

Direct HTTP and 256 MB memory keep platform compute low. A proxy is optional and disabled by default.

### How to scrape public Skool members

1. Open the Actor input page.
2. Add one or more public Skool community URLs.
3. Set **Maximum members** to your desired global output cap.
4. Keep **Maximum pages per community** conservative for a first run.
5. Leave proxy use disabled unless your network needs it.
6. Click **Start**.
7. Preview the **Public Skool members** dataset.
8. Export the records or connect an integration.

A community URL and its `/-/members` URL are equivalent inputs.

### Input parameters

#### `startUrls` (required)

Public Skool community or member-directory URLs.

Accepted:

```text
https://www.skool.com/educate
https://www.skool.com/educate/-/members
````

Rejected:

```text
https://example.com/community
https://www.skool.com/@profile
https://www.skool.com/login
```

#### `maxMembers`

Maximum unique member records across all inputs. Range: 1–10,000. Default: 30.

#### `maxPagesPerCommunity`

Safety cap for public directory pages per community. The Actor can stop earlier when Skool returns an empty or repeated page.

#### `proxyConfiguration`

Optional Apify or custom proxy configuration. Public directories normally work directly, so the prefill disables proxy use.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.skool.com/educate/-/members" }
  ],
  "maxMembers": 30,
  "maxPagesPerCommunity": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

To combine communities, add more entries to `startUrls`. The maximum remains global across the run.

### Example output

```json
{
  "memberId": "3fb79ac1a35e4c4bb045c3e4126c9a5a",
  "userId": "ddfb7d7fc2d048cfb66d7f9d7c379e40",
  "groupId": "dfef480fe8474625b514ca1bcb05c242",
  "communitySlug": "educate",
  "communityName": "Public Skool",
  "communityUrl": "https://www.skool.com/educate",
  "membersUrl": "https://www.skool.com/educate/-/members",
  "profileUrl": "https://www.skool.com/@faith",
  "displayName": "Faith Adebayo",
  "bio": "Public profile bio",
  "location": "Skool",
  "timeZone": "America/Chicago",
  "role": "member",
  "isOnline": true,
  "points": 269,
  "level": 5,
  "websiteUrl": "https://example.com",
  "scrapedAt": "2026-07-19T06:30:00.000Z"
}
```

The real record contains the complete documented schema. Empty optional fields are represented by empty strings, while numeric values remain numbers and `isOnline` remains a boolean.

### Public visibility and pagination

Skool controls which directory rows anonymous visitors can see. Some public communities expose several distinct pages; others repeat the current public page even while showing a larger community total.

The Actor attempts standard public pagination and compares each response with the previous page. When Skool repeats a page, extraction stops safely instead of creating duplicate records or claiming access that does not exist.

Therefore, `maxMembers` is a cap—not a promise that every community publicly exposes that many members.

### Tips for reliable exports

- 🎯 Start with one known public community and 30 members.
- 🔁 Use a scheduled task to refresh the same input consistently.
- 🆔 Match snapshots on `groupId` + `userId`, not display name.
- 🧹 Treat empty social fields as “not publicly supplied.”
- 📉 Keep page caps low when monitoring many communities.
- 🌐 Enable a proxy only after a direct request fails from your environment.
- 🕒 Compare ISO timestamps as UTC values in downstream systems.

### Integrations and workflow patterns

#### CRM staging

Send the dataset to Google Sheets or a database, filter by bio/location/website, then import qualified public profiles into a compliant outreach workflow.

#### Community-composition monitor

Schedule daily or weekly runs. Store snapshots in a named warehouse table and compare stable IDs to identify publicly visible additions or changes.

#### Creator partnership research

Route records with a public website or social URL into enrichment. Keep Skool profile and community URL as source provenance.

#### Webhooks and automation

Use an Apify webhook to trigger Make, Zapier, n8n, or your own API after a successful run.

#### Dataset exports

Download JSON, CSV, Excel, XML, or RSS from the Dataset tab, or query the dataset endpoint directly.

### Run with the Apify API

Use Actor ID `automation-lab/skool-public-members-scraper`.

#### JavaScript / Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/skool-public-members-scraper').call({
  startUrls: [{ url: 'https://www.skool.com/educate/-/members' }],
  maxMembers: 30,
  maxPagesPerCommunity: 2,
  proxyConfiguration: { useApifyProxy: false },
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/skool-public-members-scraper").call(run_input={
    "startUrls": [{"url": "https://www.skool.com/educate/-/members"}],
    "maxMembers": 30,
    "maxPagesPerCommunity": 2,
    "proxyConfiguration": {"useApifyProxy": False},
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~skool-public-members-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls":[{"url":"https://www.skool.com/educate/-/members"}],
    "maxMembers":30,
    "maxPagesPerCommunity":2,
    "proxyConfiguration":{"useApifyProxy":false}
  }'
```

### Use with Apify MCP

Connect the Actor to Claude Code with:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/skool-public-members-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/skool-public-members-scraper"
    }
  }
}
```

Example prompts:

- “Export 30 public members from this Skool community and group them by location.”
- “Run the Skool member scraper, then list profiles with a public website.”
- “Compare today’s public member IDs with the previous dataset.”

### Scheduling a Skool member monitor

1. Save a working Actor input as an Apify task.
2. Open **Schedules** in Apify Console.
3. Choose a daily, weekly, or monthly interval.
4. Attach a webhook or downstream integration if needed.
5. Compare stable IDs and timestamps between datasets.

Respect source limits and choose a cadence proportionate to your research need.

### Data quality and limitations

- Skool decides what is anonymously visible.
- Public page depth can differ by community and over time.
- A displayed member total may exceed the rows exposed anonymously.
- Online and activity signals are snapshots and can change immediately.
- Members may leave profile, location, timezone, or social fields blank.
- Display names and handles can change; stable IDs are better join keys.
- Source markup or embedded payload shapes may change.
- Private, removed, or unavailable communities produce no records.

The Actor validates Skool's payload shape and fails clearly on total extraction failure.

### Privacy, safety, and legality

This Actor extracts information available to anonymous visitors of public Skool member directories. It does not bypass authentication, private-group controls, CAPTCHAs, or access restrictions.

You are responsible for your purpose, retention, outreach, and compliance with applicable law, platform terms, privacy rules, and marketing regulations. Public availability does not automatically authorize every downstream use.

Use data minimization. Keep source provenance, honor deletion or objection requests where applicable, and avoid sensitive profiling or unsolicited bulk messaging.

### Troubleshooting

#### Why did I receive fewer members than the community total?

Skool may expose only part of a directory anonymously or repeat a visible page. The Actor stops on repeated pages to avoid duplicates. Increase `maxMembers` only when the source exposes additional distinct public rows.

#### Why did the run say the community is private or unavailable?

Open the exact URL in a logged-out browser. If the member directory is not visible there, it is outside this Actor's public-only scope. Also verify the URL starts with `https://www.skool.com/` and points to a community rather than an `@profile`.

#### Should I enable a proxy?

Not normally. Try direct access first. If Skool is unavailable from your runtime network, enable an Apify proxy and retry with a small limit.

#### Why are some social fields empty?

The member did not publish that link in the public profile payload. Empty fields are expected and are not extraction errors.

### Frequently asked questions

#### Does this Actor need a Skool account?

No. It is designed for member data visible to anonymous visitors.

#### Can it scrape private Skool communities?

No. Private and authenticated content is deliberately unsupported.

#### Does it collect email addresses?

No. Email extraction is outside the product contract, even if an upstream payload contains an empty email property.

#### Can I scrape several communities in one run?

Yes. Add multiple URLs to `startUrls`; `maxMembers` applies across all of them.

#### How are duplicates handled?

Records are deduplicated by community ID and user ID. Duplicate input URLs and repeated source pages do not duplicate output.

#### Can I use the results in a spreadsheet?

Yes. Export CSV or Excel from the Dataset tab, or connect Google Sheets through Apify integrations.

### Related scrapers

Combine public community research with other automation-lab Actors:

- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) for public creator profile research
- [LinkedIn Company Scraper](https://apify.com/automation-lab/linkedin-company-scraper) for company enrichment
- [YouTube Channel Scraper](https://apify.com/automation-lab/youtube-channel-scraper) for public channel intelligence

Only use related tools in ways consistent with their source rules and your legal obligations.

### Support

If a valid public Skool member URL stops working, open an issue from the Actor page and include:

- the public community URL
- the run ID
- expected versus actual result count
- whether the URL works in a logged-out browser

Do not include account credentials, cookies, private community links, or personal secrets.

### Start your first export

Use the prefilled Public Skool community, keep the 20-member first-run limit, and run the Actor. Review the dataset, then save the input as a repeatable task when the fields match your workflow.

# Actor input Schema

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

Add public community or /-/members URLs, for example https://www.skool.com/educate. Private communities and profile URLs are not supported.

## `maxMembers` (type: `integer`):

Stop after this many unique public member records across all communities.

## `maxPagesPerCommunity` (type: `integer`):

Safety cap for each community directory. The actor also stops when Skool repeats a public page.

## `proxyConfiguration` (type: `object`):

Optional proxy settings. Direct anonymous HTTP is used by default because public Skool directories normally work without a proxy.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.skool.com/educate/-/members"
    }
  ],
  "maxMembers": 20,
  "maxPagesPerCommunity": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.skool.com/educate/-/members"
        }
    ],
    "maxMembers": 20,
    "maxPagesPerCommunity": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/skool-public-members-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 = {
    "startUrls": [{ "url": "https://www.skool.com/educate/-/members" }],
    "maxMembers": 20,
    "maxPagesPerCommunity": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/skool-public-members-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 '{
  "startUrls": [
    {
      "url": "https://www.skool.com/educate/-/members"
    }
  ],
  "maxMembers": 20,
  "maxPagesPerCommunity": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/skool-public-members-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skool Public Members Scraper",
        "description": "Export public Skool community members with profile, activity, role, points, location, and social-link data—no login or cookies required.",
        "version": "0.1",
        "x-build-id": "I39kG447yCdpvLC23"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~skool-public-members-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-skool-public-members-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/automation-lab~skool-public-members-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-skool-public-members-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/automation-lab~skool-public-members-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-skool-public-members-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🏫 Public Skool communities",
                        "type": "array",
                        "description": "Add public community or /-/members URLs, for example https://www.skool.com/educate. Private communities and profile URLs are not supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxMembers": {
                        "title": "👥 Maximum members",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique public member records across all communities.",
                        "default": 30
                    },
                    "maxPagesPerCommunity": {
                        "title": "📄 Maximum pages per community",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Safety cap for each community directory. The actor also stops when Skool repeats a public page.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Direct anonymous HTTP is used by default because public Skool directories normally work without a proxy."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```