# Skool/Whop Community Analyzer (`zucchini_gopher_m2v/skool-whop-community-analyzer`) Actor

Extract member count, disclosed subscription price, and an estimated monthly revenue (MRR) signal from a Skool or Whop community -- no account or API key needed. Built for sponsorship/collaboration lead scouting.

- **URL**: https://apify.com/zucchini\_gopher\_m2v/skool-whop-community-analyzer.md
- **Developed by:** [Faisal Ahdan naufal](https://apify.com/zucchini_gopher_m2v) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 1,000 community records

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?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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/Whop Community Analyzer

Extract member count, subscription price, and an estimated monthly revenue signal from any public Skool or Whop community — built for finding creators worth pitching for sponsorship or collaboration.

### Why use this actor

- **No account or login required** — works on fully public community pages.
- **One combined tool for both platforms** — point it at a Skool community or a Whop community with the same actor, just switch the mode.
- **Built-in revenue estimate** — combines member count and disclosed subscription price into an `estimatedMonthlyRevenue` figure, so you don't have to do the math yourself across a list of leads.
- **Stable JSON output** ready to drop into a spreadsheet, CRM, or outreach pipeline.
- **Automatic retries** on temporary network hiccups — no babysitting long lists of URLs.
- **Bulk-friendly** — feed it a list of community URLs and get one row back per community.

### How it works

1. You give it one or more Skool or Whop community URLs (or bare slugs) and pick the platform.
2. It visits each community's public page and reads the member count, name, description, and (when the creator has made it public) the subscription price.
3. For Whop communities, it also checks the community's pricing page to find the plan price.
4. It multiplies member count by the monthly price to produce an estimated monthly revenue figure, and tells you exactly how that number was derived.
5. Every community comes back as one clean row of data — no manual copy-pasting from community pages.

### Input

**Skool mode**

```json
{
  "mode": "skool",
  "urls": [
    "https://www.skool.com/freegroup",
    "https://www.skool.com/skool-100"
  ],
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

**Whop mode**

```json
{
  "mode": "whop",
  "url": "https://whop.com/kaizen",
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

| Field | Type | Description |
|---|---|---|
| `mode` | string | `"skool"` or `"whop"` — which platform the URL(s) belong to. |
| `url` | string | A single community URL or bare slug. |
| `urls` | array | Multiple community URLs/slugs to process in one run (same platform). |
| `maxConcurrency` | integer | How many communities to fetch in parallel. Default `4`. |
| `proxyConfiguration` | object | Apify Proxy settings. Residential is on by default and recommended, especially for Whop mode. |

### Output

**Skool example** (`freegroup`, real output, truncated):

```json
{
  "_input": "https://www.skool.com/freegroup",
  "_source": "S1-nextdata",
  "_scrapedAt": "2026-08-28T19:37:19Z",
  "platform": "skool",
  "communityName": "AI Automation (A-Z)",
  "url": "https://www.skool.com/freegroup",
  "memberCount": 164801,
  "isPaid": true,
  "subscriptionPrice": {
    "amountUsd": 7.0,
    "currency": "usd",
    "interval": "month",
    "monthlyEquivalentUsd": 7.0
  },
  "estimatedMonthlyRevenue": 1153607.0,
  "estimatedMonthlyRevenueBasis": "memberCount (164801) x monthly price ($7.00) -- upper-bound estimate; memberCount includes free/trial members on both platforms, so treat this as a triage signal, not verified revenue.",
  "raw": { "... full community details (description, admin count, post count, etc.)": "..." }
}
```

**Whop example** (`kaizen`, real output, truncated):

```json
{
  "_input": "kaizen",
  "_source": "S1-html-rsc-scan",
  "_scrapedAt": "2026-08-28T19:41:08Z",
  "platform": "whop",
  "communityName": "Kaizen",
  "url": "https://whop.com/kaizen",
  "memberCount": 4541,
  "isPaid": true,
  "subscriptionPrice": {
    "monthlyEquivalentUsd": 183.33,
    "currency": "usd"
  },
  "estimatedMonthlyRevenue": 832501.53,
  "estimatedMonthlyRevenueBasis": "memberCount (4541) x monthly price ($183.33) -- upper-bound estimate; memberCount includes free/trial members on both platforms, so treat this as a triage signal, not verified revenue.",
  "raw": { "... plans, access passes, review count, etc.": "..." }
}
```

| Field | Type | Description |
|---|---|---|
| `platform` | string | `"skool"` or `"whop"`. |
| `communityName` | string | The community's display name. |
| `url` | string | The community's canonical URL. |
| `memberCount` | integer | Total members shown on the community's page. This includes free/trial members, not just paying subscribers. |
| `isPaid` | boolean | Whether the community charges for access. |
| `subscriptionPrice` | object | The disclosed monthly-equivalent price, when the creator has made it publicly visible. Some paid communities don't show their price without logging in — in that case this is `null`. |
| `estimatedMonthlyRevenue` | number | `memberCount × monthly price` — a triage estimate, not verified revenue. `null` when price isn't disclosed. |
| `estimatedMonthlyRevenueBasis` | string | Plain-language explanation of how the estimate was calculated, or why it's unavailable. |
| `raw` | object | The full set of community details captured (description, admin/post counts, review ratings, plan options, etc). |

### Notes

- Neither platform publishes actual creator revenue — `estimatedMonthlyRevenue` is a member-count-times-price estimate meant for quickly ranking and shortlisting leads, not an exact figure.
- Some paid Skool communities don't disclose their price to logged-out visitors. When that happens, member count is still returned, but the price and revenue estimate come back as `null`.
- For best reliability, keep Residential proxy enabled (on by default) — especially in Whop mode.

# Actor input Schema

## `mode` (type: `string`):

Which platform the URL(s) below belong to.

## `url` (type: `string`):

A single community URL or bare slug, e.g. "https://www.skool.com/skool-100" or "skool-100" (Skool mode), or "https://whop.com/kaizen" or "kaizen" (Whop mode).

## `urls` (type: `array`):

Multiple community URLs/slugs to process in one run (same platform, per the selected mode).

## `maxConcurrency` (type: `integer`):

How many communities to fetch in parallel.

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

Apify Proxy configuration. Residential is on by default. Recommended especially for Whop mode, which sits behind Cloudflare Bot Management -- see the actor's README for details.

## Actor input object example

```json
{
  "mode": "skool",
  "url": "https://www.skool.com/skool-100",
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped community records produced by this run.

# 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 = {
    "mode": "skool",
    "url": "https://www.skool.com/skool-100",
    "maxConcurrency": 4,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zucchini_gopher_m2v/skool-whop-community-analyzer").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 = {
    "mode": "skool",
    "url": "https://www.skool.com/skool-100",
    "maxConcurrency": 4,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("zucchini_gopher_m2v/skool-whop-community-analyzer").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 '{
  "mode": "skool",
  "url": "https://www.skool.com/skool-100",
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call zucchini_gopher_m2v/skool-whop-community-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zucchini_gopher_m2v/skool-whop-community-analyzer"
        }
    }
}

```

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/wQqfFM7KeIq2J1Cnm/builds/KfBkpRFPxeoDPbd6e/openapi.json