# Skool Communities & Courses Scraper (`crawlerbros/skool-scraper`) Actor

Scrape public Skool communities and members. Discover communities from Skool's directory, get community details (name, description, member count, price, owner), and extract visible member data from public communities

- **URL**: https://apify.com/crawlerbros/skool-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Communities & Courses Scraper

Extract public data from **Skool** — the community and online course platform. Discover communities from Skool's directory, get details for specific communities, and retrieve visible member data from public communities.

No login or API key is required. Only publicly accessible data is scraped.

---

### What It Does

- Browses Skool's public community directory (`/discover`)
- Scrapes community details: name, description, member count, price, category, owner, and thumbnail
- Extracts visible member data (top contributors visible on public community pages)
- Supports filtering by category and free/paid status
- Works with both direct URL input and community slug input

---

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | select | `discover` — browse directory; `getCommunity` — get community by URL/slug; `getMembers` — get visible members |
| `startUrls` | list | Skool community URLs (e.g. `https://www.skool.com/community-slug`) |
| `slugs` | list | Community slugs (e.g. `["the-skool-of-life", "buildwithskool"]`) |
| `category` | select | Filter by category (Technology, Business, Health & Fitness, etc.) |
| `isFree` | boolean | If true, return only free communities (default: false — all communities) |
| `sortBy` | select | Sort by: `popular`, `new`, or `trending` |
| `maxItems` | integer | Maximum records to return (1–5000, default 20) |
| `maxMembersPerCommunity` | integer | Max members per community in `getMembers` mode (1–500, default 30) |

#### Example Input — Discover Communities

```json
{
  "mode": "discover",
  "maxItems": 10
}
````

#### Example Input — Get Specific Community

```json
{
  "mode": "getCommunity",
  "slugs": ["the-skool-of-life", "buildwithskool"],
  "maxItems": 5
}
```

#### Example Input — Get Members

```json
{
  "mode": "getMembers",
  "startUrls": ["https://www.skool.com/the-skool-of-life"],
  "maxMembersPerCommunity": 30
}
```

***

### Output

#### Community Record

| Field | Type | Description |
|-------|------|-------------|
| `communityId` | string | Internal Skool community identifier |
| `name` | string | Community name |
| `slug` | string | URL slug (from skool.com/{slug}) |
| `description` | string | Community description |
| `memberCount` | integer | Number of community members |
| `price` | float | Monthly membership price (0 if free) |
| `currency` | string | Price currency (usually USD) |
| `isFree` | boolean | Whether the community is free to join |
| `owner` | string | Community owner/creator name |
| `ownerUrl` | string | Owner profile URL |
| `category` | string | Community category |
| `url` | string | Full community URL |
| `thumbnailUrl` | string | Community thumbnail image URL |
| `recordType` | string | Always `community` |
| `scrapedAt` | string | ISO 8601 timestamp |

#### Member Record

| Field | Type | Description |
|-------|------|-------------|
| `username` | string | Member username/slug |
| `displayName` | string | Member display name |
| `profileUrl` | string | Member profile URL |
| `role` | string | Member role: `admin`, `moderator`, or `member` |
| `points` | integer | Community contribution points |
| `communityName` | string | Name of the community |
| `communityUrl` | string | URL of the community |
| `recordType` | string | Always `member` |
| `scrapedAt` | string | ISO 8601 timestamp |

#### Example Community Output

```json
{
  "communityId": "abc123",
  "name": "The Skool of Life",
  "slug": "the-skool-of-life",
  "description": "Learn, grow, and connect with a global community.",
  "memberCount": 15000,
  "price": 0.0,
  "currency": "USD",
  "isFree": true,
  "owner": "Sam Ovens",
  "ownerUrl": "https://www.skool.com/@samovens",
  "category": "Education",
  "url": "https://www.skool.com/the-skool-of-life",
  "thumbnailUrl": "https://...",
  "recordType": "community",
  "scrapedAt": "2026-05-17T10:00:00+00:00"
}
```

***

### FAQ

**Q: What is Skool?**
Skool is a community and online course platform where creators can build paid or free communities with discussion boards, courses, and member engagement features.

**Q: Can I scrape private or paid communities?**
No. This actor only scrapes data that is publicly visible without a login. Some paid communities restrict what is visible to non-members.

**Q: How do I find a community's slug?**
The slug is the part of the URL after `skool.com/`. For example, in `https://www.skool.com/the-skool-of-life`, the slug is `the-skool-of-life`.

**Q: Will the discover mode return all communities?**
The `discover` mode fetches Skool's public discovery page. If the page does not return structured data, the actor falls back to a curated list of well-known public communities. The total number is limited by the `maxItems` setting.

**Q: Why are some member fields missing?**
Skool only shows top contributors publicly on community pages. Full member lists are only visible to community members. Only the fields that can be reliably populated from public data are included in the output — empty fields are omitted.

**Q: Do I need a proxy?**
No. Skool public pages are accessible from datacenter IPs without a proxy. If you encounter rate limiting on large runs, adding a delay between requests is recommended.

**Q: What categories are available?**
Technology, Business, Health & Fitness, Arts & Creativity, Education, Gaming, Lifestyle, Finance, Marketing, and Other. Use the `category` filter to narrow results.

***

### Limitations

- Only **publicly accessible** data is scraped — member profiles and private community content require login.
- The `getMembers` mode only returns **top contributors** visible on the public community page. Full member lists are not publicly accessible.
- Skool's site structure may change; if the actor stops working correctly, it may need updates.
- The `discover` mode depends on Skool's public discovery page; if that page changes, the actor falls back to a curated list of known communities.
- Sorting (`popular`, `new`, `trending`) in discover mode depends on what Skool's API returns — client-side re-sorting by member count is applied for `popular`.

# Actor input Schema

## `mode` (type: `string`):

What to scrape: discover communities from directory, get details for specific communities, or list visible members.

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

Skool community URLs to scrape, e.g. https://www.skool.com/the-skool-of-life. Accepts strings or {"url": "..."} objects.

## `slugs` (type: `array`):

Community slugs from the Skool URL, e.g. \["the-skool-of-life", "buildwithskool"]. Alternative to startUrls.

## `category` (type: `string`):

Filter communities by category. Leave blank for all categories.

## `isFree` (type: `boolean`):

If enabled, only return communities with free membership. Default includes all (free and paid).

## `sortBy` (type: `string`):

Sort communities in discover mode.

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

Maximum number of records to emit (communities or members combined).

## `maxMembersPerCommunity` (type: `integer`):

Maximum number of members to extract per community.

## Actor input object example

```json
{
  "mode": "discover",
  "startUrls": [],
  "slugs": [],
  "category": "",
  "isFree": false,
  "sortBy": "popular",
  "maxItems": 20,
  "maxMembersPerCommunity": 30
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing all scraped Skool communities and member records.

# 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 = {
    "mode": "discover",
    "startUrls": [],
    "slugs": [],
    "category": "",
    "isFree": false,
    "sortBy": "popular",
    "maxItems": 20,
    "maxMembersPerCommunity": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/skool-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 = {
    "mode": "discover",
    "startUrls": [],
    "slugs": [],
    "category": "",
    "isFree": False,
    "sortBy": "popular",
    "maxItems": 20,
    "maxMembersPerCommunity": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/skool-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 '{
  "mode": "discover",
  "startUrls": [],
  "slugs": [],
  "category": "",
  "isFree": false,
  "sortBy": "popular",
  "maxItems": 20,
  "maxMembersPerCommunity": 30
}' |
apify call crawlerbros/skool-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skool Communities & Courses Scraper",
        "description": "Scrape public Skool communities and members. Discover communities from Skool's directory, get community details (name, description, member count, price, owner), and extract visible member data from public communities",
        "version": "1.0",
        "x-build-id": "cnq1ho0kvY1mgirnf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~skool-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-skool-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~skool-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-skool-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~skool-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-skool-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "discover",
                            "getCommunity",
                            "getMembers"
                        ],
                        "type": "string",
                        "description": "What to scrape: discover communities from directory, get details for specific communities, or list visible members.",
                        "default": "discover"
                    },
                    "startUrls": {
                        "title": "Community URLs (mode=getCommunity / getMembers)",
                        "type": "array",
                        "description": "Skool community URLs to scrape, e.g. https://www.skool.com/the-skool-of-life. Accepts strings or {\"url\": \"...\"} objects.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "slugs": {
                        "title": "Community slugs (mode=getCommunity / getMembers)",
                        "type": "array",
                        "description": "Community slugs from the Skool URL, e.g. [\"the-skool-of-life\", \"buildwithskool\"]. Alternative to startUrls.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category filter",
                        "enum": [
                            "",
                            "Technology",
                            "Business",
                            "Health & Fitness",
                            "Arts & Creativity",
                            "Education",
                            "Gaming",
                            "Lifestyle",
                            "Finance",
                            "Marketing",
                            "Other"
                        ],
                        "type": "string",
                        "description": "Filter communities by category. Leave blank for all categories.",
                        "default": ""
                    },
                    "isFree": {
                        "title": "Free communities only",
                        "type": "boolean",
                        "description": "If enabled, only return communities with free membership. Default includes all (free and paid).",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "popular",
                            "new",
                            "trending"
                        ],
                        "type": "string",
                        "description": "Sort communities in discover mode.",
                        "default": "popular"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of records to emit (communities or members combined).",
                        "default": 20
                    },
                    "maxMembersPerCommunity": {
                        "title": "Max members per community (mode=getMembers)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of members to extract per community.",
                        "default": 30
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
