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

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)

1. Install yt-dlp
2. Download the latest release from the Releases page
3. 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
4. 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

1. Install Go (1.18 or newer)
2. Install yt-dlp

Building the Tool

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

Usage

Basic Usage

Recommended: Using email/password for authentication

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

Alternative: Using cookies for authentication

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

Docker Usage

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

BashCopy
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:

1. Install a browser extension like "Cookie-Editor" (Chrome) or "Cookie Quick Manager" (Firefox)
2. Log in to your Skool.com account
3. Export cookies as JSON or Netscape format
4. 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:

BashCopy
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:

BashCopy
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:

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

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

1. Go to the Actions tab
2. Select "Build and Release" workflow
3. Click "Run workflow"
4. Enter the desired version (e.g., v2.0.0)
5. 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.