# Skool Classroom Scraper — Videos, Lessons, Transcripts (`scrapersdelight/skool-classroom-scraper`) Actor

Download Skool classroom videos, lessons, transcripts & attachments from any community. Gets the full course tree, every lesson's video URL (native Mux + Loom/YouTube/Vimeo) and caption transcript. No login for public communities; add your own Skool cookie for member-only classrooms.

- **URL**: https://apify.com/scrapersdelight/skool-classroom-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** AI, Videos, Automation
- **Stats:** 20 total users, 10 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 lot scrapeds

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Classroom Scraper — Videos, Lessons, Transcripts & Attachments

**Download Skool classroom videos, lessons, transcripts & attachments from any community.** Give it a community and it returns the full course → module → lesson tree — titles, order, descriptions, attachments, the playable video URL for **every** lesson (Loom, YouTube, Vimeo embeds **and** Skool's native Mux uploads), and the caption transcript where one exists. Public/free communities need no login. For member-only classrooms, add your own Skool login cookie.

It reads Skool's own server-rendered page data — fast, no browser farm.

***

### What it does

Skool is a Next.js app: every classroom page server-renders the course tree into the page, and ships each selected lesson's native video. This actor walks the whole tree and, for every lesson, returns:

- 🌳 **Full classroom tree** — courses → modules → lessons, in original order
- 📝 **Description** — clean plain text from each lesson's rich-text body
- 📎 **Attachments** — link resources (with the real URL) + uploaded files (name, type, file id)
- 🎬 **Video URL** — Loom / YouTube / Vimeo embeds, **plus** Skool native (Mux) uploads resolved to a playable HLS stream — for **every** lesson, not just the first
- 🗣️ **Transcript** — pulled from the native-video caption track when one exists (else `null` — never faked)
- 🔒 **needs\_auth** flag for lessons gated to members

***

### Output fields (one record per lesson)

- 🏷️ `community`, `course_id`, `course_title`, `course_privacy`
- 🧭 `module_path`, `lesson_id`, `lesson_title`, `lesson_order`
- 📝 `description`, 📎 `attachments[]`
- ▶️ `media_url`, `media_type` (`embed` | `mux`), ⏱️ `video_length_ms`, 🖼️ `video_thumbnail`
- 🗣️ `transcript`, 🔒 `needs_auth`, ✨ `is_new` (monitor), 🕒 `scraped_at`

Each `attachments[]` entry is either a **link** (`{type:"link", title, url}`) or an uploaded **file** (`{type:"file", title, file_name, content_type, file_id}`). Skool serves uploaded files behind auth, so files have no public download URL — open the lesson to download them (`file_url` is `null`, with a `download_note`). Link attachments carry the real, public `url`.

***

### Who it's for

- 🗄️ **Community owners** backing up / archiving classroom content
- 🤖 **AI / RAG builders** turning course material into clean structured text + transcripts
- 📚 **Course operators** auditing structure, lessons, and attachments at scale
- 🔁 **Migration teams** moving a classroom's outline + media to another platform

***

### How to use it

1. Click **Try for free**.
2. Enter one or more **communities** (e.g. `ai-automation-society`) or full `skool.com/<slug>` URLs.
3. *(Member-only classrooms)* paste **your own Skool login cookie** into `skoolCookie` — public communities need nothing.
4. Click **Start**, then open the **Dataset** tab to view/export.
5. *(Optional)* set **monitorMode** + a **Schedule** to capture new lessons as a classroom grows.

#### Quick start

```json
{ "communities": ["ai-automation-society"], "maxItems": 25, "resolveMedia": true }
```

***

### Input

| Field | What it does |
|-------|--------------|
| `communities` | Skool community slugs or `skool.com/<slug>` URLs |
| `skoolCookie` | *(optional)* **your own** Skool session cookie for member-only classrooms — never stored or logged |
| `maxItems` | cap on lessons returned (0 = all) |
| `resolveMedia` | resolve native-Mux video URL + captions for every lesson |
| `maxMediaResolves` | cap on native-video resolves per run (0 = no cap) |
| `includeLocked` | also list member-only courses you can't access (flagged) |
| `monitorMode`, `alertOnNewLesson` | recurring new-lesson watcher + alerts |
| `webhookUrl`, `slackWebhookUrl`, `emailRecipients` | alert channels |
| `proxyConfiguration`, `requestConcurrency` | proxy + parallelism |

***

### Output

Each lesson is one dataset record (fields above). Export to **JSON, CSV, Excel, HTML, or RSS**, or fetch via the **Apify API**.

***

### Pricing

Pay-per-event — you pay for results, not for time:

| Event | What it covers | Suggested price |
|-------|----------------|-----------------|
| `lot-scraped` | each lesson returned | ~$0.005 / lesson |
| `lot-detail-enriched` | each native-video URL + captions resolved | ~$0.004 / media |
| `monitor-run-completed` | each scheduled watch run | ~$0.05 / run |
| `new-lot-detected` | each new lesson found | ~$0.02 / lesson |
| `alert-delivered` | each Slack/email/webhook push | ~$0.005 / alert |

*(Final per-event prices are set on the actor's pricing page.)*

***

### How it compares

| | **This actor** | Typical Skool scraper | Leading Skool suite | Budget clone |
|---|---|---|---|---|
| Full course → module → lesson tree | ✅ | partial | ✅ | ❌ |
| Lesson descriptions + attachments | ✅ | ❌ | partial | ❌ |
| Native (Mux) video URL for **every** lesson | ✅ | ❌ | first lesson only | ❌ |
| Embed video URLs (Loom/YouTube/Vimeo) | ✅ | ✅ | ✅ | partial |
| Transcript from native captions | ✅ where present | ❌ | ❌ | ❌ |
| Bring-your-own-login for member content | ✅ | sometimes | ✅ | ❌ |
| New-lesson monitor + alerts | ✅ | ❌ | partial | ❌ |
| Pay-per-event (pay per lesson) | ✅ | monthly rental | monthly rental | per-result |

***

### How it gets every lesson's video

Skool only server-renders **one** lesson's video at a time (the selected one). This actor re-requests each lesson by id (`?md=<lesson_id>`) so it can resolve the native Mux playback URL and caption track for **every** lesson — not just the first. Embeds (Loom/YouTube/Vimeo) come straight from the tree with no extra fetch. No headless browser, no speech-to-text compute, no faked data.

***

### FAQ

**Do I need a Skool login?**
No, for public/free communities. For member-only or drip classrooms, paste your own Skool session cookie into `skoolCookie`.

**Where do I get my cookie?**
From your logged-in browser's `auth_token` cookie on `skool.com`. Paste the bare value or the full cookie string. It's used only for the request and never saved or logged.

**Does it download the video files?**
It returns the **video URL** (Loom/YouTube/Vimeo embed or a playable Mux HLS stream) plus metadata — not a re-hosted copy.

**Will every lesson have a transcript?**
Only native (Mux) videos with a caption track. Skool doesn't store transcripts, so when no caption track exists `transcript` is `null` (never faked). Loom/YouTube embeds keep their transcript on the host.

**Can it watch for new lessons?**
Yes — enable `monitorMode` and add a Schedule; it outputs/alerts only newly added lessons.

**How do I export?**
JSON, CSV, Excel, HTML, or RSS from the Dataset tab, or via the Apify API.

***

### Feedback

Want per-lesson Loom/YouTube transcript enrichment, file downloads, or another output field? Open an issue on the actor. </content> </invoke>

# Actor input Schema

## `communities` (type: `array`):

Skool communities whose classroom you want to extract — community slugs (e.g. ai-automation-society) or full https://www.skool.com/<slug> / .../classroom URLs. Public/free classrooms work with no login.

## `skoolCookie` (type: `string`):

OPTIONAL. To extract member-only / drip classrooms, paste YOUR OWN Skool session cookie — either the bare auth\_token value or the full cookie string from your logged-in browser. It is sent only as the request Cookie header, never stored or logged. Leave blank for public communities.

## `maxItems` (type: `integer`):

Hard cap on the number of lesson records returned across all courses (0 = all). Keeps demo/test runs light.

## `resolveMedia` (type: `boolean`):

For Skool's native (Mux) uploads, resolve the playable HLS video URL and pull the caption transcript if one exists (one fetch per native lesson, capped by Max media resolves). Loom/YouTube/Vimeo embed URLs are always returned from the page with no extra fetch.

## `maxMediaResolves` (type: `integer`):

Safety cap on how many native (Mux) lesson videos to resolve per run (each is one extra fetch). Keeps large runs fast and predictable. 0 = no cap.

## `includeLocked` (type: `boolean`):

Also emit a row for member-only courses you can't access (with needs\_auth=true and no content) so you can see the full classroom outline.

## `monitorMode` (type: `boolean`):

Recurring watcher: diff against the prior run's seen lessons (per community set) and output/alert ONLY new lessons. Pair with an Apify Schedule.

## `alertOnNewLesson` (type: `boolean`):

In monitor mode, deliver an alert for each new lesson via the channels below.

## `webhookUrl` (type: `string`):

POST endpoint for new-lesson alert payloads.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL for formatted cards.

## `emailRecipients` (type: `array`):

Emails for the new-lesson digest (via apify/send-mail).

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

Proxy settings. Datacenter rotation is plenty — Skool has no bot wall on the data path.

## `requestConcurrency` (type: `integer`):

Max parallel lesson/media fetches.

## `diagnose` (type: `boolean`):

Dev only. Logs the resolved community + first accessible course's lesson count + first lesson, then exits.

## Actor input object example

```json
{
  "communities": [
    "ai-automation-society"
  ],
  "maxItems": 25,
  "resolveMedia": true,
  "maxMediaResolves": 60,
  "includeLocked": false,
  "monitorMode": false,
  "alertOnNewLesson": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestConcurrency": 8,
  "diagnose": false
}
```

# Actor output Schema

## `lessons` (type: `string`):

The dataset of extracted lessons (one item per lesson).

# 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 = {
    "communities": [
        "ai-automation-society"
    ],
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/skool-classroom-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 = {
    "communities": ["ai-automation-society"],
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/skool-classroom-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 '{
  "communities": [
    "ai-automation-society"
  ],
  "maxItems": 25
}' |
apify call scrapersdelight/skool-classroom-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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