# FOMO Perps Traders Scraper (`muhammetakkurtt/fomo-perps-traders-scraper`) Actor

Scrape FOMO (fomo.family) perpetual futures traders — the largest open long and short positions on any perp (BTC, ETH, HYPE, stocks, gold and more) with size, leverage, entry and liquidation price, plus the latest trades. Export as JSON, CSV or Excel.

- **URL**: https://apify.com/muhammetakkurtt/fomo-perps-traders-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 $1.50 / 1,000 perp position 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 Perps Traders Scraper — the largest long and short perp positions of fomo.family traders](https://i.postimg.cc/P5yx9Qpg/fomo-banner.png)

## FOMO Perps Traders Scraper

**Scrape FOMO (fomo.family) perpetual futures traders — see who holds the largest long and short positions on any perp and what they trade.** Enter perps like BTC, ETH, HYPE, TSLA or GOLD and get each trader's position size, leverage, entry and liquidation price, margin, funding and realized PnL — or the latest trades on that perp — as structured data.

No coding needed. Pick perps, 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 trade spot tokens and perpetual futures in public. Its perps cover crypto (BTC, ETH, HYPE, SOL and more) as well as stocks, commodities, indices and FX. The **FOMO Perps Traders Scraper** turns FOMO traders' perp positions and trades into structured data — ideal for positioning research, whale tracking and market intelligence.

### What data does it extract?

Choose one data type per run:

| Data type | Fields |
|---|---|
| **Open positions** | Trader, side (long/short), size, leverage, average entry price, liquidation price, committed margin, funding paid, realized PnL, open time, rank by size, and the perp's total number of FOMO holders |
| **Latest trades** | Trader, direction (open/close long/short), size, price, closed PnL, fees, liquidation flag, trader's wallet address and time |

Supported perps include crypto (BTC, ETH, HYPE, SOL, kPEPE…), stocks (TSLA, NVDA, AAPL…), commodities (GOLD, SILVER, oil), indices (S\&P500, Nasdaq 100) and FX.

### Why scrape FOMO perps traders?

- 🐋 **Whale tracking** — see the biggest long and short positions on a perp and their liquidation prices
- ⚖️ **Positioning research** — compare how many FOMO traders are long vs short, and at what leverage
- 📉 **Liquidation levels** — map where large positions would be liquidated
- 🔔 **Big trade alerts** — pull the latest large trades on a perp with a minimum trade size
- 🤖 **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 Perps Traders Scraper](https://apify.com/muhammetakkurtt/fomo-perps-traders-scraper) on Apify Store and click **Try for free**
2. Choose the **Data Type** — **Open positions** or **Latest trades**
3. Enter one or more **Perps** — tickers such as `BTC`, `ETH`, `TSLA` or `GOLD`, one per line (or leave empty and pick a **Category**)
4. Optionally filter positions by **side**, or set a **minimum trade size** and **max trades** for trades
5. Click **Start**, then export as **JSON**, **CSV**, **Excel**, **XML**, **HTML**, or **RSS**

#### Example input

Largest open positions on BTC and ETH:

```json
{
  "dataType": "positions",
  "coins": ["BTC", "ETH"],
  "side": "all"
}
```

Latest BTC trades worth at least $10,000:

```json
{
  "dataType": "trades",
  "coins": ["BTC"],
  "minTradeSizeUsd": 10000,
  "maxTrades": 250
}
```

#### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `dataType` | String | No | `positions` | `positions` (largest open positions) or `trades` (latest trades). |
| `coins` | Array | No | — | Perps to scrape: tickers (`BTC`, `TSLA`), names, or FOMO perp ids (`xyz:SP500`). |
| `side` | String | No | `all` | Positions only: `all`, `long` or `short`. |
| `minTradeSizeUsd` | Integer | No | `1000` | Trades only: skip trades smaller than this value in USD (`0` = all trades). |
| `maxTrades` | Integer | No | `100` | Trades only: latest trades to return per perp (up to 1,000). |
| `category` | String | No | `Crypto` | Used when `coins` is empty: `All`, `Crypto`, `Stocks`, `Commodities`, `Indices`, `FX`, `Pre-IPO`. |
| `maxCoins` | Integer | No | `10` | Used with `category`: how many of its top perps to scrape (up to 50). |

### Output example

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

An open position (`dataType: positions`):

```json
{
  "coin": "BTC",
  "rank": 1,
  "totalHolders": 944,
  "user": { "userHandle": "SilentHuskyOrca", "displayName": "SilentHuskyOrca", "userId": "dfc243be-a439-52be-bb55-d0ab17b71f19", "verified": false },
  "positionId": "d948221b-8a88-44f8-810a-4ad53ce104bc",
  "side": "LONG",
  "szi": 54.28594,
  "leverage": 20,
  "remainingAvgEntryPrice": "84870.0298",
  "liquidationPriceUsd": "81805.7652",
  "sumEntryNotional": 4607249.35,
  "committedMargin": 221857.77,
  "fundingPaid": 4431.89,
  "realizedPnl": 0,
  "crossed": false,
  "openedAt": "2026-09-23T12:58:53.438Z"
}
```

A trade (`dataType: trades`):

```json
{
  "coin": "BTC",
  "fill": {
    "direction": "Close Long",
    "sz": "0.5249",
    "px": "84324",
    "closedPnl": "267.699",
    "fee": "41.25187",
    "isLiquidation": false,
    "userAddress": "0x014baa9c5828bd8f495775cc401186477bb5b9d0",
    "positionId": "b6c11808-1aaa-4fb6-98d1-cd51efd594ed",
    "createdAt": "2026-09-27T00:46:08.124Z"
  },
  "user": { "userHandle": "saturnSE", "displayName": "saturnSE", "userId": "2ef00fee-7682-5c0d-90a5-f13ead3179d8", "verified": false }
}
```

A short position has a negative `szi`. `rank` is the position's size rank among all open positions on that perp.

### Frequently asked questions

#### Which perps are supported?

Every perp listed on FOMO — crypto such as BTC, ETH, HYPE and SOL, plus stocks, commodities, indices and FX. Enter the ticker (e.g., `TSLA`, `GOLD`, `S&P500`) and the scraper finds the matching perp.

#### How many positions are returned?

The largest open positions on each perp, up to 50 per perp, ordered by size. `totalHolders` shows how many FOMO traders hold the perp in total.

#### How far back do trades go?

Trades are returned newest first, up to 1,000 per perp. Use `minTradeSizeUsd` to focus on larger trades — a higher minimum reaches further back in time.

#### Can I scrape a whole category?

Yes. Leave **Perps** empty, choose a **Category** (e.g., Stocks) and set **Max Perps** — the scraper takes the category's top perps.

#### How do I get support?

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

# Actor input Schema

## `dataType` (type: `string`):

What to scrape for each perp: the largest open positions held by FOMO traders, or the latest trades.

## `coins` (type: `array`):

Perps to scrape, one per line — a ticker (BTC, ETH, HYPE, TSLA, GOLD), a name, or a FOMO perp id such as xyz:SP500. Leave empty to scrape the top perps of a category.

## `side` (type: `string`):

Open positions only: return all positions, only longs, or only shorts.

## `minTradeSizeUsd` (type: `integer`):

Latest trades only: skip trades smaller than this value in USD. Use 0 for every trade, or 100000 for whale trades only.

## `maxTrades` (type: `integer`):

Latest trades only: how many of the most recent trades to return per perp (up to 1,000).

## `category` (type: `string`):

Used when no perps are listed: scrape the top perps of this FOMO category.

## `maxCoins` (type: `integer`):

How many of the category's top perps to scrape (up to 50).

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

Proxy configuration (optional).

## Actor input object example

```json
{
  "dataType": "positions",
  "coins": [
    "BTC",
    "ETH"
  ],
  "side": "all",
  "minTradeSizeUsd": 1000,
  "maxTrades": 100,
  "category": "Crypto",
  "maxCoins": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Collected FOMO perp positions or trades, one item per position or trade

# 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 = {
    "coins": [
        "BTC",
        "ETH"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammetakkurtt/fomo-perps-traders-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 = { "coins": [
        "BTC",
        "ETH",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("muhammetakkurtt/fomo-perps-traders-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 '{
  "coins": [
    "BTC",
    "ETH"
  ]
}' |
apify call muhammetakkurtt/fomo-perps-traders-scraper --silent --output-dataset

```

## MCP server setup

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