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 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:

• PnL: total profit and loss as fomo.family reports it, returned with the wallets behind it.
• 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.

Resolved wallets give researchers an independently inspectable record to compare with social claims. That improves auditability, but it does not make source coverage, attribution, prices, or derived performance metrics infallible.

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, traded volume, 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,
      "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 available 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/v2/users/crypto_wizard/positions?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 authorization: Bearer header:

curl -H "authorization: Bearer YOUR_API_KEY" 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. The app feed stream is on every plan; Growth and Scale add the on-chain stream. You can compare pricing tiers to see which fits your request volume.

You can get a key yourself from the pricing page. For Scale, contact t.me/eulatxt.

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 want a push feed. For events ahead of the app, the on-chain stream on Growth and Scale reads the chain directly. The WebSocket feed at wss://api.fomoapi.io/ws/alerts streams trade events as they are indexed from the blockchain.

Connection:

const ws = new WebSocket('wss://api.fomoapi.io/ws/alerts?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.

The app feed stream is open on every plan, including free; a paid plan removes the 15-second delay a free key drops to after 7 days. The separate on-chain stream requires Growth or Scale. 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

The free tier is for prototypes and low-volume personal tools. It uses the same endpoint-weighted credit model as paid plans, so estimate usage from the calls your application makes and monitor the returned credit headers.

Starter ($49.99/mo) provides a larger monthly credit bucket and keeps the app-feed WebSocket realtime. Size it from the endpoints and refresh cadence your application actually uses; check current pricing and stream eligibility before deployment.

Growth ($599/mo) is the first self-serve tier with the separate on-chain stream and OHLCV access, plus a larger monthly credit bucket. Confirm current concurrency, throughput, and credit allowances on the pricing page instead of designing around an article snapshot.

Scale ($1,500/mo) is the largest self-serve monthly credit bucket and includes the on-chain stream. Confirm current throughput, key, and stream allowances on the pricing page.

For redistribution, a private feed, or requirements outside the self-serve tiers, contact t.me/eulatxt to discuss the actual scope and terms.

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. Every handle resolves to real wallets, so PnL and holdings can be checked on-chain. Visit https://fomoapi.io/ for the full API documentation and to request an API key.