Skool Group Scraper - Pricing & Join Details

Skool Scraper — Extract Pricing Tiers, Join Questions & Links

Skool Group Scraper - Pricing & Join Details walks any Skool discovery page and returns every community it finds as one structured record: the full public community profile, its membership pricing tiers, its join/application questions, and its public outbound group links. Every response is typed, normalized JSON — no HTML, no selectors, no manual parsing. Toggle any of the three add-on layers off if you only need the base community record. Point it at a discovery URL and you get pricing, tier structure and join-flow friction for every community it finds, ready to load into a spreadsheet, a database, or an AI agent.

What is Skool Group Scraper - Pricing & Join Details?

Skool Group Scraper - Pricing & Join Details is an Apify Actor that turns a Skool discovery page into a structured dataset of communities, each enriched with how it prices and gates membership. It reads Skool's own public discovery and /about pages — nothing behind a login. No Skool account, cookie or session is required to run it; the one credential you need is your Apify token.

It returns four layers of data on the same row: the standard community profile, membership pricing tiers, join/application questions, and public group links.

• 🎓 Scrape every community listed on a Skool discovery page, with its full public profile
• 💳 Scrape membership pricing tiers, the decoded price and the billing period
• ❓ Scrape the join / application questions asked at signup
• 🔗 Scrape public outbound group links
• 📤 Export as JSON or CSV, or pull results straight through the Apify API

🧩 What data does Skool Group Scraper collect?

Every discovery URL you provide is walked for communities, and each community comes back with its base profile plus up to three enrichment layers — pricing, join questions and links — all read from the same public /about page.

Data Type	Key Fields	JSON Field Names
Community profile	name, display name, member count, owner identity, courses, tab visibility	displayName, name, totalMembers, ownerName, numCourses, classroomVisible
Membership pricing	decoded price, currency, billing interval, membership model	priceAmount, priceCurrency, priceInterval, membershipModelLabel
Pricing tiers	tier name, billing model, benefits, billing-plan IDs	pricingTiers[] (tier, model, benefits[], monthlyBpId, annualBpId, oneTimeBpId)
Join / application questions	question text, answer type, count	joinQuestions[] (question, type), joinQuestionsCount
Public group links	outbound label + URL	groupLinks[] (url, label), groupLinksCount

Why not build this yourself?

Skool does not publish a general public API for its discovery pages or its community pricing data, so the alternative to this Actor is scraping Skool yourself — and the maintenance burden is the real cost, not the first script.

Skool renders its discovery and /about pages as Next.js server-side pages: every field this Actor returns is embedded in a <script id="__NEXT_DATA__"> JSON blob, and several of the values inside it — metadata.displayPrice, metadata.survey, metadata.links — are themselves JSON-encoded strings that need a second decode pass before they're usable. Paginating past the first page of discovery results means calling Skool's own internal _next/data/{buildId}/discovery.json endpoint, and buildId changes on every Skool deploy, so a hardcoded pagination URL breaks the moment Skool ships a release.

The second cost is access. A cold, unauthenticated request can get blocked, so a durable scraper needs a fallback ladder — direct connection, then a datacenter proxy, then a residential proxy, with retries and sticky sessions at each tier — plus a real Chromium renderer to execute the page's own JavaScript before the data exists in the DOM. That's infrastructure to build, run and pay for before a single price field comes back.

Why do developers and teams scrape Skool communities?

🤖 For AI engineers and agent builders

An agent tasked with recommending or evaluating online communities needs structured pricing and access data, not a page render. Skool Group Scraper returns priceAmount, priceInterval, membershipModelLabel and pricingTiers[] as typed JSON, so a pricing-comparison tool or a RAG index can answer "which AI communities charge under $50/month with no application gate" by filtering on priceAmount and joinQuestionsCount, without an LLM ever parsing raw HTML from Skool's marketing page.

📊 For marketers and community operators

Positioning a paid community starts with knowing what comparable communities charge and how much friction they put in front of a new member. Pulling priceAmount, priceInterval, hasTieredPricing and joinQuestions[] across a category on Skool's discovery page shows whether the market favors a single price or tiered plans, and how many application questions competitors ask before they let someone in — and before they charge them.

🔬 For researchers and analysts

Academic and market researchers studying the creator-economy and cohort-based-course sector can map how communities in a given category price and gate access at scale, using only publicly published /about page data — totalMembers, priceAmount, membershipModelLabel and numCourses across hundreds of discovery results — without creating a Skool account or touching any member-only data behind a group's login wall.

For developers building data products

A pricing-intelligence or lead-scoring product can schedule this Actor against a fixed set of discovery URLs, diff priceAmount, pricingTiersCount and totalMembers run over run, and flag a community the moment it changes its price or moves from a single price to a tiered plan — feeding a monitoring dashboard or a CRM enrichment pipeline through the Apify API.

How to scrape Skool communities (step by step)

1. Open Skool Group Scraper - Pricing & Join Details on the Apify Store and click Try for free.
2. Provide the required input — paste one or more Skool discovery URLs into urls, the only required parameter. The prefilled default is https://www.skool.com/discovery; a filtered URL like https://www.skool.com/discovery?q=marketing walks only that search.
3. Set your add-ons and cap — toggle includePricingTiers, includeJoinQuestions and includeGroupLinks on or off, and set maxItems to the number of communities to collect per discovery URL.
4. Click Start to run the Actor on the Apify platform.
5. Open the Dataset tab and download results as JSON or CSV, or pull them through the Apify API.

What to do when Skool changes its page structure

Skool Group Scraper is maintained, and its output schema is fixed — field names and types don't change on your end between runs. Every field it reads comes from a specific path inside Skool's own __NEXT_DATA__ payload (metadata.displayPrice, metadata.survey, metadata.links, pageProps.groupMembershipProducts). If Skool moves one of those paths, the affected field returns its documented empty default (null, [] or 0) rather than breaking the row or the run.

⬇️ Input

Parameter	Required	Type	Description	Example Value
urls	✅ Yes	array	Discovery page URLs to walk, one per line. Add each discovery URL you want to walk. Example: the main Skool discovery page.	["https://www.skool.com/discovery"]
maxItems	No	integer	Upper bound of communities collected from each discovery URL. Minimum 1, maximum 50000. Default 10. Lower = faster preview, higher = fuller export.	25
includePricingTiers	No	boolean	Append pricingTiers[] (tier name, model, benefits, billing-plan IDs), the decoded price summary and the membership-model label. Full tier lists exist only for tiered-membership communities; single-price communities return the price summary with an empty tier list. Default true.	true
includeJoinQuestions	No	boolean	Append joinQuestions[] — the exact questions (and answer type) a new member is asked when requesting to join. Default true.	true
includeGroupLinks	No	boolean	Append groupLinks[] — the community's public outbound links (label + URL). Default true.	true
proxyConfiguration	No	object	Apify Proxy configuration. Enable to route through Apify Proxy from the first request. Leave off for the standard automatic behavior. Prefilled with {"useApifyProxy": false}.	{"useApifyProxy": true}

Example input

{
  "urls": [
    "https://www.skool.com/discovery",
    "https://www.skool.com/discovery?q=marketing"
  ],
  "maxItems": 25,
  "includePricingTiers": true,
  "includeJoinQuestions": true,
  "includeGroupLinks": true,
  "proxyConfiguration": { "useApifyProxy": false }
}

Common pitfall: urls must be Skool discovery pages (skool.com/discovery or a filtered/search variant of it), not a single community's own page. The Actor reads the list of communities out of pageProps.groups in the discovery page's own __NEXT_DATA__ payload — a single community's /about URL doesn't carry that key, so it silently returns zero communities for that URL instead of scraping the community you pasted.

⬆️ Output

Every row is typed, normalized JSON with a fixed key set — the same 63 base community fields on every row, plus up to 13 more if you leave the pricing, join-question and link add-ons on (76 fields total with everything enabled). Export the dataset as JSON, CSV, Excel or any other format the Apify platform's Dataset tab supports, or read it directly through the Apify API.

The Actor's own dataset view shows 11 summary columns — displayName, name, membershipModelLabel, priceAmount, priceCurrency, priceInterval, hasTieredPricing, pricingTiersCount, joinQuestionsCount, groupLinksCount, totalMembers. That view is a display filter for the Console table, not the row itself — every field documented below is written to every dataset item regardless of which columns the view shows.

Community identity & basics

Field	Description
id	Skool's internal group ID
name	The community's URL slug/handle
displayName	The community's display name
description	Short description shown on the discovery page
landingPageDescription	Longer description text from the /about page (null until enrichment succeeds)
supportEmail	The owner's public email, or an address pattern-matched out of landingPageDescription if none is set directly, or null
color	Hex theme color
initials	Fallback-avatar initials
logoUrl	Logo asset URL
logoBigUrl	Large logo asset URL — only populated after /about enrichment
coverSmallUrl	Small cover image URL
faviconUrl	Favicon URL — only populated after /about enrichment
createdAt / updatedAt	ISO timestamps for the group
createdBy	Creator's user ID — only populated after /about enrichment

Legacy price pair (base record)

Field	Description
monthlyPrice	Monthly price, decoded once at discovery time
monthlyCurrency	Currency code for monthlyPrice
annualPrice	Annual price, decoded once at discovery time
annualCurrency	Currency code for annualPrice

These four fields are computed a single time when the row is first built and are never refreshed by the /about enrichment step. Treat priceAmount / priceCurrency / priceInterval (below, under Pricing & membership model) as the canonical, refreshed price — this legacy pair is kept for backward compatibility with an earlier output shape and can disagree with the canonical fields.

Membership & access flags

Field	Description
privacy	Raw access-privacy code from Skool (populated after /about enrichment)
membership	Raw membership-setting code from Skool — distinct from membershipModelCode/membershipModelLabel below
plan	Raw subscription-plan value from Skool
landingPageAccessType	Raw landing-page access-type code

Always-constant fields (never populated)

Field	Description
affiliatePercent	Always 0 — set once at row creation and never updated by any enrichment step
pluginAutoDmEnabled	Always 0
pluginMinChatLevelEnabled	Always 0
surveyEnabled	Always 0
surveyQuestions	Always [] — do not confuse with joinQuestions[], which is the field this Actor actually populates
customLinks	Always [] — do not confuse with groupLinks[], which is the field this Actor actually populates

These six fields are present on every row but carry no live data in this Actor version — they are inherited from an earlier output schema and were never wired to a data source. joinQuestions[] and groupLinks[] (documented below) are the real, populated equivalents.

Membership stats & content counts

Field	Description
totalMembers	Member count — present from discovery data, then refreshed by /about enrichment
totalOnlineMembers	Members currently online — /about only
totalAdmins	Admin count — /about only
totalPosts	Post count — /about only
totalRules	Community rules count — /about only
numCourses	Number of courses — /about only
numModules	Number of course modules — /about only

Tab visibility

Field	Description
audioChatVisible	Whether the Audio Chat tab is visible
calendarVisible	Whether the Calendar tab is visible
classroomVisible	Whether the Classroom tab is visible
mapVisible	Whether the Map tab is visible

Landing page attachments

Field	Description
landingPageAttachments	Array of {id, type, imageFileId, imageOriginalUrl, imageSmallUrl, imageBigUrl, videoId, videoUrl, videoThumbnailUrl} — images and videos embedded on the landing page

Owner / creator fields

Field	Description
ownerId, ownerName, ownerFirstName, ownerLastName	Owner identity
ownerBio, ownerLocation, ownerDiscTop, ownerActivityStatus, ownerMyersBriggs	Owner profile details, as published
ownerOnline, ownerLastOffline	Owner presence status
ownerPictureProfile, ownerPictureBubble	Owner avatar URLs
ownerInstagram, ownerYoutube, ownerFacebook, ownerTwitter, ownerLinkedin, ownerWebsite	Owner's linked social/website URLs, where published
ownerCreatedAt, ownerUpdatedAt	Owner account timestamps

Pricing & membership model (includePricingTiers)

Field	Description
pricingTiers	Array of {tier, model, benefits[], monthlyBpId, annualBpId, oneTimeBpId} — populated only for tiered-membership communities, [] otherwise
pricingTiersCount	Length of pricingTiers
hasTieredPricing	true when pricingTiers is non-empty
membershipModelCode	Raw Skool membership-model code
membershipModelLabel	Decoded label — one of free, paid_recurring, one_time, tiered, or paid as a fallback
priceAmount	Canonical decoded price, in major currency units
priceCurrency	Lowercased ISO currency code
priceInterval	Billing interval as published by Skool (month, year, one_time, or another raw value)

How the price fields are parsed

Skool ships price data as a JSON string (metadata.displayPrice, or the legacy metadata.currentMBp / metadata.currentABp pair) already containing a structured {amount, currency, recurring_interval} object — there is no rendered $/€ symbol to strip. currency is taken verbatim from that JSON and lowercased.

amount arrives in minor units (cents). normalize_amount() divides by 100 to get major units, unless the currency is in a fixed zero-decimal set (bif, clp, djf, gnf, jpy, kmf, krw, mga, pyg, rwf, ugx, vnd, vuv, xaf, xof, xpf), in which case the raw amount is returned unchanged. A price whose cents divide evenly (e.g. 4900 → 49) is returned as an integer; a price that doesn't (e.g. 1250 → 12.5) is returned as a float — the same field can be either JSON type depending on the exact cents.

Free vs. paid is decided purely by whether a price amount was found: no displayPrice/currentMBp/currentABp means priceAmount is null, which resolves membershipModelLabel to "free". Billing period comes from recurring_interval — "month" and "year" map to "paid_recurring", "one_time" maps to "one_time", and a tiered community (pricingTiers non-empty) is always labeled "tiered" regardless of interval.

Known failure modes:

• If amount is present but not a number (Skool has never been observed to do this, but the code doesn't guard it), normalize_amount() returns it unmodified — an un-divided minor-unit value would silently pass through as if it were major units.
• If a community's /about page fails to load after two attempts, its pricing fields fall back to whatever the discovery page seeded — and the discovery seed always sets hasTieredPricing: false and pricingTiersCount: 0, because Skool's discovery payload never carries the tier list. A genuinely tiered-membership community whose /about page can't be reached will report hasTieredPricing: false in that row.
• The legacy monthlyPrice/annualPrice pair (above) is computed once from the discovery-time payload and is never reconciled with the canonical priceAmount/priceInterval pair computed from the /about page — the two can disagree if Skool's discovery and about-page prices differ.

Join / application questions (includeJoinQuestions)

Field	Description
joinQuestions	Array of {question, type} — the questions asked at join time, in order
joinQuestionsCount	Length of joinQuestions
surveyLastUpdatedAt	Timestamp the join survey was last edited, or null

Public group links (includeGroupLinks)

Field	Description
groupLinks	Array of {url, label} — public outbound links published on the community
groupLinksCount	Length of groupLinks

Scraped community record (tiered-membership example)

{
  "id": "5f3a9c2e1b7d4a68a1f2e3c4d5b6a7f8",
  "name": "ai-creators-hub",
  "displayName": "AI Creators Hub",
  "description": "A community for AI builders, prompt engineers and indie hackers shipping real products.",
  "landingPageDescription": "Join 4,000+ AI builders sharing workflows, prompts and launch playbooks every week.",
  "supportEmail": "support@aicreatorshub.io",
  "monthlyPrice": 49,
  "monthlyCurrency": "usd",
  "annualPrice": null,
  "annualCurrency": null,
  "color": "#1E1B4B",
  "initials": "AC",
  "privacy": 1,
  "membership": 1,
  "plan": null,
  "landingPageAccessType": 1,
  "affiliatePercent": 0,
  "pluginAutoDmEnabled": 0,
  "pluginMinChatLevelEnabled": 0,
  "surveyEnabled": 0,
  "surveyQuestions": [],
  "surveyUpdatedAt": null,
  "logoUrl": "https://assets.skool.com/f/5f3a9c2e/logo.png",
  "logoBigUrl": "https://assets.skool.com/f/5f3a9c2e/logo-big.png",
  "coverSmallUrl": "https://assets.skool.com/f/5f3a9c2e/cover-sm.jpg",
  "faviconUrl": "https://assets.skool.com/f/5f3a9c2e/favicon.png",
  "customLinks": [],
  "totalMembers": 4218,
  "totalOnlineMembers": 63,
  "totalAdmins": 4,
  "totalPosts": 9143,
  "totalRules": 5,
  "numCourses": 6,
  "numModules": 42,
  "audioChatVisible": false,
  "calendarVisible": true,
  "classroomVisible": true,
  "mapVisible": false,
  "landingPageAttachments": [
    {
      "id": "91549370e67a4bef9d5cec15d534dce0",
      "type": 2,
      "imageFileId": null,
      "imageOriginalUrl": null,
      "imageSmallUrl": null,
      "imageBigUrl": null,
      "videoId": null,
      "videoUrl": "https://www.loom.com/share/f47a593978ac46a89de213503090fe9c",
      "videoThumbnailUrl": "https://cdn.loom.com/sessions/thumbnails/f47a593978ac46a89de213503090fe9c.gif"
    }
  ],
  "ownerId": "8a1f2e3c4d5b6a7f8e9d0c1b2a3f4e5d",
  "ownerName": "jordan-lee-4821",
  "ownerFirstName": "Jordan",
  "ownerLastName": "Lee",
  "ownerBio": "Building AI tools in public. Ex-YC founder.",
  "ownerLocation": "Austin, TX",
  "ownerDiscTop": null,
  "ownerActivityStatus": null,
  "ownerMyersBriggs": "ENTP",
  "ownerOnline": 0,
  "ownerLastOffline": "1764200517573641700",
  "ownerPictureProfile": "https://assets.skool.com/f/8a1f2e3c/profile.jpg",
  "ownerPictureBubble": "https://assets.skool.com/f/8a1f2e3c/bubble.jpg",
  "ownerInstagram": "https://instagram.com/jordanlee",
  "ownerYoutube": null,
  "ownerFacebook": null,
  "ownerTwitter": "https://twitter.com/jordanleeai",
  "ownerLinkedin": "https://linkedin.com/in/jordanlee",
  "ownerWebsite": "https://jordanlee.ai",
  "ownerCreatedAt": "2022-03-14T10:12:00.000Z",
  "ownerUpdatedAt": "2025-10-02T08:45:12.000Z",
  "createdAt": "2022-04-01T00:00:00.000Z",
  "updatedAt": "2026-07-20T14:32:09.000Z",
  "createdBy": "8a1f2e3c4d5b6a7f8e9d0c1b2a3f4e5d",
  "pricingTiers": [
    {
      "tier": "core",
      "model": "recurring",
      "benefits": ["Weekly office hours", "Private Discord bridge", "Course library access"],
      "monthlyBpId": "bp_core_m_123",
      "annualBpId": "bp_core_a_123",
      "oneTimeBpId": null
    },
    {
      "tier": "pro",
      "model": "recurring",
      "benefits": ["Everything in Core", "1:1 monthly call", "Early feature access"],
      "monthlyBpId": "bp_pro_m_456",
      "annualBpId": "bp_pro_a_456",
      "oneTimeBpId": null
    }
  ],
  "pricingTiersCount": 2,
  "hasTieredPricing": true,
  "membershipModelCode": "tiered",
  "priceAmount": 49,
  "priceCurrency": "usd",
  "priceInterval": "month",
  "membershipModelLabel": "tiered",
  "joinQuestions": [
    { "question": "What are you building right now?", "type": "text" },
    { "question": "How did you hear about AI Creators Hub?", "type": "text" }
  ],
  "joinQuestionsCount": 2,
  "surveyLastUpdatedAt": "2025-09-01T12:00:00.000Z",
  "groupLinks": [
    { "url": "https://aicreatorshub.io", "label": "Website" },
    { "url": "https://twitter.com/aicreatorshub", "label": "Twitter" }
  ],
  "groupLinksCount": 2
}

Single-price community — the pricing fields that differ

A community with one flat price instead of tiers returns the same 76 keys, but the pricing block looks like this instead:

{
  "pricingTiers": [],
  "pricingTiersCount": 0,
  "hasTieredPricing": false,
  "membershipModelCode": "paid",
  "priceAmount": 29,
  "priceCurrency": "usd",
  "priceInterval": "month",
  "membershipModelLabel": "paid_recurring"
}

A free community returns priceAmount: null, priceCurrency: null, priceInterval: null and membershipModelLabel: "free", with pricingTiers still present as [].

How does Skool Group Scraper compare to other Skool scrapers?

Feature	Skool Group Scraper - Pricing & Join Details	Generic Skool scraper
Pricing tier breakdown (tier name, model, benefits, billing-plan IDs)	✅ pricingTiers[] on every row	❌ Not documented on the closest listings checked on the Apify Store, 2026-07-25
Join/application question extraction	✅ joinQuestions[] with question text + answer type	❌ Not documented on the closest listings checked, 2026-07-25
Public outbound group links	✅ groupLinks[]	❌ Not documented on the closest listings checked, 2026-07-25
Login required	✅ None — fully logged-out, public /about page only	⚠️ Varies — one closest listing requires a Skool session cookie for member-level data (checked 2026-07-25)
Discovery auto-pagination	✅ via Skool's own _next/data endpoint	✅ Also documented on the two closest listings checked, 2026-07-25
Output format	✅ Typed, normalized JSON, fixed schema	Varies by listing

If you're building an AI agent or RAG pipeline, the output format row is the decision-maker — parsing HTML inside an agent loop is a reliability failure mode, not a feature. scrapersdelight/skool-community-scraper's listing advertises a derived MRR estimate and owner-socials extraction (checked on the Apify Store, 2026-07-25) — not measured or reproduced here; memo23/skool-members-scraper's listing is built around member/user-level scraping and requires a Skool login cookie for that data (checked 2026-07-25).

⚠️ How many communities can you scrape with Skool Group Scraper?

maxItems is a per-discovery-URL cap, not a total — default 10, up to 50000 per URL you supply, with no additional hard cap in the Actor itself. Provide five discovery URLs at maxItems: 100 and you can collect up to 500 rows in that run, minus any duplicate community found under more than one URL (deduplicated by group ID across the whole run, so it's only saved once).

Pagination past the first page uses Skool's own _next/data/{buildId}/discovery.json endpoint and stops when a page request fails, returns no communities, or returns only communities already collected — whichever comes first, so the actual row count for a URL can land below your maxItems if Skool's discovery list for that search runs out first.

Every community that reaches the dataset is charged as one row_result event, whether or not its /about enrichment step succeeded. If the /about page can't be loaded after two attempts, the row is still saved and charged — with pricingTiers, joinQuestions and groupLinks at their empty defaults and pricing fields carried over from the discovery-page seed rather than the (more complete) about-page values. There is no separate, uncharged event for a degraded row — budget for this when scraping at volume against communities with unreliable /about pages.

Integrate Skool Group Scraper and automate your workflow

Skool Group Scraper works with any language or tool that can send an HTTP request.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/skool-group-scraper-pricing-join-details").call(run_input={
    "urls": ["https://www.skool.com/discovery?q=marketing"],
    "maxItems": 25,
    "includePricingTiers": True,
    "includeJoinQuestions": True,
    "includeGroupLinks": True,
})

for community in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(community["displayName"], community["priceAmount"], community["membershipModelLabel"])

Works in Python, Node.js, Go, Ruby, cURL.

Automation platforms (n8n, Make)

In n8n, use the Apify node — or an HTTP Request node pointed at the Apify run endpoint with your token — and pass the same JSON input shown above. In Make, use the Apify module and map the dataset output directly into a Google Sheets or Airtable step for a scheduled pricing-monitor workflow. Both platforms handle scheduling, so a weekly community-pricing sweep needs no code.

Is it legal to scrape Skool?

Yes — Skool Group Scraper collects only data Skool already publishes to any anonymous, logged-out visitor on a community's discovery listing and public /about page. No login, cookie or session is used to reach any of it.

The core of this Actor's output — community names, descriptions, pricing tiers, join questions, group links, member and course counts — is business/product data: pricing and catalog information, not personal data, and it is governed by Skool's terms of service and any applicable database-rights rules rather than GDPR or CCPA. The owner fields (name, bio, location, social links) are personal information the community owner has chosen to publish as part of their public creator or business profile; treat bulk collection of those fields with the same care you would any personal-data processing.

Consult legal counsel for commercial use cases involving bulk personal data.

❓ Frequently asked questions

Does Skool Group Scraper work without a Skool account?

Yes. No Skool account, cookie or login is used anywhere in the run — the Actor reads only what Skool serves to an anonymous visitor. The one credential you need is your own Apify token.

How often is the scraped data updated?

Every run does a live fetch. There is no caching layer — each discovery page and each community's /about page is loaded fresh at run time, so results reflect Skool's current state at the moment your run executes.

What happens if a community's /about page fails to load or the community is gone?

The Actor retries the /about page up to two times. If it still can't load, the row is saved anyway with its pricing, join-question and link fields at their empty defaults ([], 0, null, or membershipModelLabel: "free") rather than being dropped — and it is still charged as one row_result (see How many communities can you scrape, above, for the exact behavior).

Can I scrape private or invite-gated Skool communities?

No. Only publicly accessible discovery and /about page data is returned. Member lists, private posts, chat and any content requiring an approved membership are out of scope — this Actor never logs in.

Can I try Skool Group Scraper on a small run first?

Yes. Set maxItems to a small number like 1–5 and run against a single discovery URL. Billing is pay-per-event on row_result, so a small test run costs proportionally to the rows it actually saves.

Does Skool Group Scraper work for AI agent workflows and LLM pipelines?

Yes. It's callable as a standard HTTP endpoint through the Apify API — apify_client in Python, or any language that can make a request — so any agent framework can invoke it and receive typed JSON directly, with no MCP server required.

How does Skool Group Scraper handle Skool's anti-bot protection?

The Actor renders every page with a real headless Chromium browser (via Playwright), not a bare HTTP client, and waits for Skool's __NEXT_DATA__ script tag to attach before reading the page. Requests escalate through a connection ladder — direct connection first, then a datacenter proxy, then a residential proxy — with retries and sticky sessions at each tier, plus a randomized pre-navigation delay. You can also supply your own proxyConfiguration to route through Apify Proxy from the first request instead.

How does Skool Group Scraper compare to other Skool scrapers?

See the comparison table above. The two closest listings on the Apify Store, checked 2026-07-25, focus on MRR estimation and owner-social extraction, or member/user-level scraping with a required login cookie — neither documents tier-level pricing breakdown or join-question extraction the way this Actor does.

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

Yes. Every response is typed, normalized JSON with stable field names on every run. No HTML, no selectors. Pass a row directly into an LLM context window, index it into a vector store, or route it through an agent tool with no parsing step in between.

Can I use Skool Group Scraper without managing proxies?

Yes. By default the Actor handles its own connection ladder — direct, then datacenter, then residential — automatically, with no proxy account or configuration required from you. Turn on proxyConfiguration only if you want to route through Apify Proxy from the first request.

What happens when Skool changes its structure or blocks the scraper?

The scraper is maintained, and the output schema stays stable — field names and types don't change on your end. Fields read from a path Skool has since moved return their documented empty default rather than breaking the run.

💬 Your feedback

Found a bug, or missing a field that's genuinely on Skool's /about page but not in this output? Open an issue on the Actor's Issues tab in the Apify Console. Reports that include a sample discovery URL or community slug are the fastest to act on.