Real-Time Price-at-Trade Enrichment: Why Spot APIs Lie on Fast Memecoins

Every KOL trade and copy-trade signal MadeOnSol emits carries `market_cap_usd_at_trade` and `price_usd_at_trade` — the market cap and USD price at the exact swap moment, stamped from our in-memory mc-tracker. No round-trip to Dexscreener, no spot-lag drift, no wrong-pool phantom price.

MadeOnSol·May 14, 2026· 8 min read

Real-Time Price-at-Trade Enrichment: Why Spot APIs Lie on Fast Memecoins

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 product on Solana 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.

See Business pricing

Tools mentioned

Compare features and read reviews.

Live health scores, average ratings, and direct links on MadeOnSol.

GetBlock

Multi-chain RPC provider with free and paid Solana nodes — shared and dedicated endpoints for dApps, bots, and analytics

extrnode

Decentralized Solana RPC gateway with auto-failover across a node cluster

Ankr

Decentralized Web3 infrastructure with Solana RPC endpoints

Get this data via API

Stream real-time KOL trades, PnL rankings, and coordination signals programmatically.

New customers try Pro free for 5 days — card, cancel anytime.

Start free

import { MadeOnSol } from "madeonsol";

const client = new MadeOnSol({ apiKey: "msk_your_key" });

// Real-time KOL trades
const { trades } = await client.kol.feed({ limit: 10, action: "buy" });

// KOL convergence signals
const { tokens } = await client.kol.coordination({ min_kols: 3 });

npm install madeonsolFull API docs

Building a product on Solana data?

MadeOnSol isn't an RPC or another generic token API — it's Solana memecoin intelligence that's painful to build in-house, pulled from dual-region gRPC shred streams: sub-second from the on-chain event to your app.

Signals you'd otherwise build

KOL & smart-money flow from 1,000+ labeled wallets, deployer reputation, coordination clusters, linked-wallet entity resolution, and an all-DEX firehose.

Keep reading

More from the blog.

All API Guides

Developer Tools

Copy-Trade Solana KOL Wallets: Build a Paper-Trading Bot in 5 Minutes

Watch live smart-money trades on Solana and paper-trade them in real time: open a virtual position when a tracked KOL buys, close when they sell, and track PnL from the market-cap multiple. This tutorial walks the open-source kol-copytrade-bot-starter — ~300 lines, one dependency, free API key — and shows how to filter by KOL win rate, deployer tier, and multi-KOL confirmation before risking anything real.

4 minJuly 5, 2026

Comparisons

BonkBot vs Trojan: Which Solana Telegram Bot Should You Use in 2026?

BonkBot and Trojan are both Telegram-native Solana trading bots with a ~1% fee, but they're built for different traders. BonkBot keeps it simple and feeds its fees back into BONK buybacks; Trojan piles on copy trading, DCA, and a cashback rewards layer. Here's how they actually compare.

Enjoyed this article?

Explore the live data.

Real-time KOL trades, Pump.fun deployer intel, and 1,200+ ranked Solana tools — free to explore.

Open the KOL Tracker

API reference Start free Browse all articles

Explore more

Top 10 API Platforms Top 10 RPC Deployer Hunter KOL Tracker Compare Yields Solana Glossary

Three specific things this unlocks

1. Fair copy-trade sizing

If a KOL bought at $200K MC and the bot tries to size 1.0 SOL by current $400K MC, the copy is buying half the conviction the source wallet did. market_cap_usd_at_trade lets you scale the entry to the original cap so the position carries the same relative position size to the KOL's exposure.

function adjustedSize(sourceSol: number, mcAtTrade: number, mcNow: number) {
  // If MC has doubled, halve the size — same dollar exposure as the KOL's entry.
  // If MC dropped, increase the size — KOL got a worse entry than you can.
  if (!mcAtTrade || !mcNow) return sourceSol;
  return sourceSol * (mcAtTrade / mcNow);
}

This pattern (already used internally on the proportional copy-trade sizing mode) lets your bot make smarter sizing decisions automatically.

2. Backtest entry MC without rebuilding history

Every historical row in kol_trades carries the MC at the time of the trade. So when you backfill an analysis like "what's the average MC at which scout-tier KOLs first-buy fresh tokens?" you don't have to look up historical pool reserves at the trade timestamp — the number is already in the row.

SELECT
  AVG(market_cap_usd_at_trade) FILTER (WHERE action = 'buy') AS avg_entry_mc,
  PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY market_cap_usd_at_trade) AS median_entry_mc
FROM kol_trades
WHERE wallet_address IN (SELECT wallet_address FROM mv_kol_scout_score WHERE scout_tier = 'S')
  AND traded_at > now() - interval '30 days';

That query runs in the millisecond range on our data because every row is pre-stamped. Doing the same against a generic swap-history dataset means joining each row against a price snapshot, which is the painful part.

3. Cluster-entry classification

The coordination and first-touches endpoints already use this internally: every cluster row carries market_cap_usd_at_first_buy — the cap stamped on the chronologically-first KOL buy in the cluster. Combined with the current cap, a single number tells you whether "8 KOLs coordinated on this token" means they all entered together at $40K MC (alpha cluster) or they piled in after the move started at $1.2M MC (late-stage chase).

curl -H "Authorization: Bearer msk_..." \
  "https://madeonsol.com/api/v1/kol/coordination?period=6h&min_kols=5&min_mc_usd=20000&max_mc_usd=200000"

min_mc_usd and max_mc_usd filter on the entry MC, not the current MC — exactly the band-pass filter that separates real alpha clusters from chase clusters.

What "real-time" actually means here

A small caveat — "real-time" in this context means "computed from the swap stream sub-second of confirmation," not "computed from the mempool." We index from CONFIRMED-commitment swaps (single-confirmation finality) because PROCESSED-commitment swaps occasionally reorg on Solana, and a reorg'd price stamp is worse than a one-second-old one. For the latency-critical sniper edge case where you want pre-confirmation MC, the DEX firehose channel () emits PROCESSED-commitment swaps — but those are intentionally NOT used to enrich fields because they can flip.

What's actually stamped

Look at any row from /api/v1/kol/feed:

{ "wallet_address": "AbCdEf...", "kol_name": "@somealpha", "action": "buy", "token_mint": "4k3Dyj...", "token_symbol": "PEPECAT", "sol_amount": 2.4, "tx_signature": "5xPq...", "traded_at": "2026-05-14T11:42:17.342Z", "market_cap_usd_at_trade": 287_000, "price_usd_at_trade": 0.000287, "token_age_minutes": 8, "kol_winrate_7d": 71.4, ... }

That MC and price are not pulled from a cache when the event is read. They were captured when the kol-tracker ingested the swap, before anything got serialized to Postgres, before the event was published to madeonsol_events. By the time a copy-trade bot receives the signal one second later, the number is already historical truth — it's not going to drift while the bot decides what to do.

Same fields live on every /api/v1/copytrade/signals payload, and the response body of /api/v1/kol/first-touches:

{ "signal_id": 81342, "subscription_id": 12, "fired_at": "2026-05-14T11:42:18.501Z", "source_wallet": "AbCdEf...", "kol_name": "@somealpha", "action": "buy", "token_mint": "4k3Dyj...", "source_sol_amount": 2.4, "suggested_sol_amount": 1.0, "tx_signature": "5xPq...", "traded_at": "2026-05-14T11:42:17.342Z", "market_cap_usd_at_trade": 287_000, "price_usd_at_trade": 0.000287, "market_cap_usd": 312_000, "last_price_usd": 0.000312 }

Two pairs, because both questions matter:

*_at_trade — what was the cap when the KOL fired? Sizes your reaction trade fairly.

market_cap_usd / last_price_usd — what is the current cap by the time you read this? Tells you whether you've already lost the entry.

The delta between them is your copy-trade lag in MC terms. If a signal arrives where market_cap_usd / market_cap_usd_at_trade > 1.4, you're already 40% behind the KOL's fill; act on that, not on a stale price you pulled five seconds ago.

Why mc-tracker beats spot APIs

MadeOnSol runs a dedicated service called mc-tracker that owns canonical token state. Its job in one paragraph: subscribe to the dual-region Kaldera gRPC stream of every swap on 11 Solana DEX programs (pump.fun, PumpSwap, Raydium AMM/CPMM/CLMM, Orca Whirlpool, Meteora DBC/DAMM/DLMM/CPAMM, launchlab/bonk.fun), classify each swap, and update a hot in-memory Map<mint, TokenState> of last-price + 15-minute VWAP + market cap + liquidity. State is written to Postgres in batches every few seconds for persistence, but every read by kol-tracker hits the in-memory layer directly.

So when a KOL swap fires:

Kaldera gRPC → dex-stream classifies the swap → publishes to mc_swaps pg_notify channel.

mc-tracker receives the swap, updates its in-memory price for the affected mint within milliseconds.

kol-tracker observes the same swap via its own gRPC filter, looks up the now-updated MC + price from mc-tracker via local HTTP (port 3007), stamps it onto the trade row.

Row inserts into kol_trades with market_cap_usd_at_trade and price_usd_at_trade populated.

kol:trade event publishes through pg_notify → WS streaming + webhook fan-out.

Total wall-clock between the on-chain swap landing and the enriched event reaching your bot: typically 1.0-1.5 seconds. The price you see was current as of about 1 second before the event arrived — same swap, same pool, no separate API call required. If you want to query that same in-memory state directly for any mint — cap, VWAP, liquidity, volume windows, and the MEV split in one shot — that's exactly what the /v1/token/{mint} endpoint returns.

Now compare a typical Dexscreener-based path:

Your copy-trade bot receives a swap event (from somewhere).

Bot polls Dexscreener /tokens/v1/solana/{mint} for current price.

Dexscreener returns a price that was synced from on-chain pool reserves N seconds ago (N varies; for popular tokens N is often 5-15s on free tier).

Your bot sizes the trade off a number that drifted while you waited for the HTTP response.

The two paths produce visibly different fills on tokens moving fast enough that 5-15 second drift matters — which is most of the interesting memecoin tape.

Endpoint	Carries `*_at_trade`?
`GET /v1/kol/feed`	yes
`GET /v1/kol/first-touches`	yes
`GET /v1/copytrade/signals`	yes
`ws://...stream` channel `kol:trades`	yes
`ws://...stream` channel `copytrade:signals`	yes
Webhook event `copytrade:signal`	yes

Real-Time Price-at-Trade Enrichment: Why Spot APIs Lie on Fast Memecoins

Compare features and read reviews.

GetBlock

extrnode

Ankr

More from the blog.

Copy-Trade Solana KOL Wallets: Build a Paper-Trading Bot in 5 Minutes

BonkBot vs Trojan: Which Solana Telegram Bot Should You Use in 2026?

Explore the live data.

Three specific things this unlocks

1. Fair copy-trade sizing

2. Backtest entry MC without rebuilding history

3. Cluster-entry classification

What "real-time" actually means here

ProxyGate

RPC Fast

Mizar Review 2026: Multi-Chain Copy Trading and DCA Bots — Including Solana

Build a Solana Rug-Check Telegram Bot in 10 Minutes (Free API Key)

Pump.fun Deployer Alerts in Your Discord: Build the Bot in 5 Minutes

White-Label Solana Data: What Redistribution Rights Actually Mean for Your Product (2026)

What's actually stamped

Why mc-tracker beats spot APIs

Tier access

Resources