Python functions: searchJupiterTokens(), screenJupiterTokens(), getJupiterOHLCV(), getJupiterPrice(), getJupiterHoldings(), getJupiterTokenTrades(), getJupiterTokenHolders(), getJupiterWalletTrades(), screenJupiterWallets(), getJupiterTokenTopTraders()
| Specification | Value |
|---|
| Delivery Frequency | continuous, real-time (24/7 on-chain markets) |
| Data Frequency | event-driven (swaps), bar-aggregated (OHLCV), live snapshot (prices, holdings) |
| Coverage | All Jupiter-tradeable Solana tokens — verified tokens, tokenized equities (xStocks), pre-IPO tokens, LSTs, meme coins |
| OHLCV Timeframes | daily, hourly, minute |
| Availability | Free |
Product Overview
Overview
Jupiter Data provides comprehensive access to the Solana token universe through Jupiter, Solana’s dominant DEX aggregator. The dataset spans ten functions covering token discovery, price history, live pricing, wallet holdings, trade tape, holder analysis, and trader leaderboards.
Because everything on Solana is public on-chain data, this dataset goes far beyond price feeds: you can inspect any wallet’s holdings and swap history, see who is buying or selling a token right now, and rank traders by realized PnL — no authentication needed. That is the raw material for copy-trading, whale-watching, and flow-driven strategies that are impossible to build on centralized-exchange data.
The universe includes a distinctive asset class: tokenized equities and pre-IPO tokens (xStocks like tokenized AAPL and NVDA, and pre-IPO tokens for SpaceX, OpenAI, Anthropic, Anduril). These trade 24/7 on-chain, giving price discovery for hours when traditional markets are closed — and for companies that are not publicly listed at all.
Functions at a Glance
| Function | Purpose | Example strategy use |
|---|
searchJupiterTokens() | Search tokens by name, symbol, or mint | Resolve “anthropic” to its tradeable J: ticker |
screenJupiterTokens() | Discover tokens by trending/volume/organic-score category | Universe selection for momentum or new-listing strategies |
getJupiterOHLCV() | OHLCV candles (daily, hourly, minute) | Backtesting, trend signals, 24/7 gap analysis vs NYSE hours |
getJupiterPrice() | Live prices with 24h change and liquidity | Entry checks and liquidity screens before execution |
getJupiterHoldings() | Token balances for any Solana wallet | Copy-trading: what is a profitable wallet holding? |
getJupiterTokenTrades() | Recent swaps for a token, with trading wallets | Flow analysis: who is accumulating right now? |
getJupiterTokenHolders() | Top holders of a token | Concentration risk screens before entering a position |
getJupiterWalletTrades() | Swap history for any wallet | Auditing a trader’s style and edge before mirroring |
screenJupiterWallets() | Trader PnL leaderboard | Finding wallets worth copying in the first place |
getJupiterTokenTopTraders() | Most active wallets in a token by volume | Spotting whales and bundlers dominating a token’s flow |
Data Sources
Data flows through the Scalar Field data server, which proxies two upstream sources:
- Jupiter APIs (Price v3, Tokens v2, Ultra): live aggregated prices, 24h stats, liquidity, token metadata, verification status, organic scores, and wallet balances. Jupiter aggregates liquidity across all major Solana DEXes (Raydium, Orca/Whirlpool, Meteora, and more), so prices reflect the whole on-chain market rather than a single pool.
- Birdeye (Solana DeFi analytics): OHLCV candles aggregated from on-chain swaps per token mint, token trade tape with trading wallets, top holders, per-wallet swap history, top traders, and the trader PnL leaderboard.
Wallet holdings and swaps are public on-chain data — any address works, no authentication needed.
Ticker Convention
Jupiter tokens use the J: namespace prefix, consistent with other Scalar Field asset classes (H: Hyperliquid, X: crypto, I: indices, C: forex). The canonical (and only) form is J:<mint_address>:
| Ticker | Token |
|---|
J:DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263 | BONK |
J:<mint> from searchJupiterTokens("anthropic") | Pre-IPO Anthropic token |
J:<mint> from searchJupiterTokens("AAPL") | Tokenized Apple (xStock) |
searchJupiterTokens() or screenJupiterTokens(). Bare mint addresses are also accepted as input.
J: tickers also work directly with the cross-asset functions getOHLCV() and getLatestPrice(), and with venue.trade() on the WALLET_SOL (Jupiter) venue — so a signal built here can be executed without ticker translation. See Trading on Jupiter DEX for order semantics and connection steps, and Strategies for the automation framework.
Querying the Data
searchJupiterTokens()
Search for verified tokens tradeable on Jupiter DEX by name, symbol, or mint address. This is the entry point of every Jupiter workflow — it resolves a human-readable name to the canonical J: ticker used by every other function.
Strategy angle: the resolver step of any strategy. A pre-IPO exposure strategy starts with searchJupiterTokens("spacex"); a pairs trade between tokenized and real equities starts by resolving the xStock mint for "AAPL".
from scalarlib import searchJupiterTokens
# Pre-IPO tokens
df = searchJupiterTokens("anthropic")
ticker = df.iloc[0]['ticker'] # 'J:Pren1FvF...'
df = searchJupiterTokens("openai")
# Meme/utility tokens
df = searchJupiterTokens("bonk")
# Lookup by mint address
df = searchJupiterTokens("DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263")
# Use with other functions
data = getJupiterOHLCV(tokens=[ticker], start='2026-06-01')
Parameters
| Parameter | Type | Required | Description |
|---|
query | str | Yes | Search string: token name, symbol, or mint address. |
limit | int | No | Maximum results (default 20). |
Return Schema
| Column | Type | Description |
|---|
ticker | string | Canonical J:-prefixed ticker — pass to all other functions and venue.trade() |
mint_address | string | Solana mint address |
symbol | string | Token symbol |
name | string | Token name |
decimals | int | Token decimals |
price | float | Live USD price |
mcap | float | Market capitalization (USD) |
volume_24h | float | 24h buy + sell volume (USD) |
liquidity | float | Total USD liquidity across pools |
holder_count | int | Number of holders |
screenJupiterTokens()
Discover tokens by market-activity category (trending, most traded, highest organic score, recently listed) or by tag (verified, liquid staking tokens). Rankings come from the Jupiter Tokens v2 API.
Strategy angle: universe selection for flow-driven strategies. A momentum strategy screens toptraded over the last hour; a new-listing strategy watches recent with liquidity filters to catch tokens early while avoiding illiquid traps; the organic_score (0–100 real-activity score) helps filter wash-traded tokens out of any universe.
from scalarlib import screenJupiterTokens
# Trending tokens right now
df = screenJupiterTokens()
# Highest volume over the last hour
df = screenJupiterTokens(category='toptraded', interval='1h')
# Liquid, verified tokens by organic score
df = screenJupiterTokens(category='toporganicscore',
min_liquidity=1_000_000, verified_only=True)
# Recently listed tokens
df = screenJupiterTokens(category='recent')
# All liquid staking tokens
df = screenJupiterTokens(tag='lst')
Parameters
| Parameter | Type | Required | Description |
|---|
category | str | No | 'toptrending' (default), 'toptraded', 'toporganicscore', 'recent'. |
interval | str | No | Ranking window: '5m', '1h', '6h', '24h' (default). Ignored for 'recent'. |
tag | str | No | List by tag instead: 'verified' or 'lst'. When set, category and interval are ignored. |
min_liquidity | float | No | Minimum total USD liquidity across pools. |
min_volume | float | No | Minimum 24h volume in USD. |
verified_only | bool | No | Only Jupiter-verified tokens (default False). |
limit | int | No | Maximum results (default 50). |
Return Schema
| Column | Type | Description |
|---|
ticker | string | Canonical J:-prefixed ticker |
mint_address | string | Solana mint address |
symbol | string | Token symbol |
name | string | Token name |
price | float | Live USD price |
mcap | float | Market capitalization (USD) |
volume_24h | float | 24h volume (USD) |
liquidity | float | Total USD liquidity |
holder_count | int | Number of holders |
organic_score | float | 0–100 real-activity score |
is_verified | bool | Jupiter verification status |
price_change_24h | float | Percent change over 24h |
getJupiterOHLCV()
OHLCV candles for Jupiter tokens at daily, hourly, or minute granularity, aggregated by Birdeye from on-chain swaps across all Solana DEXes. Accepts multiple tokens per call. Omit start and end for live mode (latest bar). Minute data is limited to 20 days per request.
Strategy angle: the backtesting backbone. For tokenized equities specifically, the 24/7 on-chain session opens strategies unavailable in traditional markets — e.g. trade the reaction to after-hours earnings through the xStock and exit before NYSE opens, or study weekend drift in tokenized SPY as a Monday-open signal. For pre-IPO tokens, daily bars are the only continuous price history that exists for those companies.
from scalarlib import getJupiterOHLCV, searchJupiterTokens
# Discover a token, then fetch daily bars
ticker = searchJupiterTokens("anthropic").iloc[0]['ticker']
data = getJupiterOHLCV(tokens=[ticker], start='2026-06-01', end='2026-07-01')
df = data[ticker]
# Minute bars (inferred from datetime format)
data = getJupiterOHLCV(tokens=[ticker],
start='2026-07-10T09:30:00', end='2026-07-10T16:00:00')
# Hourly bars
data = getJupiterOHLCV(tokens=[ticker], start='2026-07-01',
end='2026-07-10', timeframe='hour')
# Live mode — latest bar
data = getJupiterOHLCV(tokens=[ticker])
Parameters
| Parameter | Type | Required | Description |
|---|
tokens | list of str | Yes | J:-prefixed tickers from search/screen. Bare mint addresses accepted. |
start | str | No | "YYYY-MM-DD" (daily) or "YYYY-MM-DDTHH:MM:SS" (minute) — New York time. Omit for live mode. |
end | str | No | Same format as start. Defaults to now. |
timeframe | str | No | 'day', 'hour', or 'min'. Inferred from date format if omitted. Minute data limited to 20 days per request. |
Return Schema
Returns Dict[str, pd.DataFrame] keyed by token. Each DataFrame:
| Column | Type | Description |
|---|
ts_recv | datetime64[ns] | Bar timestamp (New York time, naive) |
ticker | string | Canonical J:-prefixed ticker |
open | float | Opening price (USD) |
high | float | High price |
low | float | Low price |
close | float | Closing price |
volume | float | Trading volume |
getJupiterPrice()
Live prices with 24h change and liquidity. Jupiter is a swap aggregator with no central order book, so there are no bids/asks — just the aggregated live price across all pools.
Strategy angle: the pre-trade check for every on-chain strategy. The liquidity field matters as much as the price: a strategy should size positions relative to pool liquidity (e.g. cap orders at a small fraction of it) to keep swap slippage economic.
from scalarlib import getJupiterPrice, searchJupiterTokens
ticker = searchJupiterTokens("anthropic").iloc[0]['ticker']
data = getJupiterPrice(tokens=[ticker])
data[ticker]['price'] # 761.47
data[ticker]['price_change_24h'] # 7.27
data[ticker]['liquidity'] # size positions against this
Parameters
| Parameter | Type | Required | Description |
|---|
tokens | list of str | Yes | J:-prefixed tickers. Bare mint addresses accepted. |
Return Schema
Returns Dict[str, dict] keyed by token:
| Field | Type | Description |
|---|
ticker | string | Canonical J:-prefixed ticker |
price | float | Live USD price (None if unavailable) |
price_change_24h | float | Percent change over 24h |
liquidity | float | Total USD liquidity across pools |
decimals | int | Token decimals |
ts | datetime | Quote timestamp (New York time, naive) |
getJupiterHoldings()
Token balances for any Solana wallet — native SOL plus all SPL token balances, priced live and sorted by USD value. Balances are public on-chain data; no authentication needed.
Strategy angle: the portfolio X-ray of a copy-trading pipeline. Once screenJupiterWallets() or getJupiterTokenTopTraders() surfaces an interesting wallet, this shows its full current book — snapshot it on a schedule and trade on the changes (new positions appearing, old ones shrinking).
from scalarlib import getJupiterHoldings
df = getJupiterHoldings(wallet='9WzDXwBb...')
df[['symbol', 'amount', 'usd_value']].head()
# Total portfolio value
df['usd_value'].sum()
# Everything, including dust
df = getJupiterHoldings(wallet='9WzDXwBb...', min_usd_value=None, limit=10000)
Parameters
| Parameter | Type | Required | Description |
|---|
wallet | str | Yes | Solana wallet address (base58). Any address works. |
min_usd_value | float | No | Drop holdings below this USD value (default 1.0). None keeps everything, including unpriced tokens. |
limit | int | No | Maximum holdings (default 100), largest by USD value first. |
Return Schema
One row per holding, sorted by usd_value descending:
| Column | Type | Description |
|---|
wallet | string | Queried address |
ticker | string | Canonical J:-prefixed ticker |
mint_address | string | Solana mint address |
symbol | string | Token symbol ('' if unknown) |
name | string | Token name ('' if unknown) |
amount | float | Token balance (UI units) |
price | float | Live USD price (NaN if unpriced) |
usd_value | float | amount * price (NaN if unpriced) |
getJupiterTokenTrades()
Recent swaps for a token across all Solana DEXes, with the trading wallets. This is the live tape: who is buying and selling right now, in what size, on which venue.
Strategy angle: flow analysis and wallet discovery. Compute net buy-minus-sell flow over the recent tape as a short-horizon pressure signal; filter for large trades (min_usd_value) to isolate informed flow; and feed the discovered wallets straight into getJupiterHoldings() to see what else the buyers hold.
from scalarlib import getJupiterTokenTrades, getJupiterHoldings, searchJupiterTokens
ticker = searchJupiterTokens("anthropic").iloc[0]['ticker']
df = getJupiterTokenTrades(token=ticker)
# Large buys only
df = getJupiterTokenTrades(token=ticker, side='BUY', min_usd_value=1000)
# Most active wallets in the recent tape
df['wallet'].value_counts().head()
# Inspect a discovered wallet's full portfolio
holdings = getJupiterHoldings(wallet=df.iloc[0]['wallet'])
Parameters
| Parameter | Type | Required | Description |
|---|
token | str | Yes | J:-prefixed ticker. Bare mint addresses accepted. |
side | str | No | 'BUY' or 'SELL' (relative to the token). |
min_usd_value | float | No | Minimum trade value in USD. |
limit | int | No | Maximum trades, newest first (default 100, max 500). Filters apply after fetching. |
Return Schema
Trades sorted newest first:
| Column | Type | Description |
|---|
ts_recv | datetime64[ns] | Trade timestamp (New York time, naive) |
ticker | string | Canonical J:-prefixed ticker of the token |
symbol | string | Token symbol |
wallet | string | Trading wallet address |
side | string | 'BUY' or 'SELL' (of the token) |
price | float | Token price (USD) at trade time |
amount | float | Token amount traded (UI units) |
usd_value | float | amount * price |
counter_symbol | string | The other leg of the swap (e.g. 'SOL', 'USDC') |
counter_amount | float | Amount of the counter token |
dex | string | Venue the swap executed on (e.g. 'meteora_dlmm', 'raydium') |
tx_hash | string | Solana transaction signature |
getJupiterTokenHolders()
Top holders of a token, ranked by balance, with USD value and share of total supply.
Strategy angle: the concentration-risk screen. Before entering any small-cap token position, check what share of supply the top 10 wallets control — a token where a handful of wallets hold most of the float can be dumped on you at any moment. Persistent accumulation by top holders across snapshots is conversely a bullish structural signal.
from scalarlib import getJupiterTokenHolders, getJupiterHoldings, searchJupiterTokens
ticker = searchJupiterTokens("anthropic").iloc[0]['ticker']
df = getJupiterTokenHolders(token=ticker)
# Concentration: share held by the top 10 wallets
df.head(10)['pct_supply'].sum()
# Inspect the largest holder's full portfolio
holdings = getJupiterHoldings(wallet=df.iloc[0]['wallet'])
Parameters
| Parameter | Type | Required | Description |
|---|
token | str | Yes | J:-prefixed ticker. Bare mint addresses accepted. |
limit | int | No | Maximum holders (default 50, max 500), largest first. |
Return Schema
| Column | Type | Description |
|---|
rank | int | 1-based rank by balance |
wallet | string | Holder wallet address |
ticker | string | Canonical J:-prefixed ticker |
symbol | string | Token symbol ('' if unknown) |
amount | float | Token balance (UI units) |
usd_value | float | amount * live price (NaN if unpriced) |
pct_supply | float | Share of total supply held (percent; NaN if supply unavailable) |
getJupiterWalletTrades()
Swap history for any Solana wallet across all DEXes. Each swap has two legs; the row describes the “traded token” — the non-SOL/USDC/USDT leg when one exists — with the other leg as counter symbol/amount.
Strategy angle: where copy-trading gets precise. Holdings tell you what a wallet owns; the swap history tells you when and how it got there — does the trader scale in, chase pumps, or accumulate quietly? Grouping buys by symbol reveals what a profitable wallet is currently accumulating, which is often the actionable signal.
from scalarlib import getJupiterWalletTrades, screenJupiterWallets
# Discover an active wallet, then inspect its trading
wallets = screenJupiterWallets(limit=10)
df = getJupiterWalletTrades(wallet=wallets.iloc[0]['wallet'])
# Large buys of a specific token
df = getJupiterWalletTrades(wallet='MfDuWeq...', token=ticker,
side='BUY', min_usd_value=1000)
# What is this wallet accumulating?
df[df['side'] == 'BUY'].groupby('symbol')['usd_value'].sum()
Parameters
| Parameter | Type | Required | Description |
|---|
wallet | str | Yes | Solana wallet address (base58). Any address works. |
token | str | No | Filter to swaps involving this token (matches either leg). |
side | str | No | 'BUY' or 'SELL' (of the traded token). |
min_usd_value | float | No | Minimum swap value in USD. |
limit | int | No | Maximum swaps, newest first (default 100, max 500). Filters apply after fetching. |
Return Schema
Swaps sorted newest first:
| Column | Type | Description |
|---|
ts_recv | datetime64[ns] | Swap timestamp (New York time, naive) |
wallet | string | Queried address |
ticker | string | Canonical J:-prefixed ticker of the traded token |
symbol | string | Traded token symbol |
side | string | 'BUY' or 'SELL' (of the traded token) |
price | float | Traded token price (USD) at swap time |
amount | float | Traded token amount (UI units) |
usd_value | float | Swap value in USD |
counter_symbol | string | The other leg (e.g. 'SOL', 'USDC') |
counter_amount | float | Amount of the counter token |
dex | string | Venue the swap executed on (e.g. 'whirlpool', 'raydium') |
tx_hash | string | Solana transaction signature |
screenJupiterWallets()
Trader PnL leaderboard for Solana wallets, with realized/unrealized breakdown, volume, and trade count over the selected window.
Strategy angle: the discovery step of a copy-trading pipeline. Rank by PnL, then audit the shortlist with getJupiterWalletTrades() (is the edge repeatable, or one lucky trade?) and getJupiterHoldings() (what do they hold now?). The realized/unrealized split matters: a wallet whose PnL is mostly unrealized in one illiquid token is a very different copy candidate than one with steady realized gains.
from scalarlib import screenJupiterWallets, getJupiterWalletTrades, getJupiterHoldings
# Top 10 traders this week
df = screenJupiterWallets(limit=10)
# Copy-trading workflow: screen -> trades -> holdings
wallet = df.iloc[0]['wallet']
trades = getJupiterWalletTrades(wallet=wallet)
holdings = getJupiterHoldings(wallet=wallet)
Parameters
| Parameter | Type | Required | Description |
|---|
time_period | str | No | Performance window: 'today', 'yesterday', or '1W' (default). |
limit | int | No | Maximum wallets (default 50, max 200). |
offset | int | No | Pagination offset (default 0). |
Return Schema
Wallets sorted by PnL descending:
| Column | Type | Description |
|---|
rank | int | 1-based rank (offset-adjusted) |
wallet | string | Solana address |
pnl | float | Total PnL (USD) over the window |
realized_pnl | float | Realized PnL component |
unrealized_pnl | float | Unrealized PnL component |
volume | float | Trading volume (USD) over the window |
trade_count | int | Number of trades in the window |
getJupiterTokenTopTraders()
The most active wallets in a token by volume over a chosen window, with buy/sell breakdowns and Birdeye wallet tags (e.g. 'whale', 'bundler').
Strategy angle: complements the raw tape (getJupiterTokenTrades()) and static balances (getJupiterTokenHolders()) with who is moving size right now. Net buyers among tagged whales is a strong accumulation signal; a token whose top traders are mostly bundlers is a red flag for manufactured volume.
from scalarlib import getJupiterTokenTopTraders, searchJupiterTokens
ticker = searchJupiterTokens("bonk").iloc[0]['ticker']
df = getJupiterTokenTopTraders(token=ticker)
# Whales only
whales = df[df['tags'].apply(lambda t: 'whale' in t)]
# Net buyers by USD
df[df['volume_buy_usd'] > df['volume_sell_usd']]
Parameters
| Parameter | Type | Required | Description |
|---|
token | str | Yes | J:-prefixed ticker. Bare mint addresses accepted. |
time_frame | str | No | Activity window: '30m', '1h', '2h', '4h', '6h', '8h', '12h', '24h' (default). |
limit | int | No | Maximum traders (default 10, max 100), by volume descending. |
Return Schema
Traders sorted by volume descending:
| Column | Type | Description |
|---|
rank | int | 1-based rank by volume |
wallet | string | Trader address |
ticker | string | Canonical J:-prefixed ticker |
tags | list of str | Birdeye wallet tags (e.g. 'whale', 'bundler') |
trades | int | Trade count in window |
trades_buy | int | Buy count |
trades_sell | int | Sell count |
volume_usd | float | Total USD volume |
volume_buy_usd | float | Buy-side USD volume |
volume_sell_usd | float | Sell-side USD volume |
Strategy Playbook
Concrete ways to combine these functions into a strategy:
- Copy-trading.
screenJupiterWallets() to shortlist profitable traders, getJupiterWalletTrades() to audit their realized edge and style, then poll getJupiterHoldings() on a schedule and mirror position changes via venue.trade() on the Jupiter venue.
- Tokenized-equity hours arbitrage. xStocks trade 24/7 while the underlying stocks trade 9:30–16:00 ET. Use
getJupiterOHLCV() on the xStock alongside equity OHLCV on the underlying to study overnight/weekend divergence, and trade the on-chain leg when traditional markets are closed.
- Pre-IPO exposure.
searchJupiterTokens("spacex") and friends give continuous price discovery for private companies. Combine daily OHLCV with holder concentration (getJupiterTokenHolders()) to size positions responsibly in these thinner markets.
- Whale-flow momentum.
getJupiterTokenTopTraders() and getJupiterTokenTrades(min_usd_value=...) surface large net buying in a token; confirm with rising organic_score and liquidity from screenJupiterTokens(), then enter with size capped against getJupiterPrice() liquidity.
- New-listing screens.
screenJupiterTokens(category='recent') with min_liquidity and holder-concentration checks builds a filtered feed of tradeable new tokens while screening out honeypots and bundler-driven volume.
