Skip to content
Robinhood Chain 4663
famdotfun · API

Read famdotfun from your own code.

Every coin, trade, candle and holder on famdotfun, and where every fee went, as JSON, free and without a key. Built for scanners, trading bots, dashboards and anyone who wants the numbers. The API follows the chain and can be rebuilt from it; the contracts stay the source of truth.

Base URL https://api.famdotfun.com. The full list of routes is in the docs.

Quick start

no key
Base URLhttps://api.famdotfun.com
KeyNone. Every route here is public and read-only.
FormatJSON. Amounts are strings, so no number loses digits.
Rate limit300 requests a minute per IP. Write to hello@famdotfun.com for more.
From a browserOnly our own sites may call it from a web page (CORS). Call it from your server, a bot or a script.
ChainRobinhood Chain, chain id 4663. Buying and selling happen on chain, not through this API.

Your first call

The five coins with the most volume in the last 24 hours:

curl "https://api.famdotfun.com/tokens?sort=volume&limit=5"

The same from JavaScript or TypeScript (Node 18 or newer, Bun, Deno):

const res = await fetch("https://api.famdotfun.com/tokens?sort=volume&limit=5");
const { tokens } = await res.json();
for (const t of tokens) console.log(t.symbol, t.token);

And from Python:

import requests
tokens = requests.get("https://api.famdotfun.com/tokens", params={"sort": "volume", "limit": 5}).json()["tokens"]
for t in tokens:
    print(t["symbol"], t["token"])

Reading amounts

read this first

Amounts come as strings in the asset's smallest unit, the way the chain stores them. ETH and every coin have 18 decimals, USDG has 6. A coin says what it is priced in with pair_token and pair_decimals.

FieldHow to read it
pair_amount, volume_24h, reserveDivide by 10pair_decimals to get ETH or USDG.
token_amount, sold, balanceDivide by 1018 to get coins.
priceThe pair's smallest unit per whole coin. Divide by 10pair_decimals for the price in ETH or USDG.

A worked example

A coin priced in ETH shows "price": "1127778697". That is 1127778697 / 1018 = 0.00000000113 ETH per coin. With ETH at $2,669 (from /pairs) it is $0.00000301 a coin, and with a supply of one billion the market cap is about $3,010.

const pairs = (await (await fetch("https://api.famdotfun.com/pairs")).json()).pairs;
const token = "0x…"; // any coin's address, copied from its page
const coin = await (await fetch("https://api.famdotfun.com/tokens/" + token)).json();

const pair = pairs.find((p) => p.address === coin.pair_token);
const pricePair = Number(coin.price) / 10 ** coin.pair_decimals; // ETH per coin
const priceUsd = pricePair * pair.usd;                             // dollars per coin
const marketCapUsd = priceUsd * (Number(coin.total_supply) / 1e18);

Number is fine for display. For exact sums use BigInt, or Python's int and Decimal.

Coins

GET /tokens

The board

curl "https://api.famdotfun.com/tokens?status=curve&sort=progress&limit=20"

Answers { "tokens": [ ... ] }, newest first unless you pick a sort.

QueryValues
sortnew (the default), volume, progress, graduated, boost
statuscurve, sold_out, graduated, or graduating (past half its curve, not graduated yet)
categorynew (the last 24 hours), stocks, culture, locked, direct
creatorOnly the launches of one wallet.
qSearch the name, the ticker or the address.
limit, offsetPaging. limit is 30 by default and at most 100.

One coin

Every coin's page shows its address with a copy button. The examples below read it from TOKEN:

TOKEN=0x…   # the coin's address
curl "https://api.famdotfun.com/tokens/$TOKEN"

One object with everything the board row has, plus a few fields of its own. The fields you will use most:

FieldWhat it is
tokenThe coin's contract. Every coin has 18 decimals and a fixed supply.
modecurve or direct: which machine launched it. The fields below that speak of a curve describe a curve launch only.
curveThe bonding curve it trades on until it graduates. On a direct launch it is the zero address: there is no curve, and the coin trades in its pool from the first block.
hook, splitter, locker, pool_idA direct launch only: its pool's hook, the contract that splits its fees, the locker holding its liquidity, and the Uniswap v4 pool id.
creatorThe wallet that launched it.
pair_token, pair_decimalsWhat it is priced in. The zero address 0x000…000 is ETH.
name, symbol, image, descriptionWhat the creator typed at launch, plus website, twitter and telegram.
priceThe last price, in the pair's smallest unit per whole coin. See reading amounts.
sold, curve_supplyA curve launch: coins sold off the curve, and how many it sells in all. sold / curve_supply is its progress bar. A direct launch has no curve, so do not read progress from these.
phase, bonded, statusWhere the coin is: on the curve, sold out, or graduated into its Uniswap v4 pool.
volume_24h, volume_totalVolume in the pair's smallest unit.
launched_at, block, txWhen and where it was launched.
boosted, boostsWhether it has boosts this hour, and how many. Boosts stack; sort=boost orders the board by them, most first.
cashbackA direct launch that is never charged the creator's 49 bps: traders pay the Bag's 21 bps and the pool fee.
named_exemptWallets the launch named as skipping the opening tax, beyond the launcher and the fee recipient. famdotfun never names any; above 0 the coin was launched by calling the contracts directly, and the plain volume sort leaves it out.
usd, holdersOne coin only: the pair's dollar price and the holder count.

More about one coin

RouteWhat it answers
GET /tokens/:token/first-secondsWho bought in the opening seconds: windowSeconds, and per wallet secondsIn, boughtBps and holdsBps of the supply, sameBlock and tags; bundled counts wallets that look like one buyer.
GET /tokens/:token/bondA direct launch that reached its bond: bonded, and when. Any other coin answers {"bonded":false}.

Trades & candles

GET /tokens/:token/…

The tape

curl "https://api.famdotfun.com/tokens/$TOKEN/trades?limit=50"
{ "trades": [ {
  "side": "buy",
  "trader": "0x4eecd59c19980022eed08281da990e9c6cde8c8f",
  "recipient": "0xefd700f291e75086d84d62c54564a7def732a035",
  "pair_amount": "3000000000000000",
  "token_amount": "2660096353602991245683756",
  "fee": "30000000000000",
  "price": "1127778697",
  "ts": "2026-09-30T20:51:35.000Z",
  "tx": "0xcf25499f5db67a62ff9a933b05b1082907c19a5e30fa8ab98deecc2ff5df360e"
} ] }

Newest first, 50 by default and at most 500. recipient is the wallet that got the coins. trader is whoever sent the call, which is a router or the factory when the buy went through one, so count wallets by recipient on a buy and by trader on a sell.

Candles

curl "https://api.famdotfun.com/tokens/$TOKEN/candles?interval=1%20hour&limit=48"

interval is one of 1 minute, 5 minutes (the default), 15 minutes, 1 hour, 4 hours, 1 day, with the space written as %20. limit is 288 by default and at most 1000. Each candle is t, open, high, low, close (prices, as above), volume (in the pair) and trades.

Holders

GET /tokens/:token/holders
curl "https://api.famdotfun.com/tokens/$TOKEN/holders?limit=100"

The wallets holding the coin, largest first: address, balance, team (a wallet that bought in a Block Zero team launch) and exempt (a wallet the launch named as skipping the opening tax: on a curve, the launcher and the fee recipient, or one named by calling the contracts directly). exempt does not say the wallet bought anything inside the launch transaction. At most 100 a page, with offset for the next. The curve is left out: before graduation it holds the unsold supply, and counting it would make every coin look like one wallet owns it.

Prices

GET /pairs
curl "https://api.famdotfun.com/pairs"

What a bonding curve coin can be priced in, as { "pairs": [ ... ] }. A direct pool has its own list, GET /pairs/direct, in the same shape; its shares come with usd 0, and GET /pairs/resolve/:address prices one. Each has address, symbol, decimals and usd, the dollar price the site uses. ETH is the zero address. Match a coin's pair_token to address to turn its numbers into dollars.

GET /stats gives the totals for the whole site: launches, graduations, volume, trades and traders.

Where the money goes

GET /bag, /ledger, …

The Bag, Payday, the burn clock and every payout, as the chain recorded them. Dollar figures are at today's prices; the amounts in the pair are exact.

curl "https://api.famdotfun.com/ledger?limit=20"
RouteWhat it answers
GET /bagThe Bag now: per asset what came in, went out and is held, this hour's Payday pot and the last Payday, the burn clock's burns and what waits for $FAM, and this hour's boosts. With every contract's address.
GET /ledgerEvery payout ever made, newest first, each with its transaction: fee flushes and sweeps, buybacks, claims, referral pay. ?token= for one coin; the next page is ?before= the nextBefore of the last one.
GET /fees/flowsAll-time dollar totals by destination: creatorsUsd, holdersUsd, tradersUsd, lockersUsd, burnedUsd, cashbackUsd. gaveBackUsd is their sum, keptUsd what the house kept.
GET /paid?days=1What reached wallets in the last 1 to 90 days, per asset: the amount, the number of payouts and of wallets, split into pushes, Payday and drops.
GET /burnsCoins burned, per coin and the latest burns.
GET /boostsThis hour's boosts: the price, the top and the board, and the same for the next hour.

Pools

GET /lp/…
curl "https://api.famdotfun.com/lp/pools"
RouteWhat it answers
GET /lp/poolsEvery pool that earns liquidity rewards: token, symbol, poolId, pairToken, mode, hook, the v4 key, addUrl (a Uniswap link that opens the deposit), sqrtPriceX96, tick, tvlUsd, eligibleUsd, volume24hUsd. On top: seasoningHours and minPositionUsd, the rules a position must meet.
GET /pool/:idWhether a v4 pool id is a coin's official market: official, the coin, and its known copycats.
GET /lp/:addressA wallet's positions in those pools and its cut so far, cutUsd.

Fams

GET /clans

A fam is a captain and up to 50 other wallets that trade from their own wallets; every week the three best split the prize. The API calls them clans.

curl "https://api.famdotfun.com/clans?period=season"
RouteWhat it answers
GET /clansThis week's board: prize (weekUsd, weekStart, weekEnd), rules (maxMembers, qualifyUsd, placeBps) and clans: tag, name, captain, volumeUsd, active, qualified, place, prizeUsd. ?period=season for the whole season.
GET /clans/:tagOne fam: its members with each one's weekVolumeUsd and weekCutUsd, its week standing, the captain's trades and its flags.

Joining, leaving and the fam's chat need a wallet signature on the site; they are not part of this read API.

Limit orders

GET /limits/:address
WALLET=0x…   # any wallet
curl "https://api.famdotfun.com/limits/$WALLET"
RouteWhat it answers
GET /limits/:addressA wallet's orders, the open ones first, then its last 50 closed: id, token, symbol, side, amountInWei, minOutWei, amountOutWei, expiry, status, placedAt, closedAt, closedTx. ?token= for one coin. limit is the order contract.

Placing and cancelling an order are transactions on the order contract, signed by the wallet.

Outside coins

GET /terminal
curl "https://api.famdotfun.com/terminal"
RouteWhat it answers
GET /terminalThe terminal, which trades coins launched elsewhere for a 1% fee: address, feeBps, legs (how the fee splits, in percent: burn, fam, cashback, house) and totals (trades, traders, volumeUsd, feeUsd).
GET /terminal/cashback/:addressA wallet's cashback: owedWei and owedUsd, what it has claimed, its trades and volume.

One wallet

GET /…/:address
curl "https://api.famdotfun.com/points/$WALLET"
RouteWhat it answers
GET /portfolio/:addressEverything the Portfolio page shows: holdings, launches, locks and what the wallet was paid.
GET /points/:addressThe season so far: points, volumeUsd, rank, multiplier, nextRank, position.
GET /quests/:addressEach quest with progress, done and claimed. GET /quests is the list without a wallet.
GET /leaderboardThe season's board, 100 wallets by default and at most 250 (?limit=).

Live stream

GET /stream

Server-sent events: one connection, and every trade and launch arrives as it is indexed, a few seconds after it lands on chain. Add ?tokens=0xabc…,0xdef… (up to 100) to hear only those coins.

curl -N "https://api.famdotfun.com/stream"
event: trade
data: {"token":"0x82ca…","side":"buy","trader":"0xd2e6…","pairAmount":"3000000000000000",
       "tokenAmount":"2660096353602991245683756","price":"1127778697","tx":"0xcf25…","at":"2026-09-30T20:51:35.000Z"}

From Node, without a library:

const res = await fetch("https://api.famdotfun.com/stream");
const decoder = new TextDecoder();
let buffer = "";
for await (const chunk of res.body) {
  buffer += decoder.decode(chunk, { stream: true });
  let end;
  while ((end = buffer.indexOf("\n\n")) >= 0) {
    const block = buffer.slice(0, end);
    buffer = buffer.slice(end + 2);
    const event = block.match(/^event: (.*)$/m)?.[1];
    const data = block.match(/^data: (.*)$/m)?.[1];
    if (event === "trade") console.log(JSON.parse(data));
  }
}
EventWhat it carries
tradeA buy or sell: token, side, trader, pairAmount, tokenAmount, price, tx, at.
launchA new coin: token, symbol, name, creator, mode, launched_at.
graduatedA coin sold out its curve and moved into its pool.
feeFees moved for a coin.
bagMoney into or out of the Bag, with the token when there is one.
messageA new chat message on a coin.
pingEvery 25 seconds, to keep the connection open.

Limits & errors

per IP
Over the limit429. Every answer carries x-ratelimit-limit, x-ratelimit-remaining and x-ratelimit-reset (seconds).
Unknown coin404 with {"error":"unknown token"}.
Unknown route404 with a docs link back to this page.
Live stream10 open connections per IP.
Is it up?GET /ready answers 200 while the indexer is in step with the chain, and 503 with a reason when it is not.

Polling? Once every few seconds is plenty. For anything live, the stream is cheaper for you and for us.

Straight from the chain

no API needed

Everything the API serves can be read from the contracts on chain 4663, with no key and no agreement. The contracts, their events and their addresses are in the docs: contract events and addresses.

  • A new coin is a Launched event on the factory, or DirectLaunched on the portal.
  • Curve trades are Bought and Sold events on the coin's curve, not DEX swaps.
  • After graduation the coin trades on a Uniswap v4 pool whose liquidity is locked for ever.
  • Coins have no owner and no mint function after launch.

Questions, or need a higher limit? hello@famdotfun.com. updated 30 October 2026, version 8