Learn how to build a Solana token analytics dashboard that combines real-time price feeds, holder data, trading volume, and liquidity metrics into a single view using TypeScript and the MadeOnSol API.
Disclosure: This article contains affiliate links. If you sign up through them, MadeOnSol may earn a commission at no extra cost to you. This never affects our rankings, ratings, or reviews.
Building a token analytics dashboard is one of the most practical projects for anyone working in the Solana ecosystem. Traders want a unified view of price action, holder distribution, volume trends, and liquidity depth before making decisions. Developers building trading bots or portfolio trackers need the same data in a structured format.
This tutorial walks through building a Solana token analytics dashboard from scratch. You will pull data from multiple sources, normalize it, and render it in a single dashboard view. By the end, you will have a working TypeScript application that fetches and displays comprehensive token metrics.
Platforms like Birdeye and DexScreener provide excellent analytics UIs, but they serve a general audience. A custom dashboard lets you:
If you are building any kind of Solana trading tool, a token analytics layer is foundational. For a broader look at available data providers, see our guide on the best Solana API providers. And if you're still getting oriented on the categories — RPC versus enhanced versus data APIs — our primer on what a Solana API actually is lays out which type each metric below comes from. If you would rather track your own holdings than build per-token analytics, an off-the-shelf option like the one covered in our CoinStats portfolio-tracking review handles DeFi position detection across chains out of the box.
The dashboard pulls four categories of data:
| Data type | Source | Update frequency |
|---|---|---|
| Price feed | MadeOnSol API / on-chain | Real-time or polling |
| Holder data | MadeOnSol /tokens/{mint}/holders (PRO) | Every 1-5 minutes |
| Trading volume | MadeOnSol DEX stream | Real-time via WebSocket |
| Liquidity | DexScreener or on-chain pools | Every 1-5 minutes |
The application is a Node.js backend that aggregates these feeds and exposes a normalized JSON endpoint. You can connect any frontend framework to consume it.
Building a product on Solana or Robinhood Chain data?
Skip the Geyser pipeline — embed KOL flow, deployer reputation, and the all-DEX firehose over REST, WebSocket, or webhooks. The Business tier (€400/mo) is the self-serve embed license at 500k calls/day — Enterprise adds white-label & redistribution.
Tools mentioned
Live health scores, average ratings, and direct links on MadeOnSol.
Unified crypto API covering 120+ blockchains, 200+ exchanges, and 10,000+ DeFi protocols with wallet, market, and portfolio data
World's largest API marketplace — find, test, and connect to thousands of APIs
Solana validator with 0% fee, MEV, and Jito integration
Anti-snipe human-only token launchpad on Solana with Raydium integration
First-party oracle network (EVM-first; Solana access via Neon EVM)
Access Solana DeFi data via API
KOL trading intelligence, DEX trade streaming, and deployer analytics. Free tier: 200 requests/day.
from madeonsol_x402 import MadeOnSolClient
client = MadeOnSolClient(api_key="msk_your_key")
# KOL convergence signals — what are whales accumulating?
signals = client.kol_coordination(period="24h", min_kols=3)
# KOL PnL leaderboard
leaders = client.kol_leaderboard(period="7d")Building a product on Solana or Robinhood Chain data?
MadeOnSol isn't an RPC or another generic token API — it's Solana & Robinhood Chain memecoin intelligence that's painful to build in-house, pulled from dual-region gRPC shred streams and our own Robinhood Chain node, pushed to your app as events land.
Signals you'd otherwise build
KOL & smart-money flow from 2,000+ labeled wallets, deployer reputation, coordination clusters, linked-wallet entity resolution, and an all-DEX firehose.
Embed it in your product
The Business tier (€400/mo, self-serve) licenses you to display MadeOnSol data inside your own product — 500k calls/day, 15 WS + 6 firehose connections. Enterprise above adds white-label & redistribution rights and custom endpoints.
Evaluate first, commit later
Test everything on a free ULTRA key — no commitment. If it fits, we scope volume or white-label pricing.
Keep reading
Developer Tools
Learn how to set up Solana webhooks for real-time blockchain alerts. Compare Helius, QuickNode, Shyft, and Triton webhook providers, with TypeScript code examples for wallet monitoring, NFT sales alerts, and payment confirmation.
Developer Tools
Learn how to track Solana program activity by monitoring program IDs, decoding instructions with Anchor IDLs, parsing custom events, and following CPI chains. Covers real use cases like DEX monitoring and pool creation detection.
Developer Tools
Build a Solana DEX trade monitor on MadeOnSol's filtered WebSocket firehose. Covers the current permanent stream-token flow, 14 decoded programs across 8 venues, named subscriptions, replay, and production reconnects.
Developer Tools
Understand what Solana APIs are, what types exist, and how developers use them to build trading bots, portfolio trackers, and analytics dashboards. Covers RPC, enhanced APIs, data APIs, and when to use each.
Developer Tools
If your Solana data API ships an OpenAPI spec, you can skip writing fetch wrappers entirely. Here's how to codegen a fully typed TypeScript client — with typed routes and parameters, explicit quota handling, and a reproducible contract update workflow.
Developer Tools
Solana stores everything in accounts. This guide explains the Solana account model, account structure (lamports, data, owner), program accounts, PDAs, token accounts, and how to read and deserialize account data with practical TypeScript examples.
Enjoyed this article?
Real-time KOL trades, Pump.fun deployer intel, and 1,200+ ranked Solana & Robinhood Chain tools — free to explore.
Open the KOL TrackerInstall the dependencies:
npm init -y
npm install @solana/web3.js axios ws dotenv
npm install -D typescript @types/node @types/ws tsx
Create a src/types.ts file to define the core data structures for your dashboard:
export interface TokenMetrics {
mint: string;
symbol: string;
name: string;
price: PriceData;
holders: HolderData;
volume: VolumeData;
liquidity: LiquidityData;
lastUpdated: number;
}
export interface PriceData {
current: number;
change24h: number;
high24h: number;
low24h: number;
}
export interface HolderData {
total: number;
top10Percentage: number;
top10Holders: { address: string; balance: number; percentage: number }[];
}
export interface VolumeData {
volume24h: number;
buyVolume24h: number;
sellVolume24h: number;
tradeCount24h: number;
}
export interface LiquidityData {
totalUsd: number;
pools: { dex: string; pairAddress: string; liquidityUsd: number }[];
}
The MadeOnSol API provides token price data with a single call. This avoids the complexity of parsing on-chain pool state yourself.
import axios from "axios";
import type { PriceData } from "./types";
const MADEONSOL_API = "https://madeonsol.com/api/v1";
const API_KEY = process.env.MADEONSOL_API_KEY!;
export async function fetchPrice(mint: string): Promise<PriceData> {
const { data } = await axios.get(`${MADEONSOL_API}/tokens/${mint}/price`, {
headers: { Authorization: `Bearer ${API_KEY}` },
});
return {
current: data.priceUsd,
change24h: data.priceChange24h,
high24h: data.high24h,
low24h: data.low24h,
};
}
For real-time price updates without polling, you can connect to the MadeOnSol WebSocket DEX stream and calculate price from incoming trades. See How to Stream Solana DEX Trades with WebSockets for the full setup.
Holder data tells you how concentrated ownership is. A token where the top 10 wallets hold 90% of supply carries different risk than one with broad distribution. The MadeOnSol API exposes this directly: GET /api/v1/tokens/{mint}/holders (PRO) runs a live, full holder census of the mint at read time and returns the exact holder_count, the top holders (merged per owner, with pool / bonding-curve / burn accounts already excluded and named), and a concentration block with top10_share, top20_share, deployer_pct, kol_pct, bundle_pct and more. No RPC plumbing on your side:
import type { HolderData } from "./types";
export async function fetchHolders(mint: string): Promise<HolderData> {
const { data } = await axios.get(`${MADEONSOL_API}/tokens/${mint}/holders`, {
headers: { Authorization: `Bearer ${API_KEY}` },
});
// holders[] is ranked, already merged per owner, pools/curves/burns excluded.
// concentration.holder_count is exact from the census (null only when the
// provider refuses the census for a mega-cap and the endpoint falls back to top-20).
const top10 = data.holders.slice(0, 10);
return {
total: data.concentration.holder_count ?? data.concentration.token_accounts_nonzero,
top10Percentage: data.concentration.top10_share,
top10Holders: top10.map((h: { owner: string; amount: number; pct_of_circulating: number }) => ({
address: h.owner,
balance: h.amount,
percentage: h.pct_of_circulating,
})),
};
}
Each holder row also carries labels (deployer, kol, early_buyer, bundle, dump_cluster) so you can flag risky concentration without a second lookup. The response is cached per mint for a short window, so polling every minute is fine.
For a deeper dive into indexing options if you also want raw token-account access, check out the best Solana data indexers.
Volume is best tracked in real-time. The MadeOnSol DEX firehose (wss://madeonsol.com/ws/v1/dex-stream, ULTRA/BUSINESS) provides parsed trades across 14 Solana program IDs spanning 8 venues. Authenticate with the permanent stream token returned by POST /api/v1/stream/token, then send a subscribe message with at least one targeting filter (here, token_mint). In server-side clients, prefer Authorization: Bearer <stream-token>; the query-string form remains supported. Trades arrive with sol_amount and action; multiply by your cached SOL price if you want USD. Here is how to accumulate volume over a rolling 24-hour window:
import WebSocket from "ws";
import type { VolumeData } from "./types";
interface Trade {
timestamp: number;
volumeSol: number;
side: "buy" | "sell";
}
const tradeHistory: Map<string, Trade[]> = new Map();
async function getStreamToken(): Promise<string> {
const { data } = await axios.post(`${MADEONSOL_API}/stream/token`, null, {
headers: { Authorization: `Bearer ${API_KEY}` },
});
return data.token; // does not expire; the same token comes back on every call
}
export async function startVolumeTracker(mint: string): Promise<void> {
const token = await getStreamToken();
const ws = new WebSocket("wss://madeonsol.com/ws/v1/dex-stream", {
headers: { Authorization: `Bearer ${token}` },
});
ws.on("open", () => {
ws.send(JSON.stringify({
type: "subscribe",
sub_id: `vol-${mint.slice(0, 6)}`,
filters: { token_mint: mint },
}));
});
ws.on("message", (raw: Buffer) => {
const msg = JSON.parse(raw.toString());
if (msg.channel !== "dex:trades") return; // ignore acks / replay / control frames
const trade = msg.data;
const trades = tradeHistory.get(mint) || [];
trades.push({
timestamp: Date.now(),
volumeSol: trade.sol_amount,
side: trade.action,
});
tradeHistory.set(mint, trades);
});
ws.on("close", () => {
setTimeout(() => startVolumeTracker(mint), 3000);
});
}
export function getVolume(mint: string): VolumeData {
const cutoff = Date.now() - 24 * 60 * 60 * 1000;
const trades = (tradeHistory.get(mint) || []).filter(
(t) => t.timestamp > cutoff
);
return {
volume24h: trades.reduce((sum, t) => sum + t.volumeSol, 0),
buyVolume24h: trades
.filter((t) => t.side === "buy")
.reduce((sum, t) => sum + t.volumeSol, 0),
sellVolume24h: trades
.filter((t) => t.side === "sell")
.reduce((sum, t) => sum + t.volumeSol, 0),
tradeCount24h: trades.length,
};
}
Periodically prune entries older than 24 hours to keep memory usage stable. The volume figures above are SOL-denominated; convert with a cached SOL/USD price if your UI expects dollars.
Liquidity depth determines how much slippage a trade will experience. DexScreener provides a convenient API for pool-level liquidity data:
import type { LiquidityData } from "./types";
export async function fetchLiquidity(mint: string): Promise<LiquidityData> {
const { data } = await axios.get(
`https://api.dexscreener.com/latest/dex/tokens/${mint}`
);
const pools = (data.pairs || []).map(
(pair: { dexId: string; pairAddress: string; liquidity: { usd: number } }) => ({
dex: pair.dexId,
pairAddress: pair.pairAddress,
liquidityUsd: pair.liquidity?.usd || 0,
})
);
return {
totalUsd: pools.reduce(
(sum: number, p: { liquidityUsd: number }) => sum + p.liquidityUsd,
0
),
pools: pools.slice(0, 10),
};
}
Now tie everything together in a single aggregator that returns the full TokenMetrics object:
import type { TokenMetrics } from "./types";
import { fetchPrice } from "./price";
import { fetchHolders } from "./holders";
import { getVolume } from "./volume";
import { fetchLiquidity } from "./liquidity";
export async function getTokenMetrics(
mint: string,
symbol: string,
name: string
): Promise<TokenMetrics> {
const [price, holders, liquidity] = await Promise.all([
fetchPrice(mint),
fetchHolders(mint),
fetchLiquidity(mint),
]);
const volume = getVolume(mint);
return {
mint,
symbol,
name,
price,
holders,
volume,
liquidity,
lastUpdated: Date.now(),
};
}
You can serve this from an Express or Fastify endpoint, or call it from a Next.js API route. The Promise.all call ensures price, holder, and liquidity data fetch in parallel, keeping latency low.
Fetching all four data sources on every request is wasteful and will hit rate limits quickly. Add a simple in-memory cache with per-source TTLs:
const cache = new Map<string, { data: unknown; expiry: number }>();
function getCached<T>(key: string): T | null {
const entry = cache.get(key);
if (!entry || Date.now() > entry.expiry) return null;
return entry.data as T;
}
function setCache(key: string, data: unknown, ttlMs: number): void {
cache.set(key, { data, expiry: Date.now() + ttlMs });
}
Recommended TTLs: price data at 10 seconds, holder data at 5 minutes, liquidity at 60 seconds. Volume is already tracked in memory via the WebSocket stream, so it needs no cache.
Production dashboards need to handle failures gracefully. Each data source can fail independently, so never let one source block the entire response:
async function safeFetch<T>(
fn: () => Promise<T>,
fallback: T,
label: string
): Promise<T> {
try {
return await fn();
} catch (err) {
console.error(`[${label}] fetch failed:`, err);
return fallback;
}
}
Wrap each data fetcher in safeFetch so the dashboard returns partial data rather than a 500 error when one provider is down.
For the WebSocket volume tracker, the reconnection logic in Step 4 handles disconnections automatically. In production, add exponential backoff and a maximum retry count.
Once the core metrics are in place, consider these additions:
It depends on which metrics matter most. The MadeOnSol API covers price feeds, live holder distribution (/tokens/{mint}/holders — exact holder count plus top holders and concentration from a full census), and real-time DEX trade streaming across all major Solana programs. DexScreener provides reliable liquidity and pair-level data. For most dashboards, combining these two sources gives you complete coverage without redundancy.
The most efficient approach is subscribing to a DEX trade WebSocket stream and computing price from incoming trades. MadeOnSol provides a filtered WebSocket feed that covers Raydium, Jupiter, Orca, Pump.fun, and other Solana DEXs. Each trade event includes the SOL amount, token amount and the pool-perspective executed_price_sol for that swap, so you can derive the latest price from the most recent trade. This eliminates polling entirely and gives you sub-second price updates.
Holder data changes much slower than price or volume, so refreshing every 1 to 5 minutes is plenty for most use cases. The MadeOnSol holders endpoint runs a full census at read time and caches the result per mint for a short window, so polling faster than that just returns the cached snapshot. If you need near-real-time holder tracking, consider subscribing to token account changes via Solana gRPC streams rather than polling the full holder list repeatedly.
Partly. DexScreener's token endpoint is publicly accessible, and the MadeOnSol free tier (200 calls/day, 60/min burst) covers price lookups while you build. The holders endpoint is PRO ($49/mo) and the DEX firehose is ULTRA ($149/mo), so a production dashboard with live holder concentration and streaming volume needs a paid MadeOnSol plan. The main limitation on the free tier is the daily quota, which matters once you are tracking more than a handful of tokens or need sub-minute refresh intervals.
The dashboard's DEX example now uses the permanent stream-token lifecycle introduced in August: no 24-hour expiry/refresh timer, Authorization-header auth for server clients, and ULTRA/BUSINESS firehose access. The stream is described as 14 program IDs across 8 venues, and token_refresh is no longer presented as a routine control frame; it is only relevant to an explicit credential rotation.
Sources: streaming reference, API reference, and the stream-token reconnect guide.