# Skool Communities Scraper (`nice_dev/skool-communities-scraper`) Actor

Scrape the whole Skool community directory: members, price, rating, owner contacts, and the posts, members, classroom and calendar of public communities.

- **URL**: https://apify.com/nice\_dev/skool-communities-scraper.md
- **Developed by:** [Nice Dev](https://apify.com/nice_dev) (community)
- **Categories:** Lead generation, Social media, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.19 / 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

### 👥 What is Skool Communities Scraper?

Extract the **whole Skool community directory** — not the first thousand results, all of it — with members, price, posts, courses, rating and owner contacts, and optionally everything a public community holds: its posts, comments, members, classroom, calendar and leaderboards.

Skool Communities Scraper reads [skool.com](https://www.skool.com) and turns it into a table. Search the directory by keyword, paste the URL of a community, a post or a member profile, or ask for the **entire directory of 74 000+ communities** in one run. Every community comes back with its slug, member count, exact price and billing period, number of posts and courses, rating, and its owner's bio, website and social links.

Try it in one click: press **Start** — the pre-filled input searches `ai automation` and returns 100 communities in under two minutes.

It runs on the Apify platform, so you get a REST **API**, scheduling, webhooks, integrations with Google Sheets, Slack, Make and Zapier, automatic retries and monitoring, and the export formats below, without hosting anything yourself.

### 📋 What data can you extract from Skool?

One row per community, **130 fields** in all — and, when you ask for them, extra rows for what a community holds: its posts, comments, members, courses, lessons, events and leaderboard entries. The `itemType` column says what a row is; a field that does not apply to a row is empty, so every export has the same columns.

| Category | What you get |
| --- | --- |
| 👥 **Community** | name, link, slug, short description, language, keywords, logo and cover — `AI Automation Society` |
| 💰 **Price and revenue** | exact price, currency, billing period, price per month, free trial, affiliate commission, estimated monthly revenue — `49 USD / month` |
| 📈 **Size and activity** | members, members online, number of posts, courses and modules — `4,405 members`, `17 courses` |
| ⭐ **Reputation** | rating, number of reviews and the latest reviews — `4.9 (23 reviews)` |
| 🧑 **Owner** | name, bio, location, website and social links (Facebook, Instagram, LinkedIn, X, YouTube) |
| 📄 **About page** | long sales text, custom links, levels, join questions, landing-page media |
| 💬 **Posts and comments** | title, text, upvotes, number of comments, attachments, video links, author |
| 🎓 **Classroom and calendar** | courses and lessons (text and video), events with their start and end times |
| 🏆 **Members and leaderboards** | name, bio, location, level, points, rank, social links, join date |
| 🕒 **Dates** | creation and update dates — what the date filters read |

Every field, with an example, is listed in the **Output** section below.

### ✅ Why use Skool Communities Scraper?

- **The whole directory, not a sample.** A keyword search on Skool stops at 1 000 results. Tick **Whole directory** and the Actor goes through the complete index — 74 000+ communities, private ones included — in a single run.
- **Find creators worth contacting.** Filter on members, monthly price, number of posts and courses, rating, estimated monthly revenue, or keep only the communities whose owner published a way to reach them.
- **No account needed for public communities.** Posts, comments, courses, calendars and leaderboards of PUBLIC communities are read without any login. Paste your own Skool cookie only if you want the private communities you belong to, or the full member list.
- **Built to run often.** The proxy is included in the price, and **Only new items** returns just what appeared since the last run.
- **Market research, lead lists, competitor tracking, price benchmarks**: schedule it weekly and let it feed your own tools.

### 🚀 How to scrape Skool

1. Click **Try for free** (or **Start** if you already have an account).
2. Type a keyword in **Search keyword**, or tick **Whole directory** to take the lot.
3. Optional: set **Max communities** (100 by default, 0 = no limit), the filters (members, price, rating…), and the extras (posts, members, classroom…).
4. Press **Start** and watch the log.
5. When the run ends, open the **Storage** tab and download the dataset as **JSON, CSV, Excel, XML or HTML** — or call the API to get it straight into your own tool.

### 💰 How much does it cost to scrape Skool?

The Actor uses **pay per event** pricing: **$0.25 per 1,000 results**, whatever the kind of row, plus **$0.001 per run start** at the Actor's default memory (10 cents per 100 runs; the platform counts that event once per gigabyte, so a run you give more memory pays proportionally more). Higher Apify plans pay less per result: $0.23 (Bronze), $0.21 (Silver) and $0.19 (Gold and above) per 1,000. Filters that Skool's directory does not offer are applied by the Actor on every community it reads: a community you keep costs its normal price, a community a filter drops costs **$0.04 per 1,000** when **Exclude keywords** drops it, and **$0.20 per 1,000** when a filter that reads the community profile drops it — **Created after / before**, **Min / Max members**, **Min / Max monthly price**, **Min posts**, **Min courses**, **Min rating**, **Min / Max estimated MRR**, **With a contact only** or **With an affiliate programme only** — $0.038 and $0.19 on Bronze, $0.036 and $0.18 on Silver, $0.034 and $0.17 on Gold and above. Filtering never costs more than taking everything. Platform usage (compute, proxy) is included in the price. A run that finds nothing only pays the start fee, plus the communities its filters dropped.

| Event | What it is |
|---|---|
| Actor start | A small fee when a run starts. |
| Result | One row of the dataset, whatever its kind: a community with its profile and About page, a post, a comment, a member, a course, a lesson, an event or a leaderboard entry. Every row has the same price. |
| Filter check | One community of the directory dropped by **Exclude keywords** (a community you keep costs its normal price). |
| Detail filter check | One community profile dropped by a filter that needs it (dates, members, price, posts, courses, rating, revenue, contact, affiliate program); a community you keep costs its normal price. |

Examples: 1,000 communities with their profile and About page ≈ $0.25; the whole directory of 74,000+ communities ≈ $19. The filters are applied by the Actor on every community it reads: a community filtered out is never saved as a result, it only costs its filter fee, lower than a result; a community you keep costs its normal price. A community skipped by **Only new items** is never charged.

Speed, measured on the Apify platform with the default settings: 100 communities in under 2 minutes, 1,000 communities in about 10 minutes. The whole directory is about 75 index calls plus two requests per community (one if you turn off **About page**), so it runs for many hours: raise the run **Timeout** in the run options (the default is one hour, about 6,000 communities), give it more memory and a higher **Max concurrency**, or split it with the filters.

### ⚙️ Input

Everything is optional: with no input at all the Actor returns the first 100 communities of the directory. You can give several keywords in one run (up to 101: **Search keyword** plus 100 in **More search keywords**), and up to 1 000 start URLs.

Search the directory by keyword:

```json
{
    "query": "ai automation",
    "maxItems": 200,
    "minMembers": 500,
    "minRating": 4
}
```

Take the whole directory, paid communities only, and keep the big ones:

```json
{
    "allCommunities": true,
    "priceType": "paid",
    "minMembers": 1000,
    "minMrr": 10000,
    "maxItems": 0
}
```

One community with everything it holds:

```json
{
    "startUrls": [{ "url": "https://www.skool.com/ai-automation-society" }],
    "scrapePosts": true,
    "maxPostsPerCommunity": 50,
    "includeComments": true,
    "scrapeMembers": true,
    "scrapeClassroom": true,
    "scrapeCalendar": true,
    "scrapeLeaderboards": true
}
```

Watch a keyword and get only what is new, every day:

```json
{
    "query": "copywriting",
    "onlyNew": true,
    "stateKey": "copywriting-watch"
}
```

#### Input fields

| Field | What it does |
|---|---|
| `startUrls` | Skool URLs: a community (`https://www.skool.com/my-group`), a discovery search (https://www.skool.com/discovery?q=ai), a single post (https://www.skool.com/my-group/my-post) or a member profile (https://www.skool.com/@handle). When this list is not empty, the search fields below (keyword, whole directory) are ignored; filters, caps and monitoring still apply. Max 1 000 URLs. |
| `query` | Free-text search of the Skool directory, exactly as typed on skool.com/discovery (e.g. `ai automation`). Empty = the directory without a keyword. |
| `searchQueries` | Several keywords in one run: one search per keyword. Added to **Search keyword**; a community found by several searches is saved once. |
| `allCommunities` | Go through the ENTIRE Skool directory (74 000+ communities, private ones included) instead of searching by keyword. A keyword search stops at 1 000 communities — this does not. Combine with **Max communities** and the filters below to keep the run short. Default: off. |
| `language` | Language declared by the community. |
| `priceType` | Keep only free communities, or only paid ones. |
| `privacyType` | A private community still gives its profile (members count, price, posts, courses, owner); its posts, members and courses are only readable with a **Skool cookie** of a member. |
| `hasFreeTrial` | Keep only the paid communities that offer a free trial. Default: off. |
| `maxItems` | Maximum number of communities to save for the whole run (after deduplication and filters). Posts, comments, members and lessons are not counted here — they have their own caps. `0` = no limit. Default: 100. |
| `maxItemsPerQuery` | Cap for EACH search (keyword or start URL), so that the first search cannot use up the whole **Max communities** budget. 0 = no per-search cap. Default: 0. |
| `includeAbout` | Also read the public About page of each community (1 extra request): long description, custom links, gamification levels, number of rules, join survey questions and the latest reviews. Off = the community profile only (name, slug, members, price, posts, courses, rating, owner), which is always read. Default: on. |
| `scrapePosts` | Save the posts of each community (30 per request): title, text, upvotes, comment count, attachments, videos, channel and full author. Default: off. |
| `maxPostsPerCommunity` | 0 = every post (a large community can hold 20 000+). Default: 100. |
| `includeComments` | Save the comments of each extracted post (1 extra request per post), with their nested replies. Default: off. |
| `maxCommentsPerPost` | Top-level comments kept per post, each with its replies. Skool gives at most 30 top-level comments per post: 0 = those 30. Default: 25. |
| `maxRepliesPerComment` | Replies kept under each comment. 0 = every reply. Default: 0. |
| `scrapeMembers` | Save the members of each community: name, bio, location, social links, time zone, level, points, join date, last seen and role. Skool shows only ~30 members to a visitor — paste a **Skool cookie** below to get the whole list. Default: off. |
| `maxMembersPerCommunity` | 0 = every member Skool returns (~30 without a cookie). Default: 30. |
| `memberTab` | All members, admins only (the full admin list is public) or members online now. |
| `includeMemberProfiles` | Also read the public Skool profile of each extracted member (1 extra request per member): followers, following, total contributions, and the list of the communities they are a member of. Default: off. |
| `scrapeClassroom` | Save the courses of each community and their lessons: title, description, cover, section, video link, video length, thumbnail and attached resources. Locked courses are reported as locked, without their lessons. Default: off. |
| `includeLessonContent` | Also read the written content of each lesson (1 extra request per lesson — a 50-lesson course means 50 requests). Default: off. |
| `maxLessonsPerCourse` | 0 = every lesson. Default: 0. |
| `scrapeCalendar` | Save the upcoming events of each community: title, description, start and end time, link. Default: off. |
| `scrapeLeaderboards` | Save the leaderboards of each community (top members by points) for the chosen period. Default: off. |
| `leaderboardWindow` | Which leaderboard to save. |
| `cookies` | The auth\_token cookie of YOUR Skool account (DevTools › Application › Cookies › skool.com), pasted as auth\_token=... or as the whole cookie header. Your account only sees what it is a member of. Leave empty to scrape public data only. |
| `postedAfter` | Only items created on or after this date: 2026-09-01 (a day starts at midnight UTC, the zone of every date saved), or a period before now such as `7 days`, 2 weeks, 1 month (API: 24 hours and full ISO date-times work too). Read on the creation date of a community, a post or a comment, and on the day a member joined; courses, lessons, events and leaderboard entries carry no date and are always kept. A community pasted in **Start URLs** with its posts, members… asked for is always saved: the dates then pick its content. |
| `postedBefore` | Only items created on or before this date (the whole day is included, until midnight UTC), or older than a period such as `30 days`. |
| `excludeKeywords` | Drop the items whose name or title contains one of these words (case and accents ignored). |
| `minMembers` | Keep only communities with at least this many members. 0 = no minimum. Default: 0. |
| `maxMembers` | Keep only communities with at most this many members (to find small ones). 0 = no maximum. Default: 0. |
| `minMonthlyPrice` | Keep only communities whose price, brought back to one month, is at least this. 0 = no minimum. Default: 0. |
| `maxMonthlyPrice` | Keep only communities whose price, brought back to one month, is at most this. 0 = no maximum. Default: 0. |
| `minPosts` | Keep only communities with at least this many posts (an active community). 0 = no minimum. Default: 0. |
| `minCourses` | Keep only communities with at least this many courses in their classroom. 0 = no minimum. Default: 0. |
| `minRating` | Keep only communities rated at least this (1 to 5). Communities with no review are dropped. 0 = no minimum. Default: 0. |
| `minMrr` | Keep only communities whose ESTIMATED monthly revenue (members × monthly price) is at least this. It is an estimate computed from public numbers, not a figure published by Skool. 0 = no minimum. Default: 0. |
| `maxMrr` | Same, as a maximum. 0 = no maximum. Default: 0. |
| `requireContact` | Keep only communities whose owner shows at least one way to be reached: website, e-mail or a social network. Default: off. |
| `hasAffiliateProgram` | Keep only communities that pay a commission to the members who bring new paying members. The commission itself is in the Affiliate commission (%) column of every result. Default: off. |
| `onlyNew` | Skip the communities, posts, comments, members and lessons that a previous run (same **Memory key**) already delivered: they are not saved and not charged, and their page is not even opened. First run = everything is new. Default: off. |
| `stateKey` | Name of the memory used by **Only new items**. Give each schedule / task its own key (e.g. `ai-communities`) so that they do not share their memory. Letters, digits, - and \_. |
| `resetState` | Forget everything remembered under this **Memory key** before the run: this run returns (and charges) every item again. Untick it afterwards. Default: off. |
| `proxyConfiguration` | Apify Proxy or your own proxies. Keep the default: it is included in the price. The residential Apify proxy is not available in this Actor. |
| `maxConcurrency` | Maximum number of requests processed in parallel. A community's About page is read right after its profile, in the same slot: never more than this many calls to Skool at once. Default: 8. |
| `maxRequestsPerMinute` | Global request rate. Lower it if the site answers HTTP 429 / 403 in the log. It counts the profile of a community and its About page as ONE request: with **About page** on, up to twice this number of calls reach Skool per minute — halve it to keep the same pace. Default: 300. |
| `minRequestIntervalMs` | Smallest gap between two calls to Skool, in milliseconds — the About page included. The per-minute rate lets a burst through; this spreads the calls evenly. 0 = no gap (Skool has shown no per-second limit). Default: 0. |
| `maxRequestRetries` | Retries per request before it is marked as failed. Default: 5. |
| `debugLog` | Include debug messages in the run log. Default: off. |

### 📦 Output

One row per item, in the dataset of the run:

```json
{
    "itemType": "community",
    "id": "64ab25f02f6f42fe90f0f9d989aa86bb",
    "url": "https://www.skool.com/ai-automation-society",
    "communitySlug": "ai-automation-society",
    "name": "AI Automation Society",
    "description": "Build your own AI Operating System.",
    "language": "english",
    "privacy": "public",
    "isPaid": true,
    "price": 49,
    "currency": "USD",
    "priceInterval": "month",
    "monthlyPrice": 49,
    "estimatedMrr": 215845,
    "totalMembers": 4405,
    "totalPosts": 24838,
    "numCourses": 17,
    "rating": 4.9,
    "reviewCount": 23,
    "ownerHandle": "nateherk",
    "ownerName": "Nate Herk",
    "ownerYoutube": "https://www.youtube.com/@nateherk",
    "createdAt": "2024-01-05T16:07:10.269Z",
    "scrapedAt": "2026-09-20T12:00:00.000Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV or Excel.

#### All 130 fields

| Field | What it holds |
|---|---|
| `itemType` | Item type — community / post / comment / member / course / lesson / event / leaderboardEntry. |
| `id` | ID — Skool id of the item. An event that repeats: its id, a colon, then the start of that date as a UNIX time. |
| `url` | URL — Public Skool page of the item. |
| `communityId` | Community ID |
| `communitySlug` | Community slug |
| `communityName` | Community name |
| `communityUrl` | Community URL |
| `name` | Name — Community: its display name. Member: full name. Post / lesson / course / event: its title. |
| `description` | Description — Short description of the community, of the course or of the event. |
| `aboutDescription` | About text — Long landing-page text of the community (with About page on). |
| `keywords` | Keywords — Keywords declared by the community (directory only). |
| `language` | Language |
| `privacy` | Privacy — public or private. |
| `isPaid` | Paid |
| `hasFreeTrial` | Free trial |
| `affiliatePercent` | Affiliate commission (%) |
| `membershipModel` | Membership model — free or paid, read from the community's own billing settings. |
| `price` | Price — Numeric price of the membership; null when the community is free or shows no price. |
| `currency` | Currency |
| `priceInterval` | Billing period — month, year or one\_time. |
| `monthlyPrice` | Monthly price — Price brought back to one month (a yearly price divided by 12), to compare communities. Empty for a price paid once. Read by the price filters. |
| `estimatedMrr` | Estimated MRR — Members × monthly price. An estimate computed from public numbers, NOT a figure published by Skool: members who joined for free or at another price are not known. |
| `totalMembers` | Members |
| `totalOnlineMembers` | Members online |
| `totalAdmins` | Admins |
| `totalPosts` | Posts — Community: posts published in it. Member profile: posts written by the member. |
| `numCourses` | Courses |
| `numModules` | Lessons — Number of lessons (modules) across all courses. |
| `totalRules` | Rules |
| `rating` | Rating — Average review score out of 5; null when the community has no review. |
| `reviewCount` | Reviews |
| `reviews` | Latest reviews — Latest public reviews (About page on): rating, text, author, date. |
| `levels` | Levels — Gamification levels of the community: number, title, share of members. |
| `customLinks` | Custom links — Links the community shows in its sidebar: label and URL. |
| `surveyQuestions` | Join questions — Questions asked to a candidate before joining. |
| `visibleTabs` | Visible tabs — Tabs the community shows: classroom, calendar, leaderboards, about… |
| `plugins` | Plugins — Skool plugins the community has switched on: auto-DM, Zapier, webhook, Google Ads, Meta conversions, Hyros. |
| `landingPageMedia` | Landing page media — Images and videos of the sales page of the community. |
| `logoUrl` | Logo |
| `coverUrl` | Cover image |
| `color` | Colour |
| `ownerId` | Owner ID |
| `ownerHandle` | Owner handle |
| `ownerName` | Owner name |
| `ownerFirstName` | Owner first name |
| `ownerLastName` | Owner last name |
| `ownerBio` | Owner bio |
| `ownerLocation` | Owner location |
| `ownerProfileUrl` | Owner profile |
| `ownerPictureUrl` | Owner picture |
| `ownerWebsite` | Owner website |
| `ownerEmail` | Owner e-mail — Only when the community publishes a support e-mail; null otherwise (Skool hides member e-mails). |
| `ownerFacebook` | Owner Facebook |
| `ownerInstagram` | Owner Instagram |
| `ownerLinkedin` | Owner LinkedIn |
| `ownerTwitter` | Owner X / Twitter |
| `ownerYoutube` | Owner YouTube |
| `ownerTimezone` | Owner time zone |
| `ownerMyersBriggs` | Owner Myers-Briggs |
| `ownerDiscTop` | Owner DISC type — Dominant DISC personality letter declared by the owner. |
| `ownerLastSeenAt` | Owner last seen — ISO 8601 UTC. |
| `ownerIsOnline` | Owner online now |
| `ownerCreatedAt` | Owner account created |
| `ownerUpdatedAt` | Owner account updated |
| `ownerBadge` | Owner badge — Skool revenue badge shown on the owner profile (diamond, platinum…). |
| `title` | Title — Post, lesson, course or event title. |
| `content` | Content — Text of the post, of the comment or of the lesson. |
| `postType` | Post type |
| `channel` | Channel — Channel (label) the post was published in. |
| `upvotes` | Upvotes |
| `commentCount` | Comments |
| `isPinned` | Pinned |
| `attachments` | Attachments — Files attached to the post or resources attached to the lesson. |
| `videoLinks` | Videos — Video URLs of the post. |
| `imageUrl` | Image — Preview image of the post. |
| `contributors` | Contributors — Members who commented on the post, as Skool lists them. |
| `postId` | Post ID — Post the comment belongs to. |
| `parentId` | Parent comment ID — Comment this reply answers; null for a top-level comment. |
| `depth` | Reply depth — 0 = top-level comment, 1 = reply, 2 = reply to a reply. |
| `courseId` | Course ID |
| `courseTitle` | Course title |
| `sectionTitle` | Section title — Section of the course the lesson belongs to. |
| `hasAccess` | Unlocked — false = the course or lesson is locked for a visitor; its content is not returned. |
| `minAccessLevel` | Min level — Gamification level needed to unlock the course. |
| `videoUrl` | Video URL — Video of the lesson, as Skool publishes it (YouTube, Loom, Vimeo, Skool player…). The video file itself is not downloaded. |
| `videoLengthMs` | Video length (ms) |
| `videoThumbnail` | Video thumbnail |
| `startTime` | Event start — ISO 8601 UTC. |
| `endTime` | Event end |
| `memberId` | Member ID |
| `handle` | Handle — Skool handle of the member or of the post author. |
| `firstName` | First name |
| `lastName` | Last name |
| `bio` | Bio |
| `location` | Location |
| `timezone` | Time zone |
| `role` | Role — Role in the community: member, admin, owner. |
| `level` | Level |
| `points` | Points |
| `rank` | Rank — Rank in the leaderboard, or rank of the community in the search results. |
| `leaderboardWindow` | Leaderboard period — 7day, 30day or alltime. |
| `requestedAt` | Requested at — Date the member asked to join the community, ISO 8601 UTC. |
| `joinedAt` | Joined at — Date the member was approved in the community, ISO 8601 UTC. |
| `lastSeenAt` | Last seen — Last time the member was online, ISO 8601 UTC. |
| `isOnline` | Online now |
| `profileUrl` | Profile URL |
| `pictureUrl` | Picture |
| `website` | Website |
| `facebook` | Facebook |
| `instagram` | Instagram |
| `linkedin` | LinkedIn |
| `twitter` | X / Twitter |
| `youtube` | YouTube |
| `totalFollowers` | Followers — Member public profile. |
| `totalFollowing` | Following |
| `totalContributions` | Contributions — Posts and comments written by the member, all communities together. |
| `totalGroups` | Communities joined |
| `memberOfGroups` | Communities of the member — Public communities the member belongs to: name, slug, members, price. |
| `myersBriggs` | Myers-Briggs — Personality type declared by the member. |
| `authorId` | Author ID — Author of the post or of the comment. |
| `authorName` | Author name |
| `authorHandle` | Author handle |
| `authorBio` | Author bio |
| `authorProfileUrl` | Author profile |
| `authorPictureUrl` | Author picture |
| `authorLocation` | Author location |
| `createdAt` | Created at — Community, post, comment: its creation date. Member and leaderboard rows: when the person's Skool account was created (the date filters read `joinedAt` for a member). Courses, lessons and events: empty. ISO 8601 UTC. |
| `updatedAt` | Updated at |
| `searchUrl` | Search URL — Search the community was found by; null for the whole-directory mode and for URLs given in startUrls. |
| `scrapedAt` | Scraped at — ISO 8601 timestamp of the extraction. |

### 💡 Tips and advanced options

- **Start small.** Leave **Max communities** at 100 for a first run, then raise it once the output looks right.
- **Extras multiply the rows.** Posts on a community with 20 000 posts writes 20 000 rows. Use **Max posts per community** and the other caps.
- **Only new items** is the cheap way to watch a keyword: the items a previous run under the same **Memory key** delivered are skipped before their page is even opened. The memory is a store of your account (`skool-communities-scraper-seen`, up to 150,000 items per key), and it never expires.
- **Private communities** give their profile, price, member count and owner without any login; their posts, members and courses need a **Skool cookie** of an account that belongs to them.
- **The member list stops at about 30** for a visitor — that is Skool's own limit, not the Actor's. A cookie of a member of the community lifts it.
- **Speed.** At the default memory (512 MB) the run's processor is the limit, not Skool: raising **Max concurrency** alone gains 5-10 %. Give the run more memory (it also gets more processor) together with a higher **Max concurrency** if you are in a hurry. If Skool ever answers HTTP 429, the run retries at once through another proxy IP — or, without a proxy, after a pause of 5 seconds, doubled at each retry up to 150 seconds, instead of giving up.
- **A safety net against a silent change.** If the first 20 communities read all lack a field every community has, the run stops and says so rather than filling your dataset with empty columns. A community dropped by your filters counts among those 20. The same goes for the About page, and for each kind of content row on its own: the first 20 posts, comments, members, courses, lessons, events or leaderboard entries that all lack a field every row of their kind has (a post's title, date or author, a member's handle or join date…) stop the run too. A search filtered on price, privacy, free trial or language that finds nothing checks once that Skool's directory still knows that filter, so a renamed filter fails the run instead of returning an empty, successful one.
- **A failed run means an outage, not a few misses.** Requests that still fail after every retry are counted in the last line of the log and listed, with the reason, in the `FAILED_REQUESTS` record of the run's key-value store; one failure among many is only a warning. A run that saved nothing fails when requests failed, and a run that saved some rows fails too when at least as many requests failed as were read (the first page read, the rest refused): a green run with a short dataset would hide the outage.

### 🔌 Integrations and API

Run it from your own code, or wire it to the tools you already use:

- **API**: start a run and read the dataset with the [Apify API](https://docs.apify.com/api/v2) or the JavaScript / Python clients.
- **Schedules**: run it every day or every hour, with **Only new items** on.
- **Webhooks and integrations**: Google Sheets, Google Drive, Slack, Make, Zapier, GitHub, Airbyte and the rest of the Apify integrations.
- **MCP**: usable from an AI agent through the Apify MCP server.

### 🤖 Use with AI agents (MCP)

AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the [Apify MCP server](https://mcp.apify.com), billed to their Apify account like any run. It returns one item per Skool community (and, when asked, one per post, comment, member, lesson, event or leaderboard entry). Actor id: `nice_dev/skool-communities-scraper`; MCP server with this Actor only: `https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/skool-communities-scraper`.

Smallest input, for a cheap first call:

```json
{
    "query": "ai automation",
    "maxItems": 10
}
```

Key output fields: `itemType`, `url`, `name`, `totalMembers`, `monthlyPrice`, `rating`, `ownerName`, `ownerWebsite`.

Cost: $0.25 per 1,000 results plus $0.001 per run start at the default memory ($0.19 per 1,000 on the Gold plan and above); a community a filter drops costs $0.04 or $0.20 per 1,000, see the pricing section above. Cap each call with `maxItems` and, through the API, with the run option `maxTotalChargeUsd`.

### ❓ FAQ

#### Is it legal to scrape Skool?

The Actor only reads pages any visitor can open, and it collects no login-protected data unless you give it your own session cookie. Public posts, member names and bios are personal data in the sense of the GDPR and similar laws: you are responsible for having a lawful basis before you store them, for honouring deletion requests, and for respecting Skool's terms of use and the copyright of the content you download. This Actor is not affiliated with Skool.

#### Do I need a Skool account?

No for public communities and for the whole directory. Yes — your own cookie — for private communities and for the full member list.

#### Why are the e-mail addresses empty?

Skool stopped returning member e-mails in June 2026. No Skool scraper can give you one; anything that claims otherwise is guessing.

#### Why do I only get about 30 members?

That is what Skool shows a visitor, whatever page is asked for. Paste the cookie of an account that is a member of the community to get the whole list.

#### What does the estimated MRR mean?

Members × monthly price. It is an estimate computed from public numbers, not a figure Skool publishes: members who joined for free, at another price or through a trial are not known.

#### Can I get more than 1 000 results for a keyword?

Not for one keyword — that is the directory's own limit. Use **Whole directory** with the filters instead, or split your search into several keywords.

### 🛟 Support

Something missing or wrong? Open an issue in the **Issues** tab of this Actor: include the run ID and the input you used, and it gets looked at. Feature requests are welcome there too, and a custom version of this Actor can be built on request.

# Actor input Schema

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

Skool URLs: a community (`https://www.skool.com/my-group`), a discovery search (`https://www.skool.com/discovery?q=ai`), a single post (`https://www.skool.com/my-group/my-post`) or a member profile (`https://www.skool.com/@handle`). When this list is not empty, the search fields below (keyword, whole directory) are ignored; filters, caps and monitoring still apply. Max 1 000 URLs.

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

Free-text search of the Skool directory, exactly as typed on skool.com/discovery (e.g. `ai automation`). Empty = the directory without a keyword.

## `searchQueries` (type: `array`):

Several keywords in one run: one search per keyword. Added to **Search keyword**; a community found by several searches is saved once.

## `allCommunities` (type: `boolean`):

Go through the ENTIRE Skool directory (74 000+ communities, private ones included) instead of searching by keyword. A keyword search stops at 1 000 communities — this does not. Combine with **Max communities** and the filters below to keep the run short.

## `language` (type: `string`):

Language declared by the community.

## `priceType` (type: `string`):

Keep only free communities, or only paid ones.

## `privacyType` (type: `string`):

A private community still gives its profile (members count, price, posts, courses, owner); its posts, members and courses are only readable with a **Skool cookie** of a member.

## `hasFreeTrial` (type: `boolean`):

Keep only the paid communities that offer a free trial.

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

Maximum number of communities to save for the whole run (after deduplication and filters). Posts, comments, members and lessons are not counted here — they have their own caps. 0 = no limit.

## `maxItemsPerQuery` (type: `integer`):

Cap for EACH search (keyword or start URL), so that the first search cannot use up the whole **Max communities** budget. 0 = no per-search cap.

## `includeAbout` (type: `boolean`):

Also read the public About page of each community (1 extra request): long description, custom links, gamification levels, number of rules, join survey questions and the latest reviews. Off = the community profile only (name, slug, members, price, posts, courses, rating, owner), which is always read.

## `scrapePosts` (type: `boolean`):

Save the posts of each community (30 per request): title, text, upvotes, comment count, attachments, videos, channel and full author.

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

0 = every post (a large community can hold 20 000+).

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

Save the comments of each extracted post (1 extra request per post), with their nested replies.

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

Top-level comments kept per post, each with its replies. Skool gives at most 30 top-level comments per post: 0 = those 30.

## `maxRepliesPerComment` (type: `integer`):

Replies kept under each comment. 0 = every reply.

## `scrapeMembers` (type: `boolean`):

Save the members of each community: name, bio, location, social links, time zone, level, points, join date, last seen and role. Skool shows only ~30 members to a visitor — paste a **Skool cookie** below to get the whole list.

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

0 = every member Skool returns (~30 without a cookie).

## `memberTab` (type: `string`):

All members, admins only (the full admin list is public) or members online now.

## `includeMemberProfiles` (type: `boolean`):

Also read the public Skool profile of each extracted member (1 extra request per member): followers, following, total contributions, and the list of the communities they are a member of.

## `scrapeClassroom` (type: `boolean`):

Save the courses of each community and their lessons: title, description, cover, section, video link, video length, thumbnail and attached resources. Locked courses are reported as locked, without their lessons.

## `includeLessonContent` (type: `boolean`):

Also read the written content of each lesson (1 extra request per lesson — a 50-lesson course means 50 requests).

## `maxLessonsPerCourse` (type: `integer`):

0 = every lesson.

## `scrapeCalendar` (type: `boolean`):

Save the upcoming events of each community: title, description, start and end time, link.

## `scrapeLeaderboards` (type: `boolean`):

Save the leaderboards of each community (top members by points) for the chosen period.

## `leaderboardWindow` (type: `string`):

Which leaderboard to save.

## `cookies` (type: `string`):

The `auth_token` cookie of YOUR Skool account (DevTools › Application › Cookies › skool.com), pasted as `auth_token=...` or as the whole cookie header. Your account only sees what it is a member of. Leave empty to scrape public data only.

## `postedAfter` (type: `string`):

Only items created on or after this date: `2026-09-01` (a day starts at midnight UTC, the zone of every date saved), or a period before now such as `7 days`, `2 weeks`, `1 month` (API: `24 hours` and full ISO date-times work too). Read on the creation date of a community, a post or a comment, and on the day a member joined; courses, lessons, events and leaderboard entries carry no date and are always kept. A community pasted in **Start URLs** with its posts, members… asked for is always saved: the dates then pick its content.

## `postedBefore` (type: `string`):

Only items created on or before this date (the whole day is included, until midnight UTC), or older than a period such as `30 days`.

## `excludeKeywords` (type: `array`):

Drop the items whose name or title contains one of these words (case and accents ignored).

## `minMembers` (type: `integer`):

Keep only communities with at least this many members. 0 = no minimum.

## `maxMembers` (type: `integer`):

Keep only communities with at most this many members (to find small ones). 0 = no maximum.

## `minMonthlyPrice` (type: `integer`):

Keep only communities whose price, brought back to one month, is at least this. 0 = no minimum.

## `maxMonthlyPrice` (type: `integer`):

Keep only communities whose price, brought back to one month, is at most this. 0 = no maximum.

## `minPosts` (type: `integer`):

Keep only communities with at least this many posts (an active community). 0 = no minimum.

## `minCourses` (type: `integer`):

Keep only communities with at least this many courses in their classroom. 0 = no minimum.

## `minRating` (type: `integer`):

Keep only communities rated at least this (1 to 5). Communities with no review are dropped. 0 = no minimum.

## `minMrr` (type: `integer`):

Keep only communities whose ESTIMATED monthly revenue (members × monthly price) is at least this. It is an estimate computed from public numbers, not a figure published by Skool. 0 = no minimum.

## `maxMrr` (type: `integer`):

Same, as a maximum. 0 = no maximum.

## `requireContact` (type: `boolean`):

Keep only communities whose owner shows at least one way to be reached: website, e-mail or a social network.

## `hasAffiliateProgram` (type: `boolean`):

Keep only communities that pay a commission to the members who bring new paying members. The commission itself is in the `affiliatePercent` field of every result.

## `onlyNew` (type: `boolean`):

Skip the communities, posts, comments, members and lessons that a previous run (same **Memory key**) already delivered: they are not saved and not charged, and their page is not even opened. First run = everything is new.

## `stateKey` (type: `string`):

Name of the memory used by **Only new items**. Give each schedule / task its own key (e.g. `ai-communities`) so that they do not share their memory. Letters, digits, `-` and `_`.

## `resetState` (type: `boolean`):

Forget everything remembered under this **Memory key** before the run: this run returns (and charges) every item again. Untick it afterwards.

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

Apify Proxy or your own proxies. Keep the default: it is included in the price. The residential Apify proxy is not available in this Actor.

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

Maximum number of requests processed in parallel. A community's About page is read right after its profile, in the same slot: never more than this many calls to Skool at once.

## `maxRequestsPerMinute` (type: `integer`):

Global request rate. Lower it if the site answers HTTP 429 / 403 in the log. It counts the profile of a community and its About page as ONE request: with **About page** on, up to twice this number of calls reach Skool per minute — halve it to keep the same pace.

## `minRequestIntervalMs` (type: `integer`):

Smallest gap between two calls to Skool, in milliseconds — the About page of a community included. Unlike the per-minute rate, this spreads the calls evenly instead of letting them go out in a burst. 0 = no gap.

## `maxRequestRetries` (type: `integer`):

Retries per request before it is marked as failed.

## `debugLog` (type: `boolean`):

Include debug messages in the run log.

## Actor input object example

```json
{
  "startUrls": [],
  "query": "ai automation",
  "searchQueries": [],
  "allCommunities": false,
  "language": "",
  "priceType": "any",
  "privacyType": "any",
  "hasFreeTrial": false,
  "maxItems": 100,
  "maxItemsPerQuery": 0,
  "includeAbout": true,
  "scrapePosts": false,
  "maxPostsPerCommunity": 100,
  "includeComments": false,
  "maxCommentsPerPost": 25,
  "maxRepliesPerComment": 0,
  "scrapeMembers": false,
  "maxMembersPerCommunity": 30,
  "memberTab": "all",
  "includeMemberProfiles": false,
  "scrapeClassroom": false,
  "includeLessonContent": false,
  "maxLessonsPerCourse": 0,
  "scrapeCalendar": false,
  "scrapeLeaderboards": false,
  "leaderboardWindow": "all",
  "excludeKeywords": [],
  "minMembers": 0,
  "maxMembers": 0,
  "minMonthlyPrice": 0,
  "maxMonthlyPrice": 0,
  "minPosts": 0,
  "minCourses": 0,
  "minRating": 0,
  "minMrr": 0,
  "maxMrr": 0,
  "requireContact": false,
  "hasAffiliateProgram": false,
  "onlyNew": false,
  "stateKey": "default",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8,
  "maxRequestsPerMinute": 300,
  "minRequestIntervalMs": 0,
  "maxRequestRetries": 5,
  "debugLog": false
}
```

# Actor output Schema

## `results` (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 = {
    "query": "ai automation",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nice_dev/skool-communities-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 = {
    "query": "ai automation",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nice_dev/skool-communities-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 '{
  "query": "ai automation",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nice_dev/skool-communities-scraper --silent --output-dataset

```

## MCP server setup

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