🎓 Skool Group Scraper
Pricing
from $2.99 / 1,000 results
🎓 Skool Group Scraper
🎓 Skool Group Scraper pulls members, posts, comments, reactions, topics & links from Skool groups. 📊 Clean, structured data for community analytics, content research, outreach and lead gen. 🔍 Fast, reliable, export-ready (CSV/JSON). 🚀
Pricing
from $2.99 / 1,000 results
Rating
0.0
(0)
Developer
SimpleAPI
Maintained by CommunityActor stats
0
Bookmarked
2
Total users
0
Monthly active users
6 days ago
Last modified
Share
Skool Group Scraper — Community Pricing, Members and Owner Data
Skool Group Scraper turns any Skool discovery page into structured JSON: one row per community with its name, description, monthly and annual price, member count, join survey, plugin settings, and the owner's name, bio, location and social links. Paste a discovery URL, set how many communities you want, and rows stream into your dataset as each one is found and enriched. Built for community operators benchmarking competitors, agencies scoping a niche before launch, and researchers tracking pricing and growth across Skool's creator economy.
What is Skool Group Scraper?
Skool Group Scraper is an Apify Actor that walks a Skool discovery page (the site's public directory and search results), collects every community listed there, then opens each community's public /about page to fill in the details the discovery listing doesn't carry — pricing, member counts, owner profile, join-survey questions, plugin and tab configuration. No Skool account, login or cookie is used anywhere in the process; every field comes from pages Skool serves to an anonymous visitor.
- Discovery by URL — feed it the main discovery page, a search query (
?q=), or a category filter; the Actor paginates through Skool's own discovery pagination until it has enough communities or Skool stops returning new ones. - Automatic About-page enrichment — every discovered community is followed up with its own
/aboutpage fetch to pull pricing, owner and stats data the discovery listing omits. - Owner-level lead fields — name, bio, location and social links (Instagram, YouTube, Facebook, Twitter/X, LinkedIn, personal website) for the community's owner.
- Join-survey capture — the actual application questions a prospective member has to answer to join, with type and options.
- Cross-URL deduplication within a single run — a community that appears under two different discovery URLs in the same run is only scraped and charged once.
- Live streaming output — rows land in the dataset as each community finishes enrichment, exportable as JSON, CSV, Excel, HTML, XML or RSS through the standard Apify dataset export.
- Per-URL fault isolation — if a discovery URL can't be loaded at all after every connection attempt is exhausted, the Actor logs the failure for that URL and moves on to the next one in your
urlslist instead of aborting the whole run.
What data can I extract with Skool Group Scraper?
Every dataset row is a single community record built from two sources: the discovery listing (identity, price, member count, timestamps) and that community's own /about page (owner profile, stats, plugins, survey, media). All 63 keys are present on every row — a field Skool doesn't expose for a given community comes back null or an empty array, never a missing key. The dataset's default Results (live) view only surfaces 12 of these as table columns (id, name, displayName, description, monthlyPrice, monthlyCurrency, totalMembers, ownerName, ownerFirstName, ownerLastName, ownerBio, ownerLocation) for quick scanning in the Apify Console — every other key below is still present in the underlying row and included in every JSON, CSV or Excel export.
| Field | Example Value | Use Case |
|---|---|---|
id | "e44528d24bfe4d65b0a412441feaa489" | Skool's internal community ID — stable primary key for dedup and re-scraping |
name | "skoolers" | URL slug — build the community's canonical skool.com/{name} link |
displayName | "Skoolers" | Human-readable community name for reports and dashboards |
description | "Private club for skool owners." | Short discovery-card description for listing pages |
landingPageDescription | "Imagine a place where..." | Full marketing copy from the About page landing section |
supportEmail | "sam@skool.com" | Owner's declared contact email, or one found in the landing copy — for outreach |
monthlyPrice | 39 | Monthly subscription price, normalized to major currency units |
monthlyCurrency | "usd" | ISO currency code for monthlyPrice |
annualPrice | null | Annual subscription price when the community offers one |
annualCurrency | null | ISO currency code for annualPrice |
color | "#FCB900" | Community's theme color hex code |
initials | "S" | Fallback avatar initials Skool shows when no logo is set |
privacy | 1 | Skool's privacy setting flag for the community |
membership | 1 | Skool's membership model flag |
plan | null | Skool's plan identifier for the community, when set |
landingPageAccessType | 1 | Access-type flag controlling who sees the landing page |
affiliatePercent | 40 | Affiliate commission percentage, when the affiliate program is enabled |
pluginAutoDmEnabled | 0 | Whether Skool's auto-DM plugin is enabled |
pluginMinChatLevelEnabled | 2 | Minimum member level required to use chat |
surveyEnabled | 0 | Whether a join/application survey is required |
surveyQuestions | [{"question": "Why do you want to join?", "type": "text"}] | The actual application questions asked at signup |
surveyUpdatedAt | "2025-01-14T10:02:00Z" | Last time the join survey was edited |
logoUrl | "https://assets.skool.com/f/.../logo.png" | Community logo image URL |
logoBigUrl | "https://assets.skool.com/f/.../logo-big.png" | Higher-resolution logo URL |
coverSmallUrl | "https://assets.skool.com/f/.../cover-md.jpg" | Cover image thumbnail URL |
faviconUrl | "https://assets.skool.com/f/.../favicon.png" | Community favicon URL |
customLinks | [{"url": "https://...", "label": "Website", "public": true}] | Custom links the owner added to the community profile |
totalMembers | 184608 | Total member count — the headline growth metric |
totalOnlineMembers | 1854 | Members currently online |
totalAdmins | 12 | Number of admin accounts |
totalPosts | 79502 | Total posts across the community feed |
totalRules | 5 | Number of community rules published |
numCourses | 4 | Number of courses in the classroom |
numModules | 61 | Total modules across all courses |
audioChatVisible | false | Whether the audio-chat tab is visible to visitors |
calendarVisible | true | Whether the calendar tab is visible |
classroomVisible | true | Whether the classroom tab is visible |
mapVisible | true | Whether the member map tab is visible |
landingPageAttachments | [{"id": "...", "type": 2, "videoUrl": "https://www.loom.com/..."}] | Images and videos embedded on the landing page |
ownerId | "59e737d659f24e69a3810c6191054efd" | Skool's internal user ID for the community owner |
ownerName | "sam" | Owner's Skool username/handle |
ownerFirstName | "Sam" | Owner's first name, as Skool stores it |
ownerLastName | "Ovens" | Owner's last name, as Skool stores it |
ownerBio | "CEO @ Skool" | Owner's public bio text |
ownerLocation | "Los Angeles, CA" | Owner's declared location |
ownerDiscTop | null | Owner's DISC personality top result, when set |
ownerActivityStatus | null | Owner's activity status label |
ownerMyersBriggs | null | Owner's Myers-Briggs type, when set |
ownerOnline | 1 | Whether the owner is currently online |
ownerLastOffline | "1764200517573641700" | Owner's last-offline timestamp, as reported by Skool |
ownerPictureProfile | "https://assets.skool.com/f/.../profile.png" | Owner's profile picture URL |
ownerPictureBubble | "https://assets.skool.com/f/.../bubble.png" | Owner's small chat-bubble avatar URL |
ownerInstagram | null | Owner's linked Instagram URL |
ownerYoutube | "https://www.youtube.com/@skool-news" | Owner's linked YouTube URL |
ownerFacebook | null | Owner's linked Facebook URL |
ownerTwitter | null | Owner's linked Twitter/X URL |
ownerLinkedin | null | Owner's linked LinkedIn URL |
ownerWebsite | null | Owner's linked personal or business website |
ownerCreatedAt | "2019-08-02T00:00:00Z" | When the owner's Skool account was created |
ownerUpdatedAt | "2025-10-30T12:16:04Z" | When the owner's Skool profile was last updated |
createdAt | "2019-12-04T04:52:35.870973Z" | When the community was created |
updatedAt | "2025-10-30T12:16:04.043493Z" | When the community was last updated |
createdBy | "59e737d659f24e69a3810c6191054efd" | User ID credited as the community's creator |
Pricing, membership and owner profile data
monthlyPrice and annualPrice are normalized to major currency units — Skool sends amounts in minor units (cents) for most currencies, and the Actor divides by 100 automatically, except for a fixed list of zero-decimal currencies (BIF, CLP, DJF, GNF, JPY, KMF, KRW, MGA, PYG, RWF, UGX, VND, VUV, XAF, XOF and XPF) where the raw amount is already the display value. A community with no price set on Skool returns null for both price fields rather than 0 — that's how a free community shows up in the data. totalMembers, numCourses and numModules are the fields that separate an active paid community from a dormant one. The owner* fields identify the individual behind the community — name, bio, location and social links — which is the data set you'd use for outreach or attribution, and it is personal data about that individual rather than data about the community itself (see the legal section below).
Filtering and targeting fields
totalMembers, monthlyPrice and monthlyCurrency are the fields to sort and threshold on when screening a batch of communities for size or price tier. membership, landingPageAccessType and privacy are Skool's own configuration flags for how a community is structured. createdAt and updatedAt let you separate recently launched communities from long-running ones in the same discovery result.
Why not build this yourself?
Skool does not publish a general-purpose developer API for discovering or reading community data, so the alternative to this Actor is writing and maintaining your own scraper — and the two things that make that non-trivial are exactly what this Actor already handles.
First, Skool is a Next.js single-page app. The discovery page and every /about page embed their data in a <script id="__NEXT_DATA__"> block rather than in readable HTML, and paginating past the first page of results means calling Skool's internal /_next/data/{buildId}/discovery.json endpoint with the build ID extracted from that same block — an endpoint with no public documentation and a build ID that changes on every Skool deploy. Get the parsing or the build-ID extraction wrong and you get zero rows, not a clear error.
Second, Skool occasionally blocks straightforward automated requests. The Actor starts every run on a direct connection and only escalates to a datacenter, then a residential, Apify proxy if a request doesn't come back clean — infrastructure you'd otherwise have to provision and pay for before you've scraped a single community.
How does Skool Group Scraper handle blocking and retries?
Skool Group Scraper doesn't fail a discovery URL the moment a page comes back blocked — it escalates through a connection ladder and retries before giving up on it.
Every discovery page load starts direct, with no proxy. Before requesting the page, the Actor waits a randomized 1–2 seconds, loads the URL, then waits up to 30 seconds for the <script id="__NEXT_DATA__"> block to attach — the same embedded-JSON block the Actor reads its data from. If the direct load fails, the Actor escalates to a datacenter proxy tier; if that specific proxy group isn't available on the account running the Actor, it skips straight to residential instead of failing outright. Once on residential, it retries up to three times, generating a fresh proxy session ID between attempts and waiting roughly 1–2 seconds between them. As soon as one residential attempt succeeds, the Actor sticks with residential for the rest of that URL's pagination requests rather than dropping back to a tier that already failed.
This ladder only runs when Proxy (optional) is left off, which is the schema default. Turn it on and the Actor skips the ladder entirely: it builds a single Apify Proxy configuration from whatever groups you selected and makes one attempt per discovery URL, with no automatic escalation or retry behind it — if that one connection fails, the Actor logs the error and moves on to the next urls entry.
The same two-attempt pattern applies to per-community /about page enrichment: the Actor requests the /about page and waits up to 45 seconds for it to load and up to 15 seconds for the __NEXT_DATA__ block to attach, and if either step throws, it opens a fresh page and tries once more before leaving that row's About-page fields unset (see the billing note above). Enrichment for a batch of newly discovered communities runs at a concurrency of 3 — three /about pages open in parallel — so a large maxItems value enriches in overlapping batches rather than one community at a time.
None of this is configurable beyond the single Proxy (optional) on/off switch; retry counts, timeouts and enrichment concurrency are fixed in the Actor's code, not exposed as input parameters.
How to use data extracted from Skool
Community operators and course creators
Pull a competitor's discovery category, sort the resulting rows by totalMembers and monthlyPrice, and see where your own community sits against similarly sized peers before you change your price or launch a new tier. numCourses and numModules show how much content competitors ship relative to their member count.
Agencies and community-launch consultants
Scoping a new niche for a client, run a handful of discovery search URLs for the target category (?q=fitness, ?q=copywriting, and so on), and use monthlyPrice, totalMembers and affiliatePercent across the results to show the client what a viable price point and affiliate structure look like in that space before they commit to a launch plan.
Market research and intelligence
Re-run the same discovery URLs on a schedule and diff totalMembers and monthlyPrice per id over time to track growth and pricing movement across a category, or bucket a large discovery pull by monthlyCurrency and price band to map how a whole niche prices itself. Because id is Skool's own stable identifier, the same community can be tracked across as many scheduled runs as you like without any risk of matching the wrong row.
AI agents and automated pipelines
Index displayName, description and landingPageDescription into a vector store so an agent can answer "which paid communities in this niche have an active affiliate program" against live data, or wire the Actor into a pipeline that flags newly discovered communities above a member-count threshold for a human to review. Because every row carries the same 63 keys whether or not a given field applies, downstream code can read any key directly without a presence check first.
⚠️ Every saved row is billed, even when About-page enrichment fails
This Actor charges the row_result pay-per-event exactly once for every row it pushes to your dataset — and every discovered community is pushed, whether or not its /about page enrichment succeeded. Enrichment is attempted up to two times per community; if both attempts fail (a timeout, a block, a missing __NEXT_DATA__ block on that specific page), the row is still saved and still billed, just with the discovery-only fields populated (id, name, displayName, description, monthlyPrice, totalMembers, timestamps) and the About-page-only fields — the entire owner* group, surveyQuestions, plugin flags, stats beyond totalMembers — left null or empty. There is no separate uncharged accounting row for a failed enrichment; the outcome is folded into the same row and the same charge. If your workflow depends on owner or survey data specifically, filter your results on ownerId is not None after the run rather than assuming every row carries it.
⬇️ Input
| Parameter | Required | Type | Description | Example Value |
|---|---|---|---|---|
urls | ✅ Yes | array | Add every discovery URL you want (one per line is fine). Example: the main Skool discovery page. | ["https://www.skool.com/discovery"] |
maxItems | No | integer | Cap per discovery URL — keeps runs fast and predictable. Minimum 1, maximum 50000. Default 10. | 50 |
proxyConfiguration | No | object | Turn on only if you want to run through Apify Proxy from the start. Leave off for the normal experience (the Actor handles hiccups automatically when possible). Default {"useApifyProxy": false}. | {"useApifyProxy": true} |
Example input
Common pitfall: urls must be Skool discovery pages — the directory or search results page that lists many communities (skool.com/discovery, skool.com/discovery?q=marketing) — not a single community's own page (skool.com/skoolers). A single-community URL doesn't carry the list of communities the discovery page embeds, so the Actor finds nothing to enrich and logs "No new communities here" for that URL instead of raising an error.
proxyConfiguration is off by default, and most runs never need to touch it — the Actor already escalates through datacenter and residential Apify proxies on its own when a direct connection is blocked. Turning it on replaces that automatic behavior with a single pass through your selected proxy groups and no further escalation (see "How does Skool Group Scraper handle blocking and retries?" below).
⬆️ Output
Every community is one dataset row with the same 63 keys, typed and present on every row — null or [] where Skool has nothing to report, never a missing key. Rows are pushed live as each community finishes enrichment, so the dataset fills while the run is still going. Export as JSON, CSV, Excel, HTML, XML or RSS, or read the dataset through the Apify API.
Example output
ownerFirstName and ownerLastName are not split out of ownerName — they come straight from separate first_name / last_name fields on Skool's own owner object. When Skool doesn't have a first or last name on file for an owner, that key comes back null rather than a value parsed out of ownerName.
How do you filter and target specific communities?
Skool Group Scraper has no query-parameter filter of its own — targeting happens at the URL level, before the Actor ever runs. Build the discovery URL you want directly in your browser (a plain category browse, or skool.com/discovery?q=your-keyword for a search), then paste it into urls; every filter Skool's own discovery page supports travels with the link. Add multiple discovery URLs to the same run to cover several categories or search terms at once — a community that shows up under more than one of your URLs is only scraped and counted once, so overlapping searches don't inflate your row count or your bill. The only volume control is maxItems, applied separately to each discovery URL you supply — three URLs at maxItems: 50 can save up to 150 rows before deduplication, not 50 total.
🔗 Related community and discovery scrapers
Skool Group Scraper is the only Skool Actor on this account today. If you're covering multiple community platforms in the same research, these cover comparable discovery-style directories:
| Scraper | What it extracts |
|---|---|
| Facebook Groups Search Scraper — Member Size & Activity Metrics | Facebook group listings with member counts and activity signals |
| Facebook Group Profile Scraper | Facebook group profile details |
| Quora Search Scraper — Fresh & Trending Question Monitor | Quora search results and trending questions |
| Reddit Posts Scraper | Reddit posts with author and media details |
How to extract Skool data programmatically
Skool Group Scraper runs on Apify like any other Actor — start it from the Console or trigger it over the Apify API and read the results back as JSON.
Python example
Works in Go, Ruby, Node.js, cURL — any language that can call the Apify API.
Export to spreadsheets or CRM
Export the dataset as CSV or Excel directly from the Apify Console, or automate it: map displayName, ownerName, ownerBio, ownerLocation and supportEmail into a CRM's contact fields for outreach, and totalMembers and monthlyPrice into a tracking sheet's metric columns. Apify's Google Sheets and Airtable integrations can push the dataset on a schedule with no code involved.
Is it legal to scrape Skool?
Scraping publicly accessible pages is broadly treated as permissible where no login or authentication is bypassed, and Skool Group Scraper reads only what Skool's discovery page and each community's /about page already show an anonymous visitor.
The community-level fields — pricing, member count, description, plugin settings — are business and product data about the community itself, governed by Skool's terms of service and ordinary database-reuse rules rather than personal-data law. The owner* fields are different: a name, bio, location and social links tied to an identifiable individual are personal data, and storing or reusing them in bulk falls under regimes like GDPR and CCPA even though Skool itself displays that same information publicly on the community's About page. Consult legal counsel for commercial applications involving bulk storage of personal data, particularly the owner profile fields.
❓ Frequently asked questions
What if a discovery URL returns zero communities?
The Actor logs "No new communities here" for that URL and moves on to the next one in your urls list — it does not fail the whole run. This is the usual symptom of pasting a single community's own page instead of a discovery/search page, since only discovery pages carry the list of communities the Actor reads.
Can I get the owner's contact details along with the community data?
Yes, when the community's /about page enrichment succeeds. ownerName, ownerFirstName, ownerLastName, ownerBio, ownerLocation, supportEmail and the linked social profiles all come from that page. If enrichment fails for a given community after two attempts, those fields land as null on an otherwise-complete row — see the warning above.
How accurate is the pricing and member-count data?
The Actor returns exactly what Skool's discovery and About pages show at request time. Accuracy depends on how current Skool's own listing is for that community — totalMembers and pricing reflect Skool's live count and price at the moment the row was scraped, not a cached or delayed figure.
How many communities can I get per run?
maxItems (default 10, minimum 1, maximum 50000) caps the number of communities pulled per discovery URL, not across the whole run. Supply five discovery URLs at maxItems: 100 and the run can save up to 500 rows before any duplicate communities found under more than one URL are removed.
Does Skool impose its own limit on how many communities a discovery page returns?
Not documented. The Actor keeps requesting Skool's own paginated discovery data (/_next/data/{buildId}/discovery.json) until it either reaches your maxItems cap or Skool returns an empty page with no new communities — there is no separate hard ceiling coded into the Actor beyond your own input.
What happens if Skool's discovery pagination runs out before I reach maxItems?
Nothing breaks. If a paginated request comes back with zero communities that haven't already been collected, the Actor stops paginating that discovery URL and moves on — you simply get however many communities Skool's own discovery results actually contained, which can be fewer than your maxItems value for a narrow search or category.
Does the proxy setting change how blocking is handled?
Yes. Leaving proxyConfiguration off runs the automatic escalation ladder described above — direct connection, then datacenter, then residential, with retries at each step. Turning it on replaces that ladder with a single pass through your selected Apify Proxy groups; if that pass fails, the Actor logs the error for that discovery URL rather than retrying through a different tier.
Does Skool Group Scraper work with Claude, ChatGPT and other AI agent frameworks?
Yes. It's callable as a standard HTTP endpoint through the Apify API, so any agent framework that can make a request — LangChain, CrewAI, n8n, a custom tool definition — can trigger a run and read back typed JSON.
How does Skool Group Scraper compare to other Skool scrapers?
Checked on the Apify Store on 2026-07-25: gordian/skool-group-scraper documents a nearly identical field set (pricing, owner profile, plugins, survey) taken from URL, slug or discovery input, and gates support-email extraction behind a paid Apify plan. memo23/skool-members-scraper targets a different entity — individual members rather than communities — and requires the caller to supply their own logged-in Skool session cookies for its fuller scraping modes. easyapi/skool-groups-scraper covers a narrower field set (no owner social links, no survey, no plugin flags) from a keyword search only, with no discovery-URL input. Skool Group Scraper takes discovery URLs directly, needs no login or cookies at any point, and returns the full 63-field record — including owner social links and join-survey questions — with no fields gated behind a separate paid tier. All three listed competitors and this Actor price on a pay-per-event basis rather than compute time, so the meaningful cost comparison across them is the charged-event definition and rate, not machine-minute pricing.
Can I use Skool Group Scraper without a Skool account or API key?
Yes. No Skool account, login or cookie is used anywhere in the run. The only credential you need is your own Apify account to start the Actor.
Conclusion
Skool Group Scraper turns Skool's public discovery pages into a structured, typed dataset — community identity, pricing, member counts and owner profile data in one row, with no login and no manual page-by-page copying. It's built for anyone benchmarking Skool communities at scale: operators pricing against competitors, agencies scoping a niche, researchers tracking a category over time. Paste a discovery URL into the Apify Console or trigger a run through the Apify API to get your first dataset.
💬 Your feedback
Found a bug, or need a field that's in Skool's /about payload but missing from the output? Open an issue on the Actor's Issues tab — reports that include the discovery URL and the affected community slug are the fastest to reproduce and fix.
