# Skool Post & Comment Scraper (`goat255/skool-post-scraper`) Actor

Bulk export posts and full comment threads (with nested replies) from any Skool.com community you have joined. Get author profiles, engagement, date filters and multi-group runs, with residential proxies built in. Ideal for community research, lead generation and engagement analysis.

- **URL**: https://apify.com/goat255/skool-post-scraper.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 13 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $8.00 / 1,000 posts

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Posts & Comments Scraper Goat - Extract Posts, Comments & Replies from Skool Communities

Scrape posts and full comment threads (with nested replies) from any Skool.com community you have joined. Bulk-export Skool community content, conversations, engagement metrics, and author profiles in clean JSON - no Skool API key, no manual copy-paste.

> **Part of the Skool Scraper Goat suite:**
>
> - 🏘️ [Skool Community & MRR Scraper Goat](https://apify.com/goat255/skool-scraper-goat) - discover communities with pricing and MRR.
> - 👥 [Skool Member Scraper Goat](https://apify.com/goat255/skool-member-scraper-goat) - member profiles + email/contact enrichment.
> - 🧰 [Skool All-in-One Scraper Goat](https://apify.com/goat255/skool-all-in-one-scraper-goat) - communities + members + posts in one run.

### What this Skool post scraper does

Point it at one or more Skool group URLs (or just group names) you've joined, paste your Skool cookies once, and the actor returns one clean record per post containing:

- Post **title**, full **content**, post URL, post type, created/updated timestamps
- Engagement: **upvote count**, **comment count**, pinned flag
- **Author profile** - name, bio, picture, MRR status, full social links
- **Contributors** (everyone tagged on the post)
- **Attachments**, image preview, video IDs, label IDs
- **Nested comment threads** (optional) with full reply tree
- Comment author profiles, upvotes, created/updated dates
- Date-range filtering (`postsDateFrom` / `postsDateTo`)

Perfect for **community research, content audits, sentiment analysis, lead extraction, and AI training data** on the Skool platform.

### Why use this scraper

- **No URL needed** - list all the communities your account has joined, or paste community names instead of full URLs.
- **Posts and comments in one pass** - comments are nested directly inside each post, with optional reply trees.
- **Date filtering** - only scrape posts created in your target window, not the whole archive.
- **Residential proxy rotation** with adaptive retry/backoff - survives Skool's rate limits.
- **No primary-key surprises** - pay per post and per comment separately, only scrape comments when you ask for them.
- Works for any group you have joined, including private and paid communities.

### What data you get per post

```json
{
  "groupUrl": "https://www.skool.com/example-community",
  "groupName": "example-community",
  "postId": "00000000000000000000000000000000",
  "postUrl": "https://www.skool.com/example-community/welcome-start-here",
  "title": "Welcome - start here",
  "content": "Hey everyone! Here's how to get the most from this community...",
  "createdAt": "2026-05-17T16:21:28Z",
  "upvotes": 32,
  "commentCount": 12,
  "pinned": true,
  "author": {
    "handle": "jane-doe-1234",
    "firstName": "Jane",
    "social": {
      "instagram": "https://www.instagram.com/example",
      "linkedin": "https://www.linkedin.com/in/example",
      "youtube": "https://www.youtube.com/@example"
    }
  },
  "comments": [
    {
      "content": "Loved it!",
      "upvotes": 3,
      "author": { "handle": "alex-smith-5678", "firstName": "Alex" },
      "replies": [
        { "content": "Same here", "author": { "handle": "sam-roe-9012", "firstName": "Sam" } }
      ]
    }
  ]
}
```

### How to use the Skool Post Scraper

1. **Join the target Skool communities** with the account you'll use for scraping (membership is mandatory - Skool hides feeds from non-members, even on "public" groups).
2. **Export your Skool cookies** with the free Cookie-Editor browser extension (JSON export, all skool.com cookies).
3. Open the actor on Apify Store, click **Try for free**.
4. Paste the cookies into the `cookies` input field.
5. Pick targets in **Group URLs or Names** - paste full URLs (`https://www.skool.com/groupname`) or just the names (`groupname`). **Leave it empty to scrape every community your account has joined.**
6. Set `maxPostsPerGroup`, toggle **Get Comments** if you want comment threads, optionally set `commentsPerPost`, `includeReplies`, and `postsDateFrom`/`postsDateTo` filters.
7. Click **Save & start**. Download in JSON / CSV / Excel / XML / HTML.

### Top use cases

- **Content audits** - export everything posted in your own communities for analysis.
- **Community research** - what topics drive the most engagement in your competitors' Skool groups.
- **Lead extraction** - pull active community members from comment threads with their social links.
- **AI training data** - clean Q\&A and discussion threads for model fine-tuning.
- **Sentiment analysis** - analyse community feedback at scale across multiple groups.
- **Archive backup** - snapshot posts before content is edited or deleted.

### Pricing

Pay-per-event. You only pay for comments when you enable comment scraping.

| Event | Price |
|---|---|
| Post scraped (primary) | $0.005 |
| Comment scraped | $0.0015 |

You only pay for comments when you enable comment scraping, and failed/empty fetches are never billed. Apify's $5 platform free credit applies on first use - that's ~1,000 free posts.

### FAQ

#### Why are cookies required?

Skool blocks the post feed for non-members on every group, even "public" ones - an unauthenticated request is 307-redirected to the marketing/about page with zero posts visible. The cookies prove the account has joined the group.

#### Are public Skool group posts accessible without joining?

**No.** Confirmed via live testing: Skool returns the post feed only to authenticated members. You must join each group with the account whose cookies you use.

#### Can I scrape posts from multiple groups in one run?

Yes - pass multiple group URLs or names in the input, or leave `groupUrls` empty to automatically scrape every community your account has joined.

#### Does it scrape private and paid Skool communities?

Yes, as long as the account you're using has joined them. The scraper respects the same access as the user.

#### How fast is it?

\~5-8 seconds per post including residential proxy rotation. A full 17-community sweep (12 posts each, 5 comments per post) runs in about 8 minutes.

#### What if Skool rate-limits me?

Built-in: exponential backoff, fresh proxy session per retry, adaptive concurrency. The actor survives 403/429 transient errors automatically.

#### Can I filter by date?

Yes - set `postsDateFrom` and/or `postsDateTo` (ISO `YYYY-MM-DD`).

### Related Apify actors

- 🏘️ [Skool Community & MRR Scraper Goat](https://apify.com/goat255/skool-scraper-goat) - discover communities by keyword, extract pricing and MRR.
- 👥 [Skool Member Scraper Goat](https://apify.com/goat255/skool-member-scraper-goat) - member profiles with real emails and contact enrichment.
- 🧰 [Skool All-in-One Scraper Goat](https://apify.com/goat255/skool-all-in-one-scraper-goat) - communities + members + posts in one run.

### Support

Issues, missing fields, or feature requests? Open an issue on the actor page. Reviews are read and replied to.

### Privacy

To improve our actors we collect anonymized usage telemetry (run stats and input patterns). No personal account data is collected.

# Actor input Schema

## `listCommunitiesOnly` (type: `boolean`):

When enabled, the actor only lists the communities your account has joined (name, URL, members, posts) and stops. Use this first to pick which communities to scrape, then paste their names or URLs into Group URLs. Requires cookies.

## `groupUrls` (type: `array`):

Communities to scrape posts from. Accepts either full Skool URLs (https://www.skool.com/groupname) or just the community name/slug (groupname). Replace the placeholder with your own. Leave this EMPTY to scrape every community your account has joined. You must be a member of each group and supply cookies from the same account; Skool blocks the post feed for non-members even on public groups.

## `maxPostsPerGroup` (type: `integer`):

Maximum number of posts to collect per group. The feed is ordered by most recent comment activity.

## `scrapeComments` (type: `boolean`):

Also scrape the comments on each post. When off, only the posts themselves are returned (faster, cheaper).

## `commentsPerPost` (type: `integer`):

Maximum comments to collect per post (only applies when Get Comments is on).

## `includeReplies` (type: `boolean`):

Nest replies under their parent comment. When off, only top-level comments are returned.

## `postsDateFrom` (type: `string`):

Only include posts created on or after this date (YYYY-MM-DD). Leave empty for no lower bound.

## `postsDateTo` (type: `string`):

Only include posts created on or before this date (YYYY-MM-DD). Leave empty for no upper bound.

## `batchSize` (type: `integer`):

Number of posts processed per batch before saving to the dataset. Recommended 30-75.

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

Parallel requests. Default 10 is reliable. Values above 15 may trigger rate limits on Skool. Max 30.

## `maxRetries` (type: `integer`):

Retry attempts per failed request. Each retry uses a new proxy session with exponential backoff.

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

Cookies from Skool.com for an account that has joined the target groups. Export with the Cookie-Editor browser extension (export all skool.com cookies as JSON). Required - the post feed is gated behind authentication.

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

Proxy settings. Residential proxies are required - Skool blocks datacenter IPs.

## Actor input object example

```json
{
  "listCommunitiesOnly": false,
  "groupUrls": [
    "https://www.skool.com/your-skool-group-here"
  ],
  "maxPostsPerGroup": 100,
  "scrapeComments": false,
  "commentsPerPost": 50,
  "includeReplies": true,
  "batchSize": 50,
  "maxConcurrency": 10,
  "maxRetries": 4,
  "cookies": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `posts` (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 = {
    "groupUrls": [
        "https://www.skool.com/your-skool-group-here"
    ],
    "batchSize": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/skool-post-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 = {
    "groupUrls": ["https://www.skool.com/your-skool-group-here"],
    "batchSize": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("goat255/skool-post-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 '{
  "groupUrls": [
    "https://www.skool.com/your-skool-group-here"
  ],
  "batchSize": 50
}' |
apify call goat255/skool-post-scraper --silent --output-dataset

```

## MCP server setup

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