# Skool Members Roster Scraper (`michael_bloom10x/skool-members-scraper`) Actor

Scrapes a Skool community's full member roster across all lifecycle segments (active, cancelling, churned, banned) with per-member subscription/revenue detail — price, billing interval, renewal date, LTV, attribution, points/level.

- **URL**: https://apify.com/michael\_bloom10x/skool-members-scraper.md
- **Developed by:** [Michael](https://apify.com/michael_bloom10x) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Members Roster Scraper

### What does Skool Members Roster Scraper do?

Skool Members Roster Scraper lets you extract comprehensive member data from [Skool](https://www.skool.com) communities with greater detail and flexibility than manual exports — including subscription and revenue fields not shown in Skool's CSV.

Skool Members Roster Scraper can scrape:

- Member email addresses
- First and last names, and member handle
- Join and approval dates
- Subscription price, currency, and billing interval
- Renewal date and Stripe subscription id
- Lifetime value (LTV)
- Acquisition source
- Points and level information
- Member lifecycle status: active, cancelling, churned, banned

### Why scrape Skool?

Skool is a rapidly growing community platform with thousands of active communities. The member roster data is valuable for community managers, business analysts, and operators who need deep insights into their community composition and member behavior. Here are just some of the ways you could use that data:

- **CRM integration**: Sync your complete member roster into your CRM for unified customer management
- **Churn analysis**: Identify patterns in cancellations and churn with detailed lifecycle data
- **Revenue analytics**: Track subscription pricing, billing intervals, and lifetime value across your member base
- **Growth attribution**: Analyze acquisition sources to understand which channels drive your most valuable members
- **Engagement tracking**: Monitor member points and level progression to spot engagement trends
- **Community health dashboards**: Build dashboards showing member composition across all lifecycle segments

### How to scrape Skool

It's easy to scrape [Skool](https://www.skool.com) with Skool Members Roster Scraper. Just follow these steps and you'll get your data in a few minutes.

1. Click on **Try for free** / **Start**.
2. Paste your Skool **admin session cookie** into the `cookie` input.
3. Set `groupSlug` to your community slug (e.g. `your-community` from `skool.com/your-community`).
4. Optionally choose which `segments` to scrape (defaults to all four).
5. Click on **Run**, then preview or download your data from the **Dataset** tab (one record per member).

### Input parameters

- **cookie** (required): The full `Cookie` header from a logged-in Skool **admin** session. Must include `auth_token` and `aws-waf-token`. Export it via a cookie extension or copy the `Cookie:` request header from DevTools. Cookies expire after a few days — refresh on a `401/403`.
- **groupSlug** (required): The community slug from its URL, e.g. `your-community`.
- **segments** (optional): Which lifecycle segments to scrape. Default: `["active", "cancelling", "churned", "banned"]`.
- **maxItems** (optional): Cap on the total number of members scraped across all segments.
- **requestDelayMs** (optional, default `400`): Politeness delay between page fetches.
- **proxyConfiguration** (optional): Defaults to Apify **Residential** proxy, required to clear Skool's WAF.

### Results

The actor outputs one record per member in JSON. Monetary values are in the account currency (dollars):

```json
{
  "userId": "a1b2c3d4e5f60718293a4b5c6d7e8f90",
  "handle": "john-doe-1234",
  "firstName": "John",
  "lastName": "Doe",
  "email": "john@example.com",
  "timeZone": "America/New_York",
  "bio": "Coach and lifelong student of the game.",
  "location": "(united states)",
  "segment": "active",
  "role": "member",
  "joinedAt": "2026-01-05T10:30:00Z",
  "approvedAt": "2026-01-05T10:31:00Z",
  "lastOffline": "2026-01-14T22:15:00Z",
  "isPaid": true,
  "billingProductId": "b0c1d2e3f4a5b6c7d8e9f0a1b2c3d4e5",
  "price": 29,
  "priceCurrency": "usd",
  "billingInterval": "month",
  "renewalAt": "2026-02-05T10:31:00Z",
  "ltv": 87,
  "subscriptionId": "sub_ExampleAbc123",
  "billingEmail": "john@example.com",
  "attribution": "direct",
  "points": 120,
  "level": 3
}
````

Free members have `isPaid: false` with `price`, `renewalAt`, `ltv`, and `subscriptionId` set to `null`.

### Tips for scraping Skool

- **Authentication required**: You must provide a valid admin session cookie to access the roster — log in to your Skool community as an admin to obtain it.
- **Residential proxy recommended**: Skool uses WAF protection. The actor defaults to a residential proxy and retries with a fresh proxy session on transient errors.
- **Complete lifecycle coverage**: All segments (active, cancelling, churned, banned) are scraped in a single run for a full member picture. If any segment can't be fetched, the run fails loudly rather than returning partial data.
- **Regular exports**: Schedule runs to track member changes, growth, and churn over time.
- **CRM sync / dashboards**: The consistent JSON output (keyed by `email`) integrates cleanly with a CRM or a BI pipeline. Pair it with the Skool Revenue Dashboard Scraper for top-line financials.

### Is it legal to scrape Skool?

You should only use this actor on Skool communities you **own or have explicit admin permission to access** — admin rights are required to obtain the session cookie. Note that personal data is protected by GDPR in the EU and by other regulations worldwide. Do not scrape or share personal data without a legitimate reason. If you're unsure whether your reason is legitimate, consult your lawyers. We also recommend reading Apify's post: [is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

# Actor input Schema

## `cookie` (type: `string`):

The full Cookie header from a logged-in Skool ADMIN session (must include auth\_token and aws-waf-token). Export via a cookie extension (e.g. EditThisCookie) → copy the skool.com cookie string. Expires every few days; refresh on 401/403.

## `groupSlug` (type: `string`):

The community slug from its URL, e.g. skool.com/your-community → "your-community".

## `segments` (type: `array`):

Which member segments to scrape. Iterate all four for a complete roster incl. churn.

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

Optional cap on total members scraped (across all segments). Leave empty for all.

## `requestDelayMs` (type: `integer`):

Politeness delay between page fetches to avoid WAF throttling.

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

Skool is behind AWS WAF — residential proxy strongly recommended.

## Actor input object example

```json
{
  "groupSlug": "your-community",
  "segments": [
    "active",
    "cancelling",
    "churned",
    "banned"
  ],
  "requestDelayMs": 400,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "groupSlug": "your-community"
};

// Run the Actor and wait for it to finish
const run = await client.actor("michael_bloom10x/skool-members-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 = { "groupSlug": "your-community" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skool Members Roster Scraper",
        "description": "Scrapes a Skool community's full member roster across all lifecycle segments (active, cancelling, churned, banned) with per-member subscription/revenue detail — price, billing interval, renewal date, LTV, attribution, points/level.",
        "version": "1.0",
        "x-build-id": "RVQEuXUFAlFdzryEs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/michael_bloom10x~skool-members-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-michael_bloom10x-skool-members-scraper",
                "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/michael_bloom10x~skool-members-scraper/runs": {
            "post": {
                "operationId": "runs-sync-michael_bloom10x-skool-members-scraper",
                "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/michael_bloom10x~skool-members-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-michael_bloom10x-skool-members-scraper",
                "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",
                "required": [
                    "cookie",
                    "groupSlug"
                ],
                "properties": {
                    "cookie": {
                        "title": "Skool auth cookie",
                        "type": "string",
                        "description": "The full Cookie header from a logged-in Skool ADMIN session (must include auth_token and aws-waf-token). Export via a cookie extension (e.g. EditThisCookie) → copy the skool.com cookie string. Expires every few days; refresh on 401/403."
                    },
                    "groupSlug": {
                        "title": "Group slug",
                        "type": "string",
                        "description": "The community slug from its URL, e.g. skool.com/your-community → \"your-community\"."
                    },
                    "segments": {
                        "title": "Lifecycle segments",
                        "type": "array",
                        "description": "Which member segments to scrape. Iterate all four for a complete roster incl. churn.",
                        "default": [
                            "active",
                            "cancelling",
                            "churned",
                            "banned"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max members",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional cap on total members scraped (across all segments). Leave empty for all."
                    },
                    "requestDelayMs": {
                        "title": "Delay between pages (ms)",
                        "type": "integer",
                        "description": "Politeness delay between page fetches to avoid WAF throttling.",
                        "default": 400
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Skool is behind AWS WAF — residential proxy strongly recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```