FOMO Data API: Get Trader Data Programmatically

A FOMO data API delivers programmatic access to verified trader performance, on-chain wallet data, and live trade feeds across social trading platforms. Instead of scraping profiles or trusting self-reported stats, you query real wallet addresses and transaction history. fomoapi.io resolves any social trader's handle to their Solana and EVM wallets, then serves verified PnL, holdings, trade history, and realtime updates through a single REST and WebSocket API.

What is FOMO trader data?

FOMO trader data is the full record of a social trader's on-chain activity: every token purchase, every sale, current holdings, realized profits and losses, and wallet addresses tied to their public handle. "FOMO" refers to the fear-of-missing-out behavior that drives retail traders to follow influencers, copy trades, or build tools that surface trending wallets.

The data includes:

• Verified PnL: Total profit and loss calculated from actual blockchain transactions, not self-reported numbers.
• Trade history: Every buy and sell, with token address, quantity, price, timestamp, and transaction hash.
• Current balances: Live token holdings across all linked wallets.
• Leaderboard rankings: Traders sorted by 24-hour, 7-day, or 30-day PnL.
• Token holder graphs: Who holds a specific token, with quantities and entry prices.

Because the data comes from real wallets, it cannot be faked. A trader who claims 10x returns but whose wallet shows a 40% loss is immediately exposed. This verification layer is what separates a FOMO data API from Twitter scraping or self-reported leaderboards.

Why programmatic access matters for trading tools

Manual lookups do not scale. If you are building a copy-trading bot, a wallet tracker dashboard, or a token analytics platform, you need machine-readable data that updates in real time.

Use cases for a trader data API:

• Copy trading bots: Monitor top traders' wallets, replicate their buys within seconds of execution.
• Influencer verification: Check if a Twitter account's claimed gains match their on-chain history before promoting them.
• Portfolio dashboards: Aggregate holdings and PnL across multiple traders or wallets in one interface.
• Token research: See which high-performing wallets are accumulating a specific token, then cross-reference their track records.
• Alert systems: Trigger notifications when a tracked trader opens or closes a position above a certain size.

Without programmatic access, you are stuck refreshing web pages, copying addresses by hand, and writing fragile scrapers that break every time a site redesigns. A proper API returns structured JSON, handles rate limits, and documents breaking changes.

Core endpoints: leaderboard, users, trades, balances

fomoapi.io exposes five primary REST endpoints. Each returns JSON and accepts standard query parameters for filtering and pagination. Full details are in the full API endpoint documentation.

GET /v2/leaderboard/{window}

Returns ranked traders by PnL over a time window: 24h, 7d, or 30d. Each entry includes handle, total PnL, win rate, and linked wallet addresses.

Example request:

GET https://api.fomoapi.io/v2/leaderboard/7d

Response shape:

{
  "leaderboard": [
    {
      "user_id": "abc123",
      "handle": "degen_king",
      "pnl_usd": 45320.12,
      "win_rate": 0.68,
      "wallets": {
        "solana": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU",
        "evm": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
      }
    }
  ]
}

You can filter by minimum PnL, exclude bots, or limit results to traders active within the last N hours.

GET /v2/users/{handle}

Resolves a social handle (Twitter username, Telegram handle, or Discord ID) to the trader's profile and linked wallets. Returns PnL summary, total trades, and wallet addresses for both Solana and EVM chains.

Example:

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

Response:

{
  "user_id": "xyz789",
  "handle": "crypto_wizard",
  "total_pnl_usd": 12450.00,
  "trade_count": 342,
  "wallets": {
    "solana": "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
    "evm": "0x8ba1f109551bD432803012645Ac136ddd64DBA72"
  },
  "created_at": "2024-01-15T08:23:00Z"
}

This is the starting point for any social trading data workflow: map a public persona to verifiable wallet addresses.

GET /trades

Query the full trade history for a user, token, or time range. Supports pagination and sorting by timestamp, PnL, or trade size.

Parameters:

• user: Filter by user ID or handle.
• token: Filter by token contract address.
• from, to: Unix timestamps for date range.
• limit, offset: Pagination controls.

Example:

GET https://api.fomoapi.io/trades?user=crypto_wizard&limit=50

Returns an array of trade objects with token symbol, buy/sell action, quantity, price, gas fees, and transaction hash. Each trade links back to the on-chain transaction for full transparency.

GET /v2/users/{id}/balances

Returns current token holdings for a user's linked wallets. Includes token address, symbol, quantity, current price, and unrealized PnL.

Example:

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

Response:

{
  "balances": [
    {
      "token_address": "So11111111111111111111111111111111111111112",
      "symbol": "SOL",
      "quantity": 42.5,
      "current_price_usd": 105.30,
      "unrealized_pnl_usd": 320.50
    }
  ]
}

This endpoint updates in near-realtime as the underlying wallet balances change.

GET /token/{address}/holders

Returns all traders holding a specific token, sorted by quantity or PnL. Useful for seeing which high-performing wallets are accumulating a new token before it trends.

Example:

GET https://api.fomoapi.io/token/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/holders

Returns a list of user IDs, handles, quantities held, and entry prices.

Authentication and rate limits

fomoapi.io offers a free tier with no API key required. Requests are rate-limited to 10 per minute per IP address. This is enough for testing and small personal projects.

Paid plans require an API key passed in the X-API-Key header:

curl -H "X-API-Key: your_key_here" https://api.fomoapi.io/v2/leaderboard/24h

Rate limits by plan:

If you exceed your rate limit, the API returns a 429 Too Many Requests status with a Retry-After header. Paid plans also unlock the WebSocket feed and historical data exports. You can compare pricing tiers to see which fits your request volume.

To get an API key, contact t.me/eulatxt. Keys are provisioned manually within 24 hours.

Resolving social handles to on-chain wallets

The core problem in social trading data is identity resolution: mapping a Twitter handle or Telegram username to the actual wallets that person controls. Most platforms rely on self-reported wallet addresses, which traders can fake by linking a burner wallet with a clean record.

fomoapi.io solves this by cross-referencing multiple data sources:

1. On-chain signatures: Transactions signed by a wallet that reference a social profile in the memo field or metadata.
2. Platform integrations: Direct API access to platforms where traders link wallets to profiles (subject to platform terms).
3. Historical activity: Pattern matching between trade timing, token choices, and public social media posts.

When you query /v2/users/{handle}, the API returns all linked wallets for that trader across Solana and six EVM chains (Ethereum, Base, BSC, Arbitrum, Polygon, Avalanche). If a trader uses multiple wallets, all of them appear in the response, and PnL is aggregated across the set.

This multi-wallet resolution is critical because serious traders split capital across wallets for operational security or to compartmentalize strategies. A trader data API that only returns one wallet per handle misses the full picture.

Real-time WebSocket feed for live trades

REST endpoints are fine for dashboards and batch jobs, but copy-trading bots need sub-second latency. The WebSocket feed at wss://api.fomoapi.io/ws streams trade events as they are indexed from the blockchain.

Connection:

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

ws.on('open', () => {
  ws.send(JSON.stringify({
    action: 'subscribe',
    channels: ['trades', 'balances'],
    filters: { user_ids: ['abc123', 'xyz789'] }
  }));
});

ws.on('message', (data) => {
  const event = JSON.parse(data);
  console.log(event);
});

Event shape:

{
  "type": "trade",
  "user_id": "abc123",
  "token_address": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU",
  "action": "buy",
  "quantity": 1500,
  "price_usd": 0.042,
  "timestamp": 1704123456,
  "tx_hash": "5Kq7..."
}

You can subscribe to specific users, tokens, or all trades above a certain dollar value. The feed includes balance updates, PnL recalculations, and new user registrations. Latency from on-chain confirmation to WebSocket delivery averages 2-4 seconds on Solana, 8-12 seconds on Ethereum.

WebSocket access requires a paid plan (Starter or higher). The connection stays open indefinitely and reconnects automatically on network errors.

Example requests and response shapes

Here is a realistic workflow: you want to build a Telegram bot that alerts your group when any top-10 trader buys a new token.

Step 1: Fetch the current leaderboard.

curl https://api.fomoapi.io/v2/leaderboard/7d?limit=10

Extract the user_id values from the response.

Step 2: Subscribe to those users via WebSocket.

ws.send(JSON.stringify({
  action: 'subscribe',
  channels: ['trades'],
  filters: { user_ids: top10UserIds }
}));

Step 3: On each incoming trade event, check if it is a buy and if the token is new (not in the user's prior holdings).

ws.on('message', (data) => {
  const event = JSON.parse(data);
  if (event.action === 'buy' && isNewToken(event.token_address, event.user_id)) {
    sendTelegramAlert(`${event.user_id} just bought ${event.quantity} of ${event.token_address}`);
  }
});

This setup processes trades in near-realtime and scales to thousands of monitored wallets with a Pro or Scale plan. The same pattern applies to Discord bots, Slack integrations, or custom dashboards.

Pricing tiers and choosing the right plan

Free tier works for prototypes and personal trackers with low request volume. You can query the live trader leaderboard a few times per hour and manually inspect user profiles without hitting rate limits.

Starter ($99/mo) fits small bots and dashboards serving up to a few hundred users. 60 requests per minute covers polling the leaderboard every 10 seconds and fetching user details on demand. WebSocket access lets you monitor 20-30 wallets in realtime.

Pro ($399/mo) supports production copy-trading bots, influencer verification tools, and analytics platforms with moderate traffic. 300 requests per minute handles aggressive polling, and 250,000 daily requests accommodate spikes during high-volatility periods. WebSocket bandwidth supports 100+ concurrent wallet subscriptions.

Scale ($1,200/mo) is for high-frequency trading systems, large dashboards, or reselling social trading data as part of a broader platform. 1,200 requests per minute and 1 million daily requests cover intensive workloads. WebSocket capacity scales to thousands of wallets.

If your use case does not fit these tiers, contact t.me/eulatxt for custom pricing. Enterprise plans include dedicated infrastructure, SLA guarantees, and priority support.

Closing

fomoapi.io provides programmatic access to verified trader data across Solana and EVM chains. You get REST endpoints for leaderboards, user profiles, trade history, and token holders, plus a realtime WebSocket feed for live trades. All data is read from on-chain wallets, so PnL and holdings are verifiable, not self-reported. Visit https://fomoapi.io/ for the full API documentation and to request an API key.