Skool Group Community Infos Scraper

Skool Group Scraper — Members, Posts, Owner and Course Data

Skool Group Scraper turns a list of Skool community links into structured JSON rows — group name, description, member and post counts, course/module counts, active tabs, onboarding survey questions, and the community owner's profile. No login, no browser, no API key: every field comes straight from the public /about page. Paste your links and start a run from the Apify Console below.

What is Skool Group Scraper?

Skool Group Scraper (published on Apify as Skool Group Community Infos Scraper) is an Apify Actor that reads a public Skool community's /about page and returns its group metadata, activity counts, and owner profile as one clean JSON row per link. It does not require a Skool account, password, or API key — it reads the same data a logged-out visitor's browser already receives. It's built for marketers and agencies vetting communities before a partnership, course creators benchmarking competitors, and analysts tracking a watchlist of communities over time.

What Skool group data is publicly available to scrape?

A Skool community's /about page ships its full landing-page data to any visitor without a login — logging in only unlocks the group's internal member list, posts, and classroom content.

Data category	Publicly available (no login)	Requires joining / logging in
Group name, description, cover image	Yes
Member, post, admin, and online-member counts	Yes
Privacy setting, membership type, course and module counts	Yes
Which landing-page tabs are enabled (calendar, classroom, map, chat, etc.)	Yes
Onboarding survey questions shown to new members	Yes
Owner's name, bio, location, and profile photo	Yes
Owner's email address	Rarely published
Full member directory or individual member profiles		Yes — join/login
Post content, comments, and classroom/course materials		Yes — join/login

Skool Group Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

What data can I extract with Skool Group Scraper?

Skool Group Scraper returns one row per community link, made up of identity/landing-page fields, activity metrics, and a nested owner profile. Every field below is a real key written by the Actor's source code, not a subset of the default view.

Community identity & landing-page fields

Field name	Description
slug	The community's short Skool slug, taken from the input link.
url	The /about page URL that was actually fetched.
group_id	Skool's internal group ID.
group_name	The community's display name.
group_description	Full landing-page description text, HTML-unescaped.
group_image	Landing-page or logo/cover image URL.
group_created_at	ISO timestamp the group was created.
group_updated_at	ISO timestamp the group was last updated.
privacy	Skool's own internal privacy code (raw integer, not decoded into a label).
membership	Skool's own internal membership-type code (raw integer, not decoded).
tabs	Object of which landing-page tabs are visible (calendar, classroom, map, audio-chat, etc.).
survey	Object holding the onboarding survey questions and options shown to new members, if any.

Activity & structure metrics

Field name	Description
total_members	Total member count.
total_online_members	Members shown as online at scrape time.
total_posts	Total post count.
total_admins	Total admin count.
num_courses	Number of courses in the classroom.
num_modules	Number of modules across all courses.

Owner profile (nested owner object)

Field name	Description
owner_name	Owner's display name, flattened to the top level of the row for easy filtering.
owner.id	Owner's Skool user ID.
owner.name	Owner's display name (same value as owner_name, kept inside the nested object too).
owner.email	Owner's email address, when Skool's own payload includes it. ⚠️ This is empty on most communities — Skool doesn't publish it to a logged-out visitor by default, and this Actor never fabricates a value when it's missing.
owner.location	Owner's stated location.
owner.bio	Owner's bio text.
owner.picture_profile	Owner's profile picture URL.
owner.created_at	ISO timestamp the owner's account was created.
owner.updated_at	ISO timestamp the owner's account was last updated.

A row that fails to resolve (bad link, unreachable page, blocked request) is pushed as a short error shape instead: slug, url, group_name (empty string), owner_name (empty string), and error with a plain-language reason — never guessed or fabricated data.

Add-on: Need additional community data?

Skool Group Scraper covers community-level metadata only — it doesn't return individual member lists or post content. If you also track other creator-community platforms, pair it with Patreon Scraper for creator campaign data, membership-tier pricing, and patron counts from the same account.

Why not build this yourself?

Skool has no official, documented public API — no /api/v1/... endpoints, no developer portal, no OAuth app registration (verified via a search of Skool's own community and third-party API-tracking docs, checked 2026-08-16). The only way to get this data programmatically is to read the same JSON payload Skool's Next.js frontend hydrates from, which means handling everything this Actor already handles: detecting blocked/CAPTCHA responses, retrying on network errors, and falling back through datacenter and residential proxies when a plain connection gets refused. Building and maintaining that yourself means watching for Skool's frontend structure to change, paying for and rotating your own proxies, and re-testing block detection on your own schedule. Skool Group Scraper runs that pipeline for you from the Apify Console with no code to maintain.

How to use Skool Group Scraper

Skool Group Scraper runs on the Apify platform — there's no separate Skool signup or API key to obtain first.

1. Open Skool Group Scraper on its Apify Store listing.
2. Paste one or more Skool community links or short slugs into Community links to collect (urls) — the only required input.
3. Optionally turn on Proxy (optional) if a page seems slow or blocked, and adjust Retry attempts (maxRetries, default 3) if your network is unreliable.
4. Click Start.
5. Watch rows land in the Output tab live as each community finishes, then export as JSON, CSV, or another supported format.

How to scale to bulk community extraction

urls is an array — paste as many links or slugs as you need, one per line, and each becomes its own row in the output table. There's no fixed cap in the input schema; the run works through the list sequentially, pausing 0.5–1.5 seconds between requests, so a longer list simply takes longer rather than needing multiple runs or a loop in your own code.

What can you do with Skool community data?

• Agencies and marketers vetting a partnership use total_members, total_posts, and owner.bio to judge how active a community really is before pitching a sponsorship.
• Course creators benchmarking competitors use num_courses, num_modules, and membership to compare how rival communities structure their curriculum and access tiers.
• Growth analysts tracking a watchlist use total_members and total_online_members across repeated runs to chart a community's growth or decline over time.
• Partnerships and outreach teams use owner_name, owner.location, and owner.email (when Skool publishes it) to build a first-contact list of community owners worth reaching out to.
• AI engineers feed group_description and the survey questions into a RAG pipeline or agent tool so an LLM can answer questions about a community's positioning and onboarding flow without manual copy-paste.

How does Skool Group Scraper handle rate limits and blocking?

Every request first goes out as a plain, unproxied connection with browser-matching headers. A response is treated as blocked on HTTP 403, 429, 502, or 503, or when the page body is missing Skool's __NEXT_DATA__ script tag or contains a CAPTCHA/"access denied" marker. Network or timeout errors on a single request are retried up to maxRetries times (default 3) with a short linear backoff. If Proxy (optional) is turned on and a plain connection is blocked, the Actor escalates automatically: first to an Apify datacenter proxy, then to an Apify residential proxy (retried on fresh IPs up to three times). Once a residential proxy successfully loads one community, the rest of that run sticks to residential proxying instead of retrying the earlier tiers. If every tier is exhausted for one link, that link is skipped and pushed as an error row instead of failing the whole run.

⬇️ Input

Parameter	Required	Type	Description	Example value
urls	Yes	array	Skool community/group links, one per line. Accepts a full URL (https://www.skool.com/your-group/about) or just the short slug (your-group).	["https://www.skool.com/thatpickleballschool/about", "adonis-gang"]
proxyConfiguration	No	object	Apify Proxy settings. Default {"useApifyProxy": false} — a direct connection is tried first regardless; when enabled, the Actor escalates to datacenter and then residential proxy only if the direct connection is blocked.	{"useApifyProxy": true}
maxRetries	No	integer	How many times to retry a single request on a network/timeout error (not when data is simply missing). Minimum 0, maximum 10, default 3.	3

Example input

{
  "urls": [
    "https://www.skool.com/thatpickleballschool/about",
    "adonis-gang"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRetries": 3
}

⬆️ Output

Every community is pushed to the dataset as one JSON row, live, as soon as it's collected. Export the dataset as JSON, CSV, Excel, XML, or RSS from the Console, or read it via the Apify API. The default Live results table view surfaces slug, url, group_name, owner_name, total_members, total_posts, group_id, and error, but every field documented above is written to each row regardless of what the view displays.

Example output

{
  "slug": "thatpickleballschool",
  "url": "https://www.skool.com/thatpickleballschool/about",
  "group_id": "44b2fb4fbc424b16b63d61010ec229b5",
  "group_name": "That Pickleball School",
  "group_description": "Learn strategies to play better pickleball right away!",
  "group_image": "https://assets.skool.com/f/example/md.png",
  "group_created_at": "2024-06-05T16:09:18.389257Z",
  "group_updated_at": "2026-08-12T07:55:25.663918Z",
  "total_members": 1201,
  "total_online_members": 3,
  "total_posts": 3042,
  "total_admins": 20,
  "privacy": 1,
  "membership": 1,
  "num_courses": 19,
  "num_modules": 454,
  "tabs": {
    "calendar": { "visible": true },
    "classroom": { "visible": true },
    "map": { "visible": true },
    "audio-chat": { "visible": false }
  },
  "survey": {
    "updated_at": "2025-11-02T10:15:00.000Z",
    "survey": [
      { "question": "What's your current pickleball skill level?", "type": "options", "options": ["Beginner", "Intermediate", "Advanced"] }
    ]
  },
  "owner": {
    "id": "841795c5a39f42598ad61c1d7951d199",
    "name": "kyle-koszuta-7833",
    "email": "",
    "location": "Phoenix, Arizona",
    "bio": "Co-Founder of THATpickleballschool. Top 10 Mens Doubles Player on the APP Tour.",
    "picture_profile": "https://assets.skool.com/f/example/full",
    "created_at": "2024-06-05T21:07:16.370613Z",
    "updated_at": "2026-08-05T15:20:05.329479Z"
  },
  "owner_name": "kyle-koszuta-7833"
}

How does it work?

For each link, the Actor normalizes it down to the community slug and requests https://www.skool.com/{slug}/about with a plain HTTP GET carrying real browser headers — no headless browser, no rendering step. It then parses the __NEXT_DATA__ JSON script tag embedded in the response, the exact same payload React hydrates the page from, so the fields returned match what a logged-out visitor's browser already downloaded. If a response looks blocked, the Actor retries and, when the optional proxy is enabled, escalates through an Apify datacenter proxy and then a residential proxy before giving up on that link. Because every field is read from one stable JSON structure rather than scraped off rendered HTML, the output schema stays the same even when Skool changes its page layout or styling.

Integrations

Skool Group Scraper works with what you already use — the Apify API, Python/JS clients, AI agent frameworks, and no-code automation tools.

Calling Skool Group Scraper programmatically

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("YOUR_USERNAME/skool-group-community-infos-scrape").call(run_input={
    "urls": ["https://www.skool.com/thatpickleballschool/about"],
    "maxRetries": 3,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["group_name"], item.get("total_members"))

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

MCP integration for AI agents

Skool Group Scraper is callable through Apify's hosted MCP Server: configure your tools at mcp.apify.com or point an MCP-compatible client (Claude, Cursor, and other agent frameworks) at Apify's MCP endpoint and select this Actor by its store ID (skool-group-community-infos-scrape) to let an agent run it and read the resulting dataset directly.

No-code tools (n8n, Make, LangChain)

In n8n, use the Apify node — or a generic HTTP Request node pointed at the Actor's run endpoint — to trigger a run and pull the dataset into your workflow. In Make, use the Apify app's "Run Actor" module the same way. In LangChain, call the Actor via apify-client inside a custom Tool, or load a finished dataset directly as Documents.

Pay-per-event

Every row pushed to the dataset — a fully resolved community or a short error row for a link that couldn't be reached — is charged as one row_result event; there's no separate uncharged accounting event for failed rows. If you only want billable-and-useful rows in downstream processing, filter out rows where error is present.

⚖️ Is it legal to scrape Skool group data?

Scraping publicly accessible business data is generally lawful, and Skool Group Scraper collects only what any logged-out visitor already sees on a community's /about page — no member lists, no posts, no paywalled classroom content. Most of what it returns (group name, description, member/post counts, course structure) is business data about the community itself, which falls under Skool's Terms of Service and database-rights considerations rather than a personal-data regime. The nested owner object is the one exception: it can include the community owner's name, bio, location, and (rarely) email, which is personal data tied to an identifiable individual, so GDPR/CCPA considerations apply to how you store and reuse that portion. Consult legal counsel if your use case involves bulk storage of personal data.

❓ Frequently asked questions

What Skool community fields does Skool Group Scraper return?

The top fields are group_name, total_members, total_posts, group_description, and owner_name, alongside the full owner profile and landing-page structure. See What data can I extract with Skool Group Scraper? for the full field tables.

Does Skool Group Scraper require a Skool account or login?

No. It reads only the public /about page, which Skool serves to logged-out visitors, so no Skool username, password, or API key is needed to run it.

How many Skool communities can I extract in one run?

As many as you list in urls — there's no fixed maximum in the input schema. Each link becomes its own row, processed sequentially with a short pause between requests.

What happens if a community link is invalid, unreachable, or blocked?

The Actor pushes a short error row instead of failing the whole run: slug, url, group_name: "", owner_name: "", and an error string explaining why (an unparseable link, a page that never loaded, or a response that still looked blocked after retries and, if enabled, the proxy ladder). No field is ever guessed to fill the gap.

Can I scrape multiple Skool communities at once?

Yes. urls is an array — paste as many links or bare slugs as you need, one per line, and each is fetched and pushed as its own row in the same run.

Does Skool Group Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes. It's reachable through Apify's MCP Server for MCP-compatible clients like Claude and Cursor, and callable as a plain HTTP endpoint by any agent framework via the Apify API.

How does Skool Group Scraper compare to other Skool scrapers?

Other Skool Actors on Apify Store take different angles as observed on their listings on 2026-08-16: some extract member and post content but require a logged-in Skool account (e.g. klinzinger/skool-scraper), some add group pricing and owner social links behind a paid tier (e.g. gordian/skool-group-scraper), and some are built for bulk discovery across thousands of communities rather than a curated link list (e.g. crustapi/skool-community-scraper). Skool Group Scraper stays focused on one thing — turning a list of community links into landing-page metadata and owner profile fields, with no login required and no discovery step.

Does Skool Group Scraper return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with consistent field names across runs — no HTML parsing or CSS selectors needed. Pass rows directly to an LLM, index them into a vector store, or feed them to an agent tool.

What happens when Skool changes its layout or anti-bot system?

The Actor is maintained and reads from Skool's own __NEXT_DATA__ JSON payload rather than parsing rendered HTML, so the output schema is designed to stay stable across visual layout changes. No specific update or fix turnaround time is published or guaranteed.

Can I use Skool Group Scraper without managing proxies or browser infrastructure?

Yes. By default the Actor connects directly with no proxy at all. Turning on Proxy (optional) lets it automatically escalate through an Apify datacenter proxy and then a residential proxy only when a request looks blocked — you don't have to configure or monitor proxies yourself.

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

For RAG, index the high-information text fields — group_description and the survey question text — alongside url as a source link. For training or structured data, total_members, total_posts, num_courses, and num_modules give consistently-typed numeric structure across every community row.

🔗 Related scrapers

Scraper	What it extracts
Patreon Scraper	Creator campaign data — patron counts, paid membership tiers with pricing, and connected social links.
Reddit Scraper	Public posts, comment threads, user activity, and subreddit metadata.
Udemy Course Reviews Scraper	Course ratings, review text, and reviewer details from Udemy courses.

💬 Your feedback

Found a bug or missing a field? Let us know — open an issue on the Actor's Apify Store page or send feedback through the Console's built-in issue reporter, and we'll take a look. Bug reports and field requests are what keep this scraper aligned with Skool's real output.