# Skool Scraper — Communities, Posts & Comments (`innolabs/skool-scraper`) Actor

Skool scraper API: extract public Skool communities (members, price, owner, rating), posts (likes, comments, author) and comment threads. No login needed.

- **URL**: https://apify.com/innolabs/skool-scraper.md
- **Developed by:** [Tristan Leroux](https://apify.com/innolabs) (community)
- **Categories:** Social media, For creators
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Skool Scraper — Communities, Posts & Comments

Extract public Skool communities, their posts and full comment threads: member counts, price, owner, rating, post titles and text, likes, comment counts, authors and nested replies. No login, no cookies and no API key needed — paste a community URL and export the results as JSON, CSV or Excel.

### What does Skool Scraper do?

Skool Scraper turns any public Skool community into clean, structured data. For each community URL or slug you give it, it returns:

- **Community details** — name, description, members, members online, total posts, price and billing interval (or "Free"), owner, rating and review count, logo and cover image, creation date.
- **Posts** — title, full text, author, category label, likes, comment count, image, created/updated dates and a direct link. Read the latest feed or search a community for a keyword.
- **Comments** (optional) — every comment and nested reply with author, text, likes, date and its parent, so you can rebuild the thread.
- **Discovery directory** (optional) — also scrape the communities currently listed on Skool's public discovery page.

Private communities still return their public community details; their posts are skipped.

### Use cases

- **Community builders and course creators** — benchmark competing communities on members, price, activity and engagement before launching or repricing yours.
- **Marketers and agencies** — find the most-liked posts and recurring questions in a niche to inspire content and offers.
- **Lead researchers** — list active Skool communities and their owners in a market, with size and price.
- **Investors and analysts** — track community growth (members, total posts) over time with scheduled runs.
- **AI and data teams** — collect post and comment text for sentiment analysis, topic modelling or RAG knowledge bases.

### How much does it cost?

You pay only for the items you get (pay-per-event). Prices per 1,000 items:

| Event | What you pay for | Free plan | Paid plans (from) |
| --- | --- | --- | --- |
| `community` | one community with its details | $3.00 | $2.00 (Gold+) |
| `post` | one post | $1.50 | $1.00 (Gold+) |
| `comment` | one comment or reply | $0.50 | $0.30 (Gold+) |

Plus a tiny platform start fee of $0.00005 per run.

**Examples (Free plan prices):**

- 1 community with its latest 50 posts: 1 × $0.003 + 50 × $0.0015 = **about $0.08**.
- 10 communities, 50 posts each, up to 20 comments per post: 10 × $0.003 + 500 × $0.0015 + 10,000 × $0.0005 = **about $5.78**.

The Apify Free plan includes $5 monthly credit, enough for thousands of posts every month.

### How to use Skool Scraper

1. Open Skool Scraper in Apify Console and click **Try for free**.
2. In **Communities**, paste one or more Skool URLs (for example `https://www.skool.com/ai-automation-society`) or just their slugs (`ai-automation-society`).
3. Optionally turn on **Include comments**, set a **Search query**, or adjust **Max posts per community**.
4. Click **Start**. When the run finishes, open the **Output** tab and download the data as JSON, CSV, Excel or HTML.
5. To automate, call the Actor from the Apify API (see [Integrations and API](#integrations-and-api)) or set up a schedule.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `communities` | array | required | Skool URLs (`https://www.skool.com/ai-automation-society/about`) or slugs (`ai-automation-society`). |
| `includePosts` | boolean | `true` | Return one item per post. |
| `includeComments` | boolean | `false` | Return comments and nested replies for every scraped post. |
| `maxPostsPerCommunity` | integer | `50` | Posts per community (up to 1,000). |
| `maxCommentsPerPost` | integer | `100` | Comments per post, replies included. |
| `query` | string | — | Search the community for this keyword instead of reading the latest feed. |
| `includeDiscovery` | boolean | `false` | Also scrape communities listed on Skool's discovery page. |
| `maxDiscoveredCommunities` | integer | `10` | How many discovery communities to add. |
| `maxItems` | integer | `1000` | Maximum items in the dataset; the run stops cleanly when reached. |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings; Apify Proxy is recommended for larger runs. |

Example:

```json
{
  "communities": ["https://www.skool.com/ai-automation-society"],
  "includeComments": true,
  "maxPostsPerCommunity": 20,
  "maxCommentsPerPost": 50
}
```

### Output

Every item has a `type` field: `community`, `post` or `comment`. Examples from a real run (long text shortened):

```json
{
  "type": "community",
  "slug": "ai-automation-society",
  "communityId": "b51c57150c70495899bf4bc8aaee8166",
  "name": "AI Automation Society",
  "url": "https://www.skool.com/ai-automation-society",
  "members": 478224,
  "description": "Learn to get paid for AI solutions, regardless of your background.",
  "price": 0.0,
  "currency": null,
  "priceInterval": null,
  "priceLabel": "Free",
  "category": null,
  "createdAt": "2024-10-15T02:49:53.91923Z",
  "public": true,
  "totalPosts": 26669,
  "onlineMembers": 1810,
  "owner": "Nate Herk",
  "rating": null,
  "reviewCount": 0,
  "logoUrl": "https://assets.skool.com/…jpg",
  "coverUrl": "https://assets.skool.com/…jpg",
  "scrapedAt": "2026-11-02T13:47:28Z"
}
```

```json
{
  "type": "post",
  "community": "ai-automation-society",
  "communityId": "b51c57150c70495899bf4bc8aaee8166",
  "postId": "353d0b255a1448a4afc5e68e0708d3d3",
  "postName": "new-video-every-claude-20-concept-explained-for-non-coders",
  "title": "🚀New Video: Every Claude 2.0 Concept Explained for Non-Coders",
  "body": "In the last six weeks Anthropic shipped three new models, …",
  "author": {
    "id": "fcb8f1ac74644b298f8268197d647ad4",
    "username": "nateherk",
    "name": "Nate Herk",
    "avatarUrl": "https://assets.skool.com/…jpg"
  },
  "createdAt": "2026-10-30T23:27:12.908891Z",
  "updatedAt": "2026-11-02T13:22:44.175457Z",
  "likes": 259,
  "commentCount": 135,
  "labelId": "e2d58b6295b940cebad1e96bb936efb1",
  "labelName": "YouTube Resources 📚",
  "imageUrl": "https://i.ytimg.com/vi/tcb5q_6jwvY/hqdefault.jpg",
  "url": "https://www.skool.com/ai-automation-society/new-video-every-claude-20-concept-explained-for-non-coders",
  "scrapedAt": "2026-11-02T13:47:28Z"
}
```

```json
{
  "type": "comment",
  "community": "ai-automation-society",
  "postId": "353d0b255a1448a4afc5e68e0708d3d3",
  "commentId": "69341f0884864569947188390e415a95",
  "parentId": "e5dc1a5258654acca3a9f5f958c1eef3",
  "depth": 1,
  "author": {
    "id": "abee52fe5acc4330873eff317593e47c",
    "username": "mike-chinea-2980",
    "name": "Mike Chinea",
    "avatarUrl": "https://assets.skool.com/…"
  },
  "body": "@Gerald Gerlich Another one to help me get to the bank.",
  "createdAt": "2026-10-31T03:04:11.431207Z",
  "likes": 14,
  "scrapedAt": "2026-11-02T13:47:34Z"
}
```

Field notes:

- `price` is `0.0` and `priceLabel` is `"Free"` for free communities; paid ones show e.g. `9.0`, `"usd"`, `"month"`, `"$9/month"`.
- `rating` is `null` until a community has reviews. `category` is `null` because Skool doesn't publish it for every community.
- For comments, `parentId` is the post ID for top-level comments and the parent comment ID for replies; `depth` is 0 for top-level and 1+ for replies.
- `body` is plain text; Skool's list formatting is converted to `- ` bullets.

### Integrations and API

Run the Actor and get results in one call with the Apify API:

```bash
curl -X POST "https://api.apify.com/v2/acts/<username>~skool-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"communities": ["https://www.skool.com/ai-automation-society"], "maxPostsPerCommunity": 20}'
```

Python with [apify-client](https://docs.apify.com/api/client/python):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("<username>/skool-scraper").call(
    run_input={"communities": ["ai-automation-society"], "includeComments": True}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["type"], item.get("title") or item.get("name"))
```

- **Make, Zapier, n8n** — use the Apify app/node to start the Actor and pass the dataset to Google Sheets, Airtable, Slack, a CRM or a database.
- **Scheduling** — create a schedule in Apify Console (e.g. daily) to track member counts and new posts over time.
- **AI agents (MCP)** — connect Claude, Cursor or other MCP clients to this Actor through the Apify MCP server at https://mcp.apify.com.
- **Webhooks** — get notified when a run finishes and fetch the dataset automatically.

### FAQ

#### Is it legal to scrape Skool?

The Actor only reads data that Skool shows publicly to any visitor without logging in: public community pages, posts and comments. It never logs in and cannot access private communities' posts. You are responsible for how you use the data, especially personal data such as names, which may be covered by GDPR or similar laws. If unsure, consult a lawyer.

#### Do I need proxies?

Small runs work without special setup. Skool limits how fast one IP address can make requests, so for runs over roughly 50 pages (many communities or many comments) keep the default Apify Proxy enabled.

#### How many posts and comments can I get?

Up to 1,000 posts per community and up to 5,000 comments per post per run, capped overall by `maxItems`. Use the search query to reach older posts about a specific topic.

#### Can I get only new posts?

Posts are returned newest first (pinned posts included) and each has a `createdAt` date and a stable `postId`. Schedule the Actor and keep the posts whose `postId` you haven't seen before, or filter by `createdAt`.

#### What happens if a community is private or a URL is wrong?

Private communities return their community details only, without posts. A misspelled or deleted community is reported in the run log and the run continues with the remaining communities. The run fails only if no items at all could be extracted.

#### Can I scrape the Classroom, members list or events?

No. These are visible only to logged-in members, and this Actor works without login.

### Limits

- Only public communities return posts and comments; private communities return community details only.
- Members lists, Classroom content, calendars and chat are not available.
- Skool rate-limits rapid requests from one IP; if that happens, the Actor stops fetching comments for that community, keeps everything already collected and reports it in the run log. Use Apify Proxy for large runs.
- Up to 1,000 posts per community and 5,000 comments per post per run.

# Changelog

This Actor's version history is a separate document: https://apify.com/innolabs/skool-scraper/changelog.md

# Actor input Schema

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

Skool community slugs or full URLs, e.g. 'ai-automation-society' or 'https://www.skool.com/ai-automation-society/about'. Public communities return posts and comments; private ones still return community details.

## `includePosts` (type: `boolean`):

Emit one item per post from each community feed.

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

Emit comment threads (nested replies included) for every scraped post. Costs one request per ~30 comments.

## `maxPostsPerCommunity` (type: `integer`):

Maximum posts read per community. The feed returns 30 posts per page.

## `maxCommentsPerPost` (type: `integer`):

Maximum comments, including nested replies, stored per post.

## `query` (type: `string`):

Optional in-community search term. When set, posts come from the community search instead of the feed.

## `includeDiscovery` (type: `boolean`):

Also scrape the first public communities listed on skool.com/discovery.

## `maxDiscoveredCommunities` (type: `integer`):

How many communities to take from the discovery directory.

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

Hard cap on dataset items. The run stops cleanly when reached.

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

Skool's CDN rate-limits datacenter IPs. Use Apify Proxy (or your own proxy URLs) for runs over ~50 requests.

## `debug` (type: `boolean`):

Verbose logs for development.

## Actor input object example

```json
{
  "communities": [
    "https://www.skool.com/ai-automation-society"
  ],
  "includePosts": true,
  "includeComments": false,
  "maxPostsPerCommunity": 50,
  "maxCommentsPerPost": 100,
  "includeDiscovery": false,
  "maxDiscoveredCommunities": 10,
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debug": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

All items produced by the run, one JSON object per record.

# 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": [
        "https://www.skool.com/ai-automation-society"
    ]
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,innolabs/skool-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/hYreNyK31Ca8zvkG6/builds/r5slNSZjbcGQLho8e/openapi.json