# Skool Scraper (`rowfeed/skool-community-scraper`) Actor

Scrape Skool's community discovery catalog as clean JSON: name, description, category, price, member count and image for every community. Filter by category or keyword. No login.

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

## Pricing

$1.00 / 1,000 communities

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/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 Community Scraper – Discover Niches & Pricing

Get every community listed on [Skool's discovery catalog](https://www.skool.com/discovery) as clean JSON rows: name, description, category, price, member count and logo.
Built for creators researching a niche before launching a community, market researchers tracking the creator-economy space, and AI agents that need Skool's public catalog without a login or a headless browser.
Plain HTTPS calls to Skool's own server-rendered discovery page, with retries and a silent-failure check, so a scheduled run keeps working when the site hiccups.

### What you get

- **Every community as one row** – name, slug, public URL, description, price (free or monthly/yearly/one-time USD), member count, logo image, and its position in Skool's own discovery order.
- **Filters that match real research** – any combination of Skool's discovery categories (Hobbies, Music, Money, Spirituality, Tech, Health, Sports, Self-improvement, Relationships) and a keyword search, with a hard cap on rows so the cost of a run is known up front.
- **Catalog data only** – no member lists, no personal profiles, no emails. Just the public discovery listing Skool itself shows to every visitor.

### Sample row

One community from a default run (no filters):

```json
{
  "id": "4e1ca14852434c0abdefff35382cdf66",
  "name": "Imperio Agéntico",
  "slug": "imperio",
  "url": "https://www.skool.com/imperio",
  "description": "Comunidad #1 de IA\nAquí ahorramos tiempo, vamos al grano y crecemos en serio con agentes, sistemas, vibe coding y automatizaciones con IA.",
  "category": null,
  "is_free": false,
  "price_usd": 59.0,
  "price_interval": "month",
  "member_count": 3991,
  "is_private": null,
  "image_url": "https://assets.skool.com/f/4e1ca14852434c0abdefff35382cdf66/aeb420cc00cc4f8dbc31660aaff02e0c7720982540fb4a47bec630575891bd78.jpg",
  "rank": 1,
  "created_at": "2024-04-09T15:26:09.355362Z",
  "updated_at": "2026-09-11T06:51:44.491754Z",
  "scraped_at": "2026-09-11T07:59:10+00:00"
}
```

### Filters

| Input | Default | What it does |
|---|---|---|
| `categories` | `[]` | Skool discovery category slugs, e.g. `["money", "tech"]`. Empty = all categories. An unknown slug becomes a non-charged error row instead of failing the run. |
| `query` | `""` | Keep only communities matching this keyword (Skool's own discovery search). |
| `maxCommunities` | `200` | Keep this many rows after filtering. |

Multiple categories run as separate scrapes and are merged, deduplicated by community id. `category` on a row is the filter that matched it, not an intrinsic property — Skool's discovery catalog does not tag a community's own category, only the search filter.

### Pricing

Pay per event, no subscription: **$1 per 1,000 communities**. A default run (200 communities) costs $0.20. Set a maximum charge on the run and the Actor stops cleanly when it is reached, charging only for rows that were actually saved.

### Use it from your tools

- **API and SDKs** – call it via the Apify API or the official Python/JavaScript clients: one call to start the run, one to fetch the dataset as JSON or CSV.
- **Schedules** – run it daily inside Apify and push new communities to Google Sheets, a webhook or your own storage automatically.
- **n8n, Make and Zapier** – trigger runs and pipe communities into a workflow through Apify's integration for each.
- **AI agents and MCP** – this Actor supports pay-per-event pricing, so an agent can call it mid-task and pay only per community it actually reads.

### Details

- **Source**: Skool's public discovery page (`skool.com/discovery`), a server-rendered Next.js page whose `__NEXT_DATA__` JSON block carries the full community list, category list and pagination state. No authentication, no proxies, no browser, no personal data.
- **Pagination**: 30 communities per page; the Actor pages until it reaches `maxCommunities` or Skool returns a short/empty page.
- **No sort option**: rows come in Skool's own discovery order (roughly trending/relevance); there is no way to order by members, price or age on the source, so sort the dataset yourself.
- **`is_private`**: Skool's discovery catalog does not expose a private/public flag for a community, so this column is always `null`; it is kept for forward compatibility if Skool adds it.
- **Reliability**: 429 and 5xx responses are retried with exponential backoff (5 tries), a 200 without the expected `__NEXT_DATA__` block counts as a failure, and one bad category never stops the run: it becomes an error row (`category`, `error`, `errorMessage`) and the rest continues. A run fails only when it produced no rows *and* hit request errors; a filter with no matching communities is a successful, empty run.
- **Run stats**: the `STATS` record in the run's key-value store holds request and error counts per category (`network`, `rate_limit`, `blocked`, `not_found`, `other`).
- **Speed**: a default run (200 communities, 7 requests) finishes in a few seconds.
- **Output**: one dataset row per community with the columns above first and every raw Skool metadata field after them. The Overview table shows name, category, free/paid, price, members and URL. Export as JSON, CSV or Excel, fetch through the Apify API, or schedule runs and pipe them into Google Sheets, Make, Zapier or your own code.

Not affiliated with Skool.

# Actor input Schema

## `categories` (type: `array`):

Skool discovery categories to scrape, by slug. Leave empty to scrape all categories. Known slugs: hobbies, music, money, spirituality, tech, health, sports, self\_improvement, relationships (the Actor also verifies the current list at run time and reports an error row for an unknown slug).

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

Keep only communities matching this keyword (Skool's own discovery search). Leave empty to skip search filtering.

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

Keep this many community rows after filtering. Each row is one `community` event ($1 per 1,000). Communities are scraped in Skool's own discovery order (roughly trending/relevance), 30 per page.

## Actor input object example

```json
{
  "categories": [
    "money",
    "tech"
  ],
  "query": "",
  "maxCommunities": 200
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rowfeed/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rowfeed/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 '{}' |
apify call rowfeed/skool-community-scraper --silent --output-dataset

```

## MCP server setup

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