Quick reference (TL;DR for agents)

Why Goose + Skool?

Skool has no official API. If Goose already runs your dev tasks, you don’t want to drop out of it to open the Skool web UI and click through member approvals or course uploads by hand.

Goose helped shape MCP, and its extension system is MCP all the way down — every extension you add is an MCP server, every server’s tools become callable by the agent. The Skool All-in-One API actor is hosted on Apify’s MCP gateway, so adding it is the same one-step flow as any other Goose extension. No SDK, no Playwright in your runtime — Goose can drive your whole Skool admin surface.

Why Goose specifically fits well here:

  1. Extension = MCP server, no special casing. Skool is just another stdio extension alongside your developer/computercontroller extensions.
  2. Interactive goose configure wizard. Add the extension by answering prompts — name, command, timeout, env vars — no hand-edited JSON if you don’t want it.
  3. Autonomous task runs. Goose is built to run multi-step tasks unattended; “every morning, approve verified applicants and post the digest” is a natural Goose recipe once the Skool extension is wired.

Setup — add the Skool extension (5 minutes)

1. Get your Apify API token

Sign up at apify.com — the free tier covers most communities. Grab a token from console.apify.com/account/integrations.

2. Get your Skool cookies (one-time, valid ~3.5 days)

Run this once and keep the returned cookies string — you’ll store it in the extension env:

curl -X POST \
  "https://api.apify.com/v2/acts/cristiantala~skool-all-in-one-api/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "action": "auth:login",
    "email": "admin@yourcommunity.com",
    "password": "your-skool-password",
    "groupSlug": "your-community-slug"
  }'

3. Add the extension

Option A — interactive (goose configure):

goose configure
# → Add Extension
# → Command-line Extension (STDIO)
#   Name:    skool
#   Command: npx -y @apify/actors-mcp-server --token=YOUR_APIFY_TOKEN --actors=cristiantala/skool-all-in-one-api
#   Timeout: 60   (seconds — auth:login needs headroom)
#   Env:     SKOOL_COOKIES=...   SKOOL_GROUP_SLUG=your-community-slug

Option B — edit ~/.config/goose/config.yaml directly (on Windows: %APPDATA%\Block\goose\config\config.yaml). Add a skool entry under extensions:

extensions:
  skool:
    type: stdio
    command: npx
    args:
      - "-y"
      - "@apify/actors-mcp-server"
      - "--token=YOUR_APIFY_TOKEN"
      - "--actors=cristiantala/skool-all-in-one-api"
    env:
      SKOOL_COOKIES: "the-cookies-string-from-step-2"
      SKOOL_GROUP_SLUG: "your-community-slug"
    timeout: 300

4. Start a session and verify

goose session

The Skool actions are now available as tools. You can also load it for a single run without persisting config:

goose session --with-extension "npx -y @apify/actors-mcp-server --token=YOUR_APIFY_TOKEN --actors=cristiantala/skool-all-in-one-api"

How the connection works

Goose                              Apify                          Skool
─────                              ─────                          ─────
reads ~/.config/goose/config.yaml  →  starts @apify/actors-mcp-server (extension)
        │  picks a tool + structured params
        ▼
[MCP call ───────────→ run-sync-get-dataset-items ──────────────→ api.skool.com]
{ action, cookies, groupSlug, ... }                              (login + WAF token +
        │                                  │                       buildId handled by actor)
        ◄──────── { success: true, data } ◄────────────────────────┘
        │
   Goose reports back / continues the task

Every Skool operation = one MCP tool call backed by one HTTP POST. The actor handles Playwright login, WAF token rotation, and Skool buildId changes for you.

Example session — clear the waitlist by chat

You start goose session and type:

List my pending Skool members and approve the ones with a real LinkedIn. Show me the rest so I can decide.

Goose calls, in sequence:

1. members:pending                    → fetches the approval queue
2. (reasons over each: LinkedIn reachable? survey specific? channel?)
3. members:batchApprove               → approves the clear yeses in one call
4. prints the borderline ones for you → you decide the edge cases

End-to-end this replaces ~10 minutes of clicking through the Skool admin UI, at about a cent per approved member. Full walkthrough: Review & batch-approve your waitlist.

What you can ask Goose to do — full action surface

The actor exposes the entire Skool admin surface as MCP tools. You ask in plain English; Goose maps it to one of these actions. Full params for each: Actions reference.

Posts & comments

Action What it does
posts:list / posts:filter List or filter posts (by date, label, unanswered)
posts:get Fetch a single post
posts:create Publish a post (plain text + optional label/video)
posts:update / posts:delete Edit or delete a post/comment
posts:createComment Comment on a post or reply to a comment
posts:pin / posts:unpin Pin or unpin a post
posts:vote Upvote / clear vote
posts:getComments / posts:getCommentsFull Read a post’s comment tree (fast / full-scroll, no cap)

Members

Action What it does
members:list List active members
members:pending List the approval queue
members:approve / members:reject Approve or reject one applicant
members:batchApprove Approve N applicants in one run
members:ban Ban a member (destructive — confirm first)

Events

Action What it does
events:list / events:upcoming List calendar events (all / future only)

Classroom (courses)

Action What it does
classroom:listCourses / classroom:getTree List courses / read a course’s full tree
classroom:createCourse / createFolder / createPage Build course structure
classroom:setBody Set a lesson’s content (markdown → auto-converted to TipTap)
classroom:updateCourse Edit course settings — cover, tier, privacy (read-then-write)
classroom:updateResources Attach / detach downloadable files on a lesson
classroom:deleteUnit Delete a course / folder / page (destructive — confirm first)

Files & groups

Action What it does
files:uploadImage / files:uploadFile Upload a cover image / a private attachment
groups:get Read group metadata (incl. post categories)
groups:setAutoDM Set the welcome DM new members receive

System

Action What it does
system:health / system:debug Healthcheck / SSR diagnostics
auth:login Get fresh cookies (~3.5 day TTL)

Production gotchas

Hand this to your agent

Don’t want to run the extension? Paste this primer into a Goose session (or any agent) and it knows how to drive Skool over plain HTTP in one shot:

You can operate a Skool community through the Apify-hosted "Skool All-in-One API"
actor (cristiantala/skool-all-in-one-api). Skool has no official API; this actor is it.

Every action is ONE HTTP POST:
  POST https://api.apify.com/v2/acts/cristiantala~skool-all-in-one-api/run-sync-get-dataset-items?token=$APIFY_TOKEN&build=latest&timeout=90
  body: { "action": "<namespace>:<op>", "cookies": "$SKOOL_COOKIES",
          "groupSlug": "<your-slug>", "params": { ...per action... } }

Auth: call "auth:login" with {email,password,groupSlug} ONCE, save the returned
  `cookies` string, reuse it (~3.5 day TTL). On errorCode "WAF_EXPIRED", re-run auth:login.

Rules: members approve/reject use params.memberId (NOT id). Comment reply: parentId =
  comment id, rootId = post id. Posts are plain text. ~25 writes/min hard limit (actor
  queues — no retry loop). Every response is { success, data } or { success:false,
  errorCode, hint } — read `hint` to recover.

Full action list + params: https://skool-api.cristiantala.com/docs/actions/

The full pattern library (function-calling specs, idempotency table, the LLM-readable hint contract) lives in Skool for AI agents.

See also

Plug Skool into Goose today

→ Use the Skool All-in-One API actor on Apify

No Skool community yet? Launch one in 10 minutes — 14-day free trial.

More in Integrations