Skool Group Community Infos Scraper & Member Reviews

Skool Scraper — Extract Communities, Member Reviews and Owner Data

Skool Group Community Infos Scraper & Member Reviews pulls structured data from any public Skool group's /about page — community identity, member and post counts, course structure, the group owner's profile, and, uniquely, the star-rated reviews real members left before joining. Each community you submit comes back as one dataset row, built from a single logged-out HTTP request. Unlike scraping frameworks that return raw HTML, Skool Group Community Infos Scraper & Member Reviews returns typed JSON — ready for your model, your database, or your pipeline without any parsing. This guide covers every input and output field, plus three ways teams put the review data to work.

🧭 What Does Skool Group Community Infos Scraper & Member Reviews Do?

It fetches the public /about page of one or more Skool communities and parses the __NEXT_DATA__ JSON blob every Skool page ships to the browser — no Skool account, login, or cookies required. From that single response it returns the community's snapshot fields, the owner's profile, and (when enabled) the member reviews Skool displays on that same page, with rating and paying-status filters applied before the row is written.

• Community identity and metadata — name, description, cover image, slug, timestamps
• Activity counters — total members, online members, posts, admins
• Group configuration — privacy setting, membership type, course/module counts
• Raw tab-visibility and onboarding-survey JSON blocks as Skool stores them
• Owner profile — id, name, bio, location, profile picture, account timestamps
• Member reviews — star rating, review text, dates, and paying/member-since status per reviewer
• Review filtering by minimum star rating and by currently-paying status, before the row is written

⚡ Features & Capabilities

The Actor combines a base community-snapshot extractor with a review harvester that reads off the same response, plus an automatic connection ladder for pages that are slow to load.

Core features

• One dataset row per submitted URL or slug, written to the dataset as soon as it's collected
• Community fields straight from Skool's own metadata block: group_id, group_name, group_description, total_members, total_online_members, total_posts, total_admins, privacy, membership, num_courses, num_modules
• Nested owner object (id, name, email, location, bio, picture_profile, created_at, updated_at) plus a flattened owner_name for quick display
• reviews[] array — each item carries id, rating, body, createdAt, updatedAt, memberSince, memberCurrentlyPaying, and a nested user block
• Two independent review filters — minReviewRating and payingReviewersOnly — applied before reviewsReturned is counted
• Automatic proxy escalation: direct connection first, then Apify datacenter proxy, then residential proxy with retries, only when proxyConfiguration is supplied

How Skool Group Community Infos Scraper & Member Reviews compares to other Skool scrapers

Feature	Skool Group Community Infos Scraper & Member Reviews	Skool Group Scraper (gordian)	Skool Scraper (louisdeconinck)
Member reviews (rating, text, reviewer status)	Yes	Not listed on the Actor's store page (checked 2026-08-16)	Not listed on the Actor's store page (checked 2026-08-16)
Skool login / cookies required	No	No (per store listing, checked 2026-08-16)	Yes — auth token from a browser extension (per store listing, checked 2026-08-16)
Owner profile fields	id, name, email, location, bio, picture, timestamps	Owner profile with social links (per store listing, checked 2026-08-16)	Owner/creator profile (per store listing, checked 2026-08-16)
Connection handling	Direct → datacenter proxy → residential proxy, automatic	Not stated on the store listing	Not stated on the store listing
Pricing model	Pay per event (row_result)	Pay per event — $8.00 / 1,000 results (per store listing, checked 2026-08-16)	Monthly rental + usage — $19.00/month (per store listing, checked 2026-08-16)
Store rating (checked 2026-08-16)	New listing	No ratings yet	2.39 / 5

If your use case is feeding structured data to an LLM, the output format row is the decision-maker — HTML parsing inside an agent loop is a reliability failure mode, not a feature.

When another tool might suit you better

This Actor returns one row per community, not a full member roster — if you need every member's name, email, and social links across an entire community, a members-and-groups scraper such as memo23's Skool Members Scraper is built for that (it requires Skool login cookies, which this Actor deliberately avoids). Likewise, this Actor does not extract subscription price fields — Skool Group Scraper (gordian) returns monthly/annual subscription amounts if pricing data is what you need instead of reviews.

Skool Group Community Infos Scraper & Member Reviews within the Scrapio data stack

This is currently Scrapio's only Skool Actor, and it already combines the community snapshot and the member-review data in a single run — you don't need to chain two Actors together to get both. For review data on other platforms, Scrapio publishes platform-specific review scrapers: Google Maps Reviews Scraper By Place Search & Location, Airbnb Review Scraper: Category Ratings & Host Replies, Facebook Reviews Scraper With Date & Keyword Filters, and Udemy Course Reviews Scraper — Syllabus, Lectures & Quizzes.

Why do developers and data teams scrape Skool?

Skool has no official public API — no documented REST endpoints, developer portal, or API key system — so structured access to community data has to come from parsing the pages Skool already serves publicly.

🏢 Community operators and creators

Anyone running a paid Skool community checks what competitors are doing before setting their own price, curriculum, or positioning. Feed a list of rival community URLs in and get back total_members, total_posts, num_courses, num_modules, and — through reviews[] — what paying members actually say about the experience, including memberCurrentlyPaying so you can tell current subscribers from people who already churned out.

📊 AI training data and RAG indexing

group_description and reviews[].body are the two high-information free-text fields here — group descriptions explain what a community promises, and review bodies describe what members actually got. For RAG, index group_description and review text so an assistant can answer "what is this community about" and "what do members say" from real page content. For training data, total_members, total_posts, reviewsReturned, and reviews[].rating are consistently structured numeric fields across every row, with no text cleanup needed.

📱 Competitive and market intelligence

Track total_members and total_posts for the same slug over repeated runs to watch growth or stagnation, and watch reviewsReturned and the distribution of reviews[].rating to see whether member sentiment is trending up or down after a pricing or curriculum change.

🔬 Research and academic use

Researchers studying the creator economy or paid-community engagement can build a dataset of community size, activity, and member-reported experience across many Skool groups using only publicly visible /about page data — no account creation or authentication involved.

🎥 Product and SaaS development

Community-discovery or "due diligence before you join" products can be built directly on owner, reviews[], and the activity counters — surfacing who runs a community, what it costs in effort to stay active, and what real members thought, without maintaining your own Skool parser.

🍚 Input Parameters

Parameter	Required	Type	Description	Example Value
urls	Yes	array (string list)	Skool community/group links, one per line — a full /about URL or a bare slug. Each entry becomes its own dataset row.	["https://www.skool.com/ai-automation-society-plus/about", "adonis-gang"]
scrapeReviews	No	boolean	When true (default), each row also carries the community's member reviews. When false, reviews comes back empty and only the snapshot fields are populated. Default true.	true
maxReviewsPerCommunity	No	integer	Caps how many reviews are kept per community, after filtering. Minimum 1, maximum 500, default 50.	50
minReviewRating	No	integer	Drops reviews rated below this many stars. Minimum 1, maximum 5, default 1 (keep every review).	4
payingReviewersOnly	No	boolean	When true, keeps only reviews from members Skool currently marks as paying (memberCurrentlyPaying: true). Default false.	false
proxyConfiguration	No	object (proxy editor)	Optional Apify Proxy configuration. Leave unset for the simplest setup — the Actor always tries a direct connection first.	{"useApifyProxy": true}
maxRetries	No	integer	How many times to retry a single request on a connection error (not on missing data). Minimum 0, maximum 10, default 3.	3

Example input:

{
  "urls": [
    "https://www.skool.com/ai-automation-society-plus/about",
    "adonis-gang"
  ],
  "scrapeReviews": true,
  "maxReviewsPerCommunity": 50,
  "minReviewRating": 1,
  "payingReviewersOnly": false,
  "maxRetries": 3
}

Supported URL types and input formats

The Actor accepts a mix of formats in the same urls list — each entry is normalized to https://www.skool.com/{slug}/about before it's fetched:

• Full /about URL: https://www.skool.com/ai-automation-society-plus/about
• Any other Skool URL for that group — only the first path segment (the slug) is used, so https://www.skool.com/adonis-gang/classroom resolves the same as the /about link
• Bare slug, no domain: adonis-gang

Entries that resolve to no slug (empty strings, malformed URLs) are skipped and pushed as an error row rather than stopping the run.

📦 Output Format

Every run writes one dataset row per input entry as soon as that community is collected — the Output tab fills in live while the run is in progress. Rows export from the Apify dataset as JSON, CSV, Excel, XML, or RSS through the standard Apify dataset export options.

A row for an unreachable or unparsable URL carries only slug, url, group_name, owner_name, and error — it does not include the full field set below.

Output for a community row

{
  "slug": "ai-automation-society-plus",
  "url": "https://www.skool.com/ai-automation-society-plus/about",
  "group_id": "29a80fa0d5f8420a9b2a3f0e2f7e9b13",
  "group_name": "AI Automation Society Plus",
  "group_description": "Learn to build and sell AI automations. Weekly calls, templates, and a community of builders.",
  "group_image": "https://img.skool.com/cover-images/example-cover.png",
  "group_created_at": "2023-11-02T14:21:09.000Z",
  "group_updated_at": "2026-08-01T09:12:44.000Z",
  "total_members": 4820,
  "total_online_members": 63,
  "total_posts": 9142,
  "total_admins": 4,
  "privacy": "private",
  "map_enabled": "N/A",
  "membership": "paid",
  "num_courses": 12,
  "num_modules": 58,
  "tabs": {},
  "survey": {},
  "owner": {
    "id": "8f21c3e4a9b7452d8c1e0f6a9d3b7c22",
    "name": "Jamie Carter",
    "email": "N/A",
    "location": "Austin, TX",
    "bio": "Building AI automation tools and teaching others to do the same.",
    "picture_profile": "https://img.skool.com/profiles/example-owner.jpg",
    "created_at": "2022-05-14T08:30:00.000Z",
    "updated_at": "2026-07-28T11:02:15.000Z"
  },
  "owner_name": "Jamie Carter",
  "reviews": [
    {
      "id": "b7a2e1f0-4c3d-4a9e-9f21-8e6b5c3a7d10",
      "rating": 5,
      "body": "Best community I've joined for actually shipping AI products, not just talking about them.",
      "createdAt": "2026-06-11T17:45:22.000Z",
      "updatedAt": "2026-06-11T17:45:22.000Z",
      "memberSince": "2024-01-09T00:00:00.000Z",
      "memberCurrentlyPaying": true,
      "user": {
        "id": "c4d9f2a1-7b6e-4e3d-a8c5-1f9b2e6d4a70",
        "name": "Morgan Lee",
        "bio": "Indie hacker, AI tinkerer.",
        "pictureProfile": "https://img.skool.com/profiles/example-reviewer.jpg"
      }
    }
  ],
  "reviewsReturned": 1,
  "hasMoreReviews": false
}

Output for a member review

Each item inside reviews[] has this shape on its own — useful when you're only pulling the review array out for downstream processing:

{
  "id": "b7a2e1f0-4c3d-4a9e-9f21-8e6b5c3a7d10",
  "rating": 5,
  "body": "Best community I've joined for actually shipping AI products, not just talking about them.",
  "createdAt": "2026-06-11T17:45:22.000Z",
  "updatedAt": "2026-06-11T17:45:22.000Z",
  "memberSince": "2024-01-09T00:00:00.000Z",
  "memberCurrentlyPaying": true,
  "user": {
    "id": "c4d9f2a1-7b6e-4e3d-a8c5-1f9b2e6d4a70",
    "name": "Morgan Lee",
    "bio": "Indie hacker, AI tinkerer.",
    "pictureProfile": "https://img.skool.com/profiles/example-reviewer.jpg"
  }
}

Output for the owner profile

The owner object is the same shape on every successful row, regardless of scrapeReviews:

{
  "id": "8f21c3e4a9b7452d8c1e0f6a9d3b7c22",
  "name": "Jamie Carter",
  "email": "N/A",
  "location": "Austin, TX",
  "bio": "Building AI automation tools and teaching others to do the same.",
  "picture_profile": "https://img.skool.com/profiles/example-owner.jpg",
  "created_at": "2022-05-14T08:30:00.000Z",
  "updated_at": "2026-07-28T11:02:15.000Z"
}

owner.email always returns "N/A" and map_enabled always returns "N/A" — Skool doesn't expose either field on the logged-out /about page, so these are known placeholders rather than scraped values.

Schema stability and export options

Field names match Skool's own __NEXT_DATA__ metadata keys, converted to snake_case for the top-level community fields and left as Skool names inside owner, reviews, and the reviewer's user block. Success rows and error rows have different key sets — check for the presence of the error key before reading community fields, for example [row for row in items if "error" not in row] in Python. Every pushed row, success or error, triggers one row_result charged event — there's no separate free "accounting" row, so a clean input list of valid slugs keeps costs predictable.

⚠️ maxReviewsPerCommunity only trims the single batch of reviews Skool's /about page ships in that one response — it does not page through further reviews. Skool returns a hasMoreReviews flag alongside that batch, but no working logged-out endpoint for fetching additional pages of reviews was found, so hasMoreReviews: true means more reviews exist on Skool, not that this Actor can reach them.

💡 Skool Group Community Infos Scraper & Member Reviews Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run from your CRM or lead-scoring tool whenever a new Skool community URL is captured (a partnership lead, an affiliate offer, a competitor mention). Call the Actor with that single URL in urls, then write total_members, total_posts, owner_name, and the average of reviews[].rating back onto the lead record. Because rows are pushed as soon as each community is collected, a single-URL run returns fast enough to sit inline in a webhook-triggered workflow.

🎯 Strategy 2: Scheduled monitoring and alerting

Run the same slug list on a recurring Apify Schedule (daily or weekly) and diff each new dataset against the previous run on total_members, reviewsReturned, and the newest reviews[].createdAt. Alert your team when member count jumps sharply, when reviewsReturned increases (new reviews landed), or when the newest review's rating drops below a threshold you set with minReviewRating.

🎯 Strategy 3: Bulk dataset build

For a large list of communities, split the slugs across several concurrent Actor runs rather than one giant run — each run processes its own URL list sequentially, pacing requests with a short randomized delay between them. Aggregate the resulting datasets (via the Apify API or by exporting each run to CSV) into one research or benchmarking dataset.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Lead scoring, CRM enrichment on a single new community	API-triggered single-URL run	JSON via API response
Scheduled monitoring	Tracking member growth and review sentiment over time	Recurring scheduled run, diffed against the prior run	Dataset export, JSON or CSV
Bulk dataset build	Research or competitive benchmarking across many communities	Multiple concurrent runs, one URL batch per run	Aggregated CSV or JSON

🌴 Related Skool Scrapers & Tools

Scraper name	What it extracts
Google Maps Reviews Scraper By Place Search & Location	Star ratings and review text for physical locations
Airbnb Review Scraper: Category Ratings & Host Replies	Guest reviews, category ratings, and host replies for listings
Facebook Reviews Scraper With Date & Keyword Filters	Page reviews filtered by date range and keyword
Udemy Course Reviews Scraper — Syllabus, Lectures & Quizzes	Course reviews alongside curriculum structure
Patreon Scraper & Public Posts	Public creator page and post data from Patreon
Reddit Scraper With Subreddit Data	Subreddit metadata, posts, and community activity

How to integrate Skool Group Community Infos Scraper & Member Reviews with your stack

Skool Group Community Infos Scraper & Member Reviews works with any language or tool that can make an HTTP request, through the Apify API and its official client SDKs.

Python

import csv
from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run_input = {
    "urls": [
        "https://www.skool.com/ai-automation-society-plus/about",
        "adonis-gang",
    ],
    "scrapeReviews": True,
    "maxReviewsPerCommunity": 50,
    "minReviewRating": 1,
    "payingReviewersOnly": False,
    "maxRetries": 3,
}

run = client.actor("VTyIbQaZ9MLZqCaj7").call(run_input=run_input)

fields = ["slug", "group_name", "owner_name", "total_members", "total_posts", "reviewsReturned", "error"]
with open("skool_communities.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=fields)
    writer.writeheader()
    for item in client.dataset(run["defaultDatasetId"]).iterate_items():
        writer.writerow({k: item.get(k, "") for k in fields})

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<APIFY_API_TOKEN>' });

const run = await client.actor('VTyIbQaZ9MLZqCaj7').call({
    urls: ['https://www.skool.com/ai-automation-society-plus/about', 'adonis-gang'],
    scrapeReviews: true,
    maxReviewsPerCommunity: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const row of items) {
    console.log(row.slug, row.group_name, row.total_members, row.reviewsReturned);
}

MCP for AI agents

The Actor is reachable through Apify's MCP server, which exposes any Apify Actor as a callable tool. Register it once:

$apify mcp install claude-code

Or add it directly to any MCP-compatible client's config:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}

From there, an agent can call this Actor mid-task — for example "look up this Skool community's member count and reviews before recommending it" — through the call-actor tool, without leaving the IDE. Compatible clients include Claude Code, Claude Desktop, Cursor, and VS Code.

Async and scheduled pipelines

For large batches, start the run through the API and poll client.run(runId).get() for status instead of waiting on a synchronous call, then read the dataset once the run finishes. For recurring collection, use an Apify Schedule to run the same input on a cron interval — there's no built-in webhook configuration inside the Actor itself, but Apify's platform-level run webhooks can be attached to any run to notify your system on completion.

🎯 Who Needs Skool Group Community Infos Scraper & Member Reviews? (Use Cases & Industries)

🏢 Community operators and creators

A creator planning to launch a paid Skool community pulls total_members, num_courses, and reviews[] from three or four established competitors to benchmark pricing, curriculum depth, and what members complain about before setting their own offer.

📊 Marketing and growth teams

Growth teams building an affiliate or partnership list score prospective Skool communities by total_members and average reviews[].rating, prioritizing outreach to active, well-reviewed communities over stagnant ones.

📱 Community discovery and directory products

Teams building a "browse Skool communities" or "read reviews before you join" product index group_description, owner_name, and reviews[] directly into their own listings, refreshing on a schedule to keep member counts current.

🔬 Researchers

Academic and market researchers studying the paid-community and creator-economy space build datasets of community size, activity, and member-reported experience across many Skool groups, using only publicly visible /about page data.

🎥 Prospective members doing due diligence

Individuals deciding whether to pay to join a specific community run a single URL through the Actor to read reviews[].body and reviews[].rating from real, dated reviews before committing — the same use case the Actor's own input screen is built around.

Is it legal to scrape Skool?

Scraping publicly accessible web pages is generally lawful in the United States — courts have held that accessing data any visitor can see without logging in does not violate the Computer Fraud and Abuse Act (hiQ Labs v. LinkedIn, 9th Cir. 2019/2022). That precedent covers the technical act of scraping; it does not cover everything you do with the result. Using Skool while violating its Terms of Service is a contract matter between you and Skool, a civil risk rather than a criminal one, and separate from whether the scraping itself was lawful.

This Actor's output includes personal data — the community owner's name, bio, and location, and each reviewer's name and bio — all of it already displayed publicly by Skool on the logged-out /about page. If you store or process this data about EU/UK residents, data protection law (GDPR/UK GDPR) still applies to what you do with it, even though the source is public; you need your own lawful basis for that processing.

Skool Group Community Infos Scraper & Member Reviews returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

❓ Frequently asked questions

Does Skool Group Community Infos Scraper & Member Reviews work without a Skool account?

Yes. The Actor sends a plain, logged-out GET request to each community's /about page with browser-like headers and no cookies — no Skool account, login, or session token is used or required.

How does Skool Group Community Infos Scraper & Member Reviews handle Skool's anti-scraping measures?

It detects blocked responses (HTTP 403/429/502/503, or a body missing the expected __NEXT_DATA__ script or containing captcha/access-denied text) and retries the request up to maxRetries times with a short backoff. If proxyConfiguration is enabled, a blocked page escalates from a direct connection to Apify's datacenter proxy, then to residential proxy with its own retry loop; once a residential fetch succeeds, the run sticks with residential proxy for the remaining URLs in that run.

Can I run Skool Group Community Infos Scraper & Member Reviews at scale without getting blocked?

URLs within a run are processed one at a time with a randomized 0.5–1.5 second pause between requests, plus the proxy escalation ladder above when proxy is enabled. No uptime or success-rate figure is published for this Actor. Every row pushed to the dataset — including error rows for pages that never loaded — triggers a billed row_result event, so a clean, deduplicated input list keeps a large run's cost predictable.

How fresh is the data Skool Group Community Infos Scraper & Member Reviews returns?

It's a live fetch every run — each URL triggers a fresh HTTP request to Skool at run time, with no caching layer in the Actor. The data reflects whatever Skool's /about page serves at the moment your run executes.

Which Skool fields work best for AI training and RAG indexing?

For RAG, index group_description and reviews[].body — the two free-text fields that actually describe what a community offers and what members experienced. For training data, total_members, total_posts, reviewsReturned, and reviews[].rating are the most consistently structured fields across every row. All fields return as typed primitives (strings, integers, booleans, or nested objects) — no HTML or markup to strip before passing them into an LLM context window.

Does Skool Group Community Infos Scraper & Member Reviews return personal data, and who is responsible for it?

Yes — the owner block and each review's user block contain names, bios, and (for the owner) a location, all pulled from Skool's own publicly displayed /about page. The Actor only returns data Skool already shows to any logged-out visitor; lawful basis for storing, processing, or acting on that personal data sits with you as the user of the output.

Does Skool Group Community Infos Scraper & Member Reviews work with Claude, ChatGPT, and other AI agent tools?

Yes, two ways. It's reachable through Apify's MCP server (https://mcp.apify.com, or apify mcp install claude-code for Claude Code) as a callable tool for any MCP-compatible agent. It's also callable as a plain HTTP endpoint by any agent framework through the Apify API — every response is typed JSON, so no parsing step is needed before handing it to an LLM.

How does Skool Group Community Infos Scraper & Member Reviews compare to other Skool scrapers?

Against Skool Group Scraper (gordian) — also login-free — this Actor's advantage is the member-review data, which isn't listed as a feature on that Actor's store page as of 2026-08-16; that Actor's advantage is subscription price fields, which this Actor does not extract. Against Skool Scraper (louisdeconinck), which requires a Skool auth token obtained through a browser extension and carries a 2.39/5 store rating as of 2026-08-16, this Actor's advantage is that no login is needed at all — the trade-off is that member-level rosters (every member's email and social links) are out of scope here, which that tool covers when authenticated.

What happens when a community can't be reached, or has no reviews yet?

An unreachable or blocked community is still written as a dataset row, but with only slug, url, group_name, owner_name, and an error message describing why — the run continues to the next URL rather than stopping. A community with no reviews yet returns a successful row with reviews: [], reviewsReturned: 0, and hasMoreReviews: false, not an error.

ℹ️ Disclaimer

Skool Group Community Infos Scraper & Member Reviews extracts only publicly available data from Skool. This tool is intended for lawful use cases only. Users are responsible for complying with Skool's terms of service and applicable data protection laws in their jurisdiction.