# Skool Events Scraper — Community Calendar & Reminders (`scrapersdelight/skool-events-scraper`) Actor

From $0.004/event: scrape any Skool community calendar — title, description, start/end time, timezone, recurring flag, host, location & link. Public communities need no login; bring your own Skool login for member-only data. Monitor mode alerts you to new events via Slack/email/webhook.

- **URL**: https://apify.com/scrapersdelight/skool-events-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Automation, Lead generation, Agents
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 lot scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 📅 Skool Events Scraper — Community Calendar & Reminders

**Pull every event from a Skool community's calendar in seconds — `title`, `description`, `start`/`end` time (with timezone), `recurring` flag, `host`, `location` and the `join link`. Public communities scrape with **no login**; for members-only calendars, bring your own Skool login. Turn on **Monitor mode** + a **Schedule** to get a reminder feed: a Slack / email / webhook ping the moment a community posts a new event. From ~$0.004 per event.**

No browser, no anti-bot fighting — Skool server-renders its calendar, so this reads it straight from the page.

***

### Why this one

Most Skool scrapers grab posts, members or community metadata and **skip the calendar entirely**. This actor is built for the events lane and does it cleanly:

- ✅ **Full event detail** — title, description, start/end datetime (ISO with offset), per-event timezone, cover image, host
- ✅ **Recurring-aware** — detects recurring series and (optionally) emits every occurrence as its own dated row
- ✅ **Location-typed** — physical address, online/video link, or a linked Skool page, plus the raw join `link`
- ✅ **Multi-community** — pass a list of communities and pull them all in one run
- ✅ **Public lane needs no login** — and a **member-only lane** when you supply your own Skool cookie
- ✅ A **new-event monitor** — schedule it and get reminders for newly-posted events (no other event actor offers this)

***

### What you get (per event occurrence)

`title` · `description` · **`startTime`** · **`endTime`** · `timezone` · **`recurring`** · `host` · `locationType` · `locationLabel` · **`link`** (join URL) · `address` · `coverImage` · `reminderDisabled` · `hasAccess` · `eventId` · `occurrenceId` · `createdAt` · `updatedAt` · `groupId` · `communitySlug` · `communityName` · **`eventUrl`** · `is_new` · `scraped_at`

Export to CSV/JSON/Excel or pull via the Apify API into Google Calendar, Notion, n8n, Make, or your CRM.

***

### How to use it

1. Click **Try for free**.
2. Paste one or more **communities** — a URL (`https://www.skool.com/ai-automation-society`) or just the slug (`ai-automation-society`).
3. Click **Start**, then open the **Dataset** tab.
4. **Members-only calendar?** Paste your own Skool `auth_token` cookie in **Your Skool login** (see FAQ).
5. **For a reminder feed:** turn on **Monitor mode** + an Apify **Schedule** to be alerted when new events are posted.

#### Quick start (public community)

```json
{ "communities": ["ai-automation-society"], "maxItems": 50 }
```

#### Daily new-event reminders

```json
{ "communities": ["ai-automation-society"], "monitorMode": true, "slackWebhookUrl": "https://hooks.slack.com/services/…" }
```

#### Members-only calendar (your own login)

```json
{ "communities": ["my-private-community"], "skoolCookie": "<your auth_token value>" }
```

***

### Who it's for

- 🗓️ **Members** who want every community's events in one calendar / one feed
- 🔔 **Community managers** tracking what other communities run and when
- 🤖 **Automators** piping Skool events into Google Calendar, Notion, n8n or Make
- 📊 **Researchers / analysts** studying event cadence across communities

***

### Pricing (pay-per-event)

| Event | What it covers | Suggested price |
|-------|----------------|-----------------|
| `lot-scraped` | each event occurrence returned | **~$0.004 / event** (~$4 / 1,000) |
| `monitor-run-completed` | each scheduled watch run | ~$0.05 / run |
| `new-lot-detected` | each newly-posted event occurrence | ~$0.02 |
| `alert-delivered` | each Slack / email / webhook reminder | ~$0.005 |

You're charged per result, not per run, and never for the actor start. The new-event monitor remembers what it has seen, so you never pay for or get reminded about the same event twice.

***

### Related Skool actors (our suite)

| Actor | What it pulls |
|-------|---------------|
| **Skool Events Scraper** (this one) | Community calendar events + new-event reminders |
| Skool Posts Scraper | Feed posts, comments, engagement |
| Skool Members Scraper | Community member rosters |
| Skool Profile Scraper | Individual member profiles |
| Skool Community Scraper | Community metadata & stats |
| Skool Discovery Scraper | Discover/browse public communities |

***

### Notes & legal

- **Public community data.** A community's calendar is fetched the same way your browser renders it. For **members-only** calendars you must supply **your own** Skool login (`auth_token`) — you are accessing only data you already have access to. We never log or store your cookie.
- **You are responsible** for using the data in line with Skool's Terms and applicable law.
- **No double-counting** — monitor mode keys on each event occurrence and emits/reminds once.

***

### FAQ

**Does it need a login?** No — for **public** communities. The daily demo and most communities work with no cookie. Only **members-only** calendars require your own Skool `auth_token`.

**How do I get my `auth_token`?** Log into Skool in your browser → DevTools (F12) → **Application** → **Cookies** → `www.skool.com` → copy the `auth_token` value → paste it into **Your Skool login**. It's optional and only needed for private calendars.

**How are recurring events handled?** Each occurrence is detected and flagged `recurring: true`. By default every occurrence is its own dated row (`occurrenceId`); flip **Include every recurring occurrence** off to collapse a series to its next occurrence only.

**Can I watch several communities at once?** Yes — pass a list in **communities**. The monitor tracks all of them in one scope.

**What time zone are events in?** Each event carries its own `timezone` (events can differ within one calendar); the calendar's default timezone is used as a fallback. `startTime`/`endTime` are ISO-8601 with the UTC offset baked in.

**Why don't I get any events for a community?** Its calendar may be members-only (you'll see a warning to add your `skoolCookie`) or it simply has no upcoming events.

**Is there a host/organizer field?** `host` is derived from the community owner. Skool's public calendar payload doesn't attach a per-event organizer, so per-event host isn't always available on the public lane.

**Will it break when Skool redeploys?** No — it reads Skool's dynamic build id at runtime and falls back to the rendered calendar page, so it keeps working across deploys.

# Actor input Schema

## `communities` (type: `array`):

One or more Skool communities to pull calendar events from. Paste a community URL (https://www.skool.com/ai-automation-society) or just its slug (ai-automation-society). Public communities need no login.

## `communityUrl` (type: `string`):

Convenience field for a single community URL or slug. Merged with the list above.

## `maxItems` (type: `integer`):

Cap on total event occurrences per run. 0 = unlimited.

## `skoolCookie` (type: `string`):

OPTIONAL. To pull events from communities whose calendar is members-only, paste YOUR OWN Skool 'auth_token' cookie value (DevTools → Application → Cookies → www.skool.com → auth_token). Public communities don't need this. Never shared or logged. Leave blank for the public/free lane.

## `includeRecurringOccurrences` (type: `boolean`):

On: emit each occurrence of a recurring event (one row per date). Off: collapse each recurring series to its single next occurrence.

## `monitorMode` (type: `boolean`):

Recurring watcher: diff against the prior run (per community) and output/alert ONLY new event occurrences. Pair with an Apify Schedule for a reminder feed.

## `alertOnNewEvent` (type: `boolean`):

In monitor mode, send a reminder for each new event occurrence.

## `webhookUrl` (type: `string`):

POST endpoint for new-event reminders.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL for new-event reminders.

## `emailRecipients` (type: `array`):

Emails for the new-event digest (via apify/send-mail).

## `proxyConfiguration` (type: `object`):

Proxy settings. Datacenter rotation is plenty — Skool's public calendar is server-rendered with no anti-bot.

## `diagnose` (type: `boolean`):

Dev only. Logs the first parsed event of the first community, then exits.

## Actor input object example

```json
{
  "communities": [
    "ai-automation-society"
  ],
  "maxItems": 50,
  "includeRecurringOccurrences": true,
  "monitorMode": false,
  "alertOnNewEvent": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "diagnose": false
}
```

# Actor output Schema

## `events` (type: `string`):

The dataset of community calendar events (one item per event occurrence).

# 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 = {
    "communities": [
        "ai-automation-society"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/skool-events-scraper").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 = {
    "communities": ["ai-automation-society"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/skool-events-scraper").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 '{
  "communities": [
    "ai-automation-society"
  ],
  "maxItems": 50
}' |
apify call scrapersdelight/skool-events-scraper --silent --output-dataset

```

## MCP server setup

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

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/zuR7An4fNvmpjxoNV/builds/dnW7gFj94eJKrisgO/openapi.json