# Skool Community Growth Tracker & Scraper (`davidbenittah/skool-community-growth-tracker`) Actor

Scrape Skool discovery search for your niche, then track the same communities run after run: members, monthly price, estimated MRR, member delta, members gained per day, price changes and new communities entering the niche. Run it weekly to see who grows and who bleeds members.

- **URL**: https://apify.com/davidbenittah/skool-community-growth-tracker.md
- **Developed by:** [David](https://apify.com/davidbenittah) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Skool Community Growth Tracker & Scraper

Most Skool scrapers return a snapshot: the members and the price of a community today. This one remembers what it saw last week. Point it at a niche, run it weekly, and every community comes back with its deltas: members gained, growth per day, price moves, estimated MRR, and whether it just appeared in the niche.

### What this Skool community scraper does

1. Finds communities via Skool discovery search for your niche keywords (and/or specific community URLs you list).
2. Normalizes each community: members, pricing, currency, estimated MRR (members × monthly price — an upper-bound estimate, labeled as such).
3. Compares against the previous run and outputs every community **with its growth metrics**, sorted by member gains.

### Use cases: pick a niche, watch competitors, find deals

- **Choosing a niche to launch in**: track 2-3 candidate niches weekly for a month. Launch where `membersPerDay` is high across many communities and `isNewInNiche` keeps firing — demand is arriving faster than supply.
- **Competitive watch**: add your competitors via `communityUrls`; `priceChanged` and `membersDelta` tell you when they move.
- **Deal flow**: for community brokers/buyers, sustained negative deltas mark acquisition targets before they're listed.

### Input example

```json
{
  "searchTerms": ["ai automation"],
  "maxCommunitiesPerSearch": 30
}
````

The defaults work as-is: just set your niche keywords.

### Output example

```json
{
  "communityId": "8d6813d75d2949349a9f60f767c04f84",
  "displayName": "AI Automations by Jack",
  "communityUrl": "https://www.skool.com/aiautomationsbyjack",
  "totalMembers": 3300,
  "monthlyPrice": 97,
  "currency": "USD",
  "estimatedMrr": 320100,
  "membersDelta": 68,
  "membersGrowthPct": 2.1,
  "membersPerDay": 9.71,
  "priceChanged": true,
  "previousMonthlyPrice": 87,
  "isNewInNiche": false,
  "firstSeenAt": "2026-07-06T00:00:00.000Z"
}
```

### Data you get per community

| Field | What it holds |
| --- | --- |
| `communityId` / `displayName` / `communityUrl` | Identity of the community |
| `totalMembers` | Member count at this run |
| `monthlyPrice` / `currency` | Price of the paid community |
| `estimatedMrr` | Members multiplied by monthly price, upper-bound estimate |
| `membersDelta` | Members gained or lost since the previous run |
| `membersGrowthPct` | Same delta as a percentage |
| `membersPerDay` | Growth velocity between the two runs |
| `priceChanged` / `previousMonthlyPrice` | Price moves since the previous run |
| `isNewInNiche` | The community appeared in this niche after the baseline |
| `firstSeenAt` | First run that saw this community |
| `SUMMARY` record | Niche picture in the key-value store: scanned, grown, price changes, fastest grower, new entrants |

### FAQ

#### First run shows no deltas — why?

The first run saves the baseline (flagged `isBaseline: true`). Growth appears from the second run on. Schedule weekly for clean week-over-week velocity.

#### A community disappeared from search results — is its history lost?

No: it stays in memory for 180 days, so a search-ranking wobble doesn't reset its baseline.

#### How do I reset the memory?

Set a new `monitorId` — each ID keeps its own baseline.

#### How is this different from a Skool community scraper?

A scraper gives you the state of a community today. This Actor stores what it saw on the previous run and returns the difference: `membersDelta`, `membersPerDay`, `priceChanged`, `isNewInNiche`. Run it once, you get a snapshot plus a baseline. Run it weekly, you get the growth curve of the niche.

#### Can I export the Skool data to CSV or Google Sheets?

Yes. Each run writes to a standard Apify dataset, so results export as CSV, JSON or Excel, or go to Google Sheets through an Apify integration.

### Fair use & data

- Uses only **public Skool discovery data** (no login).
- **No owner personal data** — names, emails and socials of community owners are deliberately not collected.
- `estimatedMrr` is an upper-bound estimate (on Skool, members of a paid community are paying members); it is never presented as a measured number.
- Inputs are hard-capped (5 keywords, 100 communities per search) so runs stay bounded and predictable.

> This is an unofficial tool and is not affiliated with, endorsed by, or sponsored by Skool.

# Actor input Schema

## `searchTerms` (type: `array`):

What you would type in Skool's discovery search, e.g. 'ai automation' or 'fitness coaching'. Hard maximum: 5 terms per run.

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

Optional: track specific communities by URL (e.g. https://www.skool.com/makerschool) instead of, or in addition to, niche keywords.

## `maxCommunitiesPerSearch` (type: `integer`):

Safety cap on communities scanned per run. Hard maximum: 100.

## `includeBaselineInOutput` (type: `boolean`):

The very first run saves a baseline snapshot. When enabled, that snapshot is also pushed to the dataset (flagged isBaseline=true). Later runs always output stats WITH growth deltas.

## `monitorId` (type: `string`):

Optional. Advanced: name this monitor to keep several baselines for the same niche, or reset one by changing the ID.

## Actor input object example

```json
{
  "searchTerms": [
    "ai automation"
  ],
  "maxCommunitiesPerSearch": 30,
  "includeBaselineInOutput": true
}
```

# Actor output Schema

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

Structured result items.

# 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 = {
    "searchTerms": [
        "ai automation"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("davidbenittah/skool-community-growth-tracker").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 = { "searchTerms": ["ai automation"] }

# Run the Actor and wait for it to finish
run = client.actor("davidbenittah/skool-community-growth-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "ai automation"
  ]
}' |
apify call davidbenittah/skool-community-growth-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skool Community Growth Tracker & Scraper",
        "description": "Scrape Skool discovery search for your niche, then track the same communities run after run: members, monthly price, estimated MRR, member delta, members gained per day, price changes and new communities entering the niche. Run it weekly to see who grows and who bleeds members.",
        "version": "1.0",
        "x-build-id": "1A11um8UoISEcOFFv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/davidbenittah~skool-community-growth-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-davidbenittah-skool-community-growth-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/davidbenittah~skool-community-growth-tracker/runs": {
            "post": {
                "operationId": "runs-sync-davidbenittah-skool-community-growth-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/davidbenittah~skool-community-growth-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-davidbenittah-skool-community-growth-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Niche keywords",
                        "type": "array",
                        "description": "What you would type in Skool's discovery search, e.g. 'ai automation' or 'fitness coaching'. Hard maximum: 5 terms per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "communityUrls": {
                        "title": "Specific community URLs",
                        "type": "array",
                        "description": "Optional: track specific communities by URL (e.g. https://www.skool.com/makerschool) instead of, or in addition to, niche keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCommunitiesPerSearch": {
                        "title": "Max communities per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety cap on communities scanned per run. Hard maximum: 100.",
                        "default": 30
                    },
                    "includeBaselineInOutput": {
                        "title": "Output the baseline on first run",
                        "type": "boolean",
                        "description": "The very first run saves a baseline snapshot. When enabled, that snapshot is also pushed to the dataset (flagged isBaseline=true). Later runs always output stats WITH growth deltas.",
                        "default": true
                    },
                    "monitorId": {
                        "title": "Custom monitor ID",
                        "type": "string",
                        "description": "Optional. Advanced: name this monitor to keep several baselines for the same niche, or reset one by changing the ID."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```