# Skool Community Scraper — Members, MRR & Discovery (No Login) (`vnx0/skool-community-scraper`) Actor

Scrape Skool.com communities with no login — members, online counts, posts, courses, pricing and MRR estimates. Discover communities by keyword, track growth with snapshot deltas, export clean JSON/CSV/Excel. Structured error rows, never failed runs. Works with AI agents via MCP.

- **URL**: https://apify.com/vnx0/skool-community-scraper.md
- **Developed by:** [Vnx0](https://apify.com/vnx0) (community)
- **Categories:** Social media, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 community profiles

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

**Export everything public about any Skool.com community — members, online counts, posts, courses, pricing and MRR estimates — with zero credentials.** This Skool community scraper turns [Skool](https://www.skool.com) discovery pages and community URLs into a clean, deduplicated dataset you can schedule, monitor, and pipe into your CRM, spreadsheet, or AI agent. No login. No cookies. No browser extension.

### With this Actor you can

- **Discover communities by keyword or category** — find groups you did not know about, ranked by where they appear in Skool discovery. Filter by price, privacy and language.
- **Export community intelligence** — members, online counts, posts, courses, modules, admins, pricing, owner profiles, gamification levels, public links, logo and wallpaper URLs.
- **Estimate community MRR** — a per-community revenue estimate with a confidence level and derivation notes, built from public pricing and member signals.
- **Monitor growth on autopilot** — enable monitoring mode and schedule the Actor; each run returns only what is new, with growth snapshots over time.
- **Find and qualify leads** — owner names, bios, public socials, websites and locations, one row per community.
- **Feed your stack** — JSON, CSV or Excel downloads, Apify API, webhooks, schedules, and Zapier/Make/n8n flows.
- **Call it from AI agents** — a clean single-purpose input schema plus an MCP endpoint (see the AI agents section below).

### Who is this Skool scraper for?

| You are… | You use it to… |
|---|---|
| Market researcher / analyst | Size niches, map communities, track category leaders |
| Agency owner / growth team | Find client communities and outreach targets, benchmark pricing |
| Community operator | Monitor your own community's growth and spot competing groups |
| Course creator / educator | Scout demand, pricing and positioning before launching |
| Lead-gen / sales | Build a list of community owners with public contact info |
| AI builder / automation engineer | Feed clean community data into RAG pipelines and agent workflows |

### What data can this Actor extract?

| Field | Type | Description |
|---|---|---|
| `source` | string | How the community entered the run: `target` or `discovery` |
| `id` / `slug` / `url` | string | Skool community id, slug, and canonical URL |
| `displayName` / `description` | string | Public name and description |
| `category` | string | Skool category |
| `memberCount` / `onlineCount` | integer | Members total and online at scrape time |
| `postCount` / `courseCount` / `moduleCount` / `adminCount` | integer | Posts, classroom courses, modules and admins |
| `isPublic` / `privacy` / `createdAt` | boolean / integer / string | Visibility flags and creation date when public |
| `price` | object | `displayPrice` ("$69/month", "$97/year", "Free"), `amountUsd`, `currency`, `interval`, `freeTrial`, `isFree` |
| `owner` | object | Name, bio, location, public socials and website (only if public) |
| `levels` / `links` | array | Gamification levels with titles and share of members; public links with labels |
| `reviewAverageRating` / `reviewCount` | number / integer | Public community rating and review count, when reviews exist |
| `affiliatePercent` | number | Affiliate commission when publicly listed |
| `mrrEstimate` | object | Estimated MRR in USD with `confidence`, `method` and derivation `notes` |
| `memberGrowth` | object | 7-day and 30-day member change computed from stored snapshots |
| `growthSnapshot` rows | object | Time-series row per community per run: member/online/post counts plus deltas |
| `discoveryRank` / `discoveryKeyword` | integer / string | Where and under what term it was discovered |
| `logoUrl` / `wallpaperUrl` / `imageUrls` | string / array | Public imagery |
| `firstSeenAt` / `lastSeenAt` / `scrapedAt` | string | Lifecycle timestamps |

### How to scrape Skool communities (no login, step by step)

1. Open the Actor. The default input is prefilled with one public community — click **Start** to see output immediately, without any credentials.
2. To target your own list, add public community URLs or bare slugs to **Community URLs or slugs** (e.g. `ai-automation-society`).
3. To discover communities you do not know yet, add **Discovery keywords** and/or a **Discovery URL**, and optionally narrow with **Category**, **Sort by**, **Price filter**, **Privacy filter** and **Language**.
4. Optional: turn on **Monitoring mode** to get only new communities on repeat runs, and **Include growth snapshots** for time-series data.
5. Set **Max communities** to cap the run size, and optionally **Max cost per run (USD)**.
6. Run it. Download the dataset as JSON, CSV, or Excel — or save it as a task with a schedule so your list stays fresh.

### Input

See the input tab for full configuration options. A complete, runnable example:

```json
{
    "action": "scrape",
    "communityUrls": ["https://www.skool.com/ai-automation-society"],
    "keywords": [],
    "maxCommunities": 5,
    "monitoringMode": false,
    "includeGrowthSnapshots": false
}
```

| Input field | Type | Default | What it does |
|---|---|---|---|
| `action` | string | `scrape` | `scrape`, or `system:health` for a cheap self-check row |
| `communityUrls` | array | prefilled example | Public URLs or slugs to scrape directly |
| `keywords` | array | `[]` | Discovery keywords (each gets its own watermark) |
| `categorySearch` | string | `""` | Restrict discovery to a category (name or slug) |
| `discoveryUrl` | string | `""` | Walk an exact discovery/search page |
| `sortBy` | string | `trending` | Discovery ordering: `trending` or `top-v2` (top rated) |
| `priceFilter` | string | `any` | Discover `any`, `free`, `paid` or `free-trial` communities |
| `typeFilter` | string | `any` | Discover `any`, `public` or `private` communities |
| `language` | string | `""` | Discovery language slug, e.g. `english`, `spanish` |
| `maxCommunities` | integer | `25` (prefill `5`) | Hard cap on communities per run |
| `monitoringMode` | boolean | `false` | Only output communities not seen before |
| `includeGrowthSnapshots` | boolean | `false` | Also emit time-series growth rows |
| `maxCostPerRun` | number | — | Stop producing billable results at this USD spend |
| `proxyConfiguration` | object | disabled | Proxy settings; enable only if requests get blocked |

When `communityUrls`, `keywords`, `discoveryUrl` and `categorySearch` are all empty, the Actor falls back to the prefilled example community so an empty input still produces results.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. One community row looks like this (real run, numbers change over time):

```json
{
    "type": "community",
    "source": "target",
    "id": "b51c57150c70495899bf4bc8aaee8166",
    "slug": "ai-automation-society",
    "url": "https://www.skool.com/ai-automation-society",
    "displayName": "AI Automation Society",
    "category": "ai",
    "memberCount": 472384,
    "onlineCount": 1231,
    "postCount": 26104,
    "courseCount": 17,
    "moduleCount": 296,
    "adminCount": 16,
    "price": { "displayPrice": "Free", "isFree": true },
    "owner": { "id": "…", "name": "nateherk", "socials": { "twitter": "…" }, "website": "…" },
    "levels": [{ "number": 1, "name": "Level 1", "title": "AI Explorer", "percentOfMembers": 89 }],
    "links": [{ "url": "https://youtube.com/@…", "label": "YOUTUBE RESOURCES", "isPublic": true }],
    "firstSeenAt": "2026-10-18T13:43:51.758Z",
    "lastSeenAt": "2026-10-18T13:43:51.758Z",
    "scrapedAt": "2026-10-18T13:43:51.758Z"
}
```

With **Include growth snapshots** enabled, each community also gets a time-series row for charting:

```json
{
    "type": "growthSnapshot",
    "source": "target",
    "slug": "ai-automation-society",
    "snapshotAt": "2026-10-18T13:45:40.982Z",
    "memberCount": 472384,
    "previousMemberCount": 472371,
    "previousSnapshotAt": "2026-10-18T12:10:03.000Z",
    "deltaMembers": 13,
    "delta7d": 812,
    "delta30d": 3410
}
```

Failures never crash the run — they arrive as structured error rows you can filter out or act on:

```json
{
    "success": false,
    "errorCode": "TARGET_NOT_FOUND",
    "errorCategory": "not-found",
    "target": "https://www.skool.com/example-community",
    "message": "Community does not exist.",
    "retryable": false,
    "hint": "Check the community slug."
}
```

An `action: "system:health"` run emits one deterministic health row instead of scraping, useful as a cheap uptime check:

```json
{
    "type": "system:health",
    "status": "ok",
    "actorVersion": "0.1.0",
    "checks": [{ "name": "input", "status": "ok" }, { "name": "scraper", "status": "ok" }]
}
```

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

This Actor uses Apify's pay-per-event pricing — you pay per delivered result, nothing is charged as a bundle, and **failures are free** (error rows are never billed).

| Event | What it bills | FREE plan | Paid plans |
|---|---|---|---|
| `community` | One community metadata row | $4.00 / 1,000 | $2.50 / 1,000 |
| `discovered-community` | One community found through discovery | $6.00 / 1,000 | $3.50 / 1,000 |
| `growth-snapshot` | One growth snapshot row | $1.00 / 1,000 | $0.60 / 1,000 |

A typical starter run (5 communities, as prefilled) costs about **$0.02** on the FREE plan. A 10-community discovery run costs about **$0.06**, and adding growth snapshots adds about **$0.001** per community. Monitoring runs bill only newly delivered communities. Set **Max cost per run** to put a hard ceiling on any run; the Actor stops producing billable results when the cap is hit and still finishes successfully.

### Reliability

- **Reads the same public surface the website uses**: Skool's Next.js data routes, with an automatic fallback to the public REST metadata endpoint if a route is blocked or changes shape.
- **Self-healing**: the Next.js build id is cached and refreshed automatically; a stale id is detected and retried before anything is reported as failed.
- **Polite by default**: requests are serialized with a small delay and retried with backoff on 429/5xx/timeouts.
- **Structured errors, never silent gaps**: anything that fails appears as an error row with a category, a retryable flag and a hint. Gated or private communities produce a clear `TARGET_GATED` row instead of garbage data.
- **Resumable and abort-safe**: if a run is stopped, state is persisted and a re-run picks up cleanly.
- **`system:health` action**: a cheap action that verifies the run pipeline end to end without scraping.
- **Proxies optional**: public surfaces usually work without them; enable Apify Proxy only if you get blocked.

### 🤖 For AI agents & LLM apps

- **Purpose**: return structured intelligence about Skool communities.
- **Minimal call**: `{ "communityUrls": ["https://www.skool.com/ai-automation-society"] }`.
- **Behavior**: one JSON row per community; failures come back as error rows; enable `monitoringMode` for only-new delta results across scheduled runs.
- **Connect via MCP**:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=Vnx0~skool-community-scraper",
            "headers": {
                "Authorization": "Bearer <YOUR_APIFY_TOKEN>"
            }
        }
    }
}
```

### ⚠️ Disclaimer

This Actor is not affiliated with, endorsed by, or sponsored by Skool, Inc. It collects only publicly available information; you are responsible for complying with Skool's Terms of Service and with applicable data-protection laws (GDPR and others) when you use the data.

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

### Support, issues & reviews

- Found a bug or need a field? Open an issue via the **Issues** tab — feedback shapes the roadmap.
- Want to call this from your own code? See the **API** tab for ready-made snippets (cURL, Node.js, Python) that run the Actor programmatically.
- If this Actor saved you time, a ⭐ review on the Store page helps more than you would think.

### Related actors

Companion Actors in this suite (coming soon — cross-links go live as they ship):

- **Skool Posts, Comments & Members Scraper** — full post feeds, nested comment threads and member lists.
- **Skool Classroom Archiver** — courses, lesson videos, transcripts and AI-ready markdown exports.

### SEO keywords

skool scraper, skool.com scraper, skool api, scrape skool, skool community scraper, skool discovery scraper, skool group scraper, skool members, skool member count, skool mrr, skool community data, skool group data, export skool communities, community engagement export, membership community data, creator community analytics, skool community analytics, skool no login, skool scraper without login, skool delta monitoring, skool mcp, skool claude, skool n8n, skool zapier, skool automation, skool api alternative

# Actor input Schema

## `action` (type: `string`):

What this run should do. "system:health" performs a cheap end-to-end self-check that returns one deterministic status row and makes no requests to skool.com.

## `communityUrls` (type: `array`):

Public Skool community URLs or bare slugs to collect intelligence for, e.g. "https://www.skool.com/ai-automation-society" or "ai-automation-society". No login is required for public communities. When this and every discovery field are empty, the Actor falls back to the example community shown in the prefill.

## `keywords` (type: `array`):

Keywords used to discover communities through Skool discovery when you do not provide community URLs, e.g. "ai automation". Each keyword keeps its own monitoring watermark.

## `categorySearch` (type: `string`):

Optional Skool category restricting discovery, by name or slug: Hobbies, Music, Money, Spirituality, Tech, Health, Sports, Self-improvement or Relationships. Leave empty to search all categories.

## `discoveryUrl` (type: `string`):

Optional Skool discovery/search page to walk, e.g. "https://www.skool.com/discovery?q=ai". Use this to start from an exact listing page instead of keywords.

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

How Skool orders discovery results. "Trending" is Skool's default; "Top rated" uses the top-v2 ranking.

## `priceFilter` (type: `string`):

Restrict discovery to free communities, paid communities or communities with a free trial.

## `typeFilter` (type: `string`):

Restrict discovery to public or private communities.

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

Optional discovery language slug, e.g. "english", "spanish", "portuguese" or "french". Leave empty for all languages.

## `monitoringMode` (type: `boolean`):

When enabled, per-source watermarks in the run's key-value store make this run return only communities that were not already delivered by previous runs (delta runs). Ideal for scheduled tasks.

## `includeGrowthSnapshots` (type: `boolean`):

Also emit a growthSnapshot row per community (member, online and post counts, plus deltas against previous runs) so you can chart growth from stored runs. Works for both direct targets and discovered communities.

## `maxCommunities` (type: `integer`):

Safety cap on the total number of communities processed in one run (targets plus discovered). Keeps runaway discovery cheap.

## `maxCostPerRun` (type: `number`):

Optional spending cap for this run in USD. Once reached, the Actor stops producing new billable results and finishes successfully. Failures are never charged.

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

Proxy settings for the requests to skool.com. Public pages usually work without proxies — the default disables Apify Proxy; enable it only if requests get blocked.

## Actor input object example

```json
{
  "action": "scrape",
  "communityUrls": [
    "https://www.skool.com/ai-automation-society"
  ],
  "keywords": [
    "ai automation"
  ],
  "categorySearch": "Tech",
  "discoveryUrl": "",
  "sortBy": "trending",
  "priceFilter": "any",
  "typeFilter": "any",
  "language": "",
  "monitoringMode": false,
  "includeGrowthSnapshots": false,
  "maxCommunities": 5,
  "maxCostPerRun": null,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset containing community metadata, growth snapshots, structured errors and system:health rows.

## `keyValueStore` (type: `string`):

Run state and per-keyword monitoring watermarks used for delta runs in monitoring mode.

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vnx0/skool-community-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/4kTg7aL747x6OV9Cu/builds/2OXkXOne4aQ6kj8a5/openapi.json