Skip to main content

FOMO App Trades API: Wallets, Tokens and Fees on Solana

FOMO is a social trading app and website: users follow other traders and buy memecoins and other tokens without paying gas themselves. FOMO does not list a public API on fomo.family (checked 29 September 2026). This page shows how to read FOMO's Solana trades straight from the chain with Bitquery GraphQL. Bitquery is not affiliated with FOMO.

This page covers Solana only. FOMO also lets users buy tokens on EVM chains. On Robinhood Chain, which we checked, those orders are filled by Relay's solver and look like any other Relay fill; we could only tell them apart using Relay's own order records.

note

To query or stream data via GraphQL outside the Bitquery IDE, you need to generate an API access token.

Follow the steps here to create one: How to generate Bitquery API token ➤

How Bitquery finds FOMO trades​

FOMO uses one wallet to sign, and pay gas for, every trade its users make. Its fees arrive in USDC at a separate account:

RoleAddress
Signer and fee payer on every FOMO tradeAgmLJBMDCqWynYnQiPCuj9ewsNNsBJXyzoUhD9LJzN51
FOMO fee account (USDC token account)HrTf9CzXR1dRH4Sof5QrpmGWwpwAf3qZzwCsEjQpXcSq
Owner of the fee accountR4rNJHaffSUotNmqSKNEfDcJE8A7zJUkaoM5Jkd7cYX

Bitquery identified these addresses from on-chain activity. FOMO has not published or confirmed them. If FOMO moves to new addresses, the queries on this page will return nothing, so run the check below first.

Three things to know before you read the results:

  • Not every signed transaction is a trade. Between 12:00 and 13:00 UTC on 29 September 2026 the signer signed about 33,600 transactions, and about 26,000 of them contained a DEX trade. Count trades from DEX trade data, not from everything the signer signs.
  • Most FOMO trades go through the DFlow aggregator. In that hour, about 22,000 of the 26,000 trades did. The DFlow row carries the user's own wallet in Trade.Account.Owner; in a sample of 1,166 trades it matched the wallet that paid the app's fee 94% of the time. Rows for the individual pools along the route can show a temporary token account instead, so the wallet queries on this page filter on DFlow.
  • Signer and fee payer fields always show FOMO. FOMO pays the gas, so Transaction.Signer and Transaction.FeePayer never hold the user's wallet.

Check that the signer is still active​

This returns the latest transaction the signer has signed. A timestamp from the last few minutes means the signer is still in use. Run it in the IDE: signer check.

query FomoSignerCheck {
  Solana {
    Transactions(
      limit: {count: 1}
      orderBy: {descending: Block_Time}
      where: {Transaction: {Signer: {is: "AgmLJBMDCqWynYnQiPCuj9ewsNNsBJXyzoUhD9LJzN51"}}}
    ) {
      Block {
        Time
      }
      Transaction {
        Signature
      }
    }
  }
}

How far back the data goes​

  • The trade-level queries on this page read Solana DEX trades, which cover about the last 12 hours.
  • The daily query at the end uses the Trading API, which keeps about 30 days. It has no user wallet field: on every trade from the app its Trader.Address is the signer.
  • Counts for a finished hour can still move by a few trades as recent data settles, so the figures on this page are rounded.
  • The queries return USD values per trade, but this page quotes no USD totals. A single mispriced trade can distort a sum, so check outliers before you add values up.

Latest trades​

This returns the 10 most recent trades made in the app, with the token sold, the token bought and the user's wallet. Run it in the IDE: latest trades.

To stream new trades as they happen, change query to subscription and remove the limit and orderBy lines.

query FomoLatestTrades {
  Solana {
    DEXTrades(
      limit: {count: 10}
      orderBy: {descending: Block_Time}
      where: {Transaction: {Signer: {is: "AgmLJBMDCqWynYnQiPCuj9ewsNNsBJXyzoUhD9LJzN51"}}, Trade: {Dex: {ProtocolName: {is: "dflow"}}}}
    ) {
      Block {
        Time
      }
      Transaction {
        Signature
      }
      Trade {
        Buy {
          Amount
          AmountInUSD
          Account {
            Owner
          }
          Currency {
            Symbol
            MintAddress
          }
        }
        Sell {
          Amount
          AmountInUSD
          Currency {
            Symbol
            MintAddress
          }
        }
      }
    }
  }
}

Buy is what the user received and Sell is what they paid. Most balances in the app are held in USDC, so one side is usually USDC.

One wallet's trades​

Paste a Solana wallet address into the wallet variable to list that wallet's recent trades in the app. The not: "" condition stops the query from matching trades with a blank owner if the wallet value is mistyped. Run it in the IDE: one wallet's trades.

query FomoWalletTrades($wallet: String) {
  Solana {
    DEXTrades(
      limit: {count: 20}
      orderBy: {descending: Block_Time}
      where: {Transaction: {Signer: {is: "AgmLJBMDCqWynYnQiPCuj9ewsNNsBJXyzoUhD9LJzN51"}}, Trade: {Dex: {ProtocolName: {is: "dflow"}}, Buy: {Account: {Owner: {is: $wallet, not: ""}}}}}
    ) {
      Block {
        Time
      }
      Transaction {
        Signature
      }
      Trade {
        Buy {
          Amount
          Currency {
            Symbol
            MintAddress
          }
        }
        Sell {
          Amount
          Currency {
            Symbol
            MintAddress
          }
        }
      }
    }
  }
}
{
  "wallet": "PASTE_A_SOLANA_WALLET_ADDRESS"
}

Top tokens bought​

This ranks tokens by how many app users bought them in the last hour. USDC, which users pay with, and wrapped SOL are left out. Run it in the IDE: top tokens bought.

query FomoTopTokensBought {
  Solana {
    DEXTradeByTokens(
      limit: {count: 10}
      orderBy: {descendingByField: "buyers"}
      where: {Transaction: {Signer: {is: "AgmLJBMDCqWynYnQiPCuj9ewsNNsBJXyzoUhD9LJzN51"}}, Trade: {Dex: {ProtocolName: {is: "dflow"}}, Side: {Type: {is: buy}}, Currency: {MintAddress: {notIn: ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "So11111111111111111111111111111111111111112"]}}}, Block: {Time: {since_relative: {hours_ago: 1}}}}
    ) {
      Trade {
        Currency {
          Symbol
          Name
          MintAddress
        }
      }
      buys: count(distinct: Transaction_Signature)
      buyers: count(distinct: Trade_Account_Owner)
    }
  }
}

Most active wallets​

This lists the 10 wallets with the most trades in the app in the last hour, with how many different tokens each one traded. Run it in the IDE: most active wallets.

query FomoMostActiveWallets {
  Solana {
    DEXTradeByTokens(
      limit: {count: 10}
      orderBy: {descendingByField: "trades"}
      where: {Transaction: {Signer: {is: "AgmLJBMDCqWynYnQiPCuj9ewsNNsBJXyzoUhD9LJzN51"}}, Trade: {Dex: {ProtocolName: {is: "dflow"}}}, Block: {Time: {since_relative: {hours_ago: 1}}}}
    ) {
      Trade {
        Account {
          Owner
        }
      }
      trades: count(distinct: Transaction_Signature)
      tokens: count(distinct: Trade_Currency_MintAddress)
    }
  }
}

Fees paid to the app​

This counts the USDC fee payments that reached the fee account in the last hour, and how many wallets paid them. Some trades also send a second, smaller fee to another account, which this query does not include. Run it in the IDE: fees paid.

query FomoFees {
  Solana {
    Transfers(
      where: {Transfer: {Receiver: {Address: {is: "HrTf9CzXR1dRH4Sof5QrpmGWwpwAf3qZzwCsEjQpXcSq"}}}, Block: {Time: {since_relative: {hours_ago: 1}}}}
    ) {
      fee_payments: count
      paying_wallets: count(distinct: Transfer_Sender_Owner)
      usdc_total: sum(of: Transfer_Amount)
    }
  }
}

In that same 12:00 to 13:00 UTC hour on 29 September 2026, the fee account received about 25,900 payments, close to one per trade.

Trades and traders per hour​

This shows activity for each hour of the last 12. The first list counts all trades. The second counts distinct user wallets, using the DFlow rows. Run it in the IDE: activity per hour.

query FomoHourlyActivity {
  Solana {
    trades: DEXTradeByTokens(
      orderBy: {descendingByField: "Block_Time"}
      where: {Transaction: {Signer: {is: "AgmLJBMDCqWynYnQiPCuj9ewsNNsBJXyzoUhD9LJzN51"}}, Block: {Time: {since_relative: {hours_ago: 12}}}}
    ) {
      Block {
        Time(interval: {in: hours, count: 1})
      }
      trades: count(distinct: Transaction_Signature)
    }
    traders: DEXTradeByTokens(
      orderBy: {descendingByField: "Block_Time"}
      where: {Transaction: {Signer: {is: "AgmLJBMDCqWynYnQiPCuj9ewsNNsBJXyzoUhD9LJzN51"}}, Trade: {Dex: {ProtocolName: {is: "dflow"}}}, Block: {Time: {since_relative: {hours_ago: 12}}}}
    ) {
      Block {
        Time(interval: {in: hours, count: 1})
      }
      traders: count(distinct: Trade_Account_Owner)
    }
  }
}

Trades per day​

This uses the Trading API to count trades and distinct tokens for each of the last 7 days. The Trading API can store more than one row per trade and repeats a small share of rows, so the query counts distinct transactions. The first day in the window is partial. Run it in the IDE: trades per day.

query FomoDailyActivity {
  Trading {
    Trades(
      orderBy: {descendingByField: "Block_Date"}
      where: {Trader: {Address: {is: "AgmLJBMDCqWynYnQiPCuj9ewsNNsBJXyzoUhD9LJzN51"}}, Block: {Time: {since_relative: {days_ago: 7}}}}
    ) {
      Block {
        Date
      }
      trades: count(distinct: TransactionHeader_Hash)
      tokens: count(distinct: Pair_Token_Id)
    }
  }
}

From 23 to 28 September 2026, the Trading API counted between about 925,000 and 1.21 million FOMO trades on Solana per day. For the 12:00 to 13:00 UTC hour on 29 September, this API counted about 25,600 trades against about 26,000 in the Solana DEX data above. The Trading API covers a curated set of DEXs, so expect it to run slightly lower.

What this page cannot do​

  • Link usernames to wallets. Profiles live in the app, not on-chain.
  • Track the app's EVM-chain orders. On Robinhood Chain they are filled by a bridge solver, and only the bridge's own records show which fills came from FOMO.
  • Show one wallet's history older than about 12 hours. The Trading API keeps 30 days but records the app's signer as the trader, not the user.

Frequently Asked Questions

Does FOMO have an official API?

FOMO does not list a public API on fomo.family (checked 29 September 2026). This page reads FOMO trades from Solana directly with Bitquery GraphQL. Bitquery is not affiliated with FOMO.

How does Bitquery know a trade came from FOMO?

FOMO's wallet AgmLJBMDCqWynYnQiPCuj9ewsNNsBJXyzoUhD9LJzN51 signs and pays gas for every FOMO trade on Solana, and fees arrive in USDC at the account HrTf9CzXR1dRH4Sof5QrpmGWwpwAf3qZzwCsEjQpXcSq. Bitquery identified both from on-chain activity; FOMO has not confirmed them.

How do I find the user behind a trade?

Filter the trade to the DFlow row (ProtocolName dflow) and read Trade.Account.Owner. That is the user's wallet. Signer and fee payer always show the app's wallet.

Why do the Trading API and the Solana DEX data give different counts?

The Trading API covers a curated set of DEXs and can store more than one row per trade, so count distinct transaction hashes there. For one hour on 29 September 2026 it counted about 25,600 trades against about 26,000 in the Solana DEX data.

Do I need an API key outside the IDE?

Yes. Generate an access token from your Bitquery account to run these queries in your own app or bot.

Build with Bitquery

Ready to run this in production?

Get an API key and run these queries in minutes, or talk to us about plans and enterprise delivery.

Get your API keyBuy Solana DEX history as filesSee pricingTry the MCP serverSubscribe to newsletter
Talk to the teamTelegramEmail

On this page