live on Robinhood Chain · chain id 4663

Everything on pons, one call away.

Market caps, creator fees, holders, trade history and live launches — read straight from the contracts and handed to you as JSON. No ABIs to wire up, no logs to decode, no Uniswap V3 maths to get wrong.

connecting
PONS price···
Market cap···
Chain head···
Chain id4663
indexing Robinhood Chain…streaming launches…warming caches…
···
Tokens indexed
···
Launches · 24h
···
Creators
···
Graduated
Why it exists

A market cap costs six contract reads.

Everything on pons is onchain and public, which is not the same as being easy to read. Getting one number out means finding the pool, undoing a fixed-point square root, checking which side of the pair you are on, subtracting what was burned, and fetching an ETH price from somewhere else entirely. ponsapi does that on every request so you never write it again.

Reading it yourself
viem · ~35 lines
import { createPublicClient, http, erc20Abi } from "viem";

const rpc = createPublicClient({ transport: http(RPC_URL) });

// 1. find the pool the launch created
const pool = await rpc.readContract({
  address: token, abi: tokenAbi, functionName: "liquidityPool",
});

// 2. read the price as a Q64.96 fixed-point square root
const [sqrtPriceX96] = await rpc.readContract({
  address: pool, abi: poolAbi, functionName: "slot0",
});

// 3. figure out which side of the pair the token is on
const token0 = await rpc.readContract({
  address: pool, abi: poolAbi, functionName: "token0",
});

// 4. undo the square root, mind the orientation and the decimals
const ratio = (Number(sqrtPriceX96) / 2 ** 96) ** 2;
const priceEth =
  token.toLowerCase() === token0.toLowerCase() ? ratio : 1 / ratio;

// 5. circulating supply is total minus whatever was burned
const [supply, burned] = await Promise.all([
  rpc.readContract({ address: token, abi: erc20Abi, functionName: "totalSupply" }),
  rpc.readContract({
    address: token, abi: erc20Abi, functionName: "balanceOf",
    args: ["0x000000000000000000000000000000000000dEaD"],
  }),
]);

// 6. and an ETH price, which is not on this chain at all
const ethUsd = await fetch(SOME_PRICE_FEED).then((r) => r.json());

const mcapUsd = (Number(supply - burned) / 1e18) * priceEth * ethUsd;
The same number, through ponsapi
3 lines
const { priceUsd, mcapUsd, fdvUsd } = await fetch(
  "https://api.ponsapi.dev/v1/tokens/0x39dBED3a2bd333467115dE45665cC57F813C4571/price",
).then((r) => r.json());
One call each, same story
Market cap & FDV/v1/tokens/{token}/price
instead of: Pool discovery, sqrtPriceX96 decoding, token0 orientation, burned supply, ETH price.
Pending creator fees/v1/tokens/{token}/fees
instead of: Uncollected V3 position fees: feeGrowthInside across both ticks, tokensOwed, split by the creator share.
Holder distribution/v1/tokens/{token}/holders
instead of: Every Transfer log since the launch block, replayed into balances and sorted.
Trade history/v1/tokens/{token}/trades
instead of: Swap events across chunked eth_getLogs ranges, decoded into sides and amounts, cursor paged.
Graduation progress/v1/tokens/{token}
instead of: Paired principal against the launch config threshold, plus the factory metadata around it.
Live launches and tradeswss://…/v1/ws
instead of: Two factories, every pool you care about, one socket instead of a polling loop.
What you get

Four APIs. One key.

Data API

Prices and market caps, decoded

Pool discovery, sqrtPriceX96 maths, token0 orientation, burned supply and the ETH conversion all happen server-side. You get numbers.

/v1/tokens/v1/tokens/{t}/price/v1/tokens/{t}
Fees & holders

The numbers nobody wants to compute

Exact uncollected creator fees straight out of the locked V3 position, and holder balances replayed from every Transfer since the launch block.

/v1/tokens/{t}/fees/v1/tokens/{t}/holders/v1/tokens/{t}/trades
WebSocket

Launches and trades, live

Every launch on both factories, trades on the tokens you watch, trades by the wallets you follow. One socket, no polling loop, no log decoding.

subscribeNewTokensubscribeTokenTradesubscribeAccountTrade
Trade API

Transactions, already built

Quotes through Quoter V2 and unsigned transactions for buys, sells, launches and fee claims. Sign and send with your own wallet — or let a lightning wallet do it.

/v1/trade/quote/v1/trade/build/v1/wallets/{id}/trade
Copy, paste, ship

Two calls to your first launch feed.

One public call · no key needed
curl -s https://api.ponsapi.dev/v1/tokens/0x39dBED3a2bd333467115dE45665cC57F813C4571/price
WebSocket · live launches and trades
const ws = new WebSocket("wss://api.ponsapi.dev/v1/ws?api-key=" + process.env.PONS_KEY);

ws.onopen = () => {
  ws.send(JSON.stringify({ method: "subscribeNewToken" }));
  ws.send(JSON.stringify({
    method: "subscribeTokenTrade",
    keys: ["0x39dBED3a2bd333467115dE45665cC57F813C4571"],
  }));
};

ws.onmessage = (raw) => {
  const msg = JSON.parse(raw.data);
  if (msg.event === "tokenTrade") {
    console.log(msg.data.side, msg.data.amountEth, "ETH", msg.data.token);
  }
  if (msg.event === "newToken") console.log("launched:", msg.data.token);
};
How it works

From zero to streaming in a minute.

1Point

Take any pons token address

Anything launched through either factory. Nothing to register, nothing to index on your side first.

2Read

Ask for what you need

Price, market cap, graduation, holders, trade history, pending creator fees. One endpoint each, JSON out.

3Stream

Subscribe to what moves

New launches, trades on a token, trades by a wallet — pushed to you the moment they land onchain.

4Trade

Act on it

Get an unsigned transaction back, sign it with your own wallet, or hand it to a lightning wallet and let the API execute.

Built with ponsapi

What people ship on it.

Sniper bots

subscribeNewToken fires the moment a launch lands. Quote, build, sign, send — or hand it to a lightning wallet and skip the plumbing.

Launch tools

Build the launchToken transaction, track graduation progress and claim creator fees for the tokens you deploy.

Trading terminals

Price, market cap, FDV, holders and full trade history with cursor pagination. Everything a chart and an order ticket need.

Telegram + Discord alerts

Follow wallets with subscribeAccountTrade and post the moment a whale moves. One socket covers your whole watchlist.

Creator dashboards

Exact uncollected fees from the locked V3 position, split by the token's snapshotted creator share. No estimates.

Analytics and research

Holder distributions rebuilt from Transfer logs, volume, graduation stats — the whole chain, already indexed.

The token

$PONSAPI is the API key.

No subscriptions, no seats, no per-event metering. Hold 1 $PONSAPI and every endpoint and stream stays open. Sell, and the key parks itself until you're back above the line. The 0.25% we take on API-built trades doesn't go to a bank account — it buys $PONSAPI back on the open market.

Devs build
Bots and apps route their trades through the API.
0.25% fee
Charged on trades built or executed by ponsapi.
Buybacks
Fees are spent buying $PONSAPI back. More usage, more bid.
$PONSAPI launching soon — contract drops hereHow access works
Pricing

Free data. 0.25% when you trade.

Per trade / per streamponsapiTypical third-party API
Unsigned transaction building0.25%0.5%
Server-side (lightning) execution0.25%1%
Launch and trade streamsFreeMetered per 10k events
Data, history, holders, feesFreeMetered or gated
AccessHold 1 $PONSAPIFunded wallet + key
FAQ

Straight answers.

What do I need to start?+
A wallet holding 1 $PONSAPI on Robinhood Chain. Sign a message with it and you get an API key. That's the entire onboarding.
What does it cost?+
Data, history and every WebSocket stream are free — no per-event metering. Trades built or executed through the API carry a 0.25% fee, and that fee goes into buying $PONSAPI back on the open market.
Is it custodial?+
Not by default. The Trade API returns an unsigned transaction you sign and broadcast yourself. Lightning wallets are opt-in for bots that need server-side execution; their keys are encrypted at rest and you can withdraw at any time.
What if I sell my tokens?+
Keys are re-checked periodically. Drop below 1 $PONSAPI and the key suspends until you top back up — nothing is deleted, and it reactivates on the next check.
What are the rate limits?+
10 requests per second per key, 2 WebSocket connections and 25 subscriptions. Historical backfill is bounded per request and keeps advancing a cursor, so a cold token warms up over a few calls.
Which chain is this?+
Robinhood Chain, chain id 4663. ponsapi indexes every token launched through pons on both factories.

Start building on pons.

The first call needs no key at all — prices are public. When you want the rest, a wallet signature gets you one.