# Skool Content Scraper & Skool API: Videos, Posts, 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:** [CrustAPI](https://apify.com/crustapi) (community)
- **Categories:** Lead generation, Social media, Videos
- **Features:** Limited permissions
- **Stats:** 150 total users, 14 monthly users, 100.0% runs succeeded, 2 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Skool Content Scraper & Skool API: Videos, Posts, Members

A **Skool scraper** that exports everything a public Skool.com community shows: 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 a course with one command.

It is the Skool scraper that pulls **classroom video URLs you can actually download** (Bunny CDN, Loom, YouTube, Vimeo) and harvests **active members** beyond Skool's 30-member limit - all from public communities, with **no login and no cookies**.

With this scraper, you can:

- 📹 **Download Skool classroom videos** - every public 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
- 🔓 **Public communities, no login** - nothing to sign into, no cookies to paste
- 📦 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 a 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. *(Optional)* Set **Max posts** to 20 for a quick test run first.
4. Click **Start**.

Private, member-only communities are not supported - this scrapes what a community shows publicly.

### Export a Skool members list

The scraper exports the public 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 this active-member list is how you get a real, usable members export for outreach and lead generation.

### 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 |

There is no start fee. An empty or failed run costs $0. Use the **Max posts** and **Max comments per post** limits to control spend on big communities.

### Who uses it

- **Course buyers and archivers** downloading public Skool classroom videos and lessons for offline access.
- **Lead generation teams** exporting active members and their profiles for outreach.
- **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 public lesson and saves a `video-urls.txt` file so you can bulk-download a course with `yt-dlp -a video-urls.txt`.

#### Do I need to log in or paste cookies to scrape Skool?

No. There is no login and no cookies. This scrapes what a Skool community shows publicly.

#### 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 public posts and comments.

#### Is it legal to scrape Skool?

You only access content that is public on Skool. 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

***

*This is an independent tool for collecting public Skool community data. It is not affiliated with, endorsed by, or sponsored by Skool. Skool is a trademark of its respective owner.*

# 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.

## `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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crustapi/skool-content-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/O5LUhq0PFkyK2FXkc/builds/x5NSpTC4UprFwdbmG/openapi.json