LAUNCH COHORT / BACKTEST of MANY token launches at once — every token whose
FIRST trade falls inside a launch window (for example all pump.fun launches of
a day), one row per launch: supply, price and FDV at launch, sniper and
first-minutes buying, and the outcome over the following hours — peak price
(the highest hourly average), peak multiple, hours to peak, last price,
drawdown, whether it still traded.
output=summary returns the cohort's distribution instead (quartiles, share
that reached 2x / 5x / 10x, share still trading) in one row. Answers
"backtest yesterday's pump.fun launches", "what share of new tokens did 10x
within 24 hours", "snipers and first-5-minute buying across launches",
"survival of launches after 6 hours", "which of today's launches had the
most buyers in the first minute". For one token or a given list of up to 50
(`addresses`) use token_launch_stats (launch snapshot), for one token's
wallets early_buyers; to list what just launched with its
current price use new_tokens. Prefer this tool over writing SQL for launch
cohorts and launch backtests.
Works for rare and newly-launched tokens.
COHORT: tokens on `blockchain` whose first trade is inside [after_time,
before_time) and that had no USD-priced trade in the `lookback_days` (default
7) before the window. Narrow it with address_pattern, a LIKE pattern on the
token address (`%pump` = pump.fun mints, `%bonk`, `%4444`), and/or protocol,
the DEX of the first trade (pump, pumpfun, pump_amm, raydium_launchpad,
pons_v2, fourmeme_v1, flap_v5, uniswap_v2 …). min_volume_usd (default 1000)
drops launches with less USD volume over the horizon (so far, while it is
still running) — most launches never trade $1,000; 0 keeps all.
min_window_buyers keeps launches with at least that many buying wallets in the
early window. Tokens that never had a USD-priced
trade are left out (almost all of them are dust).
WINDOW: at most 24 hours of launches per call; default = the 6 hours before
before_time (default now). With output=summary and neither after_time nor
before_time, the default window instead ends horizon_hours ago, so every
launch in it has a finished horizon. A longer range keeps its NEWEST 24 hours — read
Launch_Window_Start / Launch_Window_End and call again with before_time =
Launch_Window_Start for the previous day. Trade history reaches back about 30
days, and a launch within lookback_days of its start cannot be told apart
from an older token. Arc trades begin on 2026-09-16, so Arc launches within
lookback_days of that day may be older tokens.
ROW COLUMNS (output=tokens): Token_Address, Token_Symbol, Launch_Time (first
trade), First_Protocol, First_Pool, First_Quote_Symbol, Supply_At_Launch,
Launch_Price_Usd, Launch_Fdv_Usd; sniper window (first sniper_seconds):
First_Block_Buyers, Sniper_Buyers, Sniper_Buy_Usd; early window (first
window_seconds): Window_Trades, Window_Unpriced_Trades, Window_Buyers,
Window_Sellers, Window_Buy_Usd, Window_Sell_Usd, Window_End_Price_Usd,
Window_End_Fdv_Usd, Window_Complete; horizon (horizon_hours): Horizon_End,
Horizon_Complete, Horizon_Volume_Usd, Peak_Price_Usd, Peak_Fdv_Usd,
Peak_Multiple, Hours_To_Peak, Close_Price_Usd, Valuation_Price_Usd,
Valuation_Fdv_Usd, Valuation_Multiple,
Return_From_Window_End_Pct, Drawdown_From_Peak_Pct, Last_Active_Hour,
Traded_In_Last_Horizon_Hour, Supply_Change_Pct; Launch_Window_Start,
Launch_Window_End, Cursor.
READING THE ROWS: Launch_Price_Usd is the first swap worth at least $1 — a
smaller first fill prints a junk price, because on a bonding curve it buys at
the cheapest point the token will ever have (a $0.02 swap taking a tenth of
the supply implies a launch FDV of a few cents, and every multiple divides by
it). Window_End_Price_Usd keeps a $0.01 floor. USD amounts value
each swap at the lower of its two
priced sides, and Window_Unpriced_Trades counts swaps without a price.
First_Block_Buyers = buying wallets that traded at the exact timestamp of the
first trade (on chains with several blocks per second this can include the
next block). The HORIZON is measured on hourly bars that start with the
launch hour: Horizon_End is the top of an hour, so it covers between
horizon_hours − 1 and horizon_hours after the launch. Peak_Price_Usd = the
highest hourly AVERAGE price inside it, each hour weighted by its volume,
counting only hours that carried at least a thousandth of the launch's own
volume: one odd or tiny swap can print an extreme price, high or low, and a
near-empty hour can average one, so neither a bar's high nor its close nor a
trickle hour can set the peak. Peak_Fdv_Usd is that price × the supply at
launch. The peak can therefore sit BELOW Launch_Price_Usd — that one is the
price of the first swap of at least $1 — and Peak_Multiple can be under 1 for
a launch that only fell.
The horizon end has TWO prices and they answer different questions.
Close_Price_Usd = the last hourly close before Horizon_End (the last price if
the token stopped trading earlier): the latest thing known, but ONE swap, so
it can sit far above or below anything real. Valuation_Price_Usd = the average
of the newest hour that carried at least a thousandth of the launch's volume —
the same volume gate as the peak, so it is the last price at which real volume
changed hands, and it can never exceed Peak_Price_Usd. Quote Close_Price_Usd
as "the last print" and Valuation_Price_Usd as what the launch is worth. The
two are far apart when the last swap was junk — and also when the launch
STOPPED TRADING after its last real hour, which on a bonding curve leaves
Valuation_Price_Usd above Launch_Price_Usd for a launch that is already dead:
Traded_In_Last_Horizon_Hour and Drawdown_From_Peak_Pct say which of the two
it is, and both read the close.
Drawdown_From_Peak_Pct = Close_Price_Usd against Peak_Price_Usd, never above 0
and 0 for a launch that ends at or above its peak hour: it shows a collapse
inside the peak hour and a launch that died after it, both of which a
hour-against-hour comparison reads as 0. Hours_To_Peak = whole
hours from the launch hour to the peak hour (0 = the launch hour; the earliest
hour when several hours reach the peak).
Peak_Multiple and Valuation_Multiple divide by Launch_Price_Usd;
Return_From_Window_End_Pct = buying at Window_End_Price_Usd and selling at
the end of the horizon. Valuation_Fdv_Usd, Valuation_Multiple and
Return_From_Window_End_Pct are all measured at Valuation_Price_Usd, NOT at
Close_Price_Usd — a single closing swap made launches report an 80-million
FDV on a few thousand dollars of trading, and a close multiple above the peak
multiple. Close_Price_Usd × the supply is therefore not Valuation_Fdv_Usd, and
Valuation_Multiple cannot exceed Peak_Multiple any more.
FDV = price × total supply — the supply at launch, except
Valuation_Fdv_Usd, which uses the latest supply (NULL when the supply is unknown);
Supply_Change_Pct below 0 = supply burned. Window_Complete = 0 or
Horizon_Complete = 0 means that period has not elapsed yet and its figures are
still moving.
SUMMARY (output=summary): one row per group_by value (none = whole cohort,
protocol = DEX of the first trade, hour = launch hour) with Tokens,
Tokens_Horizon_Complete, totals, [p25, p50, p75, p90] arrays for window buy
USD, window buyers, sniper buyers and buy USD, first-block buyers, launch FDV,
peak FDV, peak and valuation multiples and return from window end,
Hours_To_Peak_Q = [p50, p90], and Pct_Peak_2x / 5x / 10x,
Pct_Valuation_At_Or_Above_Launch, Pct_Up_From_Window_End (both measured at
Valuation_Price_Usd, like the row columns they come from),
Pct_Down_90_From_Peak,
Pct_Traded_In_Last_Horizon_Hour. NEITHER SHARE IS A PROFIT RATE: almost every
launch has stopped trading by the end of a day-long horizon (on one measured
cohort Pct_Traded_In_Last_Horizon_Hour was 4.1 %), so a launch counted at or
above its launch price is usually one that went quiet holding the valuation
of its last real hour, not one you could still have sold into. Quote
Pct_Traded_In_Last_Horizon_Hour beside them, and Pct_Down_90_From_Peak — which
reads the last close — for how far the latest prints have fallen.
Outcome figures count only tokens whose
horizon has elapsed (NULL or [] while none has): the default summary window
already ended horizon_hours ago; an explicit window should end at least
horizon_hours ago too.
An empty result means no launch matched.
PAGING: sort=newest (default, newest launch first) pages with cursor — pass
the last row's Cursor and repeat every other argument, with after_time and
before_time set to the Launch_Window_Start / Launch_Window_End of the first
page. Other sorts (window_buy_usd, window_buyers, peak_multiple,
horizon_volume) return only the top `limit` launches, with an empty Cursor.
A call reads every launch of its window whatever the limit: for a
distribution use output=summary instead of paging through thousands of rows.
Follow launches up with token_launch_stats (one token, or a given list of
up to 50 in `addresses`), early_buyers or token_trade_bars.
Symbols longer than 32 characters are cut and end in `…` (spam tokens carry
symbols of up to 32,000 characters).