# Skool Community Lead & Engagement Extractor (`coolinbex/skool-community-lead-extractor`) Actor

Turn public Skool communities into actionable B2B intelligence. Discover members, bios, social links, leaderboard rankings, high-engagement posts, likes, comments, and recurring keywords in one clean dataset.

- **URL**: https://apify.com/coolinbex/skool-community-lead-extractor.md
- **Developed by:** [coolinbex](https://apify.com/coolinbex) (community)
- **Stats:** 2 total users, 1 monthly users, 100.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/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 Lead & Engagement Extractor

Turn public Skool communities into structured B2B intelligence for prospecting, creator research, audience analysis, and community-led growth.

Provide one or more public Skool community URLs and receive clean dataset records for community information, owners, members, posts, comments, engagement, leaderboards, and recurring topics.

> **Public content only:** This Actor does not log in, join communities, bypass access controls, or collect private content. Results depend on what Skool makes publicly visible to an unauthenticated visitor.

### Why use this Actor?

| Capability | What you get |
| --- | --- |
| **Community intelligence** | Community name, description, owner, membership model, member counts, post counts, courses, modules, visible tabs, and canonical URL |
| **Lead discovery** | Public member names, handles, profile URLs, bios, avatars, and linked social profiles |
| **Engagement analysis** | Post text, authors, dates, likes, comments, bounded comment records, and aggregate totals |
| **Creator research** | Owner profile, public bio, website and social links, role, and community context |
| **Topic discovery** | Recurring keywords ranked by document frequency across extracted posts and comments |
| **Resilient crawling** | Browser rendering, retries, session rotation, proxy support, pagination guards, timeouts, and route-level error isolation |

### Quick start

#### 1. Add community URLs

In the Actor input, add one or more public Skool URLs:

```json
{
  "startUrls": [
    { "url": "https://www.skool.com/your-community" }
  ]
}
```

You can also paste URLs directly into the **Skool community URLs** field in Apify Console.

#### 2. Choose your extraction scope

The defaults are designed for a useful first run. Increase limits for larger research jobs or disable expensive enrichment when you only need community-level data.

```json
{
  "maxCommunities": 10,
  "maxMembers": 500,
  "maxPosts": 100,
  "maxCommentsPerPost": 500,
  "includeProfiles": true,
  "includeComments": true,
  "includeLeaderboard": true,
  "includeKeywords": true
}
```

#### 3. Run and export

Start the Actor, open the **Dataset** tab when the run completes, and export the results as JSON, CSV, Excel, or any other format supported by Apify.

### Input reference

| Input | Type | Default | Description |
| --- | --- | ---: | --- |
| `startUrls` | Array | `https://www.skool.com/growth` | Public Skool community URLs to process |
| `maxCommunities` | Integer | `10` | Maximum communities to process |
| `maxMembers` | Integer | `500` | Maximum member profiles discovered per community |
| `maxPosts` | Integer | `100` | Maximum public posts extracted per community |
| `maxCommentsPerPost` | Integer | `500` | Maximum comment texts retained per post |
| `includeProfiles` | Boolean | `true` | Visit public member profiles for bios and social links |
| `includeComments` | Boolean | `true` | Emit individual comment records in addition to post metrics |
| `includeLeaderboard` | Boolean | `true` | Extract public leaderboard entries when available |
| `includeKeywords` | Boolean | `true` | Calculate recurring keywords from posts and comments |
| `proxyConfiguration` | Object | Apify Proxy | Proxy settings; residential proxies are recommended for larger runs |
| `requestTimeoutSecs` | Integer | `45` | Maximum navigation/profile request time |
| `renderWaitMs` | Integer | `1200` | Wait time for client-rendered content after navigation |

<details>
<summary><strong>Recommended configurations</strong></summary>

#### Fast community overview

Use this when you need community and owner data quickly:

```json
{
  "maxCommunities": 25,
  "maxMembers": 1,
  "maxPosts": 1,
  "includeProfiles": false,
  "includeComments": false,
  "includeLeaderboard": false,
  "includeKeywords": false
}
```

#### Lead research

Use this when building a prospect list:

```json
{
  "maxMembers": 1000,
  "maxPosts": 250,
  "includeProfiles": true,
  "includeComments": false,
  "includeKeywords": true
}
```

#### Engagement research

Use this when analyzing content and audience activity:

```json
{
  "maxMembers": 1,
  "maxPosts": 1000,
  "maxCommentsPerPost": 1000,
  "includeProfiles": false,
  "includeComments": true,
  "includeLeaderboard": true,
  "includeKeywords": true
}
```

</details>

### Dataset output

The Actor writes one normalized dataset containing several record types. Filter by `recordType` to build the view you need.

| Record type | Contains |
| --- | --- |
| `community` | Community metadata, owner, counts, visible tabs, canonical URL, and public-access status |
| `member` | A discovered public member or owner record |
| `member_profile` | Enriched public profile with bio, avatar, handle, and social links |
| `post` | Post URL, text, author, date, likes, and comment count |
| `comment` | Bounded public comment text associated with a post |
| `leaderboard` | Rank, member, points, level, and activity text |
| `keyword_summary` | Recurring keywords and document frequency |
| `community_metrics` | Extracted post, like, comment, member, and leaderboard totals |
| `error` | Structured failure information when a community cannot be navigated after retries |

#### Example community record

```json
{
  "recordType": "community",
  "communityName": "Example Community",
  "communityUrl": "https://www.skool.com/example",
  "stats": {
    "totalMembers": 1250,
    "totalPosts": 480,
    "totalCourses": 12
  },
  "owner": {
    "name": "Community Creator",
    "bio": "Public creator bio",
    "profileUrl": "https://www.skool.com/@creator",
    "socialLinks": [
      "https://www.linkedin.com/in/creator"
    ]
  }
}
```

### How reliability works

The Actor is designed for long-running research jobs:

- **Rendered-page extraction** handles Skool’s client-side interface.
- **Payload-first parsing** uses public page data when it is more complete than visible HTML.
- **Automatic retries** recover from transient navigation and network failures.
- **Session rotation** helps isolate problematic browser sessions.
- **Proxy support** is enabled through Apify Proxy by default.
- **Pagination guards** prevent infinite “load more” loops.
- **Record isolation** means a failed profile or unavailable route does not discard successful community records.
- **Visibility reporting** distinguishes unavailable private content from an empty community.

<details>
<summary><strong>Why are some posts or members missing?</strong></summary>

Skool can expose a public landing page while requiring membership or authentication for posts, members, classroom content, or leaderboards. The Actor does not bypass those restrictions. In this situation, it returns the public community and owner data and records the available access state.

Missing records can also occur when:

- a community is private;
- a route is available only to logged-in members;
- Skool changes its page structure;
- a profile is hidden or deleted;
- a transient request fails after the configured retry limit.

</details>

### Proxy and scale recommendations

For small tests, the default configuration is sufficient. For larger runs:

1. Use Apify Proxy with a residential group.
2. Keep per-community limits realistic.
3. Start with a small sample and increase `maxMembers` and `maxPosts` gradually.
4. Use `includeProfiles: false` if you only need community and post-level intelligence.
5. Review `warnings` and `community_metrics` records after each large run.

### Responsible use

Use this Actor only for public information and in accordance with:

- Skool’s Terms of Service and robots directives;
- applicable privacy and data-protection laws;
- your organization’s prospecting and outreach policies.

Do not use extracted data for harassment, deceptive impersonation, unauthorized account access, or sensitive profiling.

### Frequently asked questions

<details>
<summary><strong>Can it scrape private Skool communities?</strong></summary>

No. It does not authenticate or bypass membership controls. It extracts only content publicly available to an unauthenticated visitor.

</details>

<details>
<summary><strong>Can I process multiple communities in one run?</strong></summary>

Yes. Add multiple objects to `startUrls` and set `maxCommunities` to the desired limit.

</details>

<details>
<summary><strong>How are engagement numbers represented?</strong></summary>

Counts are normalized to numbers. Values such as `1.2K` and `3M` are converted to `1200` and `3000000`.

</details>

<details>
<summary><strong>What happens when one community fails?</strong></summary>

The Actor retries the request and rotates sessions as needed. A permanently failed community produces an `error` record rather than silently disappearing.

</details>

<details>
<summary><strong>Where do I get the results?</strong></summary>

Open the completed run in Apify Console and use the **Dataset** tab to inspect, filter, or export the records.

</details>

# Actor input Schema

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

Public Skool community URLs to crawl. Add one or more /community-slug URLs.

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

Maximum number of community pages to process.

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

Maximum number of member profiles to discover per community.

## `maxPosts` (type: `integer`):

Maximum number of public posts to extract per community.

## `maxCommentsPerPost` (type: `integer`):

Maximum number of public comments to retain for each post.

## `includeProfiles` (type: `boolean`):

Visit member profile pages to collect public bios and linked social profiles.

## `includeComments` (type: `boolean`):

Emit individual comment records in addition to post-level comment counts.

## `includeLeaderboard` (type: `boolean`):

Extract public leaderboard rankings when the community exposes them.

## `includeKeywords` (type: `boolean`):

Calculate recurring keywords from extracted post and comment text.

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

Apify Proxy settings. Residential proxies are recommended for larger runs.

## `requestTimeoutSecs` (type: `integer`):

Maximum time allowed for each browser navigation and profile request.

## `renderWaitMs` (type: `integer`):

Time to wait for client-rendered content after navigation.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.skool.com/growth"
    }
  ],
  "maxCommunities": 10,
  "maxMembers": 500,
  "maxPosts": 100,
  "maxCommentsPerPost": 500,
  "includeProfiles": true,
  "includeComments": true,
  "includeLeaderboard": true,
  "includeKeywords": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "requestTimeoutSecs": 45,
  "renderWaitMs": 1200
}
```

# Actor output Schema

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

All records produced by the actor, including community, member, post, leaderboard, keyword\_summary, and error records.

# 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("coolinbex/skool-community-lead-extractor").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("coolinbex/skool-community-lead-extractor").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 coolinbex/skool-community-lead-extractor --silent --output-dataset

```

## MCP server setup

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

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/UczHESiM31MmlS82Z/builds/e4j4XShKGEwKZFzba/openapi.json