# FOMO Clans Scraper (`muhammetakkurtt/fomo-clans-scraper`) Actor

Scrape FOMO (fomo.family) clans — the clan leaderboard by PnL or any clan by name — with members and their PnL, combined token holdings, member trade theses and the latest trading activity. Export as JSON, CSV or Excel.

- **URL**: https://apify.com/muhammetakkurtt/fomo-clans-scraper.md
- **Developed by:** [Muhammet Akkurt](https://apify.com/muhammetakkurtt) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.00 / 1,000 clan scrapeds

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?

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

![FOMO Clans Scraper — crypto trading clans, members, holdings and PnL from fomo.family](https://i.postimg.cc/P5yx9Qpg/fomo-banner.png)

## FOMO Clans Scraper

**Scrape FOMO (fomo.family) clans — the clan leaderboard ranked by PnL, or any clan by name — with members, combined holdings, trade theses and activity.** Pick a PnL window and get each clan's rank, PnL and trade count, every member with their PnL and role, the tokens the clan holds together, the theses its members write and its latest large buys and sells — as structured data.

No coding needed. Pick a window or list clan names, click **Start**, and download as JSON, CSV, Excel, XML, HTML or RSS.

### What is FOMO (fomo.family)?

FOMO is a social crypto copy-trading app where traders publish their on-chain trades, holdings and theses. Traders team up in **clans** that compete on a PnL leaderboard. The **FOMO Clans Scraper** turns clan leaderboards and clan pages into structured data — ideal for finding the most profitable trading groups, tracking what they hold and following their calls.

### What data does it extract?

Each clan produces one item containing:

| Section | Fields |
|---|---|
| **Clan** | Name, description, icon, cover photo, website and social links (X, Telegram, Discord, Instagram), creation date |
| **Ranking** | Leaderboard rank and PnL for the selected window, member count, trade count |
| **Members** | Every member with their PnL and role, plus their profile (handle, display name, Solana & EVM wallet address, followers) |
| **Top Tokens** | The clan's most profitable tokens with PnL |
| **Holdings** | Tokens the clan holds together: amount, value, PnL, % PnL and the members holding each token |
| **Theses (optional)** | Members' latest trade theses with likes and the trade's PnL |
| **Activity Feed (optional)** | Latest large buys and sells, profit milestones, new theses and perp position changes |

### Why scrape FOMO clans?

- 🏆 **Find the best trading groups** — rank clans by PnL over 24h, 7d, 30d or all-time
- 👥 **Discover profitable traders** — get every member of a top clan with their PnL and wallet addresses
- 💼 **Track clan portfolios** — see which tokens a clan holds, how much and at what profit
- 🧾 **Follow their calls** — capture the theses clan members write and their latest large trades
- 🤖 **Automation** — run it via the [Apify API](https://docs.apify.com/api/v2), on a [schedule](https://docs.apify.com/platform/schedules), with [webhooks](https://docs.apify.com/platform/integrations/webhooks)

### How to use it (step by step)

1. Open the [FOMO Clans Scraper](https://apify.com/muhammetakkurtt/fomo-clans-scraper) on Apify Store and click **Try for free**
2. Leave **Clans** empty to scrape the leaderboard, or enter clan names or FOMO clan IDs, one per line
3. Pick the **PnL Window** (`24h`, `7d`, `30d`, `all`) and what to include: **Members**, **Holdings**, **Theses**, **Activity Feed**
4. Click **Start**, then export as **JSON**, **CSV**, **Excel**, **XML**, **HTML**, or **RSS**

#### Example input

Top 10 clans of the week with members and holdings:

```json
{
  "window": "7d",
  "maxClans": 10,
  "includeMembers": true,
  "includeHoldings": true,
  "maxHoldings": 20
}
```

A specific clan with its theses and activity feed:

```json
{
  "clans": ["Fantom Troupe"],
  "window": "all",
  "includeTheses": true,
  "includeFeed": true
}
```

#### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `clans` | Array | No | — | Clan names or FOMO clan IDs, one per line. Leave empty to scrape the leaderboard. |
| `window` | String | No | `all` | PnL window for the ranking and for clan and member PnL: `24h`, `7d`, `30d`, or `all`. |
| `maxClans` | Integer | No | `10` | How many top clans to return from the leaderboard (up to 50). |
| `includeMembers` | Boolean | No | `true` | Include the full member list with PnL and role, plus top tokens and trade count. |
| `includeHoldings` | Boolean | No | `true` | Include the clan's combined token holdings. |
| `maxHoldings` | Integer | No | `20` | Cap the number of holdings per clan, largest first (up to 200). |
| `includeTheses` | Boolean | No | `false` | Include members' latest trade theses. |
| `maxTheses` | Integer | No | `20` | Cap the number of theses per clan (up to 100). |
| `includeFeed` | Boolean | No | `false` | Include the clan's latest trading activity. |
| `maxFeedItems` | Integer | No | `50` | Cap the number of activity items per clan (up to 100). |

### Output example

> The output is the raw structure returned by FOMO (fields as-is; some are nested).

```json
{
  "id": "715a68a6-657e-4424-8c65-68ad3af899b1",
  "name": "Fantom Troupe",
  "description": "private collective of on-chain chads",
  "rank": 1,
  "pnl": 2647944.69,
  "memberCount": 15,
  "tradeCount": 20122,
  "createdAt": "2026-07-31T23:49:06.543Z",
  "topTokens": [ { "symbol": "PONS", "tokenAddress": "0x39db...", "networkId": 4663, "pnl": 6674729.12 } ],
  "members": [
    { "pnl": 1966403.17, "role": "member",
      "user": { "userHandle": "unipcs", "displayName": "Unipcs", "address": "FJDy9FDRy6bwGEUKuAC98bUtN8MkpE2pT7Dj7HE3Z7Q1" } }
  ],
  "holdings": [
    { "symbol": "PONS", "name": "Pons", "tokenAddress": "0x39db...", "networkId": 4663, "humanAmount": 10957912.14,
      "value": 6738754.07, "pnl": 6671036.75, "percentagePnl": 9851.3, "memberCount": 1,
      "topMembers": [ { "userHandle": "unipcs" } ] }
  ],
  "holdingsTotalCount": 365,
  "theses": [
    { "type": "thesis", "userHandle": "unipcs", "ticker": "MarsCoin", "createdAt": "2026-09-26T17:24:10.132Z",
      "comment": { "comment": "i used ChatGPT to try to model a fair valuation for $MARSCOIN ...", "marketCapAtCreation": 138208081.18, "reactions": { "counts": { "likeCount": 146 } } },
      "authorTrade": { "usdValue": 3244762.88, "unrealizedPnlUsd": 2273439.78, "realizedPnlUsd": 6261.05 } }
  ],
  "feed": [
    { "type": "large_buy", "createdAt": "2026-09-26T18:41:50.000Z", "networkId": 1399811149,
      "body": { "ticker": "e/acc", "userHandle": "pedrigavifrenki", "marketCap": "15355200", "avgCost": 0.021021, "currentSizeUsd": 188097.9 } }
  ],
  "window": "7d",
  "query": "Fantom Troupe"
}
```

### Frequently asked questions

#### How do I find a clan?

Enter the clan's name (e.g., `Fantom Troupe`) or its FOMO clan ID — the `id` field in the output. Partial names work too; the exact name gives the most precise match.

#### How many clans does the leaderboard return?

The FOMO clan leaderboard lists the top 50 clans for each window; set `maxClans` to return fewer. Clans outside the top 50 can be scraped by name.

#### What is a FOMO clan?

A group of FOMO traders who compete together on a shared PnL leaderboard. Each clan has members, combined holdings and a feed of its members' trades and theses.

#### How do I get support?

Open an issue on the [Issues tab](https://apify.com/muhammetakkurtt/fomo-clans-scraper/issues) of the actor page, or contact the developer for a custom scraping solution.

# Actor input Schema

## `clans` (type: `array`):

Clans to scrape — one per line, by clan name or FOMO clan ID. Leave empty to scrape the top clans from the leaderboard.

## `window` (type: `string`):

Period for the leaderboard ranking and for clan and member PnL.

## `maxClans` (type: `integer`):

How many top clans to return from the leaderboard when no clans are listed (up to 50).

## `includeMembers` (type: `boolean`):

Include the full member list with each member's PnL and role, plus the clan's top tokens and trade count.

## `includeHoldings` (type: `boolean`):

Include the clan's combined token holdings with value, PnL and the members holding each token.

## `maxHoldings` (type: `integer`):

Cap the number of holdings per clan, largest first (up to 200).

## `includeTheses` (type: `boolean`):

Include the latest trade theses written by clan members, with the trade's PnL.

## `maxTheses` (type: `integer`):

Cap the number of theses per clan (up to 100).

## `includeFeed` (type: `boolean`):

Include the clan's latest activity — large buys and sells, profit milestones, new theses and perp position changes.

## `maxFeedItems` (type: `integer`):

Cap the number of activity items per clan (up to 100).

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

Proxy configuration (optional).

## Actor input object example

```json
{
  "window": "all",
  "maxClans": 10,
  "includeMembers": true,
  "includeHoldings": true,
  "maxHoldings": 20,
  "includeTheses": false,
  "maxTheses": 20,
  "includeFeed": false,
  "maxFeedItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Collected FOMO clans, one item per clan

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammetakkurtt/fomo-clans-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("muhammetakkurtt/fomo-clans-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 '{}' |
apify call muhammetakkurtt/fomo-clans-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammetakkurtt/fomo-clans-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/GS1vedv0xL1P7hqdO/builds/3jDzAlZAx0URLzCQX/openapi.json