FOMO Trading API: REST API for Social Trading Data & Wallets

A FOMO trading API connects social trader handles to real on-chain wallets and verified trade history. Instead of scraping screenshots or trusting self-reported PnL, you query a single endpoint and get back live balances, full trade logs, leaderboard rankings, and who holds what tokens. This guide covers how handle-to-wallet resolution works, the core REST endpoints, real-time WebSocket feeds, and what verified on-chain data actually means for your trading tools.

What is a FOMO Trading API?

A FOMO trading API resolves any social trader's username (Twitter, Telegram, or platform handle) to their actual on-chain wallets on Solana and EVM chains. Once you have the wallet addresses, the API serves:

• Verified PnL and track record: calculated from real blockchain transactions, not user input.
• Live holdings: current token balances across all supported chains.
• Full trade history: every buy and sell, with timestamps, amounts, and realized gains.
• Ranked leaderboards: traders sorted by 24h, 7d, or 30d performance.
• Token ownership graph: see which traders hold a specific token and how much.
• Real-time WebSocket feed: live trade events as they happen on-chain.

You authenticate once with an API key and get all of this through a handful of REST endpoints plus a WebSocket connection. The data is read directly from blockchains, so it cannot be faked or manipulated.

Use cases include building trader dashboards, copy-trading bots, social sentiment tools, portfolio analytics, and leaderboards. If you need to know what a trader actually owns and how they performed, a FOMO trading API gives you the ground truth.

How Handle-to-Wallet Resolution Works

Most social traders share a Twitter or Telegram handle, not a wallet address. A social trading API must map that handle to the correct on-chain wallets. Here is how it works:

1. User lookup: you call GET /v2/users/{handle} with a Twitter username or numeric user ID.
2. Wallet discovery: the API returns both Solana and EVM wallet addresses linked to that handle.
3. Cross-chain aggregation: the API reads balances, trades, and PnL from all wallets and chains, then aggregates them into a single response.

For example, if you query GET /v2/users/traderhandle, you get back:

{
  "user_id": "12345",
  "handle": "traderhandle",
  "solana_wallet": "7xKXt...",
  "evm_wallet": "0xABC...",
  "pnl_24h": 12500.00,
  "pnl_7d": 48000.00,
  "rank_24h": 42
}

This single call gives you everything you need to start tracking that trader. You do not need to maintain your own wallet registry or run your own indexers.

The API supports six chains in total: Solana, Ethereum, Base, BSC, and two more EVM networks. Each trader's EVM wallet is used across all EVM chains, so you get a unified view of their activity.

Core REST Endpoints for Trading Data

A crypto trader wallet API exposes several REST endpoints. Each one serves a specific part of the trading data pipeline.

GET /v2/leaderboard/{window}

Returns the top traders ranked by PnL over a time window (24h, 7d, or 30d). This is the fastest way to discover high-performing traders.

Request:

GET https://api.fomoapi.io/v2/leaderboard/24h?limit=50

Response:

{
  "window": "24h",
  "traders": [
    {
      "user_id": "12345",
      "handle": "traderA",
      "pnl": 85000.00,
      "rank": 1
    },
    {
      "user_id": "67890",
      "handle": "traderB",
      "pnl": 72000.00,
      "rank": 2
    }
  ]
}

You can see the live trader leaderboard to explore real rankings before you write any code.

GET /v2/users/{handle}

Resolves a handle to wallets and returns aggregated stats. This is your entry point for any trader-specific query.

Request:

GET https://api.fomoapi.io/v2/users/traderhandle

Response includes:

• User ID and handle
• Solana and EVM wallet addresses
• 24h, 7d, and 30d PnL
• Current rank in each leaderboard window

GET /trades?user={id}

Returns the full trade history for a trader. Each trade record includes token address, buy or sell, amount, price, timestamp, and realized PnL.

Request:

GET https://api.fomoapi.io/trades?user=12345&limit=100

Response:

{
  "trades": [
    {
      "trade_id": "abc123",
      "token": "0xDEF...",
      "side": "buy",
      "amount": 1000,
      "price_usd": 0.05,
      "timestamp": "2025-01-15T10:30:00Z",
      "chain": "base"
    },
    {
      "trade_id": "xyz789",
      "token": "0xDEF...",
      "side": "sell",
      "amount": 1000,
      "price_usd": 0.12,
      "timestamp": "2025-01-15T14:00:00Z",
      "chain": "base",
      "realized_pnl": 70.00
    }
  ]
}

This endpoint is critical for backtesting, performance analysis, and building copy-trading logic.

GET /v2/users/{id}/balances

Returns current token holdings for a trader across all chains.

Request:

GET https://api.fomoapi.io/v2/users/12345/balances

Response:

{
  "balances": [
    {
      "token": "0xABC...",
      "symbol": "TOKEN",
      "amount": 5000,
      "value_usd": 250.00,
      "chain": "ethereum"
    },
    {
      "token": "7xKXt...",
      "symbol": "SOL",
      "amount": 10,
      "value_usd": 2300.00,
      "chain": "solana"
    }
  ]
}

This is how you build live portfolio views or detect when a trader enters or exits a position.

GET /token/{address}/holders

Returns the list of traders who hold a specific token, sorted by holdings.

Request:

GET https://api.fomoapi.io/token/0xDEF.../holders?limit=20

Response:

{
  "token": "0xDEF...",
  "holders": [
    {
      "user_id": "12345",
      "handle": "traderA",
      "amount": 100000,
      "value_usd": 5000.00
    },
    {
      "user_id": "67890",
      "handle": "traderB",
      "amount": 50000,
      "value_usd": 2500.00
    }
  ]
}

This endpoint powers social sentiment analysis: if top traders are accumulating a token, you want to know about it.

You can explore all API endpoints in the full documentation.

Real-Time WebSocket Feed for Live Trades

A verified trading data API is not complete without real-time updates. The WebSocket feed pushes trade events as they happen on-chain, so you can react immediately.

Connecting to the WebSocket

const ws = new WebSocket('wss://api.fomoapi.io/ws?apikey=YOUR_KEY');

ws.onopen = () => {
  console.log('Connected to fomoapi.io WebSocket');
};

ws.onmessage = (event) => {
  const trade = JSON.parse(event.data);
  console.log('New trade:', trade);
};

Event Structure

Each message is a JSON object with the same fields as the REST /trades endpoint:

{
  "event": "trade",
  "user_id": "12345",
  "handle": "traderA",
  "token": "0xDEF...",
  "side": "buy",
  "amount": 2000,
  "price_usd": 0.08,
  "timestamp": "2025-01-15T15:45:00Z",
  "chain": "base"
}

You can filter events client-side or subscribe to specific traders or tokens (check the docs for subscription options).

Real-time feeds are essential for copy-trading bots, live dashboards, and alert systems. Latency from on-chain confirmation to WebSocket delivery is typically under 2 seconds.

Solana and EVM Chain Support

An on-chain trading history API must cover the chains where traders are active. fomoapi.io indexes six chains:

Each trader has one Solana wallet and one EVM wallet. The EVM wallet is used across all EVM chains, so a single address gives you Ethereum, Base, and BSC activity.

Why This Matters

Traders do not stay on one chain. A trader might buy a memecoin on Solana in the morning and trade a Base token in the afternoon. If your API only covers one chain, you miss half the picture.

Cross-chain aggregation means you get a complete view of a trader's performance without running multiple indexers or stitching data together yourself. The API handles chain-specific RPC calls, transaction parsing, and token price lookups.

Verified On-Chain Data vs. Self-Reported Metrics

Most trading leaderboards rely on self-reported PnL. A trader submits a screenshot or manually enters their gains, and the platform displays it. This creates two problems:

1. Manipulation: traders can cherry-pick winning trades or fabricate numbers.
2. Incompleteness: you do not see the full trade history, only what the trader chooses to share.

A verified trading data API solves this by reading directly from the blockchain. Every trade is a transaction with a timestamp, token amount, and price. The API calculates PnL by:

• Parsing all buy and sell transactions for each wallet.
• Matching buys to sells using FIFO or weighted average cost.
• Applying real-time token prices at the time of each trade.
• Summing realized and unrealized gains across all positions.

This approach is deterministic and auditable. If a trader claims a 500% gain but the on-chain data shows a 50% gain, the API reports the truth.

Trade-Offs

Verified data is slower to index than self-reported data. It requires running full nodes, indexing every block, and maintaining a price feed for thousands of tokens. But the payoff is trust: your users know the leaderboard is real.

For copy-trading bots, this is non-negotiable. You cannot risk following a trader who faked their track record.

Pricing, Rate Limits, and Free Tier

fomoapi.io offers a free tier and three paid plans. Rate limits and feature access scale with the plan.

Free Tier

• No API key required.
• Rate limit: 10 requests per minute.
• Access to all REST endpoints except real-time WebSocket.
• Good for prototyping and small projects.

Paid Plans

Rate limits are per API key, not per IP. If you need higher limits, contact the team for custom pricing.

WebSocket access is included in all paid plans. The free tier does not support WebSocket connections.

You can view pricing tiers and compare feature tables on the main site.

Cost Example

A dashboard that polls the leaderboard every 10 seconds (6 requests per minute) and fetches user data for 10 traders every minute (10 requests per minute) uses about 16 requests per minute. This fits comfortably in the Starter plan.

A copy-trading bot that monitors 50 traders via WebSocket and fetches balances every 30 seconds (100 requests per minute) needs the Pro plan.

Getting Started with fomoapi.io

To start using the API:

1. Get an API key: message t.me/eulatxt to request a key. Free tier does not require a key.
2. Read the docs: visit fomoapi.io and click the documentation link.
3. Test an endpoint: try GET /v2/leaderboard/24h to see live data.
4. Build your first query: resolve a trader handle with GET /v2/users/{handle}.
5. Connect to WebSocket: upgrade to a paid plan and open a WebSocket connection for live trades.

The API returns JSON for all endpoints. Authentication is via an apikey query parameter or an Authorization: Bearer YOUR_KEY header.

If you are building a trading bot, start with the leaderboard to find high-performing traders, then use the /trades endpoint to backtest their strategies. If you are building a dashboard, use /balances and the WebSocket feed to show live portfolio updates.

fomoapi.io handles the hard parts (chain indexing, wallet resolution, PnL calculation) so you can focus on building features your users care about. For access or questions, reach out at t.me/eulatxt.