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

Collect public Skool community listings and return names, descriptions, member counts, ratings, review counts, images and creation dates. Search by keyword or category, or provide discovery URLs; optionally fetch owner details from each community’s About page.

- **URL**: https://apify.com/axiomworks/skool-communities-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Skool Communities Scraper

**Returns:** one row per Skool community with id, slug, name, url, description, totalMembers, rating and reviewCount. Set `includeAdmin` for public owner details and community stats.
**Input:** `{"searchQueries": ["ai"], "maxItems": 20, "includeAdmin": false}`
**Best for:** Skool community lead lists, niche market research, competitor price and member tracking.

```json
{
  "id": "4c29068bb10947359c46a4bd12473aaf",
  "slug": "ai-money-hub",
  "name": "AI Money Hub",
  "sourceUrl": "https://www.skool.com/discovery?q=ai",
  "totalMembers": 3128,
  "rating": "5.0",
  "reviewCount": 2
}
```

### What does Skool Communities Scraper do?

This Skool scraper provides structured data for Skool API workflows and collects public community listings from Skool's discovery pages. You give it keywords, a category, or ready-made discovery URLs, and it returns one structured record per community: the slug, display name, description, member count, price, rating, review count, cover image, logo and creation date. If you turn on the admin option it also visits each community's About page and adds the owner, community stats and `landingPageDescription`. The latter copies the full public About-page text, preserving paragraphs and links as published. It helps compare a community's offer with its short discovery description without another scraping step.

It reads the same public discovery pages that any visitor sees without an account. There is no login, no cookies and no private data involved. The Actor pages through the discovery results, removes duplicates across pages and keywords, and stops as soon as it has saved the number of communities you asked for in `maxItems`.

Typical uses:

- Market research on a niche, for example how many communities exist around "meta ads" or "ai" and how big they are.
- Building a list of competitors with their prices and member counts.
- Tracking community growth by running the Actor on a schedule and comparing member counts over time.
- Finding community owners for outreach research when the admin option is on.
- Feeding a spreadsheet, database or AI agent with structured data instead of copying pages by hand.

This Actor is an independent tool. It is not affiliated with or endorsed by Skool.

### What data can you get?

Every record has a stable `id` (the Skool group ID) and a `sourceUrl` that points to the discovery page it was read from. Free communities have no price, so `price` is null and `isFree` is true.

| Field | Type | Description |
|---|---|---|
| `landingPageDescription` | string or null | Full public About-page text when `includeAdmin` is true; unavailable text is null |
| `id` | string | Skool group ID, unique per community |
| `slug` | string | URL slug, for example `evelyn` |
| `name` | string | Display name of the community |
| `url` | string | Public community page |
| `sourceUrl` | string | Discovery page or public About page where the community was read |
| `description` | string | Short public description |
| `totalMembers` | number | Member count shown by Skool |
| `isFree` | boolean | True when no price is shown |
| `price` | object | Amount in cents, currency, billing interval and a display string |
| `rating` | string | Average review rating as shown, such as `5.0` |
| `reviewCount` | number | Number of reviews |
| `coverImage` | string | Cover image URL |
| `logo` | string | Logo image URL |
| `createdAt` | string | Creation time in ISO 8601 |
| `updatedAt` | string | Last community update time supplied by Skool |
| `ratingValue` | number | Numeric form of rating, or null when unavailable |
| `admin` | object | Owner with id, username, first name, last name, bio, location, website, instagram, facebook, linkedin, twitter and youtube; only when `includeAdmin` is on |
| `stats` | object | Courses, modules, posts, online members and admins; only when `includeAdmin` is on |

The price object looks like `{"amount": 2900, "currency": "usd", "interval": "month", "display": "29 USD/month"}`. The amount is in cents. The owner's first and last names are often empty because many owners do not fill them in, while the username is reliable.

### How to use Skool Communities Scraper

1. Open the Actor in Apify Console and go to the Input tab.
2. Enter one or more keywords in **Community search keywords**, or pick a **Discovery category**, or paste discovery URLs. If you leave everything empty the Actor browses all communities.
3. Set **Maximum communities to save** to the number of records you want.
4. Switch on **Fetch public owner and stats** only if you need the owner, because it adds one request per community.
5. Click Start. When the run finishes, open the Output tab and download the dataset as JSON, CSV, Excel or HTML, or read it through the API.

You can combine keywords and a category. In that case each keyword is searched inside the chosen category. When you provide discovery URLs, the Actor follows their `q`, `c` and `p` parameters instead and ignores the keyword and category fields.

#### Limits to know about

Skool caps discovery at about 1,000 results for any single keyword or category, and around 30 communities appear per page. To cover a wide topic, run several related keywords in the same run: the Actor deduplicates by community ID, so a community that matches two keywords is saved once. A keyword with no matches finishes successfully with zero items, a log warning and a status message. Try broader `searchQueries`, another `category`, or a lower `minMembers`. A public community URL that no longer resolves also returns no item: check the URL or choose another community. Blocked requests suggest enabling `proxyConfiguration`. Errors affecting one target are logged and the Actor continues with the other targets.

### Input

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array of strings | Keywords such as `ai` or `meta ads`. Empty means all communities. |
| `category` | string | One of hobbies, music, money, spirituality, tech, health, sports, self-improvement, relationships. |
| `startUrls` | array | Optional skool.com/discovery URLs with `q`, `c` and `p` parameters, or direct community URLs such as `https://www.skool.com/evelyn`. |
| `includeAdmin` | boolean | Add the community owner (names, bio, location, website and social links where public) and community stats from the About page. Default false. |
| `minMembers` | integer | Skip communities with fewer members than this. Default 0. |
| `maxMembers` | integer | Skip communities with more members than this, to find small niche communities. Default 0 (no limit). |
| `minRating` | number | Skip communities rated below this value or without reviews. Default 0 (no filter). |
| `pricing` | string | `all` (default), `free` (only communities with `isFree` true) or `paid`. |
| `maxItems` | integer | Shared limit of unique communities across every keyword or URL, 1-10000, default 50. Filters and duplicates do not count. |
| `proxyConfiguration` | object | Apify Proxy settings, datacenter by default. |

Example input:

```json
{
  "searchQueries": ["meta ads"],
  "maxItems": 30,
  "includeAdmin": false,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

Example input that lists tech communities with owners:

```json
{
  "category": "tech",
  "maxItems": 40,
  "includeAdmin": true
}
```

### Output

Each run writes its records to the default dataset. Here is a real record, shortened, from a search for "meta ads":

```json
{
  "id": "af46f3593aee473cb6341d919de2fd66",
  "slug": "benheath",
  "name": "Ben Heath Meta Ads Academy",
  "url": "https://www.skool.com/benheath",
  "sourceUrl": "https://www.skool.com/discovery?q=meta+ads",
  "description": "The #1 community to master Meta ads. Exclusive training, weekly live Q&As and direct access to Ben Heath.",
  "totalMembers": 1003,
  "isFree": false,
  "price": { "amount": 4900, "currency": "usd", "interval": "month", "display": "49 USD/month" },
  "rating": "5.0",
  "reviewCount": 20,
  "coverImage": "https://assets.skool.com/f/af46f3593aee473cb6341d919de2fd66/313540993c5f4d77ba168b2e5c481c7a7a6291e7d4034a92ac733514078d0045-md.jpg",
  "logo": "https://assets.skool.com/f/af46f3593aee473cb6341d919de2fd66/ba38b320d13a4417882590aac8010a658374236841c547a5b4af275dfa596ddf.jpg",
  "createdAt": "2026-03-09T14:39:41.0707Z"
}
```

With `includeAdmin` on, each record also has an `admin` object:

```json
"admin": {
  "id": "f831a7690f5e4628919d63945ee0f51e",
  "username": "oracle",
  "firstName": "Daniel",
  "lastName": "Riley",
  "bio": "AI Content Creator & Mentor",
  "location": "United Kingdom",
  "website": null,
  "instagram": null,
  "facebook": null,
  "linkedin": null,
  "twitter": null,
  "youtube": null
},
"stats": {
  "courses": 20,
  "modules": 139,
  "posts": 29976,
  "onlineMembers": 558,
  "admins": 8
}
```

Social link fields are null when the owner has not made them public. Pass a direct community URL in `startUrls` to read a single community; with `includeAdmin` off, that run still reads the About page to build the record.

If the About page cannot be read, `admin` is null for that community and the community is still saved.

### How much does it cost?

The Actor is charged per result: each community saved to the dataset counts as one result. See the Pricing tab of the Actor for the current rate. Because the charge follows the number of results, setting `maxItems` is the simplest way to control what a run costs, and the Actor never saves or charges for more than `maxItems` records.

### Use with AI agents (MCP)

You can call this Actor from any MCP-capable assistant through the Apify MCP server. Add this to your client configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=axiomworks/skool-communities-scraper"
    }
  }
}
```

Example prompts:

- "Find 30 Skool communities about meta ads and list the ones with more than 1,000 members."
- "List the tech communities on Skool with their prices and ratings, and include the owner usernames."
- "Search Skool for communities about woodworking and tell me which are free."

The input fields are short and described as arguments, so an agent can fill them without extra guidance. No target field is mandatory: an empty input browses all discovery communities. For a precise call, provide `searchQueries`, `category`, or `startUrls`. Nonempty `startUrls` takes precedence over both keywords and category. Both URL strings and objects such as `{"url":"https://www.skool.com/discovery?q=ai"}` work. The daily-test prefill uses `{"searchQueries":["ai"],"maxItems":20,"includeAdmin":false}`; API calls must send their own values rather than relying on editor prefills. A local run of that input returned 20 records in 3.27 seconds without a proxy; network conditions can change runtime.

### Integrations and API

You can start the Actor from code, from a schedule, or from an automation tool, and read the dataset when the run ends.

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("axiomworks/skool-communities-scraper").call(
    run_input={"searchQueries": ["ai"], "maxItems": 20}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["totalMembers"])
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('axiomworks/skool-communities-scraper').call({
    searchQueries: ['ai'],
    maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
process.stdout.write(JSON.stringify(items));
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~skool-communities-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries": ["ai"], "maxItems": 20}'
```

You can also connect the Actor to Make, Zapier, n8n or Google Sheets with the Apify integrations, and set up webhooks to be told when a run finishes. Scheduling the Actor daily or weekly gives you a time series of member counts and ratings per community.

The run also respects the maximum cost per run configured in Apify. If that limit prevents saving more results, the final status says that it stopped at your maximum cost per run and reports the number saved. Those records remain available in the dataset. Increase the limit in the run options to request more on a later run.

### FAQ

**How many communities can I get per keyword?**
Skool limits discovery to about 1,000 results per keyword or category, with roughly 30 per page. Use several keywords to go wider; duplicates are removed by community ID.

**Why is `price` null for some communities?**
Free communities do not show a price. For those, `price` is null and `isFree` is true.

**Is the price in dollars?**
The `amount` is in the smallest currency unit (cents) and `currency` tells you which one. The `display` string shows the converted amount.

**Why are some admin names empty?**
Owners choose whether to fill in a first and last name. The username is shown for every owner, so use it as the reliable identifier.

**What happens with a keyword that has no results?**
The run ends successfully with zero items, a warning in the log and a final status message suggesting broader keywords, another category or a lower minimum member count. No placeholder records are written.

**What if Skool blocks a request?**
Requests are made one per second. If a request gets a block or rate-limit response, the Actor waits and retries on a fresh proxy session, up to four attempts, before giving up on that page.

**Does it work with a category and a keyword together?**
Yes. Each keyword is searched inside the selected category.

**Can I scrape a community's posts or members?**
No. This Actor covers the public community listing and, optionally, the owner. It does not log in and does not collect posts, members or private content.

### Is it legal to scrape Skool?

The Actor only reads pages that are public and open to anyone without logging in, and it makes modest, rate-limited requests. It does not access accounts, private groups, classroom content or member lists. Even so, you are responsible for how you use the data. Community descriptions, names and owner details can be personal or copyrighted information, so follow the data-protection rules that apply to you, such as GDPR, and check Skool's terms of service for your use case. Do not use the data for spam or to impersonate anyone. If you are unsure, ask a lawyer.

### Feedback

If a field is missing, a layout change breaks a run, or you want another field added, open an issue from the Actor's Issues tab in Apify Console. Include the input you used and the run ID so the problem can be reproduced quickly.

# Actor input Schema

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

Keywords to search in public Skool discovery, e.g. \["ai", "meta ads"]. Accepts an array of strings. Empty or omitted browses all communities, optionally filtered by category. Ignored when startUrls is nonempty; results are deduplicated across keywords. No matches returns zero items successfully; try broader keywords or lower minMembers.

## `category` (type: `string`):

Discovery category to combine with every keyword, e.g. "tech". Choose one listed slug; omit for all categories. Ignored when startUrls is nonempty: use the URL c parameter for a category ID.

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

Skool URLs as strings or objects with a url key, e.g. \[{"url":"https://www.skool.com/discovery?q=ai\&p=2"}] or \["https://www.skool.com/evelyn/about"]. Discovery accepts q (keyword), c (category ID), p (starting page). Nonempty URLs override searchQueries and category.

## `includeAdmin` (type: `boolean`):

Read each public About page for admin, stats and landingPageDescription, e.g. true. Default false omits these fields and avoids up to one extra request per community. Unavailable details are null when enabled.

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

Minimum totalMembers required to save a community, e.g. 1000. Integer 0-1000000, default 0 (no filter). Communities below this threshold are skipped; lower it if a run returns no results.

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

Skip communities with more than this many totalMembers, e.g. 5000 to find small niche communities. Integer 0-10000000, default 0 (no limit).

## `minRating` (type: `number`):

Skip communities whose rating is below this value or missing, e.g. 4.5. Number 0-5, default 0 (no filter). Many communities have no reviews, so a high value can return nothing.

## `pricing` (type: `string`):

Keep only free communities (free), only paid ones (paid) or both (all, default). Applied to every keyword and URL; matches the isFree field.

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

Shared limit of unique communities across all keywords or URLs, e.g. 20. Integer 1-10000, default 50. Stops earlier if results are exhausted; filters and duplicate communities do not count. Use 1 for a quick check.

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

Proxy settings object, e.g. {"useApifyProxy":true} for Apify datacenter proxy (default). Use {"useApifyProxy":false} for direct requests. Blocked or rate-limited requests retry with backoff and a fresh configured proxy session.

## Actor input object example

```json
{
  "searchQueries": [
    "ai"
  ],
  "startUrls": [],
  "includeAdmin": false,
  "minMembers": 0,
  "maxMembers": 0,
  "minRating": 0,
  "pricing": "all",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchQueries": [
        "ai"
    ],
    "includeAdmin": false,
    "minMembers": 0,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/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 = {
    "searchQueries": ["ai"],
    "includeAdmin": False,
    "minMembers": 0,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/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 '{
  "searchQueries": [
    "ai"
  ],
  "includeAdmin": false,
  "minMembers": 0,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call axiomworks/skool-communities-scraper --silent --output-dataset

```

## MCP server setup

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