# Skool Classroom Media/Video · Posts · Nested Comments (`memo23/skool-posts-with-comments-scraper`) Actor

Skool.com posts + nested comments + classroom courses + media files. Date filter for new-content delta runs, storage dedup across runs (no double-billing), tab selector for community/classroom, configurable comment depth. The most thorough Skool content extractor. JSON or CSV.

- **URL**: https://apify.com/memo23/skool-posts-with-comments-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, Social media, MCP servers
- **Features:** Limited permissions
- **Stats:** 1,149 total users, 43 monthly users, 94.4% runs succeeded, 50 bookmarks
- **User rating**: 4.85 out of 5 stars

## Pricing

from $3.82 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

Unlock valuable insights from Skool.com discussions. Extract comprehensive post data, classroom courses, and nested comments with ease, empowering your community analysis and content strategy.

### Overview

This actor allows you to scrape posts, classroom courses, and their associated comments from Skool.com. It extracts detailed information about each post and course, including content, metadata, user information, and nested comments, providing a complete picture of discussions and learning materials within Skool communities.

### Features

- **Detailed Post Information**: Extract comprehensive data about each post, including title, content, and metadata.
- **Classroom Courses**: Scrape content from classroom courses, including lessons and related details.
- **User Details**: Retrieve information about post authors, commenters, and course creators.
- **Nested Comments**: Capture full comment threads, including replies to comments.
- **Customizable Depth**: Option to include or exclude comments on each post or course.
- **Flexible Input**: Support for specific Skool.com community URLs.
- **Engagement Metrics**: Capture upvotes, comment counts, and other relevant statistics.
- **Proxy Support**: Built-in proxy configuration to enhance scraping reliability and avoid blocks.

### How to Use

1. **Set Up**: Ensure you have an Apify account and access to the Apify platform.
2. **Install** a cookie management extension like:
   - [Copy Cookies](https://chromewebstore.google.com/detail/copy-cookies/jcbpglbplpblnagieibnemmkiamekcdg)
   - [Cookie-Editor](https://chromewebstore.google.com/detail/cookie-editor/hlkenndednhfkekhgcdicdfddnkalmdm)
   - [EditThisCookie](https://chrome.google.com/webstore/detail/editthiscookie/fngmhnnpilhplaeedifhccceomclgfbg)
3. **Login** to your [Skool](https://www.skool.com/) account.
4. While on the **Skool tab**, click the extension to export the cookies.
5. **Paste** the cookies into this actor's Cookie input field (delete everything before pasting).
6. **Specify** the Skool group URL you want to scrape. Input URLs in the format https://www.skool.com/{group-name} (see Input Configuration section). Add multiple URLs for broader scraping scope.
7. **Select Tab**: Choose whether to scrape the Community or Classroom tab by setting the tab option.
8. **Configure Member Details**: Choose whether to include comments for each group by setting the includeComments option.
9. (Optional) **Customize Settings**: Adjust scraper settings, including the max number of listings to scrape, maximum concurrency, minimum concurrency, max request retries, and any specific data fields to collect.
10. (Optional) **Bypass Site Protection**: To bypass site protection, use residential proxies from the country you're scraping from. This approach helps mimic regular user behavior, minimizing detection and blocking risks.
11. **Run the Scraper**: Launch the scraper on the Apify platform. Monitor its progress and adjust settings as needed.
12. **Data Collection**: Extracted data is available in your preferred format, with support for JSON, HTML, CSV, Excel, and other formats provided by Apify.

### Input Configuration

Here's an example of how to set up the input for the Skool Scraper:

```json
{
    "startUrls": [
        {
            "url": "https://www.skool.com/ai-automation-society"
        }
    ],
    "tab": "classroom",
    "includeComments": true,
    "maxItems": 1000,
    "maxConcurrency": 100,
    "minConcurrency": 1,
    "maxRequestRetries": 30
}
```

#### Input Fields Explanation

- `startUrls`: Array of Skool.com community URLs to scrape posts, courses, and comments from.
- `tab`: Specifies which tab to scrape (community or classroom).
- `includeComments`: Boolean to determine whether to scrape comments for each post or course (default: false).
- `maxItems`: Maximum number of items to scrape across all start URLs (default: 10000). The run stops once this many items are saved, and you are never charged for more results than this.
- `maxConcurrency`: Maximum number of pages processed simultaneously (default: 10).
- `minConcurrency`: Minimum number of pages processed simultaneously (default: 1).
- `maxRequestRetries`: Number of retries for failed requests (default: 40).
- `cookies`: JSON array of cookies for authentication with Skool.com (required).
- `proxy`: Proxy configuration to specify proxy servers for scraping.

### Output Structure

#### Community Tab Output

The output data includes detailed information about each post and their comments. Here's a sample of the structure:

```json
{
    "id": "aab147fa0ea4420d83e8d3a9214f5203",
    "name": "roadmap-update",
    "metadata": {
        "action": 0,
        "content": "Post content here...",
        "comments": 37,
        "upvotes": 50,
        "title": "Roadmap Update",
        "pinned": 1,
        "imagePreview": "",
        "imagePreviewSmall": "",
        "videoLinksData": "[]",
        "contributors": "[{...}]",
        "labels": "3916973e45d64416917aaba09edff141",
        "hasNewComments": 1,
        "lastComment": 1731431342139887000
    },
    "createdAt": "2024-11-07T23:26:18.04203Z",
    "updatedAt": "2024-11-14T09:50:05.802436Z",
    "groupId": "b575158c8d8240b88e9f13da74aa66cc",
    "userId": "5222fdb103d340ecaf61d47f35302f52",
    "postType": "generic",
    "rootId": "aab147fa0ea4420d83e8d3a9214f5203",
    "labelId": "3916973e45d64416917aaba09edff141",
    "user": {
        "id": "5222fdb103d340ecaf61d47f35302f52",
        "name": "username",
        "metadata": {
            "actStatus": "hardcore",
            "bio": "User bio...",
            "pictureBubble": "URL to bubble picture",
            "pictureProfile": "URL to profile picture",
            "location": "User location",
            "linkWebsite": "User website URL",
            "linkYoutube": "User YouTube URL"
        },
        "createdAt": "2020-05-14T00:51:12.09168Z",
        "updatedAt": "2024-11-14T15:45:27.923959Z",
        "firstName": "First",
        "lastName": "Last"
    },
    "url": "https://www.skool.com/group-name/post-name",
    "comments": [
        {
            "post": {
                "id": "comment-id",
                "metadata": {
                    "action": 0,
                    "content": "Comment content...",
                    "upvotes": 4,
                    "attachments": "attachment-id",
                    "attachments_data": "[{...}]"
                },
                "created_at": "2024-11-07T23:28:36.995Z",
                "updated_at": "2024-11-08T00:40:38.94154Z",
                "user_id": "user-id",
                "post_type": "comment",
                "parent_id": "parent-post-id",
                "root_id": "root-post-id",
                "user": {
                    "id": "user-id",
                    "name": "username",
                    "metadata": {
                        "bio": "User bio",
                        "picture_bubble": "URL to bubble picture",
                        "picture_profile": "URL to profile picture"
                    },
                    "created_at": "Creation timestamp",
                    "updated_at": "Update timestamp",
                    "first_name": "First",
                    "last_name": "Last"
                }
            }
        }
    ]
}
```

##### Output Fields Explanation

**Post Object:**

- **id**: Unique identifier for the post
- **name**: URL-friendly name of the post
- **metadata**: Contains various post metadata including:
  - **content**: The main content of the post
  - **comments**: Number of comments
  - **upvotes**: Number of upvotes
  - **title**: Post title
  - **pinned**: Whether the post is pinned (1 for yes, 0 for no)
  - **imagePreview**: URL to preview image if any
  - **videoLinksData**: Array of video links if any
  - **contributors**: Array of users who contributed to the post
  - **labels**: Label identifiers for the post
- **createdAt**: Timestamp of post creation
- **updatedAt**: Timestamp of last update
- **postType**: Type of post (e.g., "generic")
- **user**: Detailed information about the post author
- **url**: Full URL to the post
- **comments**: Array of comment objects

**Comment Object:**

- **post**: Contains the comment data including:
  - **id**: Unique identifier for the comment
  - **metadata**: Comment metadata including content and upvotes
  - **created_at**: Timestamp of comment creation
  - **updated_at**: Timestamp of last update
  - **user**: Detailed information about the comment author
  - **post_type**: Type (always "comment")
  - **parent_id**: ID of the parent post
  - **root_id**: ID of the root post

#### Classroom Tab Output

The output data includes information about each module within a classroom course. Here's a sample structure:

```json
{
    "type": "module",
    "title": "Module Title",
    "postTitle": "Specific Lecture Title",
    "content": "Module content and description...",
    "id": "unique-module-id",
    "urlAjax": "https://api.skool.com/posts/module-id/comments",
    "url": "https://www.skool.com/group-name/classroom/module-name",
    "media": [
        "https://www.loom.com/share/video-id"
    ],
    "courseMetaDetails": {
        "id": "course-id",
        "name": "course-name",
        "title": "Course Title",
        "createdAt": "2024-09-20T16:51:46.06926Z",
        "updatedAt": "2024-11-12T23:47:47.319915Z"
    },
    "comments": [ ... ] // Same structure as community comments
}
```

##### Classroom Output Fields Explanation

**Module Object:**

- **type**: Type of content (e.g., "module")
- **title**: Title of the module or section
- **postTitle**: Specific title of the lecture or content
- **content**: Module description or content
- **id**: Unique identifier for the module
- **urlAjax**: API endpoint for loading module comments
- **url**: Full URL to access the module
- **media**: Array of media URLs (typically video lectures)
- **courseMetaDetails**: Course metadata including:
  - **id**: Course identifier
  - **name**: Course name/code
  - **title**: Full course title
  - **createdAt**: Course creation timestamp
  - **updatedAt**: Last update timestamp
- **comments**: Array of comments following the same structure as community posts

### Related Scrapers

- [Skool Members Scraper](https://apify.com/memo23/skool-members-scraper): Gather extensive user details such as first and last names, email, and links to social profiles (e.g., Facebook, Instagram, LinkedIn).

### Support

- For issues or feature requests, use the [Issues](https://console.apify.com/actors/9cxt3wyGIo5FJFdoa/issues) section of this actor.
- If you need customization or have questions, contact the author:
  - Author's website: [Muhamed Didovic](https://muhamed-didovic.github.io/)
  - Email: <muhamed.didovic@gmail.com>

### Additional Services

- Request customization or complete dataset: <muhamed.didovic@gmail.com>
- For other scraping needs or actor customization, email: <muhamed.didovic@gmail.com>
- For API services of this scraper (no Apify fee, just usage fee for the API), contact: <muhamed.didovic@gmail.com>

***

### 🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/skool-posts-with-comments-scraper`).

**Purpose:** Scrapes Skool.com community posts or classroom course modules — with optional nested comment threads — from any Skool group your logged-in account can access.

**Minimal input:**

```json
{
  "startUrls": [{ "url": "https://www.skool.com/ai-automation-society" }],
  "tab": "community",
  "cookies": [],
  "maxItems": 50
}
```

Replace `cookies` with your exported logged-in skool.com cookies (see How to Use) — the field is required and the run cannot access group content without a valid session. Classroom variant: set `"tab": "classroom"` to scrape course modules instead of posts.

**Output (community):** one dataset row per post — `id`, `name`, `metadata {title, content, comments, upvotes, pinned, labels}`, `createdAt`, `updatedAt`, `groupId`, `userId`, `postType`, `url`, `user {id, name, firstName, lastName, metadata {bio, location, pictureProfile}}`, `comments[]` (nested; each comment has `post {metadata {content, upvotes}, created_at, user, parent_id, root_id}`). **Output (classroom):** one row per module — `type`, `title`, `postTitle`, `content`, `id`, `url`, `media[]`, `courseMetaDetails {id, name, title}`, `comments[]`.

**Behaviors an agent should know:**

- `startUrls` and `cookies` are both required. Start URLs are group URLs in the form `https://www.skool.com/{group-name}`; the actor only reaches groups the cookie's account is a member of.
- `tab` picks the mode: `"community"` (posts) or `"classroom"` (course modules). Default is `"classroom"`.
- Comments are off by default — set `includeComments: true`; `commentsLimit` caps comments per post/module (schema default 20).
- `itemStartDate` (`YYYY-MM-DD`) restricts scraping to newer posts — community tab only.
- Always set `maxItems` (schema default 10000). `includeMedia: true` plus `storeName` stores media files in a named key-value store with deduplication and long-term retention.
- Pay-per-event billing — see the Pricing tab on the actor page.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Skool, Inc. (the operator of skool.com) or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

The scraper runs on the user's own authenticated Skool session (supplied via exported cookies) and accesses only community and classroom content that the user's own account is already permitted to view — it does not bypass Skool's authentication, paywalls, or membership restrictions. Users are responsible for ensuring their use complies with skool.com's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organization.

***

### SEO Keywords

skool scraper, scrape skool, skool.com scraper, skool API, Apify skool, community posts scraper, classroom course scraper, comment thread scraper, online course scraper, course module extraction, membership community data, group content export, creator community analytics, online learning data, course content scraper, post monitoring scraper, skool group data, community engagement export, member profile scraper, discussion thread data

# Actor input Schema

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

URLs to start with. Skool community/group URLs in the format `https://www.skool.com/{group-name}`, e.g. `https://www.skool.com/ai-automation-society`. Your cookies' account must be a member of the group, or the group must be public.

## `tab` (type: `string`):

What do you want to scrape from Skool, Classroom or Community pages (tabs)?

## `includeComments` (type: `boolean`):

Set to true if you want to include comments on each post or course.

## `itemStartDate` (type: `string`):

Format should be YYYY-MM-DD, e.g., 2022-02-20

## `commentsLimit` (type: `integer`):

Maximum number of comments to scrape per post/item.

## `includeMedia` (type: `boolean`):

Set to true if you want to include media files in the output.

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

Maximum number of items to scrape, across all start URLs. The run stops once this many items are saved, and you are never charged for more results than this. Minimum 1. Default: 10000.

## `maxConcurrency` (type: `integer`):

Maximum number of pages that can be processed at the same time. Minimum 1. Default 10.

## `minConcurrency` (type: `integer`):

Minimum number of pages that will be processed at the same time. Minimum 1.

## `storeName` (type: `string`):

Assign a custom name to the Key-Value Store where your scraped listings will be saved. This ensures:

1. **Data Deduplication**: Prevents duplicate entries in the storage.
2. **Persistent Storage**: Enables long-term retention of listings, beyond default storage limits.
3. **Project Management**: Separate datasets by using unique names for different projects or analyses.
4. **Data Reuse**: Easily reference and reuse stored data without overwriting.
   (If left blank, the default storage will be used with standard retention limits.)

## `cookies` (type: `array`):

<p>Cookie used to authorize actor with skool.com. Install <a rel="noopener noreferrer nofollow" target="_blank" href="https://chrome.google.com/webstore/detail/editthiscookie/fngmhnnpilhplaeedifhccceomclgfbg" previewlistener="true">EditThisCookie</a> chrome extension. Login to your skool.com account. Click on the extension and export the skool.com cookies. Insert the contents here</p>
## `proxy` (type: `object`):

Residential proxies recommended. The default works out of the box.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.skool.com/ai-automation-society"
    }
  ],
  "tab": "classroom",
  "includeComments": false,
  "commentsLimit": 20,
  "includeMedia": false,
  "maxItems": 50,
  "maxConcurrency": 10,
  "minConcurrency": 1,
  "storeName": "media",
  "cookies": [],
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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": [
        {
            "url": "https://www.skool.com/ai-automation-society"
        }
    ],
    "maxItems": 50,
    "cookies": [],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/skool-posts-with-comments-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": [{ "url": "https://www.skool.com/ai-automation-society" }],
    "maxItems": 50,
    "cookies": [],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/skool-posts-with-comments-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": [
    {
      "url": "https://www.skool.com/ai-automation-society"
    }
  ],
  "maxItems": 50,
  "cookies": [],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call memo23/skool-posts-with-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/skool-posts-with-comments-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/9cxt3wyGIo5FJFdoa/builds/XuuNcNxdZEasI3vQE/openapi.json
