# Skool Community Lookup: stats & pricing API from $2/1k (`accountable_eel/skool-community-lookup`) Actor

Skool community lookup by URL or slug: member count, price and billing interval, description, and owner name, straight from the community's own public about page. One row per community. Never charged for a miss.

- **URL**: https://apify.com/accountable\_eel/skool-community-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 community profile founds

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/actors/running/actors-in-store.md#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 Community Lookup: stats & pricing API from $2/1k

You give this actor a list of Skool community URLs, or bare slugs. For each one, it fetches the
community's own public "about" page and returns its display name, description, member count,
whether it's free to join, its price and billing interval if not, and the community owner's name
— one flat row per community, read straight off the page Skool itself serves.

### Who it's for

You're scouting the creator-community space before launching your own — checking how many members
a competitor's Skool community actually has and what it charges — or you're a creator tool vendor
building a lead list of paid community owners to pitch. Either way it's normally a dozen manual
page visits; here it's a list in, a table out.

### Why this one

- **Reads the live page, not a cached estimate.** Every run fetches the community's current
  "about" page — a member count or price that changed this week shows up on the next run.
- **Price and billing interval, not just "paid or free."** `priceText` gives the actual amount and
  cadence (e.g. `$87/month`), not just a yes/no flag.
- **Never charged for a miss.** A slug that doesn't resolve to a real community still returns a
  row explaining why — and costs nothing.
- **No proxy overhead.** Skool's about pages are plain server-rendered HTML — no bot wall to work
  around, unlike two other lookups in this catalogue built the same day.

### What you get

| Field | Type | Description |
|---|---|---|
| `query` | text | The URL or slug you submitted, echoed back |
| `found` | boolean | `true` if a real, public community was found |
| `status` | text | `OK` on a match; `NOT_FOUND` or `BLOCKED` on a miss |
| `message` | text | Plain-English reason for a miss — only present when `found` is `false` |
| `scrapedAt` | ISO 8601 datetime | When the page was fetched |
| `slug` | text | The community's Skool slug |
| `name` | text | Community display name |
| `description` | text | The community's own description, as shown on its about page |
| `memberCount` | number | Total member count |
| `isFree` | boolean | `true` if the community has no paid membership tier |
| `priceText` | text | Price and billing interval, e.g. `$87/month`, or `Free` |
| `ownerName` | text | The community owner's display name |
| `skoolUrl` | link | The canonical skool.com community URL that was fetched |

Deselect any field in the Input tab's column picker to drop it from every row — `query`, `found`,
`status`, `message`, and `scrapedAt` always stay.

### Price

Pay-per-event. A flat per-run fee covers session/proxy warmup; you're billed
per item only when data is actually found and returned — see
`.actor/pay_per_event.json` for exact prices. A miss is never charged.

1,000 community lookups: **~$2** if every community resolves, less for any misses, less again on
a paid Apify plan. A miss — a bad slug, a private or deleted community, a blocked request — is
never billed.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `communities` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~skool-community-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"communities":["aiautomationsbyjack"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

1) Open the Input tab and paste your list of Skool community URLs or slugs into "Skool community
   URLs or slugs" — one per line.
2) Leave "Try it first" on for your first run — it caps the run at 5 communities so you can check
   the output shape before spending on the full list.
3) Optionally narrow "Which columns do you want?" to just the fields you need, or set "Only keep
   rows containing" / "Skip rows containing" to filter by keyword.
4) Turn "Try it first" off and press Start to run the full list.

### Input

```json
{
  "communities": [
    "aiautomationsbyjack"
  ]
}
```

One community per line — a full skool.com community URL, or just the slug from it (the part after skool.com/). Accepted formats: https://www.skool.com/aiautomationsbyjack, aiautomationsbyjack.

### Sample output

| query | found | status | slug | name | description | memberCount | isFree | priceText | ownerName | skoolUrl | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| aiautomationsbyjack | true | OK | <skool slug> | <community name> | <description> | <member count> | <is free to join> | <price> | <owner name> | <skool community url> | 1970-01-01T00:00:00.000Z |

A slug that doesn't resolve to a real, public community gets a row with `found: false` and a
`status`/`message` explaining why, and is never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~skool-community-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"communities":["aiautomationsbyjack"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~skool-community-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"communities":["aiautomationsbyjack"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~skool-community-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"communities":["{{community}}"]}`, mapping the row's community into the `communities` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Skool Community Lookup: Stats API from $2/1k" — the agent will find and run this actor.

### Tips

- Paste the bare slug if you already have it — it's the part of the URL right after `skool.com/`,
  before any `/about` or `/classroom` suffix.
- `isFree` and `priceText` are inferred from the community's paid-membership price field; a
  community with a $0 or missing price is treated as free. This wasn't verified live against an
  actual free community during this build — if you spot a free community reporting a nonzero
  price, that's worth a bug report.
- A private community's about page is still typically public even if its content feed isn't — a
  `NOT_FOUND` result usually means the slug is wrong or the community was deleted/renamed, not
  that it's private.
- Run "Try it first" on a handful of communities you already know the member count for, to
  sanity-check the output before running a full list.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** (`skool-community-lookup`) | $0.002 per found row (FREE tier, less on paid tiers), plus a $0.00005 actor start, nothing for a miss | One row per community — member count, price/interval, description, and owner name, read live from the community's own about page | Only what the public about page shows; no member growth history and no classroom/course content |
| **cristiantala/skool-all-in-one-api** | Not publicly priced per row (n/d) | The closest existing Skool scraper on Apify Store, 68 users | Established incumbent — this actor is the same category of extraction, priced per row instead |
| Doing it yourself | Your time + parsing Skool's `__NEXT_DATA__` JSON payload by hand for every community you check | The same data | Re-testing the JSON shape as Skool's frontend changes is the maintenance burden this actor absorbs |

Prices for third-party tools are their published list prices as of September 2026 and are not
tracked here — check the vendor before relying on the comparison.

### FAQ

**Why is a row empty, or why does `found` say `false`?**
Either the slug doesn't match a real, public Skool community (`status: NOT_FOUND`) or the request
was blocked (`status: BLOCKED`, rare on this target). Check the `message` column for the specific
reason. Neither is billed.

**Am I charged for a miss?**
No. `Actor.charge()` only fires when a real community profile is parsed. A bad slug or a blocked
request produces a row (unless you turn on "Hide rows with no result") and costs nothing.

**Is this a live check or a stored database?**
Live. Every run fetches the community's current about page — there's no cached snapshot behind it.
A member count or price that changed since your last run will show the new value.

**Do I need to configure proxies?**
No. Skool's about pages are plain server-rendered HTML with no bot wall — this actor uses Apify's
default proxy configuration out of the box.

**Can an AI agent call this directly?**
Yes. It's registered on the Apify MCP server — an agent in Claude, Cursor, or another MCP client
can find and run it by name ("Skool Community Lookup"), or you can call the REST endpoint shown
above from any script or workflow tool.

### Related actors

- [Substack Publication Lookup](https://apify.com/accountable_eel/substack-publication-lookup) —
  subscriber-facing stats for a Substack newsletter, the same "creator platform, one row per
  publication" shape.
- [LinkedIn Company Lookup](https://apify.com/accountable_eel/linkedin-company-lookup) —
  firmographic and headcount data for a company's LinkedIn page.
- [Clutch Agency Lookup](https://apify.com/accountable_eel/clutch-agency-lookup) — rating, reviews,
  and service mix for an agency's own Clutch.co profile.

# Actor input Schema

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

One community per line — a full skool.com community URL, or just the slug from it (the part after skool.com/). Accepted formats: https://www.skool.com/aiautomationsbyjack, aiautomationsbyjack. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "communities": [
    "aiautomationsbyjack"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "columns": [
    "slug",
    "name",
    "description",
    "memberCount",
    "isFree",
    "priceText",
    "ownerName",
    "skoolUrl"
  ],
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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": [
        "aiautomationsbyjack"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/skool-community-lookup").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": ["aiautomationsbyjack"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/skool-community-lookup").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": [
    "aiautomationsbyjack"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/skool-community-lookup --silent --output-dataset

```

## MCP server setup

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

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/ZZVrWmCR1Olctobmi/builds/HvS65SJV9pgUK0Uo9/openapi.json