Skool Group Community Infos Scraper With Price & Payout

Skool Scraper — Extract Community Pricing, Tiers & Affiliate Payouts

Skool Scraper reads a public Skool community's /about page — logged out, one request per community — and returns a full monetisation snapshot: the community profile, the exact price and billing period, every paid membership tier with its benefits, the affiliate commission percent, and the owner's outbound links and landing-page sales copy. Every response is typed, normalized JSON — no HTML, no selectors, no parsing required on your end. Paste a list of Skool community links or slugs and watch structured rows land in your dataset as each one finishes.

What is Skool Group Community Infos Scraper With Price & Payout?

Skool Group Community Infos Scraper With Price & Payout is an Apify Actor that fetches a Skool community's public /about page while logged out and parses the page's embedded __NEXT_DATA__ JSON payload into structured fields. No Skool account, password, or cookie is required — the Actor never authenticates as a member. Because pricing, membership tiers, affiliate rate, and owner links all live in the same server-rendered payload as the base community profile, everything below comes from one HTTP request per community, not a chain of follow-up calls.

• Scrape the community profile — name, description, member/post counts, owner
• Scrape pricing and membership tiers — exact price, billing period, every paid tier's benefits
• Scrape affiliate payout — the commission percent Skool pays out on that community
• Scrape owner links and landing pitch — outbound funnel/social links plus the full sales copy shown before joining
• Export results as JSON, CSV, Excel, or any other format Apify's dataset export supports

What data does Skool Group Community Infos Scraper With Price & Payout collect?

Each run returns four categories of data for every community you list, all pulled from the same /about response.

Data Type	Key Fields	JSON Field Names
Community profile	name, description, member/post/admin counts, owner	group_name, group_description, total_members, total_posts, owner{}
Pricing & membership tiers	price, currency, billing period, paid tier benefits	price{amount,currency,billingPeriod,isPaid}, membershipTiers[]{id,tier,model,benefits[]}
Affiliate payout	commission percent, program flag	affiliatePercent, hasAffiliateProgram
Owner links & landing pitch	outbound links, pre-join sales copy	ownerLinks[]{label,url,public}, landingPageText

Need more Skool data?

This Actor is deliberately scoped to the public /about page — one logged-out request, community profile plus the money side. If your workflow needs member lists, post/comment content, or classroom material, that requires a different data source, since those pages sit behind Skool's member session and are out of scope for this Actor by design.

Why not build this yourself?

Skool has no published public API — no documented REST endpoints, no developer portal, no API key system. The only official programmatic surface is Stripe webhooks for payment events, which don't expose community profile, pricing, or affiliate data at all. Anyone who wants this data has to scrape the rendered page.

Doing that yourself means parsing a <script id="__NEXT_DATA__"> blob that Skool can restructure at any time, handling fields that arrive as JSON-encoded strings inside the JSON (displayPrice, benefits, links all need a second json.loads), correctly zero-decimal currencies like JPY and KRW so prices aren't off by 100x, and building a retry/proxy ladder for the communities that block a plain request. This Actor already does all of that and keeps the output schema stable when Skool changes its markup.

Why do developers and teams scrape Skool?

Skool hosts thousands of paid courses and communities, and the commercial terms — price, tier structure, affiliate rate — aren't published anywhere but the group's own landing page. Four groups use this data differently:

For affiliates and partnership marketers

Affiliates deciding which Skool communities to promote need the actual commission rate, not a guess. Pulling affiliatePercent and hasAffiliateProgram across a shortlist of communities in one run — alongside price to estimate payout per referral — turns "which group pays best" from manual page-by-page checking into a single dataset you can sort and filter.

For competing course and community creators

Pricing a new Skool community against the market means knowing what similar communities actually charge and what their paid tiers include. price.amount, price.billingPeriod, and membershipTiers[].benefits from a list of competitor communities give a direct read on prevailing price points and tier structures without joining each one.

For researchers and market analysts

The creator-economy and cohort-course market is opaque from the outside — most pricing and monetisation data sits behind a landing page, not a public database. Tracking price, total_members, and affiliatePercent across a sample of Skool communities supports public-data market sizing and pricing-trend research, scoped strictly to what each community already publishes on its own page.

For developers building data products

Price-tracking tools, deal-alert bots, and affiliate-rate dashboards all need a reliable feed of Skool monetisation data. Because the Actor is invoked over the Apify API and returns stable JSON field names, it drops into a scheduled pipeline without a custom parser to maintain.

How to scrape Skool communities (step by step)

1. Open Skool Group Community Infos Scraper With Price & Payout on its Apify Store listing and click Try for free (or Start) to open the input form in Apify Console.
2. Provide the required input — paste one or more Skool community links or bare slugs into urls (one per line).
3. Toggle what you want back: includePricing, includeAffiliatePayout, and includeOwnerLinksAndPitch are all on by default; turn any off to trim the row, or turn on paidOnly to drop free communities before you're billed for them.
4. Start the run.
5. Download results as JSON, CSV, Excel, or another format from Apify's Export menu on the dataset — or read them live from the Output tab while the run is in progress.

What to do when Skool changes its page structure

The Actor is maintained against Skool's live __NEXT_DATA__ payload, and the output field names and types stay stable on your end even when Skool's internal markup shifts. No action is required from your integration when that happens.

⬇️ Input

urls is the only required field. Everything else has a default and can be left as-is.

Parameter	Required	Type	Default	Description
urls	Yes	array (stringList)	—	Skool community/group links, one per line. Accepts full URLs (https://www.skool.com/{slug}/about) or a bare slug.
proxyConfiguration	No	object (proxy)	{"useApifyProxy": false}	Optional Apify Proxy. Off = direct connection only. On = the Actor tries a direct connection first, then falls back to datacenter, then residential proxy only if a page is blocked.
maxRetries	No	integer	3	Retries for a single request on network/timeout errors (0–10). Does not retry when a page loads but data is simply missing.
includePricing	No	boolean	true	Return price{amount,currency,billingPeriod,isPaid} and membershipTiers[].
includeAffiliatePayout	No	boolean	true	Return affiliatePercent and hasAffiliateProgram.
includeOwnerLinksAndPitch	No	boolean	true	Return ownerLinks[] and landingPageText.
paidOnly	No	boolean	false	When true, communities with no published price are dropped from the output before the row is billed.

Example input:

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

The most common input mistake is pasting a deep Skool URL — a specific post or classroom link — instead of the group root. The Actor only keeps the first path segment as the slug and always requests /{slug}/about itself, so a link like skool.com/your-group/classroom/abc123 still resolves correctly, but a URL from a different group's post won't silently redirect to the group you meant.

⚠️ Every row pushed to the dataset — including failed and blocked communities — charges the same pay-per-event row_result billing event. There is no separate uncharged error event. Clean up bad slugs before a large run rather than letting them fail on Skool's side.

⬆️ Output

Results are written to the Actor's dataset as one row per community, in the same order the request finished (not necessarily input order, since rows are pushed live). Export as JSON, CSV, Excel, or any other format Apify's dataset view supports.

Scraped community

With all three include* flags left on (the default), a successful row looks like this:

{
  "slug": "creator-launchpad",
  "url": "https://www.skool.com/creator-launchpad/about",
  "group_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "group_name": "Creator Launchpad",
  "group_description": "A community for creators building their first paid audience.",
  "group_image": "https://img.skool.com/creator-launchpad/cover.jpg",
  "group_created_at": "2023-02-14T10:00:00.000Z",
  "group_updated_at": "2026-07-01T09:12:00.000Z",
  "total_members": 4820,
  "total_online_members": 96,
  "total_posts": 3110,
  "total_admins": 3,
  "privacy": "public",
  "map_enabled": "N/A",
  "membership": "paid",
  "num_courses": 6,
  "num_modules": 41,
  "tabs": {},
  "survey": {},
  "owner": {
    "id": "u_998877",
    "name": "Jamie Rivera",
    "email": "N/A",
    "location": "Austin, TX",
    "bio": "Helping creators turn an audience into a business.",
    "picture_profile": "https://img.skool.com/users/jamie-rivera.jpg",
    "created_at": "2022-11-03T08:00:00.000Z",
    "updated_at": "2026-06-20T14:45:00.000Z"
  },
  "owner_name": "Jamie Rivera",
  "price": {
    "amount": 49,
    "currency": "usd",
    "billingPeriod": "month",
    "isPaid": true
  },
  "membershipTiers": [
    {
      "id": "prod_1A2B3C",
      "tier": "core",
      "model": "recurring",
      "benefits": ["Weekly live calls", "Private Discord access", "Course library"],
      "activatedAt": "2024-01-10T00:00:00.000Z"
    }
  ],
  "affiliatePercent": 20,
  "hasAffiliateProgram": true,
  "ownerLinks": [
    { "label": "My other community", "url": "https://www.skool.com/creator-growth-lab", "public": true }
  ],
  "landingPageText": "Join 4,800+ creators learning how to turn content into a real business — live coaching, a proven course path, and a community that actually shows up."
}

tabs and survey are raw metadata blocks Skool attaches to the group (navigation tab config and the join-survey questions, respectively); their internal shape isn't documented by Skool and is often empty, as shown here. map_enabled is always returned as the literal string "N/A" — the Actor doesn't scrape a real value for it because Skool's /about payload doesn't expose one. owner.email reads "N/A" whenever Skool doesn't publish it on the logged-out page, which is effectively always.

On communities with no published price, includePricing still returns price.isPaid: false and membershipTiers: [] — never a fabricated 0. On communities with no affiliate program, affiliatePercent: null and hasAffiliateProgram: false — never a guessed rate.

Failed or unreachable community

A community that can't be read — a bad slug, a blocked request that exhausts retries, or a page Skool won't serve — still produces one row, with the monetisation fields simply absent:

{
  "slug": "some-slug",
  "url": "https://www.skool.com/some-slug/about",
  "group_name": "",
  "owner_name": "",
  "error": "couldn't load after retries"
}

How does Skool Scraper compare to other Skool scrapers?

Feature	Skool Group Community Infos Scraper With Price & Payout	Generic Skool scraper
Login/cookies required	No — public, logged-out /about page only	Often yes — member and profile data on Skool scrapers typically requires a session cookie or auth token
Price & membership tier fields	Yes, on every row — price, membershipTiers[]	Not always — some Skool scrapers cover group and member profile fields only, with no pricing data
Affiliate payout field	Yes — affiliatePercent, hasAffiliateProgram	Rare — only a subset of Skool scrapers expose an affiliate field
Requests per community	1 (all fields parsed from the same response)	Varies — scrapers that also fetch member lists or enrich contacts typically issue several requests per group
Output format	Typed, normalized JSON dataset row	Typed JSON dataset row (standard on Apify)

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. A stable JSON schema is what lets you wire this Actor straight into a tool call without a parsing layer in between.

How many results can you scrape with Skool Scraper?

There's no hard cap in the Actor itself — urls accepts as many community links or slugs as you paste in, and every entry produces exactly one output row (or one error row if it can't be read). There's no pagination to configure, because each community is a single request rather than a paginated list. Communities are processed one at a time, with a short randomized pause (roughly half a second to a second and a half) between requests to avoid a detectable request pattern — so total run time scales with the number of communities in your list.

Integrate Skool Scraper and automate your workflow

Skool Group Community Infos Scraper With Price & Payout works with any language or tool that can send an HTTP request, through the standard Apify API.

REST API integration

import requests

run_input = {"urls": ["https://www.skool.com/thatpickleballschool/about"]}
resp = requests.post(
    "https://api.apify.com/v2/acts/YOUR_USERNAME~skool-group-community-infos-scrape-with-price-and-payout/run-sync-get-dataset-items",
    params={"token": "YOUR_APIFY_TOKEN"},
    json=run_input,
)
for row in resp.json():
    print(row["group_name"], row.get("price"))

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

MCP for AI agents

The Actor is reachable through Apify's Actors MCP Server, which exposes any public Apify Actor as a callable tool:

npx -y @apify/actors-mcp-server --actors=YOUR_USERNAME/skool-group-community-infos-scrape-with-price-and-payout

Compatible with Claude Desktop, Claude Code, Cursor, and other MCP-capable clients.

Automation platforms (n8n, Make, LangChain)

In n8n, the official Apify node's "Run Actor" operation can call this Actor and pass its output directly into the next node in your workflow. In Make, the Apify app's Actor module does the same inside a scenario. In LangChain or a custom agent framework, the Apify API call above wraps into a tool definition with no additional parsing step.

Is it legal to scrape Skool?

Yes — this Actor only reads a Skool community's public /about page, the same page Skool serves to any logged-out visitor, including search engines. Most of what it returns — member and post counts, price, membership tiers, affiliate rate — is business and product data the community owner has chosen to publish, which is governed by Skool's Terms of Service and database-rights law rather than data-protection law.

The owner block is a partial exception: owner.name, owner.bio, owner.location, and owner.picture_profile are personal data about an identifiable individual, even though the community owner published them on a public page. owner.email is not a practical concern here — it comes back as "N/A" on the logged-out payload in effectively every case. If you store or process owner profile fields at scale, GDPR/CCPA lawful-basis considerations can still apply. Consult legal counsel for commercial use cases involving bulk personal data.

Frequently asked questions

Does Skool Scraper work without a Skool account?

Yes. The Actor only reads the public /about page while logged out — no Skool account, password, or cookie is used or required at any point.

How often is the scraped data updated?

Every run fetches Skool's /about page fresh — there is no caching layer. The price, tiers, member counts, and affiliate rate reflect what Skool serves at the moment the run executes.

What happens if a community can't be reached?

That row still lands in your dataset, shaped as {slug, url, group_name: "", owner_name: "", error} with a short reason (an invalid slug, or the page still blocked after maxRetries attempts with the optional proxy). ⚠️ That row still charges the row_result pay-per-event billing event, the same as a successful row — it isn't free just because the fetch failed.

Can I scrape private or invite-only Skool communities?

No. Only communities with a public /about page are accessible. Communities that require an invite or approval to even view their about page are out of scope — the Actor does not authenticate as a member to get past that.

How is this Actor billed?

Per dataset row, via Apify's pay-per-event model on the row_result event — one charge per community row written to the dataset, success or failure alike. There's no separate flat platform fee documented in the Actor's own configuration.

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

Yes. It's callable as an HTTP endpoint through the Apify API by any agent framework, and it's also reachable through Apify's Actors MCP Server for MCP-native clients. Every response is typed JSON with stable field names — no parsing step before passing rows to an LLM.

How does Skool Scraper handle Skool's anti-bot system?

The Actor sends browser-realistic request headers (Chrome user-agent, sec-fetch-*, accept-language), detects blocks by status code (403/429/502/503) and by body content (missing __NEXT_DATA__, a captcha or "access denied" page), and retries per maxRetries. If the optional proxy is enabled, it escalates through a connection ladder — direct, then datacenter proxy, then residential proxy with its own retry budget — and sticks with residential for the rest of the run once it's needed.

How does Skool Scraper compare to other Skool scrapers?

As observed on their Apify listings on 2026-08-16: "Skool Scraper" by louisdeconinck extracts group and member profile fields but does not expose price, membership tiers, or affiliate payout, and requires a valid auth token/cookie for member-level data. The "SKOOL | Members/Groups | Discovery Search | Scraper" by memo23 does expose group pricing and an affiliatePercent field similar in spirit to this Actor, but requires session cookies ("you must be a member of any group you scrape") for member data. This Actor covers the monetisation fields — price, tiers, affiliate rate, owner links — logged out, from the public /about page alone.

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

Yes. Typed, normalized JSON with stable field names — no HTML, no selectors, no parsing. Pass rows directly into an LLM context window, index them into a vector store, or route them through an agent tool call.

Can I use Skool Scraper without managing proxies?

Yes. The default run uses a direct connection with no proxy at all. The optional proxyConfiguration input only matters if a specific community is slow or blocked — turning it on hands proxy selection and fallback entirely to the Actor.

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

The Actor is maintained against Skool's live page structure, and the output schema — field names and types — stays stable on your end when that happens. No numeric turnaround time is promised.

Your feedback

Found a bug or missing a field? We want to know. Open an issue from the Actor's Issues tab in Apify Console, or reach out through the contact link on the Actor's Store listing — that's how this scraper stays maintained against Skool's changes.