# Skool Api (`skyline_scrapers/skool-api`) Actor

Complete Skool API for reading and managing communities, members, posts, comments, classroom, courses, events, files, notifications, and admin workflows. Supports 40+ actions for Skool automation. Use your authenticated Skool session to automate repetitive tasks and access data through one API.

- **URL**: https://apify.com/skyline\_scrapers/skool-api.md
- **Developed by:** [Skyline Scrapers](https://apify.com/skyline_scrapers) (community)
- **Categories:** Automation, Integrations, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $20.00 / 1,000 successful api calls

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🚀 Skool API

![Skool API Banner](https://raw.githubusercontent.com/testerclark/assets/main/skoolbanner.png)
Automate **Skool communities, posts, comments, members, courses, classroom content, events, files, social actions, and administrative workflows** through one powerful Apify Actor.

Skool All-in-One API gives developers, community owners, course creators, agencies, and automation teams a structured interface for reading and managing Skool data without manually repeating actions in the Skool dashboard.

> This is an independent, unofficial Skool automation tool. It is not affiliated with, endorsed by, or operated by Skool. The Actor uses authenticated access supplied by the user and can only perform actions that the authenticated Skool account is permitted to perform.

***

### 🔍 What This Actor Does

Skool All-in-One API is a multi-action Skool automation Actor built for community management, content publishing, member administration, classroom automation, data extraction, and workflow integration.

Instead of using a separate scraper or automation for every task, you can select an action and run it through a single Actor.

The Actor can help you:

- Log in to Skool and reuse authenticated cookies
- Read community posts and individual post data
- Create, edit, delete, pin, and unpin posts
- Create and manage comments and nested replies
- Like or unlike posts
- Read group information and category IDs
- List active members and pending join requests
- Approve, reject, ban, unban, or batch-approve members
- Export active members to CSV
- List Skool classroom courses and lesson trees
- Create courses, folders, and lesson pages
- Update course settings and lesson content
- Upload public images and private classroom files
- Replace classroom lesson resources
- Delete classroom units and mark lessons complete
- List calendar events
- Follow or unfollow Skool users
- Mark all notifications as read
- Complete sensitive-action email verification

Results are returned as structured dataset records that can be downloaded as JSON, CSV, Excel, or consumed through the Apify API.

***

### 🚀 How to Use

#### 1. Run the Login Action

Select:

```text
auth:login
```

Enter your Skool account email and password.

A successful login returns a reusable cookie string similar to:

```text
auth_token=xxx; client_id=yyy; aws-waf-token=zzz
```

Save this cookie string securely.

#### 2. Reuse Cookies for Later Actions

For faster runs, paste the saved cookie string into the `cookies` input field for future actions.

This avoids launching the browser login flow every time and is the recommended way to use the Actor in automations.

#### 3. Enter the Community Slug

For group-specific actions, enter the community slug from the Skool URL.

For example:

```text
https://www.skool.com/my-community
```

The community slug is:

```text
my-community
```

#### 4. Select an Action

Choose the required action, such as:

```text
posts:list
members:list
classroom:listCourses
events:list
```

#### 5. Add Action Parameters

Enter the parameters required by the selected action in the `params` JSON field.

Example:

```json
{
  "page": 1,
  "sortType": ""
}
```

#### 6. Run the Actor

The Actor authenticates the request, performs the selected Skool operation, and saves the response to the default dataset.

#### 7. Export or Integrate the Results

Use the returned data through:

- JSON
- CSV
- Excel
- Apify API
- Webhooks
- Make
- Zapier
- n8n
- Custom applications

***

### ⚙️ Main Features

#### Authentication and Session Reuse

- Browser-based Skool login
- Reusable authenticated cookie output
- Cookie-based API calls for faster subsequent runs
- Support for Skool emailed login codes
- Sensitive-action email verification actions
- Debug artifacts for diagnosing login failures

#### Skool Posts API

- List community feed posts
- Get a single post by ID
- Create new community posts
- Edit existing posts
- Delete posts
- Pin and unpin posts
- Upload and attach public images
- Like and unlike posts
- Read post comments

#### Skool Comments API

- Create top-level comments
- Create nested replies
- Edit comments
- Delete comments
- Retrieve comment trees

#### Skool Members API

- List active community members
- List pending membership requests
- Approve members
- Reject members
- Ban members
- Optionally delete a banned member's recent posts
- Unban members
- Batch-approve pending members
- Export member data to CSV

#### Skool Groups API

- Retrieve group metadata
- Retrieve category names and category IDs
- Read group descriptions
- Read plugin and feature flags
- Read gamification levels
- Read community labels

#### Skool Classroom API

- List courses
- Retrieve complete course, folder, and lesson trees
- Create top-level courses
- Create folders inside courses
- Create lesson pages
- Set lesson titles and content
- Convert supported Markdown into Skool TipTap content
- Update course settings safely
- Add or replace lesson resources
- Upload private classroom files
- Delete courses, folders, or lessons
- Mark lesson pages as complete

#### Skool Events and Social API

- List group calendar events
- Return recurring event occurrences
- Follow users
- Unfollow users
- Mark all notifications as read

#### Developer and Automation Features

- One action-based input schema
- Structured JSON responses
- Apify dataset output
- API-ready workflows
- Health-check action for automated quality checks
- Error responses with categories, hints, and retry guidance
- Suitable for scheduled and event-driven automations

***

### 💡 Example Tasks

#### Automate Skool Community Management

Connect Skool community operations to an external dashboard and manage posts, members, comments, courses, and events through the Apify API.

#### Scrape Skool Community Posts

Read the latest posts from a Skool community feed for reporting, moderation, content analysis, archiving, or AI processing.

#### Export Skool Members

Create a CSV export of active Skool members for CRM enrichment, community reporting, membership analysis, or internal administration.

#### List Skool Community Members

Retrieve active members from a Skool group and use the data in dashboards, internal tools, or automation workflows.

#### Approve Skool Join Requests

List pending community applications and approve selected members automatically using an administrator or owner account.

#### Batch Approve Skool Members

Approve multiple pending membership requests in one Actor run using a list of membership IDs.

#### Moderate Skool Members

Reject, ban, or unban members and optionally remove recent posts when banning an account.

#### Publish Skool Posts Automatically

Create community posts from your CRM, content calendar, database, AI workflow, Google Sheet, or internal application.

#### Schedule Skool Content

Use Apify schedules to publish recurring announcements, lessons, prompts, reminders, or community updates.

#### Add Images to Skool Posts

Upload a public image or GIF, receive its file ID, and attach it to a newly created or updated Skool post.

#### Create Skool Comments and Replies

Post automated replies to community discussions or build approved support and engagement workflows.

#### Update or Delete Skool Content

Edit or remove posts and comments through a structured API request instead of managing each item manually.

#### Like Skool Posts

Automate post likes or remove an existing like using the post voting action.

#### Read Skool Post Comments

Retrieve a post's comment tree for moderation, analysis, customer research, sentiment workflows, or AI summarisation.

#### Retrieve Skool Group Categories

Get the real category labels and category IDs required when creating or updating posts.

#### Get Skool Group Metadata

Extract community descriptions, category labels, gamification levels, plugin settings, and related group information.

#### Build a Skool Community Dashboard

Combine posts, comments, members, courses, events, and group metadata into one reporting or administration dashboard.

#### Create Skool Courses Automatically

Generate new Skool classroom courses from templates, databases, onboarding workflows, or AI-generated curricula.

#### Build Skool Course Structures

Create courses, folders, and lesson pages programmatically for repeatable training, onboarding, coaching, or membership programmes.

#### Upload Skool Classroom Resources

Upload private documents and attach them to lesson pages as downloadable classroom resources.

#### Update Skool Lessons from Markdown

Send supported Markdown content and let the Actor convert it into Skool's TipTap-based lesson body format.

#### Manage Skool Course Settings

Update course titles, descriptions, cover images, privacy settings, access levels, tiers, free-trial locks, and other supported fields.

#### Replace Lesson Resources

Replace or clear a lesson's complete Resources list while preserving the lesson's other data.

#### Delete Skool Courses or Lessons

Remove a course, folder, or lesson using its unit ID. Deleting a parent unit can also delete its children.

#### Track Skool Lesson Completion

Mark a lesson page as completed for the authenticated account.

#### Extract Skool Calendar Events

Retrieve community calendar events and expanded recurring event occurrences for calendars, reminders, or reporting systems.

#### Automate Skool User Following

Follow or unfollow Skool users from an authenticated account using their username slug.

#### Mark Skool Notifications Read

Clear unread notifications across groups through a single automation action.

#### Connect Skool to a CRM

Send member and community activity data to HubSpot, Salesforce, Zoho, Pipedrive, Airtable, or a custom CRM.

#### Connect Skool to AI Agents

Use Skool posts, comments, members, and classroom data as structured context for AI assistants, moderation agents, reporting agents, or knowledge workflows.

#### Back Up Skool Community Data

Run scheduled exports of posts, members, group information, courses, and events for authorised internal records.

***

### 🛠 Input Parameters

| Field | Type | Required | Description |
|---|---|---:|---|
| `action` | string | Yes | The Skool operation to perform. Defaults to `system:health`. |
| `email` | string | For login | Skool account email. Required for `auth:login` unless a valid authenticated session is already available. |
| `password` | string | For login | Skool account password. Stored as a secret input. |
| `cookies` | string | Recommended | Reusable cookies returned by a previous successful login. |
| `otpCode` | string | Sometimes | One-time emailed login code used during supported login flows. |
| `interactiveOtp` | boolean | Local only | Allows a local terminal run to pause and request the emailed login code in the same process. It does not provide interactive input on Apify cloud runs. |
| `groupSlug` | string | Action-dependent | Community slug from `skool.com/{groupSlug}`. |
| `params` | object | Action-dependent | JSON parameters required by the selected action. |
| `debug` | boolean | No | Saves browser diagnostic artifacts during login debugging. |

***

### 📚 Supported Actions

#### System

| Action | Purpose | Access |
|---|---|---|
| `system:health` | Confirm the Actor is running and return its version without contacting Skool | Public Actor check |

#### Authentication

| Action | Purpose | Access |
|---|---|---|
| `auth:login` | Log in and return reusable cookies | Skool account |
| `auth:initEmailVerification` | Request a sensitive-action verification code by email | Authenticated account |
| `auth:confirmEmailVerification` | Confirm the emailed sensitive-action code | Authenticated account |

#### Posts and Comments

| Action | Purpose | Access |
|---|---|---|
| `posts:list` | List community feed posts | Community access |
| `groups:getCategories` | Get category names and IDs | Community access |
| `posts:get` | Get one post by ID | Community access |
| `posts:create` | Create a post | Posting permission |
| `posts:createComment` | Reply to a post or comment | Commenting permission |
| `posts:update` | Edit a post or comment | Authorised account |
| `posts:delete` | Delete a post or comment | Authorised account |
| `posts:pin` | Pin a feed post | Admin or owner |
| `posts:unpin` | Unpin a feed post | Admin or owner |
| `posts:vote` | Like or unlike a post | Community access |
| `posts:getComments` | Retrieve a post's comment tree | Community access |

#### Groups, Members, and Events

| Action | Purpose | Access |
|---|---|---|
| `groups:get` | Retrieve group metadata | Community access |
| `members:list` | List active members | Community access |
| `members:pending` | List pending join requests | Admin or owner |
| `members:approve` | Approve a pending member | Admin or owner |
| `members:reject` | Reject a pending member | Admin or owner |
| `members:ban` | Ban a member | Admin or owner |
| `members:unban` | Clear banned or declined status | Admin or owner |
| `members:batchApprove` | Sequentially approve multiple members | Admin or owner |
| `members:export` | Export active members to CSV | Admin/owner and verified client session |
| `events:list` | List group calendar events | Community access |

#### Classroom

| Action | Purpose | Access |
|---|---|---|
| `classroom:listCourses` | List top-level courses | Admin or owner |
| `classroom:getTree` | Get a course's folder and lesson tree | Admin or owner |
| `classroom:createCourse` | Create a course | Admin or owner |
| `classroom:createFolder` | Create a folder inside a course | Admin or owner |
| `classroom:createPage` | Create a lesson page | Admin or owner |
| `classroom:setBody` | Set lesson content and optional resources | Admin or owner |
| `classroom:updateCourse` | Safely update a course | Admin or owner |
| `classroom:deleteUnit` | Delete a course, folder, or lesson | Admin or owner; verification may be required |
| `classroom:markDone` | Mark a lesson complete | Authenticated account |
| `classroom:updateResources` | Replace a lesson's complete resource list | Admin or owner |

#### Files and Social Actions

| Action | Purpose | Access |
|---|---|---|
| `files:uploadImage` | Upload a public image or GIF for post attachments or supported covers | Authenticated account |
| `files:uploadFile` | Upload a private classroom resource file | Admin or owner |
| `social:follow` | Follow a user | Authenticated account |
| `social:unfollow` | Unfollow a user | Authenticated account |
| `notifications:markAllRead` | Mark all notifications as read | Authenticated account |

***

### 🧪 Input Examples

#### Health Check

```json
{
  "action": "system:health"
}
```

#### Log In

```json
{
  "action": "auth:login",
  "email": "your-email@example.com",
  "password": "your-password"
}
```

#### List Community Posts

```json
{
  "action": "posts:list",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "page": 1,
    "sortType": ""
  }
}
```

#### Get Community Categories

Run this before creating a categorised post so you can use a real category ID as `labelId`.

```json
{
  "action": "groups:getCategories",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community"
}
```

#### Create a Skool Post

```json
{
  "action": "posts:create",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "title": "Weekly Community Update",
    "content": "Here are this week's announcements and action items.",
    "labelId": "CATEGORY_ID"
  }
}
```

#### Create a Comment

```json
{
  "action": "posts:createComment",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "content": "Thanks for sharing this update.",
    "rootId": "ORIGINAL_POST_ID",
    "parentId": "ORIGINAL_POST_ID"
  }
}
```

For a nested reply, use the target comment ID as `parentId` while keeping the original post ID as `rootId`.

#### Like a Post

```json
{
  "action": "posts:vote",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "params": {
    "postId": "POST_ID",
    "vote": "up"
  }
}
```

Use an empty string for `vote` to remove the like.

#### List Active Members

```json
{
  "action": "members:list",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "page": 1
  }
}
```

#### List Pending Members

```json
{
  "action": "members:pending",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community"
}
```

#### Approve a Pending Member

`memberId` must be the membership ID returned by the pending-members action, not the user's account ID.

```json
{
  "action": "members:approve",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "memberId": "MEMBERSHIP_ID"
  }
}
```

#### Batch Approve Members

```json
{
  "action": "members:batchApprove",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "memberIds": [
      "MEMBERSHIP_ID_1",
      "MEMBERSHIP_ID_2"
    ]
  }
}
```

The Actor performs approvals sequentially because this workflow does not use a native bulk-approval endpoint.

#### Export Members to CSV

```json
{
  "action": "members:export",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "memberStatus": "active",
    "sortType": "",
    "billingProductIntervals": [],
    "trials": false,
    "free": false,
    "maxWaitSeconds": 60
  }
}
```

This action may require the current `client_id` session to complete sensitive-action email verification first.

#### List Courses

```json
{
  "action": "classroom:listCourses",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community"
}
```

#### Get a Course Tree

Use the course's short `name` or slug value, not its internal ID.

```json
{
  "action": "classroom:getTree",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "courseSlug": "course-name"
  }
}
```

#### Create a Course

```json
{
  "action": "classroom:createCourse",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "title": "Client Onboarding",
    "desc": "A step-by-step onboarding programme.",
    "privacy": 0
  }
}
```

#### Create a Course Folder

```json
{
  "action": "classroom:createFolder",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "parentCourseId": "COURSE_ID",
    "title": "Getting Started"
  }
}
```

#### Create a Lesson Page

```json
{
  "action": "classroom:createPage",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "courseId": "ROOT_COURSE_ID",
    "parentId": "COURSE_OR_FOLDER_ID",
    "title": "Welcome to the Programme"
  }
}
```

#### Set Lesson Content

```json
{
  "action": "classroom:setBody",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "pageId": "LESSON_PAGE_ID",
    "title": "Welcome to the Programme",
    "bodyMarkdown": "# Welcome\n\nThis lesson explains how to get started.",
    "resources": []
  }
}
```

#### Upload a Private Classroom File

```json
{
  "action": "files:uploadFile",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "filename": "checklist.txt",
    "contentType": "text/plain",
    "text": "Step 1: Complete your profile."
  }
}
```

Use the returned private file ID inside a lesson resource object.

#### Replace Lesson Resources

```json
{
  "action": "classroom:updateResources",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "courseSlug": "course-name",
    "pageId": "LESSON_PAGE_ID",
    "resources": [
      {
        "title": "Onboarding Checklist",
        "file_id": "PRIVATE_FILE_ID"
      }
    ]
  }
}
```

The `resources` array is a full replacement. Passing `[]` clears all existing resources.

#### List Events

```json
{
  "action": "events:list",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community"
}
```

#### Follow a User

Use the username slug from the user's Skool profile URL, not the hexadecimal user ID.

```json
{
  "action": "social:follow",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "groupSlug": "my-community",
  "params": {
    "username": "jane-doe"
  }
}
```

#### Mark All Notifications Read

```json
{
  "action": "notifications:markAllRead",
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz"
}
```

***

### 📤 Output Examples

Output varies by action. Every run writes a structured result to the Apify dataset.

#### Health Check Output

```json
{
  "success": true,
  "action": "system:health",
  "status": "healthy",
  "version": "1.6.0",
  "timestamp": "2026-07-29T12:00:00+00:00"
}
```

#### Login Output

A successful login returns authentication information that includes reusable cookies.

```json
{
  "success": true,
  "cookies": "auth_token=xxx; client_id=yyy; aws-waf-token=zzz",
  "note": "Cached for reuse by future runs."
}
```

#### Typical Action Output

```json
{
  "success": true,
  "action": "members:list",
  "data": {
    "members": []
  }
}
```

The exact response structure depends on the selected Skool action and the data returned by the account and community.

#### Error Output

```json
{
  "success": false,
  "action": "posts:create",
  "error": "Action could not be completed",
  "errorCode": "AUTH_ERROR",
  "errorCategory": "auth_error",
  "retryable": true,
  "hint": "Refresh the authenticated session and try again."
}
```

Error payloads are designed to provide useful troubleshooting information instead of returning only an unstructured failure message.

***

### 🧾 Data You Can Access or Manage

Depending on the selected action and the authenticated account's permissions, the Actor can work with the following data.

#### Community Data

- Community slug
- Internal group ID
- Group description
- Category labels and IDs
- Gamification levels
- Enabled plugins and group features

#### Post Data

- Post ID
- Post title
- Post content
- Category or label
- Post author data returned by Skool
- Attachments
- Voting information
- Feed metadata

#### Comment Data

- Comment IDs
- Root post ID
- Parent post or comment ID
- Comment content
- Nested comment relationships
- Author information returned by Skool

#### Member Data

- Active community members
- Pending memberships
- Membership IDs
- User IDs where returned
- Membership status
- Exportable CSV member records

#### Classroom Data

- Course IDs
- Course slugs
- Course titles and descriptions
- Course privacy and access settings
- Folder structures
- Lesson page IDs
- Lesson titles and bodies
- Video metadata where supplied
- Classroom resource files
- Completion actions

#### Event Data

- Calendar events
- Event timing and metadata returned by Skool
- Expanded recurring event occurrences

#### File Data

- Public image upload IDs
- Private classroom file IDs
- File names
- Content types
- Lesson resource references

***

### 👥 Who Uses This Actor

#### Skool Community Owners

Automate routine community administration, content publishing, membership approvals, course creation, and reporting.

#### Skool Community Managers

Manage posts, comments, pending members, events, classroom content, and daily operational workflows from one API.

#### Course Creators and Coaches

Build and update structured Skool classrooms, upload resources, publish lessons, and automate repeatable course setups.

#### Membership Businesses

Connect member exports, community activity, courses, and events to internal systems and customer operations.

#### Marketing Agencies

Manage authorised client communities, publish scheduled content, export member data, and build reporting workflows.

#### Automation Agencies

Connect Skool with CRMs, spreadsheets, databases, messaging tools, webhooks, and AI agents.

#### SaaS Developers

Use the Actor as an integration layer for authorised Skool community management features inside custom applications.

#### Data and Operations Teams

Create dashboards, community reports, backup workflows, member analytics, and operational automations.

***

### ⭐ Why This Actor Is Different

Many Skool tools focus on one narrow task, such as scraping posts or exporting members.

Skool All-in-One API combines a much broader set of read and write actions in one Actor:

- Authentication and cookie reuse
- Posts and comments
- Member administration
- Group metadata
- Classroom courses and lessons
- Public and private file uploads
- Events
- Social actions
- Notifications
- Email verification for sensitive operations

It is useful for both technical and non-technical workflows because it provides:

- A simple action selector
- JSON-based parameters
- Structured dataset output
- Reusable authenticated sessions
- Clear admin permission boundaries
- Detailed error payloads
- Apify API compatibility

***

### 🔌 API Integration

This Actor can be called through the Apify API from any application capable of making HTTP requests.

It works well with:

- Python
- Node.js
- JavaScript
- PHP
- cURL
- Make
- Zapier
- n8n
- Google Sheets
- Airtable
- HubSpot
- Salesforce
- Zoho CRM
- Pipedrive
- Notion workflows
- Internal dashboards
- AI agents
- Data warehouses

Example integrations:

- Publish Skool posts from a content calendar
- Approve members from an internal admin dashboard
- Export Skool members to a CRM
- Create courses from templates
- Add AI-generated lesson content
- Sync events with another calendar system
- Send post and comment data to an analysis pipeline
- Store authorised community backups
- Trigger webhooks after Actor runs

***

### 🔐 Authentication and Cookie Reuse

The recommended workflow is:

1. Run `auth:login` once.
2. Copy the returned `cookies` value.
3. Store it securely.
4. Pass it to later runs.
5. Log in again when the session expires or becomes invalid.

Cookies may provide access to the authenticated Skool account. Treat them like passwords or API keys.

Do not:

- Publish cookies in a public repository
- Share cookies in screenshots
- Include cookies in public Actor task inputs
- Store cookies in unsecured logs
- Use another person's account without permission

Use Apify secret inputs or another secure secrets manager whenever possible.

***

### 📧 Login Codes and Email Verification

Skool can use two different email-code flows.

#### Login Verification Code

During `auth:login`, Skool may email a one-time login code after accepting the email and password.

A newly started login run can trigger a new code and invalidate the previous code. Local interactive testing can keep the same browser session open and request the code through the terminal, but Apify cloud runs do not provide an interactive terminal.

#### Sensitive-Action Email Verification

Some administrative operations may require verification of the current `client_id` session.

Use:

```text
auth:initEmailVerification
```

Then submit the received code with:

```text
auth:confirmEmailVerification
```

After successful verification, retry the original sensitive action using the same authenticated session.

***

### 🎓 Classroom Content Notes

#### Course Slug vs Course ID

Some actions use the internal course ID, while others require the course's short `name` or slug value.

For example:

- `classroom:getTree` requires `courseSlug`
- `classroom:updateCourse` requires both `courseId` and `courseSlug`
- `classroom:createFolder` requires `parentCourseId`
- `classroom:createPage` requires `courseId` and `parentId`

Do not assume that a course ID and course slug are interchangeable.

#### Safe Course Updates

The Actor's course-update workflow retrieves the current course, merges only the supplied changes, and sends the complete updated object.

This reduces the risk of accidentally clearing fields that were not included in the Actor input.

#### Markdown Conversion

`classroom:setBody` can accept `bodyMarkdown` and convert supported content into Skool's TipTap-based body format.

Because Skool's editor uses a structured document model, not every Markdown feature is guaranteed to map exactly. Test formatting on a sample lesson before updating a large course library.

#### Lesson Resources Are Full-Replacement Arrays

Both `classroom:setBody` and `classroom:updateResources` treat the supplied `resources` array as the complete desired list.

- Include all resources that should remain
- Pass `[]` to remove all resources
- Use file IDs returned by `files:uploadFile`
- Do not use public image IDs returned by `files:uploadImage` as private lesson resources

***

### ✅ Best Practices

- Run `system:health` before testing authentication.
- Use a dedicated authorised Skool account for automation.
- Run `auth:login` once and reuse cookies.
- Store passwords and cookies as secrets.
- Test read actions before write actions.
- Retrieve category IDs before creating categorised posts.
- Confirm whether an action requires admin or owner permission.
- Use membership IDs, not user IDs, for membership-status actions.
- Test member moderation actions on a controlled community first.
- Keep course titles within supported limits.
- Retrieve the course tree before updating classroom units.
- Back up important course content before destructive actions.
- Remember that deleting a course or folder can cascade to child units.
- Treat lesson resource updates as full replacements.
- Complete email verification before retrying sensitive actions.
- Use reasonable request frequency to avoid account or platform restrictions.
- Review the returned error category and hint before retrying.

***

### ⚠️ Important Limitations

- This is an unofficial integration based on observed Skool web behaviour, not an official public Skool API.
- Skool can change internal endpoints, request formats, page structures, security checks, or authentication behaviour without notice.
- Available data depends on the authenticated account's access and the community's visibility.
- Administrative actions require the authenticated account to be an authorised group administrator or owner.
- Some sensitive actions require a verified `client_id` session.
- Login verification can require an emailed one-time code.
- Apify cloud runs cannot pause for terminal-based OTP entry.
- `posts:getComments` may be limited by Skool's own response cap and may not return every comment in very large threads.
- Batch member approval is performed sequentially rather than through a native bulk endpoint.
- Unbanning clears the declined or banned state but does not automatically restore active membership.
- Member-list pagination behaviour can depend on Skool's internal route implementation.
- Classroom resource arrays replace the complete existing list.
- Deleting classroom units may cascade to children.
- Results and action availability may change when Skool updates its platform.

***

### 🛡 Responsible Use

Use this Actor only with accounts, communities, and data you are authorised to access or manage.

You are responsible for:

- Following Skool's terms and community rules
- Obtaining required permissions
- Protecting account credentials and cookies
- Respecting member privacy
- Avoiding spam and abusive automation
- Complying with applicable privacy and data-protection laws
- Reviewing automated write actions before running them at scale

The Actor does not bypass the permissions of the authenticated account. An action can succeed only when the logged-in account has the required access.

***

### 🧰 Troubleshooting

#### Login Fails

Check:

- Email and password are correct
- The account is not blocked or challenged
- Skool has not requested an emailed login code
- The browser login flow has not changed
- The Actor has enough memory to launch Chromium

Enable `debug` to save diagnostic browser artifacts.

#### Cookies No Longer Work

The Skool session may have expired or been invalidated.

Run `auth:login` again and replace the stored cookie string.

#### Action Returns Permission Error

Confirm that the logged-in account has the required community role.

Actions such as member approval, banning, post pinning, course creation, and classroom deletion normally require admin or owner access.

#### Post Creation Fails

Retrieve categories using `groups:getCategories` and use a valid returned category ID as `labelId`.

Also confirm that the account has permission to post in the community.

#### Member Action Targets the Wrong ID

Member approval, rejection, unbanning, and related status actions use the membership ID, not necessarily the user's account ID.

Use the ID returned by the relevant pending-member or member response.

#### Course Tree Cannot Be Found

Confirm that `courseSlug` contains the course's short `name` value rather than its internal ID or display title.

#### Member Export Requires Verification

Run the sensitive-action email verification flow using the same `client_id` session, then retry the export.

#### Lesson Resources Disappear

The supplied resource array is a full replacement. Include every resource that should remain attached to the lesson.

***

### ❓ Frequently Asked Questions

#### Is this an official Skool API?

No. This is an independent, unofficial automation Actor and is not affiliated with Skool.

#### Do I need a Skool account?

Yes. Most actions require an authenticated Skool account and valid access to the target community.

#### Do I need to be a Skool admin?

Not for every action. Reading accessible posts, viewing group information, listing members, liking posts, following users, and some other actions can work with normal community access. Administrative and classroom management actions require the appropriate role.

#### Can I reuse the login session?

Yes. Reusing the cookie string returned by `auth:login` is the recommended workflow.

#### Can I create posts automatically?

Yes. Use `posts:create`, provide the community slug, and pass the required post parameters.

#### Can I upload images to posts?

Yes. Upload an image with `files:uploadImage`, then use the returned file ID in the post attachment parameters.

#### Can I export Skool members?

Yes. Use `members:export`. The current client session may need to complete email verification first.

#### Can I create complete Skool courses?

Yes. The Actor can create courses, folders, lesson pages, lesson content, and private lesson resources when the authenticated account has permission.

#### Can I scrape private Skool communities?

The Actor can access only content available to the authenticated account. It does not grant access to communities the account cannot view.

#### Can I run this Actor on a schedule?

Yes. Use Apify schedules to run supported read or write actions automatically. Review write actions carefully before enabling frequent schedules.

#### Can I connect it to Make, Zapier, or n8n?

Yes. You can call the Actor through Apify integrations, API requests, or webhooks.

#### Does unban restore the member automatically?

No. The implemented unban action clears the banned or declined state. It does not automatically restore active membership.

#### Does the comments action return every comment?

Not always. Skool's underlying response can cap the number of comments returned for a post.

***

### 🌐 About Skyline Scrapers

Skyline Scrapers builds professional Apify Actors, automation APIs, data extraction tools, lead-generation systems, and AI-ready workflow integrations.

Focused on:

- Community platform automation
- Social and membership data workflows
- Marketplace scraping
- Real estate data extraction
- CRM enrichment
- Business process automation
- AI-ready data pipelines
- Custom Apify Actors

**Skyline Scrapers — Smart Data Extraction and Automation for Modern Businesses**

# Actor input Schema

## `action` (type: `string`):

Choose the action you want to perform.

Supports 40+ actions for authentication, posts, comments, members, classroom, courses, files, events, notifications, and admin workflows.

💡 First time? Run auth:login, save the returned cookies, then use those cookies for future requests.

Some actions require Community Admin or Owner permissions.

## `email` (type: `string`):

Email address used to sign in to your Skool account. Required only for auth:login.

## `password` (type: `string`):

Password for your Skool account. Required only for auth:login.

## `cookies` (type: `string`):

Paste the cookies returned by a previous auth:login run. Using cookies skips the login step and makes future requests faster and more reliable.

## `otpCode` (type: `string`):

Optional one-time verification code sent by Skool during login. Usually only needed when Skool requests email verification.

## `interactiveOtp` (type: `boolean`):

For local development only. Pauses the login process and lets you enter the verification code interactively. Has no effect on Apify cloud runs.

## `groupSlug` (type: `string`):

Community slug from https://www.skool.com/{community}. Required for most community and admin actions.

## `params` (type: `object`):

JSON parameters for the selected action.

Each action accepts different parameters. Provide only the fields required for your chosen action.

Examples:
• posts:list → {"page":1}
• posts:get → {"postId":"..."}
• posts:create → {"title":"...","content":"..."}
• classroom:createCourse → {"title":"My Course"}
• members:approve → {"memberId":"..."}

See the README for complete parameter documentation and examples.

## `debug` (type: `boolean`):

Save additional screenshots and HTML during auth:login for troubleshooting login issues. Disable for normal use.

## Actor input object example

```json
{
  "action": "posts:list",
  "email": "john@example.com",
  "cookies": "auth_token=...; client_id=...",
  "groupSlug": "my-community",
  "params": {
    "page": 1
  },
  "debug": false
}
```

# Actor output Schema

## `results` (type: `string`):

Structured success or error result returned by the selected action.

## `dataset` (type: `string`):

Default dataset containing the Actor run output.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "params": {
        "page": 1
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("skyline_scrapers/skool-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "params": { "page": 1 } }

# Run the Actor and wait for it to finish
run = client.actor("skyline_scrapers/skool-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "params": {
    "page": 1
  }
}' |
apify call skyline_scrapers/skool-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,skyline_scrapers/skool-api"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/4TUW2rU9pDzt8FNs5/builds/8DWXxHj7xccb3xmjx/openapi.json