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)

Symbols are not accepted — they are ambiguous on Solana (lookalike tokens share symbols). Always resolve tokens to their mint via 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.

​Product Overview

​Overview

​Functions at a Glance

​Data Sources

​Ticker Convention

​Querying the Data

​searchJupiterTokens()

​Parameters

​Return Schema

​screenJupiterTokens()

​Parameters

​Return Schema

​getJupiterOHLCV()

​Parameters

​Return Schema

​getJupiterPrice()

​Parameters

​Return Schema

​getJupiterHoldings()

​Parameters

​Return Schema

​getJupiterTokenTrades()

​Parameters

​Return Schema

​getJupiterTokenHolders()

​Parameters

​Return Schema

​getJupiterWalletTrades()

​Parameters

​Return Schema

​screenJupiterWallets()

​Parameters

​Return Schema

​getJupiterTokenTopTraders()

​Parameters

​Return Schema

​Strategy Playbook

Product Overview

Overview

Functions at a Glance

Data Sources

Ticker Convention

Querying the Data

`searchJupiterTokens()`

Parameters

Return Schema

`screenJupiterTokens()`

Parameters

Return Schema

`getJupiterOHLCV()`

Parameters

Return Schema

`getJupiterPrice()`

Parameters

Return Schema

`getJupiterHoldings()`

Parameters

Return Schema

`getJupiterTokenTrades()`

Parameters

Return Schema

`getJupiterTokenHolders()`

Parameters

Return Schema

`getJupiterWalletTrades()`

Parameters

Return Schema

`screenJupiterWallets()`

Parameters

Return Schema

`getJupiterTokenTopTraders()`

Parameters

Return Schema

Strategy Playbook