# Skool Scraper - Classroom Video Downloader & Members (`crustapi/skool-content-scraper`) Actor

Scrape and download everything inside a Skool.com community: classroom videos, posts, nested comments, and members. Save an entire course offline, export member lists for outreach, and reach private content with your own cookie. No login needed for public communities.

- **URL**: https://apify.com/crustapi/skool-content-scraper.md
- **Developed by:** [Crust](https://apify.com/crustapi) (community)
- **Categories:** Lead generation, Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 posts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper - Classroom Video Downloader & Members

A **Skool scraper** that exports everything inside a Skool.com community in one run: classroom course videos, posts, full nested comments, and members. Its standout feature is **downloading Skool classroom videos** - it builds a ready-to-use list so you can save an entire course with one command.

It is the only Skool scraper that pulls **classroom video URLs you can actually download** (Bunny CDN, Loom, YouTube, Vimeo), harvests **active members** beyond Skool's 30-member limit, and reaches private, member-only content.

With this scraper, you can:

- 📹 **Download Skool classroom videos** - every lesson video, with a one-command bulk download
- 🎓 Export **classroom courses and lessons** with video URLs, thumbnails, durations, and attached docs
- 📝 Scrape **posts** with author, upvotes, images, and attachments
- 💬 Pull **nested comment threads** in full
- 👥 Export **members**, including active members who post or comment, with name, bio, and profile
- 🔓 Scrape **public communities with no login**
- 🔑 Scrape **private or paid communities** you belong to, using your own cookie
- 📦 Export as **JSON, CSV, or Excel**

### How to download Skool classroom videos

Every run saves a ready-to-use file called **`video-urls.txt`** to the run's Storage (Key-value store tab), with the download link for every lesson video. Saving an entire Skool course offline is then three steps:

1. **Install yt-dlp** (free, one time):
   - Mac: `brew install yt-dlp ffmpeg`
   - Windows: `winget install yt-dlp ffmpeg`
   - Or with Python: `pip install yt-dlp`
2. **Download `video-urls.txt`** from your run's Storage tab.
3. **Run one command** in that folder:
````

yt-dlp -a video-urls.txt

````

That bulk-downloads every lesson video, named automatically. yt-dlp handles Bunny CDN (m3u8 streams), Loom, YouTube, and Vimeo.

Each lesson row also carries a `videoStream` field (the direct `.m3u8` download link) and a `videoUrl` field (the video's page). For a single video, run `yt-dlp "<videoStream>"`.

### What data does the Skool scraper export?

| | |
|---|---|
| 📹 Lesson video download URL + HLS stream | 🖼️ Lesson thumbnail and duration |
| 🎓 Classroom courses and modules | 📄 Lesson resources (Google Docs, PDFs, links) |
| 🏷️ Post title and body | 👤 Post author |
| 💬 Full nested comments | ⬆️ Upvotes and comment counts |
| 🖼️ Post images | 📎 Post attachments |
| 👥 Member name, handle, bio, location | 🟢 Active members from posts and comments |
| 🏘️ Community name, description, members | 🔗 Direct URLs for everything |

Each output row has a `recordType` (`community`, `post`, `comment`, `member`, `course`, or `lesson`) so you can filter or join the data in Sheets, a CRM, or your own tools.

### How to use it

1. Paste one or more community URLs into **Community URLs**.
2. Choose what to scrape (members, posts, comments, classroom) - everything is on by default.
3. For a **private or paid** community, paste your Skool cookie export (see below). Public communities need nothing.
4. *(Optional)* Set **Max posts** to 20 for a quick test run first.
5. Click **Start**.

#### Scrape a private or paid Skool community with your cookie

1. Install the free [Cookie-Editor](https://cookie-editor.com) extension.
2. Log in to Skool and open any page.
3. Click the Cookie-Editor icon, then **Export** > **Export as JSON**.
4. Paste the whole thing into the actor.

### Export a Skool members list

The scraper exports the member directory, then adds **every active member** who posts or comments - with name, handle, bio, and profile picture. Skool only shows ~30 members to non-admins, so for a community you do not own, this active-member list is how you get a real, usable members export for outreach and lead generation. Full member directories are available when you scrape a community you own or admin.

### Pricing

Pay per record, so you only pay for what you pull:

| What | Price |
|---|---|
| Classroom lesson / video | $0.20 |
| Course | $0.10 |
| Member | $0.03 |
| Post | $0.03 |
| Comment | $0.002 |

Use the **Max posts** and **Max comments per post** limits to control spend on big communities.

### Who uses it

- **Course buyers and archivers** downloading Skool classroom videos and lessons for offline access.
- **Lead generation teams** exporting active members and their profiles for outreach.
- **Community owners** backing up their own posts, comments, and courses.
- **Researchers and competitors** studying how a community is structured and run.

> Need public community discovery data (member counts, owner info, pricing) instead of the content inside? Use our companion actor, [Skool Community Scraper](https://apify.com/crustapi/skool-community-scraper).

### FAQ

#### Can I download Skool course videos?

Yes. The scraper returns a download link for every lesson and saves a `video-urls.txt` file so you can bulk-download an entire course with `yt-dlp -a video-urls.txt`.

#### Do I need to log in to scrape Skool?

Only for private or paid communities. Public communities scrape with no login.

#### Does it work on private or paid Skool communities?

Yes, for communities you are a member of. Paste your Skool cookie once and the scraper reaches everything you can see as a member.

#### Can I get more than 30 members from a Skool community?

Skool caps the member directory at ~30 for non-admins. This scraper works around that by harvesting every active member from posts and comments. Full directories are available on communities you own or admin.

#### Is it legal to scrape Skool?

You only access content you can already see as a logged-in member or that is public. You are responsible for how you use the data. See Apify's notes on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

#### Can I schedule recurring scrapes?

Yes. Use Apify's scheduler for daily, weekly, or monthly runs to track new posts, comments, and members over time.

---

Built by CrustAPI

# Actor input Schema

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

Skool community URLs or names to scrape. Examples: ugc-world, https://www.skool.com/ai-automation-society
## `scrapeMembers` (type: `boolean`):

Scrape the member list (name, bio, location, profile picture, role, join date).
## `scrapePosts` (type: `boolean`):

Scrape community posts (title, body, author, upvotes, embedded video).
## `scrapeComments` (type: `boolean`):

Scrape nested comment threads on each post. Requires Posts to be on.
## `scrapeClassroom` (type: `boolean`):

Scrape classroom courses, modules, lessons, and their video URLs.
## `authToken` (type: `string`):

Leave this empty for public communities.

To scrape a private or paid community you are a member of, paste your Skool cookies so the scraper can see it exactly like you do:

1. Install the free [Cookie-Editor](https://cookie-editor.com) browser extension.
2. Log in to Skool in your browser and open any page.
3. Click the Cookie-Editor icon, then 'Export' > 'Export as JSON'.
4. Paste the whole thing here.

Paste the full export, not just one value.
## `maxPosts` (type: `integer`):

Cap how many posts to scrape per community. Set a small number like 20 for a quick, cheap test before a full run. 0 = all posts.
## `maxMembers` (type: `integer`):

Cap how many members to scrape per community. 0 = all.
## `maxCommentsPerPost` (type: `integer`):

Cap comments fetched per post. Big threads can have thousands. 0 = all.
## `postsSince` (type: `string`):

Optional. Only scrape posts created on or after this date. Good for monitoring or delta runs.
## `maxConcurrency` (type: `integer`):

Number of parallel requests. Higher is faster but heavier on Skool. Most people can leave this alone.
## `proxyConfiguration` (type: `object`):

Proxy settings. Defaults to Apify Proxy. Residential proxies are recommended for private-community (logged-in) runs.

## Actor input object example

```json
{
"startUrls": [
 "https://www.skool.com/ugc-world"
],
"scrapeMembers": true,
"scrapePosts": true,
"scrapeComments": true,
"scrapeClassroom": true,
"maxPosts": 0,
"maxMembers": 0,
"maxCommentsPerPost": 0,
"maxConcurrency": 5,
"proxyConfiguration": {
 "useApifyProxy": true
}
}
````

# Actor output Schema

## `records` (type: `string`):

All scraped records (community, members, posts, comments, lessons) as JSON.

## `videoList` (type: `string`):

Ready-to-use list of every lesson video link. Download it and run: yt-dlp -a video-urls.txt

# 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": [
        "https://www.skool.com/ugc-world"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crustapi/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": ["https://www.skool.com/ugc-world"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crustapi/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": [
    "https://www.skool.com/ugc-world"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crustapi/skool-content-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skool Scraper - Classroom Video Downloader & Members",
        "description": "Scrape and download everything inside a Skool.com community: classroom videos, posts, nested comments, and members. Save an entire course offline, export member lists for outreach, and reach private content with your own cookie. No login needed for public communities.",
        "version": "0.0",
        "x-build-id": "rRk0NrhRGUK1hB9j9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crustapi~skool-content-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crustapi-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/crustapi~skool-content-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crustapi-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/crustapi~skool-content-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crustapi-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Community URLs",
                        "type": "array",
                        "description": "Skool community URLs or names to scrape. Examples: ugc-world, https://www.skool.com/ai-automation-society",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeMembers": {
                        "title": "Members",
                        "type": "boolean",
                        "description": "Scrape the member list (name, bio, location, profile picture, role, join date).",
                        "default": true
                    },
                    "scrapePosts": {
                        "title": "Posts",
                        "type": "boolean",
                        "description": "Scrape community posts (title, body, author, upvotes, embedded video).",
                        "default": true
                    },
                    "scrapeComments": {
                        "title": "Comments",
                        "type": "boolean",
                        "description": "Scrape nested comment threads on each post. Requires Posts to be on.",
                        "default": true
                    },
                    "scrapeClassroom": {
                        "title": "Classroom (courses + videos)",
                        "type": "boolean",
                        "description": "Scrape classroom courses, modules, lessons, and their video URLs.",
                        "default": true
                    },
                    "authToken": {
                        "title": "Read this to find your Skool cookie →",
                        "type": "string",
                        "description": "Leave this empty for public communities.\n\nTo scrape a private or paid community you are a member of, paste your Skool cookies so the scraper can see it exactly like you do:\n\n1. Install the free [Cookie-Editor](https://cookie-editor.com) browser extension.\n2. Log in to Skool in your browser and open any page.\n3. Click the Cookie-Editor icon, then 'Export' > 'Export as JSON'.\n4. Paste the whole thing here.\n\nPaste the full export, not just one value."
                    },
                    "maxPosts": {
                        "title": "Max posts (0 = all)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap how many posts to scrape per community. Set a small number like 20 for a quick, cheap test before a full run. 0 = all posts.",
                        "default": 0
                    },
                    "maxMembers": {
                        "title": "Max members (0 = all)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap how many members to scrape per community. 0 = all.",
                        "default": 0
                    },
                    "maxCommentsPerPost": {
                        "title": "Limit comments per post (0 = all)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap comments fetched per post. Big threads can have thousands. 0 = all.",
                        "default": 0
                    },
                    "postsSince": {
                        "title": "Only posts newer than (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Optional. Only scrape posts created on or after this date. Good for monitoring or delta runs."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Number of parallel requests. Higher is faster but heavier on Skool. Most people can leave this alone.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Defaults to Apify Proxy. Residential proxies are recommended for private-community (logged-in) runs.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```