Quick reference (TL;DR for agents)

Why Gemini CLI + Skool?

Skool has no official API. If you run your community from Gemini CLI, you don’t want to break flow, open the Skool web UI, and click through member approvals or course uploads by hand.

Gemini CLI speaks MCP (Model Context Protocol) natively — point it at an MCP server in settings.json and every tool that server exposes becomes callable in conversation. The Skool All-in-One API actor is hosted on Apify’s MCP gateway, so it plugs straight in. No SDK, no Playwright in your runtime, no glue code — one config block and Gemini CLI can drive your whole Skool admin surface.

Why Gemini CLI specifically fits well here:

  1. Native MCP discovery. Gemini CLI lists the actor’s tools at startup; you don’t hand-write a function schema for each action.
  2. Two ways to wire it. Edit ~/.gemini/settings.json by hand, or run gemini mcp add for a guided add — pick whichever fits your workflow.
  3. Google-scale context window. Long course trees and big member lists fit comfortably, so “summarize the last 50 posts and reply to the unanswered ones” is one prompt.

Setup — add the MCP server (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 paste it into the MCP server 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 Skool MCP server

Option A — edit ~/.gemini/settings.json (global) or .gemini/settings.json (project). Add a skool entry under mcpServers:

{
  "mcpServers": {
    "skool": {
      "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": 60000
    }
  }
}

Option B — use the CLI helper:

gemini mcp add skool \
  npx -y @apify/actors-mcp-server \
  --token=YOUR_APIFY_TOKEN \
  --actors=cristiantala/skool-all-in-one-api

Bump the timeout to at least 60000 (60s) — auth:login is a real browser login and the default tool-call timeout can cut it off.

4. Restart and verify

Restart Gemini CLI. The Skool actions show up as tools — ask /mcp (or list tools) to confirm skool is connected.

How the connection works

Gemini CLI                         Apify                          Skool
──────────                         ─────                          ─────
reads ~/.gemini/settings.json  →  starts @apify/actors-mcp-server
        │  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 } ◄────────────────────────┘
        │
   Gemini reports back in plain English

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 from the terminal

You’re in a Gemini CLI session and type:

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

Gemini CLI 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 Gemini CLI to do — full action surface

The actor exposes the entire Skool admin surface as MCP tools. You ask in plain English; Gemini CLI 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 hosted MCP server? Paste this primer into Gemini CLI (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 Gemini CLI 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