Assets (collection)

All endpoints on this page are Platform API endpoints unless noted otherwise.

type VariantExecutionQuality = {
    source: 'clickhouse_fill_quality';
    range: '24h';
    horizon: '5s';
    quoteMint: string;
    volume24hUSD: number;
    trade24h: number;
    botVolume24hUSD: number;
    botTrade24h: number;
    botVolumeRatio: number;
    fee24hUSD: number;
    feeBps: number;
    flowSourceCount: number;
    markoutPnl24hUSD: number | null;
    markoutCount: number | null;
    markoutBps: number | null;
    executionScore: number;
    isEligibleForPrimary: boolean;
    asOf: number | null;
    lastComputedAt: number;
} | null;

type StockVariantTier = 'share_redeemable' | 'cash_redeemable' | 'not_redeemable';

Execution quality and primary strategy

Some Solana variants include cached fill-quality data in an executionQuality field. This is intended to help clients compare variant-level execution and routing quality. Public API routes read this data from Convex only; they do not query ClickHouse at request time.

Current coverage is cache-only and scoped to:

curated base mints with fill-quality coverage
USDC quote mint
24h range
5s horizon
production flow rollups only

executionScore is a 0–100 score derived from 24h fill volume, trade count, flow-source coverage, bot volume ratio, and fee bps. isEligibleForPrimary indicates whether the cached row passes freshness and activity eligibility. markout* fields are exposed as raw cached data, but they are not used for primary ranking in this phase.

Primary variant selection is configurable on asset detail, search, and curated endpoints:

primaryVariantStrategy=liquidity is the default. It selects the most liquid valid spot-like variant after 24h trade/volume sanity filtering.
primaryVariantStrategy=execution_quality opts into execution-aware selection. It uses the same activity filter, then allows cached fill quality to break close calls or override within the conservative liquidity-ratio cap.
primaryVariantStrategy=stock_redeemability opts into redeemability-aware selection for equities and tokenized equities. It uses the same spot-like and activity filters, then compares stockVariantTier before liquidity when the higher-tier variant has zero/unknown liquidity on both sides or is within 5x of the more liquid variant.

All strategies preserve the same fallback order when no strategy-specific rule applies: liquidity, trust/liquidity tier, 24h volume, curated mint rank, then deterministic mint tie-breaks.

Equity variants may include stockVariantTier:

share_redeemable: provider documentation indicates redemption into the corresponding share/security entitlement.
cash_redeemable: provider documentation indicates redemption for cash, stablecoin, or underlying asset value rather than direct share delivery.
not_redeemable: no verified redemption path is represented.

stockVariantTier is informational API metadata for client routing and display. It is not legal, tax, accounting, or investment advice.

You can see this live on assets with multiple covered variants, for example Tesla:

curl -sS "$API_BASE_URL/v1/assets/tesla/variants" \
  -H "x-api-key: $API_KEY"

`GET /v1/assets/search`

Search assets by text query (canonical assets plus singleton Solana tokens when available).

Auth: x-api-key
Scope: assets:read

Query params

q (required): search string
limit (optional): integer (1–50), default 20
category (optional): must be one of the supported asset categories
variants=all (optional): include every known variant for each returned canonical asset. By default only primaryVariant is returned.
primaryVariantStrategy (optional): liquidity (default), execution_quality, or stock_redeemability

Response

interface AssetsSearchResponse {
    query: string;
    category: string | null;
    primaryVariantStrategy: 'liquidity' | 'execution_quality' | 'stock_redeemability';
    results: Array<{
        assetId: string;
        name?: string;
        symbol?: string;
        category: string;
        imageUrl: string | null;
        stats: null | {
            price: number | null;
            liquidity: number | null;
            volume24hUSD: number | null;
            volume30dUSD: number | null;
            marketCap: number | null;
            priceChange24hPercent: number | null;
            priceChange1hPercent: number | null;
        };
        primaryVariant: null | {
            variantId: string;
            mint: string;
            kind: string;
            liquidityTier: string;
            trustTier: string;
            tags: string[];
            issuer?: string;
            issuerUrl?: string;
            label?: string;
            stockVariantTier?: StockVariantTier;
            symbol?: string;
            name?: string;
            market: null | {
                source?: 'birdeye' | 'rwa_xyz' | 'clickhouse_trades';
                metricsSource?: 'birdeye' | 'rwa_xyz' | 'clickhouse_trades';
                price: number | null;
                liquidity: number | null;
                volume1hUSD?: number | null;
                volume24hUSD: number | null;
                trade1h?: number | null;
                trade24h?: number | null;
                uniqueWallet1h?: number | null;
                uniqueWallet24h?: number | null;
                marketCap: number | null;
                priceChange24hPercent: number | null;
                priceChange1hPercent: number | null;
                decimals: number | null;
                logoURI: string | null;
                lastTradeAt?: number | null;
                asOf?: number | null;
                lastFetchedAt: number | null;
            };
            executionQuality: VariantExecutionQuality;
        };
        variants?: Array<{
            variantId: string;
            mint: string;
            kind: string;
            liquidityTier: string;
            trustTier: string;
            tags: string[];
            issuer?: string;
            issuerUrl?: string;
            label?: string;
            stockVariantTier?: StockVariantTier;
            symbol?: string;
            name?: string;
            market: null | {
                source?: 'birdeye' | 'rwa_xyz' | 'clickhouse_trades';
                metricsSource?: 'birdeye' | 'rwa_xyz' | 'clickhouse_trades';
                price: number | null;
                liquidity: number | null;
                volume1hUSD?: number | null;
                volume24hUSD: number | null;
                trade1h?: number | null;
                trade24h?: number | null;
                uniqueWallet1h?: number | null;
                uniqueWallet24h?: number | null;
                marketCap: number | null;
                priceChange24hPercent: number | null;
                priceChange1hPercent: number | null;
                decimals: number | null;
                logoURI: string | null;
                lastTradeAt?: number | null;
                asOf?: number | null;
                lastFetchedAt: number | null;
            };
            executionQuality: VariantExecutionQuality;
        }>;
    }>;
}

Notes

stats.liquidity is the canonical on-chain aggregate across the asset’s spot-like variants (native, wrapped, bridged, stablecoin, lst, tokenized_equity, basket). If an asset has no spot-like variants, the API falls back to aggregating across all variants.
primaryVariantStrategy=liquidity chooses primaryVariant from spot-like variants by highest liquidity after 24h activity filtering.
primaryVariantStrategy=execution_quality keeps liquidity in the ranking but allows strong cached fill-quality evidence to select the better practical trading variant.
primaryVariantStrategy=stock_redeemability applies only to equities and tokenized equities. It favors share_redeemable over cash_redeemable over not_redeemable or missing tiers, subject to the 5x liquidity cap.
variants=all keeps primaryVariant and adds variants[], sorted by variant liquidity descending.
stockVariantTier is exposed on stock-token variant objects when present, including primaryVariant and variants[].
For mapped public equities, canonical stock-market data can populate stats.price, stats.volume24hUSD, and stats.priceChange24hPercent; otherwise price fields come from the primary variant or external canonical provider.
When available, primaryVariant.market.metricsSource="clickhouse_trades" indicates price, volume, trade-count, wallet-count, price-change, lastTradeAt, and asOf fields were materialized from the internal Solana trades cache. Public API routes still read these fields from Convex.
executionQuality is cached from ClickHouse fill-quality windows in Convex. Current coverage uses curated base mints, USDC quote, 24h range, and 5s horizon. markout* fields are exposed as raw cached data and are not used for primary ranking yet.
stats.volume30dUSD is a nullable rolling 30-day USD volume sum from cached daily candles for the canonical group. When populated, clients do not need to sum candles themselves.
canonicalMarket.source can be coingecko or clickhouse_stock.
Tokens that are not part of any canonical asset may appear as singleton assets with deterministic IDs of the form solana-<mint> (with a single Solana variant).

Example

curl -sS "$API_BASE_URL/v1/assets/search?q=bitcoin&limit=10" \
  -H "x-api-key: $API_KEY"

curl -sS "$API_BASE_URL/v1/assets/search?q=tesla&variants=all" \
  -H "x-api-key: $API_KEY"

`GET /v1/assets/:assetId`

Get a single canonical asset, its aggregate stats, and its selected primaryVariant.

Auth: x-api-key
Scope: assets:read

Query params

mint (optional): require the response context to use a specific variant mint belonging to the asset
include (optional): comma-separated optional expansions, such as profile, ohlcv, or markets
variantsMode=all (optional): use the expanded variant view where supported
primaryVariantStrategy (optional): liquidity (default), execution_quality, or stock_redeemability

Notes

asset.primaryVariant.executionQuality is included when cached fill-quality data exists for the selected primary variant.
asset.primaryVariant.stockVariantTier is included for stock-token variants when present.
asset.primaryVariantStrategy echoes the strategy used to select primaryVariant.
asset.variantGroups.*[].executionQuality is included on covered variants. This is the easiest way to compare execution quality across duplicate tokenized-equity or RWA variants.
asset.variantGroups.tokenizedEquity[].stockVariantTier is included when present and can be used to distinguish redeemability tiers. This metadata is informational, not legal or investment advice.
Public API routes read execution quality from Convex only. They do not query ClickHouse at request time.

Example response excerpt

{
    "asset": {
        "assetId": "tesla",
        "primaryVariantStrategy": "execution_quality",
        "primaryVariant": {
            "variantId": "tesla:xStock",
            "mint": "XsDoVfqeBukxuZHWhdvWHBhgEHjGNst4MLodqsJHzoB",
            "label": "xStock",
            "stockVariantTier": "cash_redeemable",
            "executionQuality": {
                "source": "clickhouse_fill_quality",
                "range": "24h",
                "horizon": "5s",
                "quoteMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
                "volume24hUSD": 47017356.73,
                "trade24h": 8503,
                "botVolume24hUSD": 907765.5,
                "botTrade24h": 5635,
                "botVolumeRatio": 0.0193,
                "fee24hUSD": 49.61,
                "feeBps": 0.0106,
                "flowSourceCount": 12,
                "markoutPnl24hUSD": -15849.29,
                "markoutCount": 8503,
                "markoutBps": -3.3709,
                "executionScore": 99.2412,
                "isEligibleForPrimary": true,
                "asOf": 1780444799,
                "lastComputedAt": 1780458483037
            }
        }
    }
}

Example

curl -sS "$API_BASE_URL/v1/assets/tesla" \
  -H "x-api-key: $API_KEY"

`GET /v1/assets/:assetId/variants`

List variants for a canonical asset.

Auth: x-api-key
Scope: assets:read

Query params

mint (optional): filter to one variant mint that belongs to the asset
kind (optional): filter by variant kind
liquidityTier (optional): filter by liquidity tier
stockVariantTier (optional): share_redeemable, cash_redeemable, or not_redeemable
variantsMode=all (optional): disable default narrowing where a specialized view exists
sortBy (optional): liquidity (default), execution_quality, or stock_redeemability

Notes

Each variant row includes executionQuality when fill-quality data is cached for that mint.
Each stock-token variant row includes stockVariantTier when present.
sortBy=execution_quality puts variants with cached execution quality first, then eligible rows, then higher executionScore, then fill-quality volume, then liquidity/volume fallbacks.
sortBy=stock_redeemability sorts share_redeemable variants first, then cash_redeemable, then not_redeemable or missing tiers, with liquidity fallbacks inside each tier.
executionQuality.executionScore is useful for UI badges or comparison states. Use primaryVariantStrategy=execution_quality on asset detail/search/curated endpoints when you want the API to use that signal for primary selection.
stockVariantTier is descriptive provider metadata and should not be treated as legal or investment advice.

Example response excerpt

{
    "assetId": "tesla",
    "sortBy": "execution_quality",
    "variants": [
        {
            "mint": "XsDoVfqeBukxuZHWhdvWHBhgEHjGNst4MLodqsJHzoB",
            "label": "xStock",
            "stockVariantTier": "cash_redeemable",
            "executionQuality": {
                "source": "clickhouse_fill_quality",
                "range": "24h",
                "horizon": "5s",
                "quoteMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
                "volume24hUSD": 47017356.73,
                "trade24h": 8503,
                "botVolumeRatio": 0.0193,
                "feeBps": 0.0106,
                "flowSourceCount": 12,
                "executionScore": 99.2412,
                "isEligibleForPrimary": true,
                "asOf": 1780444799,
                "lastComputedAt": 1780458483037
            }
        },
        {
            "mint": "KeGv7bsfR4MheC1CkmnAVceoApjrkvBhHYjWb67ondo",
            "label": "Ondo",
            "stockVariantTier": "cash_redeemable",
            "executionQuality": {
                "source": "clickhouse_fill_quality",
                "range": "24h",
                "horizon": "5s",
                "quoteMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
                "volume24hUSD": 46058844.77,
                "trade24h": 2755,
                "botVolumeRatio": 0,
                "feeBps": 0,
                "flowSourceCount": 1,
                "executionScore": 82.6487,
                "isEligibleForPrimary": true,
                "asOf": 1780444799,
                "lastComputedAt": 1780458362082
            }
        }
    ]
}

Example

curl -sS "$API_BASE_URL/v1/assets/tesla/variants" \
  -H "x-api-key: $API_KEY"

curl -sS "$API_BASE_URL/v1/assets/spacex/variants?stockVariantTier=share_redeemable&sortBy=stock_redeemability" \
  -H "x-api-key: $API_KEY"

`GET /v1/assets/resolve`

Resolve a Solana mint (or an asset reference) to its canonical assetId + variant details.

If the mint is part of a canonical asset, the returned assetId is the canonical grouping slug (for example: usd, solana, tesla). Otherwise the API returns a deterministic singleton ID of the form solana-<mint>.
ref can be an assetId, alias, raw mint, or solana-<mint>. Known mint refs reverse-resolve to their canonical group, so ref=solana-EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v returns assetId: "usd".
Auth: x-api-key
Scope: assets:read

Query params

mint (optional): Solana mint address (base58)
ref (optional): asset reference string (an assetId, alias, mint, or solana-<mint>)

One of mint or ref is required. If both are provided, mint takes precedence.

Response

interface AssetsResolveResponse {
    assetId: string;
    resolvedBy?: 'assetId' | 'alias' | 'mint' | 'singletonMint' | 'registry' | 'sanctum' | 'singleton';
    mint?: string | null;
    asset: {
        assetId: string;
        name: string | null;
        symbol: string | null;
        category: string;
        aliases: string[];
    };
    variant: {
        mint: string;
        chain: string;
        kind: string;
        liquidityTier: string;
        trustTier: string;
        tags: string[];
        issuer?: string;
        issuerUrl?: string;
        label?: string;
    } | null;
}

{
    "assetId": "usd",
    "resolvedBy": "singletonMint",
    "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "asset": {
        "assetId": "usd",
        "name": "US Dollar",
        "symbol": "USD",
        "category": "stablecoin",
        "aliases": []
    },
    "variant": {
        "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
        "chain": "solana",
        "kind": "native",
        "liquidityTier": "tier3",
        "trustTier": "tier3",
        "tags": []
    }
}

Example

curl -sS "$API_BASE_URL/v1/assets/resolve?ref=solana-$MINT" \
  -H "x-api-key: $API_KEY"

curl -sS "$API_BASE_URL/v1/assets/resolve?ref=usd" \
  -H "x-api-key: $API_KEY"

`GET /v1/assets/trending`

Get ranked trending curated Solana assets from the Convex cache.

Auth: x-api-key
Scope: assets:read

Query params

category (optional): one of crypto, stablecoin, lst, rwa, commodity, equity, etf, or index
limit (optional): integer (1–50), default 50
offset (optional): zero-based result offset, default 0

Notes

This endpoint reads the cached top 50 Convex rows only. Public API routes do not query ClickHouse.
Trending rows are individual mints, not canonical asset aggregates. imageUrl prefers the mint-level token logo cached with that row.
Trending v1 is computed from successful direct USD-stable Solana trades only.
Native/wrapped SOL and stablecoin assets are excluded from the ranked trending set because they dominate Solana routing and stable-pair liquidity. category=stablecoin is accepted for schema compatibility but currently returns an empty list.
SOL-routed pricing and buy/sell imbalance are not included in this phase.
trending.score is a balanced momentum score based on 5m/15m/1h activity, acceleration versus longer windows, 1h price movement, and trade recency.
market.asOf is the shared ClickHouse trade timestamp used for the run, expressed as unix seconds. market.lastTradeAt is the most recent direct-stable trade timestamp for that mint, also unix seconds.

Response

interface AssetsTrendingResponse {
    trending: Array<{
        rank: number;
        assetId: string;
        mint: string;
        symbol: string;
        name: string;
        decimals: number;
        category: string;
        imageUrl: string | null;
        market: {
            source: 'clickhouse_trades';
            metricsSource: 'clickhouse_trades';
            price: number | null;
            volume5mUSD: number;
            volume15mUSD: number;
            volume1hUSD: number;
            volume6hUSD: number;
            volume24hUSD: number;
            trade5m: number;
            trade15m: number;
            trade1h: number;
            trade6h: number;
            trade24h: number;
            uniqueWallet5m: number;
            uniqueWallet1h: number;
            uniqueWallet24h: number;
            priceChange1hPercent: number | null;
            priceChange24hPercent: number | null;
            lastTradeAt: number | null;
            asOf: number | null;
        };
        trending: {
            score: number;
            scoringVersion: string;
        };
    }>;
    meta: {
        limit: number;
        offset: number;
        total: number; // at most 50 in the current cached set
        asOf: number | null;
        scoringVersion: string;
    };
}

Example response

{
    "trending": [
        {
            "rank": 1,
            "assetId": "hyperliquid",
            "mint": "98sM...",
            "symbol": "HYPE",
            "name": "HYPE (Wormhole)",
            "decimals": 8,
            "category": "crypto",
            "imageUrl": "https://...",
            "market": {
                "source": "clickhouse_trades",
                "metricsSource": "clickhouse_trades",
                "price": 36.42,
                "volume5mUSD": 98234.12,
                "volume15mUSD": 275001.44,
                "volume1hUSD": 910442.8,
                "volume6hUSD": 5123401.5,
                "volume24hUSD": 18420012.9,
                "trade5m": 211,
                "trade15m": 690,
                "trade1h": 2314,
                "trade6h": 12602,
                "trade24h": 50711,
                "uniqueWallet5m": 82,
                "uniqueWallet1h": 579,
                "uniqueWallet24h": 6240,
                "priceChange1hPercent": 2.13,
                "priceChange24hPercent": 5.88,
                "lastTradeAt": 1780348384,
                "asOf": 1780348387
            },
            "trending": {
                "score": 72.1482,
                "scoringVersion": "solana-direct-stable-v1"
            }
        }
    ],
    "meta": {
        "limit": 10,
        "offset": 0,
        "total": 50,
        "asOf": 1780348387,
        "scoringVersion": "solana-direct-stable-v1"
    }
}

Example

curl -sS "$API_BASE_URL/v1/assets/trending?limit=10" \
  -H "x-api-key: $API_KEY"

curl -sS "$API_BASE_URL/v1/assets/trending?category=equity&limit=10" \
  -H "x-api-key: $API_KEY"

`GET /v1/assets/curated`

Get curated assets from a list.

Auth: x-api-key
Scope: assets:read

Query params

list (optional): curated list id, or all (default all)
groupBy (optional): asset (default) or mint
limit (optional): opt into pagination with this page size (default 250 when offset is provided, max 500)
offset (optional): opt into pagination from this zero-based result offset
variantsMode=all (optional): disable the default Solana LST liquidity filter for groupBy=mint
primaryVariantStrategy (optional): liquidity (default), execution_quality, or stock_redeemability

Notes

Results are sorted by stats.volume24hUSD descending when available.
list=lsts is backed by the same dynamic, capped Solana yield-variant set used by the variants API, rather than a fixed static mint list. list=all includes that same dynamic LST membership.
For Solana LST mint rows, the default response only includes active LSTs with at least $250k liquidity. Pass variantsMode=all to return all active LST rows.
groupBy=mint expands the response to one row per variant mint.
imageUrl is curated canonical imagery (including storage-backed URLs when configured). primaryVariant.market.logoURI is a best-effort per-token icon from indexed/cache sources and may be null (the server may fall back to imageUrl when missing).
stats.liquidity, stats.volume24hUSD, and stats.volume30dUSD are canonical aggregates across the asset’s spot-like variants (fallback to all variants if none exist). In groupBy=mint, primaryVariant.market is mint-specific but stats remains canonical for the asset.
When available, primaryVariant.market.metricsSource="clickhouse_trades" means the mint-specific market metrics were materialized from direct USD-stable Solana trades into Convex.
primaryVariantStrategy=liquidity is the default conservative selector. Use primaryVariantStrategy=execution_quality when you want the primary variant to account for cached fill-quality evidence. Use primaryVariantStrategy=stock_redeemability when equity and tokenized-equity primary selection should account for stockVariantTier.
primaryVariant.executionQuality is cached from ClickHouse fill-quality windows and is exposed regardless of selected strategy.
primaryVariant.stockVariantTier is included for stock-token variants when present. It is informational metadata, not legal or investment advice.

Response

interface AssetsCuratedResponse {
    listId: string;
    primaryVariantStrategy: 'liquidity' | 'execution_quality' | 'stock_redeemability';
    pagination?: {
        offset: number;
        limit: number;
        total: number;
        hasMore: boolean;
        nextOffset: number | null;
    };
    assets: Array<{
        assetId: string;
        name?: string;
        symbol?: string;
        category: string;
        imageUrl: string | null;
        stats: null | {
            price: number | null;
            liquidity: number | null;
            volume24hUSD: number | null;
            volume30dUSD: number | null;
            marketCap: number | null;
            priceChange24hPercent: number | null;
            priceChange1hPercent: number | null;
        };
        primaryVariant: null | {
            variantId: string;
            mint: string;
            kind: string;
            liquidityTier: string;
            trustTier: string;
            tags: string[];
            issuer?: string;
            issuerUrl?: string;
            label?: string;
            stockVariantTier?: StockVariantTier;
            symbol?: string;
            name?: string;
            market: null | {
                source?: 'birdeye' | 'rwa_xyz' | 'clickhouse_trades';
                metricsSource?: 'birdeye' | 'rwa_xyz' | 'clickhouse_trades';
                price: number | null;
                liquidity: number | null;
                volume1hUSD?: number | null;
                volume24hUSD: number | null;
                trade1h?: number | null;
                trade24h?: number | null;
                uniqueWallet1h?: number | null;
                uniqueWallet24h?: number | null;
                marketCap: number | null;
                priceChange24hPercent: number | null;
                priceChange1hPercent: number | null;
                decimals: number | null;
                logoURI: string | null;
                lastTradeAt?: number | null;
                asOf?: number | null;
                lastFetchedAt: number | null;
            };
            executionQuality: VariantExecutionQuality;
        };
    }>;
}

Notes:

If groupBy=mint, assets[] becomes “one row per mint” and primaryVariant is always present for returned rows.
Pagination is opt-in. Pass limit or offset to receive pagination, then use pagination.nextOffset with the same list and groupBy params to fetch the next page.
Compatibility: clients that previously expected a complete curated list from one request still receive all matching rows unless they opt into pagination. Clients that need all active LST mint rows should add variantsMode=all.

Example

curl -sS "$API_BASE_URL/v1/assets/curated?list=all&groupBy=asset" \
  -H "x-api-key: $API_KEY"

curl -sS "$API_BASE_URL/v1/assets/curated?list=all&groupBy=asset&limit=250" \
  -H "x-api-key: $API_KEY"

curl -sS "$API_BASE_URL/v1/assets/curated?list=lsts&groupBy=mint&variantsMode=all" \
  -H "x-api-key: $API_KEY"

`POST /v1/assets/market-snapshots`

Batch lookup cached market snapshots for up to 250 mints.

Auth: x-api-key
Scope: assets:read
Body: JSON

Body

Either mints or addresses (both treated the same).

{ "mints": ["So11111111111111111111111111111111111111112"] }

Notes

Input is de-duped and capped at 250 addresses.
Returns an array (Convex-backed) of token search rows for those addresses.

Response

This endpoint returns an array of token rows. The exact row shape can evolve, but it is safe to treat each entry as “token metadata + market snapshot data” keyed by the requested address.

When a row has metricsSource="clickhouse_trades", cached direct-stable Solana trade fields may include volume1hUSD, trade1h, trade24h, uniqueWallet1h, uniqueWallet24h, lastTradeAt, and asOf in addition to existing price/volume/change fields.

type AssetsMarketSnapshotsResponse = Array<unknown>;

Example

curl -sS "$API_BASE_URL/v1/assets/market-snapshots" \
  -H "x-api-key: $API_KEY" \
  -H "content-type: application/json" \
  -d '{"mints":["So11111111111111111111111111111111111111112"]}'

`GET /v1/assets/variant-markets`

Batch lookup per-mint variant market snapshots (best-effort; may be null if not cached).

Auth: x-api-key
Scope: assets:read

Query params

mints or addresses: comma-separated list (max 50)

Response shape (high level)

variants[] where each entry contains:
- mint
- assetId (when variant is known)
- chain (when variant is known)
- market (market snapshot, or null if missing)
- executionQuality (fill-quality snapshot, or null if missing)

Response

interface AssetsVariantMarketsResponse {
    variants: Array<{
        mint: string;
        assetId: string | null;
        chain: string | null;
        market: Record<string, unknown> | null;
        executionQuality: VariantExecutionQuality;
    }>;
}

{
    "variants": [
        {
            "mint": "So11111111111111111111111111111111111111112",
            "assetId": "solana",
            "chain": "solana",
            "market": {
                "symbol": "SOL",
                "name": "Solana",
                "decimals": 9,
                "price": 0,
                "liquidity": 0,
                "metricsSource": "clickhouse_trades",
                "volume1hUSD": 0,
                "volume24hUSD": 0,
                "trade1h": 0,
                "trade24h": 0,
                "uniqueWallet1h": 0,
                "uniqueWallet24h": 0,
                "volume30dUSD": null,
                "marketCap": 0,
                "priceChange24hPercent": 0,
                "priceChange1hPercent": 0,
                "lastTradeAt": 0,
                "asOf": 0,
                "lastFetchedAt": 0
            },
            "executionQuality": {
                "source": "clickhouse_fill_quality",
                "range": "24h",
                "horizon": "5s",
                "quoteMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
                "volume24hUSD": 855000000,
                "trade24h": 1660656,
                "botVolume24hUSD": 718000000,
                "botTrade24h": 1200000,
                "botVolumeRatio": 0.84,
                "fee24hUSD": 1000,
                "feeBps": 0.0117,
                "flowSourceCount": 22,
                "markoutPnl24hUSD": -350000,
                "markoutCount": 100000,
                "markoutBps": -4.09,
                "executionScore": 83.25,
                "isEligibleForPrimary": true,
                "asOf": 1780358399,
                "lastComputedAt": 1780360200000
            }
        }
    ]
}

Example

curl -sS "$API_BASE_URL/v1/assets/variant-markets?mints=$MINT1,$MINT2" \
  -H "x-api-key: $API_KEY"

`GET /v1/assets/risk-summary`

Compute a quick market-based “risk summary” for a mint.

Auth: x-api-key
Scope: requires either assets:read or assets:risk:read

Query params

mint (required) or address (alias): Solana mint

Notes

This endpoint requires a cached market snapshot; if missing you’ll get an “Insufficient Data” response.

Response

interface AssetsRiskSummaryResponse {
    score: number;
    grade: string;
    label: string;
    tone: 'info' | 'success' | 'warning' | 'danger';
    isTrustedLaunch: boolean;
    caps: Array<unknown>;
    hasInsufficientData: boolean;
    insufficientDataReason?: string;
}

{
    "score": 0,
    "grade": "C",
    "label": "Insufficient Data",
    "tone": "info",
    "isTrustedLaunch": false,
    "caps": [],
    "hasInsufficientData": true,
    "insufficientDataReason": "Market snapshot not available in cache"
}

Example

curl -sS "$API_BASE_URL/v1/assets/risk-summary?mint=$MINT" \
  -H "x-api-key: $API_KEY"

Assets (collection)

On this page