# Skool Content Scraper — Posts, Comments & Classroom (`muhammadafzal/skool-content-scraper`) Actor

Scrape public Skool posts, nested comments, classroom lessons, media links, authors, and engagement. Use for research, course archives, RAG, and monitoring. Not for members, emails, private content, write actions, or downloads. Returns flat post/comment/lesson rows with parent and depth. $0.005/row.

- **URL**: https://apify.com/muhammadafzal/skool-content-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** Social media, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 skool content items

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

## Skool Content Scraper — Posts, Comments & Classroom

Extract public Skool community posts, full nested comment threads, classroom lessons, videos, images, attachments, authors, and engagement as clean JSON rows. **Skool Content Scraper** is built for community operators, course owners, researchers, and AI/RAG pipelines that need structured Skool content without running a browser.

The Actor returns one row per post, comment, or lesson. Nested comments remain reconstructable through `rootPostId`, `parentCommentId`, and `depth`, while media stays attached to the content that contains it. This flat shape is friendly to CSV exports, databases, Apify MCP, Claude, ChatGPT, and downstream vector pipelines.

Price: **$0.005 per stored result ($5 per 1,000)** plus a $0.00005 Actor-start event. A hard `maxResults` cap is displayed before each run, so the maximum event charge is predictable.

### What data can I extract with Skool Content Scraper?

| Data | Output fields |
|---|---|
| Community posts | `itemId`, `title`, `text`, `categoryId`, `upvotes`, `commentCount`, `isPinned` |
| Nested comments | `rootPostId`, `parentCommentId`, `depth`, `text`, `upvotes` |
| Classroom lessons | `courseId`, `courseTitle`, `lessonOrder`, `title`, `text`, `hasAccess` |
| Media and files | `mediaType`, `url`, `thumbnailUrl`, `durationMs`, `provider`, `fileName`, `contentType` |
| Authors | `authorId`, `authorName`, `authorUsername`, profile and avatar URLs |
| Detailed profiles | public bio, location, website, LinkedIn, X/Twitter, Instagram, YouTube, Facebook |
| Timestamps | `createdAt`, `updatedAt`, `scrapedAt` in ISO 8601 |
| Diagnostics | `OUTPUT` KV record with counts, warnings, completion status, and billing totals |

All record types use the same stable schema. Missing values are explicit `null` values, not changing or invented fields.

### Use cases for public Skool data

- Archive a community you own or content you are authorized to process.
- Build a searchable knowledge base from posts, replies, and course lessons.
- Study which topics, questions, and lessons receive the most engagement.
- Monitor new content with `postedAfter` and an Apify Schedule.
- Export classroom video and resource links for an internal content inventory.
- Feed flat, typed discussion rows into sentiment, topic, or support analysis.
- Preserve reply relationships for thread visualization or conversation analytics.

Do not use this Actor for member lists, emails, DMs, private communities, write actions, or binary video downloading. It extracts links and public metadata; it does not bypass access controls.

### How the nested comment output works

Each comment is its own result. A top-level comment has `depth: 0` and `parentCommentId: null`. A reply has `depth: 1` and points to its immediate parent. Deeper replies continue the same pattern. Every comment also carries the root conversation ID in `rootPostId`.

This representation avoids very large post objects, keeps each MCP item compact, and makes pagination and billing transparent. Reconstruct a tree by indexing comments by `itemId` and attaching each reply to `parentCommentId`.

### Input

The default input is a small health-check run against a public community:

```json
{
  "startUrls": [
    { "url": "https://www.skool.com/ai-automation-society" }
  ],
  "scrapeMode": "all",
  "maxResults": 200,
  "maxPostsPerGroup": 25,
  "includeComments": true,
  "maxCommentsPerPost": 50,
  "maxCommentDepth": 20,
  "maxLessonsPerGroup": 100,
  "postedAfter": "",
  "includeMedia": true,
  "responseFormat": "concise"
}
````

`scrapeMode` accepts `all`, `community`, or `classroom`. `maxResults` is the hard combined row and PPE cap. The per-group post, comment, and lesson limits control how that budget is spent. Use `responseFormat: "concise"` for AI agents and `detailed` when public author bios and social links are useful.

For daily delta runs, pass an ISO date:

```json
{
  "startUrls": [{ "url": "https://www.skool.com/ai-automation-society" }],
  "scrapeMode": "community",
  "postedAfter": "2026-07-01T00:00:00Z",
  "maxResults": 500
}
```

### Output

Example nested reply row:

```json
{
  "contentType": "comment",
  "itemId": "01d5f6f76b954f17be8aee82c2c2f11e",
  "communitySlug": "ai-automation-society",
  "sourceUrl": "https://www.skool.com/ai-automation-society?c=01d5f6f...",
  "title": null,
  "text": "I should watch the summary of this instead",
  "rootPostId": "be3fc044cfd54901b86e4d9753948f66",
  "parentCommentId": "c7af89b3b4b046bc8ec5660f81ee51d9",
  "depth": 1,
  "authorName": "Example Member",
  "upvotes": 2,
  "media": [],
  "createdAt": "2026-07-11T13:05:30.711Z",
  "scrapedAt": "2026-07-13T10:00:00.000Z",
  "warnings": []
}
```

The Actor also writes `OUTPUT` to the default key-value store. It reports post, comment, and lesson counts, completed communities, warnings, charged event count, estimated event charge, and the deployed build number.

### How much will scraping Skool cost?

| Event | Price |
|---|---:|
| Actor start | $0.00005 |
| Stored post, comment, or lesson | $0.005 |
| 100 results | $0.50 plus start |
| 1,000 results | $5.00 plus start |

The Actor charges only after a schema-valid result is stored. `maxResults: 200` caps the result-event portion at $1.00. If the run-level PPE budget is lower, the Actor stops gracefully and preserves partial results.

### API examples

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('YOUR_USERNAME/skool-content-scraper').call({
  startUrls: [{ url: 'https://www.skool.com/ai-automation-society' }],
  scrapeMode: 'community',
  maxResults: 100,
  includeComments: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("YOUR_USERNAME/skool-content-scraper").call(run_input={
    "startUrls": [{"url": "https://www.skool.com/ai-automation-society"}],
    "scrapeMode": "classroom",
    "maxResults": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["contentType"], item.get("title"), item["sourceUrl"])
```

The hosted Apify MCP server can expose the Actor as a tool. Use it when an AI agent needs public Skool discussions or classroom content. Do not use it for Skool member/email scraping or for actions such as posting, commenting, or direct messaging. Returned rows contain the exact public content types described above, billed at $0.005 per row.

### Reliability and limits

The Actor uses Skool’s server-rendered JSON and public comments endpoint instead of browser automation. It retries temporary network, 403, 429, and 5xx responses with bounded backoff; validates stable required fields; stores partial results when one course or comment thread fails; and records all non-fatal problems in `OUTPUT.warnings`.

Only content visible to a logged-out public session is part of the Store contract. Private, paid, or level-locked content can legitimately return no rows or `hasAccess: false`. An operator running a private internal copy may configure `SKOOL_COOKIE` as a secret environment variable for content their account is authorized to access, but credentials are never accepted in normal Actor input, stored in datasets, or written to logs.

Media extraction returns URLs and metadata only. Signed or provider-hosted URLs may expire, and providers such as Loom, YouTube, Vimeo, Wistia, Mux, or Skool’s asset CDN control playback and download permissions. The Actor does not copy or rehost media files.

### Legal and responsible use

This Actor is independent and is not affiliated with, endorsed by, or sponsored by Skool. Skool is a trademark of its owner. You are responsible for confirming that your collection and use comply with Skool’s terms, copyright rules, privacy laws, community agreements, and the rights of content authors. Process only public content or content you are authorized to access. Do not use the output for harassment, spam, unauthorized redistribution, or unlawful profiling. When personal data is involved, establish a lawful basis, minimize collection, secure the output, and honor deletion or access requests where applicable.

### FAQ

#### Does it scrape full nested comments?

Yes. Replies are flattened into separate rows with `rootPostId`, `parentCommentId`, and `depth`, so the complete thread can be rebuilt.

#### Does it download classroom videos?

No. It extracts the public video URL, provider, thumbnail, and duration when Skool exposes them. Binary download and rehosting are intentionally out of scope.

#### Does it need a Skool login?

No for public communities and public classroom lessons. The public Store contract does not promise private or paid content.

#### Can I run it on a schedule?

Yes. Combine an Apify Schedule with `postedAfter` for bounded delta runs. Use the last successful timestamp as the next run’s threshold.

#### Why are some comments or lessons missing?

The content may be private, deleted, outside the selected date/depth/result cap, or unavailable to a logged-out session. Check `OUTPUT.warnings`, the terminal status message, and `hasAccess` before retrying.

#### Where do I report a problem?

Open an issue on the Actor page and include the run ID, public community URL, scrape mode, and limits. Never include cookies or other credentials in an issue.

# Actor input Schema

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

Use this when you know which public Skool communities to extract. Pass full community URLs such as https://www.skool.com/ai-automation-society. Defaults to one working public community. This is not for post, profile, bare-slug, or non-Skool URLs.

## `scrapeMode` (type: `string`):

Use this when you want posts, classroom lessons, or both. Choose all, community, or classroom; for example, classroom extracts courses and lesson media only. Defaults to all. This is not a Skool feed sort option.

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

Use this to cap the combined post, comment, and lesson rows returned in one run. Enter an integer from 1 to 5000, such as 200. Defaults to 200. This is the hard billing cap, not a per-community limit.

## `maxPostsPerGroup` (type: `integer`):

Use this to limit feed posts visited for each community. Enter an integer from 1 to 1000, such as 25. Defaults to 25. This does not count comment or classroom rows.

## `includeComments` (type: `boolean`):

Use this when full conversation threads are needed with each comment emitted as a separate row. Set true or false; replies preserve parentCommentId and depth. Defaults to true. This has no effect in classroom-only mode.

## `maxCommentsPerPost` (type: `integer`):

Use this to cap flattened top-level comments and replies for each post. Enter an integer from 0 to 1000, such as 50. Defaults to 50. This is not a page count; zero disables comment rows.

## `maxCommentDepth` (type: `integer`):

Use this to restrict how deeply reply trees are flattened. Enter 0 for top-level comments only or up to 20; for example, 3 keeps replies through depth three. Defaults to 20. This is not a page-count limit.

## `maxLessonsPerGroup` (type: `integer`):

Use this to cap classroom lesson rows across courses in each community. Enter an integer from 1 to 2000, such as 100. Defaults to 100. This does not count course containers as results.

## `postedAfter` (type: `string`):

Use this for delta runs that should skip older posts, comments, and lessons. Pass an ISO date or timestamp such as 2026-07-01 or 2026-07-01T00:00:00Z. Defaults to empty for all available dates. This is not a Skool display timezone.

## `includeMedia` (type: `boolean`):

Use this to return video, image, file, and resource URLs exposed in Skool payloads. Set true or false; metadata can include provider, thumbnail, duration, name, and MIME type. Defaults to true. This extracts links only, not binary files.

## `responseFormat` (type: `string`):

Use concise for smaller AI-agent output or detailed for author bios and social links. Accepted values are concise and detailed; for example, detailed. Defaults to concise. This does not change which posts, comments, or lessons are scraped.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.skool.com/ai-automation-society"
    }
  ],
  "scrapeMode": "community",
  "maxResults": 200,
  "maxPostsPerGroup": 25,
  "includeComments": true,
  "maxCommentsPerPost": 50,
  "maxCommentDepth": 3,
  "maxLessonsPerGroup": 100,
  "postedAfter": "2026-07-01",
  "includeMedia": true,
  "responseFormat": "detailed"
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset API endpoint containing typed Skool content rows.

## `summary` (type: `string`):

Key-value store record with counts, warnings, and billing totals.

# 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/ai-automation-society"
        }
    ],
    "scrapeMode": "all",
    "maxResults": 200,
    "maxPostsPerGroup": 25,
    "includeComments": true,
    "maxCommentsPerPost": 50,
    "maxCommentDepth": 20,
    "maxLessonsPerGroup": 100,
    "postedAfter": "",
    "includeMedia": true,
    "responseFormat": "concise"
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/skool-content-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/ai-automation-society" }],
    "scrapeMode": "all",
    "maxResults": 200,
    "maxPostsPerGroup": 25,
    "includeComments": True,
    "maxCommentsPerPost": 50,
    "maxCommentDepth": 20,
    "maxLessonsPerGroup": 100,
    "postedAfter": "",
    "includeMedia": True,
    "responseFormat": "concise",
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/skool-content-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/ai-automation-society"
    }
  ],
  "scrapeMode": "all",
  "maxResults": 200,
  "maxPostsPerGroup": 25,
  "includeComments": true,
  "maxCommentsPerPost": 50,
  "maxCommentDepth": 20,
  "maxLessonsPerGroup": 100,
  "postedAfter": "",
  "includeMedia": true,
  "responseFormat": "concise"
}' |
apify call muhammadafzal/skool-content-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skool Content Scraper — Posts, Comments & Classroom",
        "description": "Scrape public Skool posts, nested comments, classroom lessons, media links, authors, and engagement. Use for research, course archives, RAG, and monitoring. Not for members, emails, private content, write actions, or downloads. Returns flat post/comment/lesson rows with parent and depth. $0.005/row.",
        "version": "1.3",
        "x-build-id": "Zw6fTobpjVAhxWV4s"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muhammadafzal~skool-content-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muhammadafzal-skool-content-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/muhammadafzal~skool-content-scraper/runs": {
            "post": {
                "operationId": "runs-sync-muhammadafzal-skool-content-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/muhammadafzal~skool-content-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-muhammadafzal-skool-content-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": {
                    "startUrls": {
                        "title": "Public Skool community URLs",
                        "type": "array",
                        "description": "Use this when you know which public Skool communities to extract. Pass full community URLs such as https://www.skool.com/ai-automation-society. Defaults to one working public community. This is not for post, profile, bare-slug, or non-Skool URLs.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "Skool community URL",
                                    "type": "string",
                                    "description": "A full public Skool community URL such as https://www.skool.com/ai-automation-society."
                                }
                            },
                            "required": [
                                "url"
                            ]
                        },
                        "default": [
                            {
                                "url": "https://www.skool.com/ai-automation-society"
                            }
                        ]
                    },
                    "scrapeMode": {
                        "title": "Content to scrape",
                        "enum": [
                            "all",
                            "community",
                            "classroom"
                        ],
                        "type": "string",
                        "description": "Use this when you want posts, classroom lessons, or both. Choose all, community, or classroom; for example, classroom extracts courses and lesson media only. Defaults to all. This is not a Skool feed sort option.",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Maximum total results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Use this to cap the combined post, comment, and lesson rows returned in one run. Enter an integer from 1 to 5000, such as 200. Defaults to 200. This is the hard billing cap, not a per-community limit.",
                        "default": 200
                    },
                    "maxPostsPerGroup": {
                        "title": "Maximum posts per community",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Use this to limit feed posts visited for each community. Enter an integer from 1 to 1000, such as 25. Defaults to 25. This does not count comment or classroom rows.",
                        "default": 25
                    },
                    "includeComments": {
                        "title": "Include nested comments",
                        "type": "boolean",
                        "description": "Use this when full conversation threads are needed with each comment emitted as a separate row. Set true or false; replies preserve parentCommentId and depth. Defaults to true. This has no effect in classroom-only mode.",
                        "default": true
                    },
                    "maxCommentsPerPost": {
                        "title": "Maximum comments per post",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Use this to cap flattened top-level comments and replies for each post. Enter an integer from 0 to 1000, such as 50. Defaults to 50. This is not a page count; zero disables comment rows.",
                        "default": 50
                    },
                    "maxCommentDepth": {
                        "title": "Maximum comment depth",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Use this to restrict how deeply reply trees are flattened. Enter 0 for top-level comments only or up to 20; for example, 3 keeps replies through depth three. Defaults to 20. This is not a page-count limit.",
                        "default": 20
                    },
                    "maxLessonsPerGroup": {
                        "title": "Maximum lessons per community",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Use this to cap classroom lesson rows across courses in each community. Enter an integer from 1 to 2000, such as 100. Defaults to 100. This does not count course containers as results.",
                        "default": 100
                    },
                    "postedAfter": {
                        "title": "Only content on or after",
                        "type": "string",
                        "description": "Use this for delta runs that should skip older posts, comments, and lessons. Pass an ISO date or timestamp such as 2026-07-01 or 2026-07-01T00:00:00Z. Defaults to empty for all available dates. This is not a Skool display timezone.",
                        "default": ""
                    },
                    "includeMedia": {
                        "title": "Extract media and video metadata",
                        "type": "boolean",
                        "description": "Use this to return video, image, file, and resource URLs exposed in Skool payloads. Set true or false; metadata can include provider, thumbnail, duration, name, and MIME type. Defaults to true. This extracts links only, not binary files.",
                        "default": true
                    },
                    "responseFormat": {
                        "title": "Response detail",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Use concise for smaller AI-agent output or detailed for author bios and social links. Accepted values are concise and detailed; for example, detailed. Defaults to concise. This does not change which posts, comments, or lessons are scraped.",
                        "default": "concise"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
