skool-loom-dl

Finished

Go LangSkool.comLoomVideo DownloaderDocker

Skool Downloader

Overview

The Skool Downloader is a Go-based CLI utility that I wrote over the weekend. I was about to leave a Skool community and wanted to download my favorite courses before leaving. I couldn't figure out a simple way to download them manually, so I decided to vibe code this tool to automate the process. In simple terms, it scrapes a Skool classroom page, based on the provided URL, and downloads all Loom and YouTube videos from that page.

Disclaimer

Warning

This tool is provided for educational and legitimate purposes only.

Use this tool only to download content you have the right to access. Please respect copyright laws and terms of service:

Only download videos you have permission to save
Do not bypass paywalls or access unauthorized content
Respect the terms of service of both Skool.com and Loom.com
The developers accept no liability for misuse

What's New in v2.0.0

Version 2.0.0 represents a major upgrade with several important changes:

YouTube Support: Now downloads both Loom and YouTube videos from Skool classrooms
Project Renamed: Changed from skool-loom-dl to skool-downloader to reflect broader video support
Pre-built Binaries: Official releases now include binaries for all major platforms
Improved Video Extraction: Enhanced JSON parsing with fallback regex extraction
URL Normalization: Automatically converts embed URLs to standard formats
Better Testing: Comprehensive unit tests and Docker integration tests
CI/CD Pipeline: Automated testing and release workflows
Docker Support: Official Docker image with all dependencies included
Better Documentation: Improved README and technical documentation
Critical Bugfix: A critical bug was fixed which caused the tool to only download a few or incorrect videos instead of the entire classroom.

Features

Scrapes Loom and YouTube video links from Skool.com classroom pages
Authentication via email/password or cookies
Supports JSON and Netscape cookies.txt formats
Downloads videos using yt-dlp with proper authentication
Automatically detects and normalizes video URLs
Configurable page loading wait time
Toggleable headless mode for debugging
Pre-built binaries for all major platforms (Linux, Windows, macOS)
Comprehensive test suite with Docker integration tests
Docker support for containerized deployment

Installation

Option 1: Download Pre-built Binaries (Recommended)

Install yt-dlp
Download the latest release from the Releases page
Choose the appropriate binary for your platform:
- Linux (x64): skool-downloader-linux-amd64
- Linux (ARM64): skool-downloader-linux-arm64
- Windows (x64): skool-downloader-windows-amd64.exe
- Windows (ARM64): skool-downloader-windows-arm64.exe
- macOS (Intel): skool-downloader-darwin-amd64
- macOS (Apple Silicon): skool-downloader-darwin-arm64
Make it executable (Linux/macOS): chmod +x skool-downloader-*

Note: Older versions were called skool-loom-dl before release v2.0.0

Option 2: Build from Source

Prerequisites

Install Go (1.18 or newer)
Install yt-dlp

Building the Tool

Bash
1git clone https://github.com/fx64b/skool-downloader
2cd skool-downloader
3
4go build

Usage

Basic Usage

Recommended: Using email/password for authentication

Bash
./skool-downloader -url="https://skool.com/yourschool/classroom/your-classroom" -email="your@email.com" -password="yourpassword"

Alternative: Using cookies for authentication

Bash
./skool-downloader -url="https://skool.com/yourschool/classroom/your-classroom" -cookies="cookies.json"

Note: Email/password authentication is more reliable as it handles session management automatically. Cookie-based authentication may fail if cookies expire or are invalid.

Command Line Options

Option	Description	Default
`-url`	URL of the skool.com classroom page	(required)
`-email`	Email for Skool login (recommended auth method)	-
`-password`	Password for Skool login (used with email)	-
`-cookies`	Path to cookies file (alternative to email/password)	-
`-output`	Directory to save videos	`downloads`
`-wait`	Page load wait time in seconds	`2`
`-headless`	Run browser headless (set to `false` for debugging)	`true`

Docker Usage

Run the tool in a containerized environment with all dependencies included:

Bash
1# Build image
2docker build -t skool-downloader .
3
4# Run container with email/password authentication
5docker run -v $(pwd)/downloads:/data skool-downloader \
6  -url="https://skool.com/yourschool/classroom/path" \
7  -email="your@email.com" \
8  -password="yourpassword"
9
10# Run with cookies file
11docker run -v $(pwd)/downloads:/data -v $(pwd)/cookies.json:/cookies.json skool-downloader \
12  -url="https://skool.com/yourschool/classroom/path" \
13  -cookies="/cookies.json"

The Docker image includes:

Chrome/Chromium for browser automation
yt-dlp for video downloads
ffmpeg for video processing
All Go dependencies

Getting Cookies (if needed)

If you choose to use cookies instead of email/password:

Install a browser extension like "Cookie-Editor" (Chrome) or "Cookie Quick Manager" (Firefox)
Log in to your Skool.com account
Export cookies as JSON or Netscape format
Save the file and use it with the -cookies parameter

Troubleshooting

No videos found: Verify your authentication and classroom URL
Authentication fails: Use email/password instead of cookies
Page loads incomplete: Increase wait time with -wait=5 or higher
Download errors: Update yt-dlp (pip install -U yt-dlp)
Login issues: Try -headless=false to see the browser and debug
Specific video errors: Check if the video is still available on Loom

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Development and Testing

Running Tests

This project includes comprehensive unit and integration tests.

Unit Tests

Run unit tests with coverage:

Bash
1# Run all tests
2go test -v ./...
3
4# Run tests with coverage
5go test -v -coverprofile=coverage.out -covermode=atomic ./...
6
7# View coverage report
8go tool cover -func=coverage.out

The unit tests cover:

Loom and YouTube URL extraction from HTML
Cookie parsing (JSON and Netscape formats)
Cookie format conversion
Utility functions

Integration Tests

Run Docker-based integration tests to verify the full application with yt-dlp:

Bash
1# Make the script executable (first time only)
2chmod +x test-integration.sh
3
4# Run integration tests
5./test-integration.sh

The integration tests verify:

Docker image builds successfully
Binary is executable in the container
yt-dlp is installed and functional
Chromium is available
ffmpeg is available
Proper error handling

Continuous Integration

The project uses GitHub Actions for automated testing:

Lint and Build (lint-and-build.yml): Runs on every push and PR
- Lints code with golangci-lint
- Builds the project
- Runs unit tests with coverage reporting
Docker Integration Tests (docker-integration-test.yml): Runs on every push and PR
- Builds the Docker image
- Runs integration tests in a containerized environment

Creating Releases (Maintainers)

To create a new release with cross-platform binaries:

Go to the Actions tab
Select "Build and Release" workflow
Click "Run workflow"
Enter the desired version (e.g., v2.0.0)
Click "Run workflow"

The workflow will automatically:

Build binaries for all supported platforms
Create a new GitHub release
Attach all binaries to the release

License

This project is licensed under the MIT License - see the LICENSE file for details.

All projects →