Querying All Tradable Tokens

Why This Endpoint?

Building a token screener or market overview requires access to summary data for many tokens at once. The token list endpoint provides:

All tracked tokens with key metrics (price, volume, market cap, holders)
Flexible sorting by any metric
Pagination for handling large result sets
Consistent data from vetted markets

Instead of making thousands of individual token requests, get everything you need in paginated batches.

Endpoint

GET /tokens

Parameters

Parameter	Type	Description
`sortByAsc`	string	Sort ascending by field
`sortByDesc`	string	Sort descending by field
`limit`	number	Results per page (max 1000)
`page`	number	Page number (0-indexed)

Sort Options

Field	Description
`price`	Current USD price
`volume24h`	24-hour trading volume
`marketCap`	Market capitalization
`holders`	Number of unique holders
`name`	Alphabetical by token name
`symbol`	Alphabetical by ticker symbol

Example: Top Tokens by Volume

curl "https://api.vybenetwork.com/tokens?sortByDesc=volume24h&limit=50" \
  -H "X-API-Key: YOUR_API_KEY"

Example Response

{
  "total": 15234,
  "page": 0,
  "limit": 50,
  "data": [
    {
      "mintAddress": "So11111111111111111111111111111111111111112",
      "name": "Wrapped SOL",
      "symbol": "SOL",
      "decimals": 9,
      "logoUrl": "https://...",
      "price": "185.42",
      "priceChange24h": "+2.3%",
      "volume24h": "1234567890.00",
      "marketCap": "85432100000.00",
      "holders": 4521300,
      "verified": true
    },
    {
      "mintAddress": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
      "name": "USD Coin",
      "symbol": "USDC",
      "decimals": 6,
      "logoUrl": "https://...",
      "price": "1.00",
      "priceChange24h": "-0.01%",
      "volume24h": "987654321.00",
      "marketCap": "34567890123.00",
      "holders": 2345678,
      "verified": true
    }
  ]
}

Response Fields

Field	Description
`total`	Total number of tracked tokens
`page`	Current page number
`limit`	Results per page
`data[].mintAddress`	Token mint public key
`data[].price`	Current USD price
`data[].priceChange24h`	24-hour price change
`data[].volume24h`	24-hour trading volume
`data[].marketCap`	Market capitalization
`data[].holders`	Number of holders
`data[].verified`	Token verification status

Common Use Cases

Use Case	Implementation
Token Screener	Filter and sort by metrics
Market Overview	Top tokens by volume/cap
Trending Page	Highest volume in 24h
Discovery Tool	Find tokens by criteria
Watchlist Sync	Update multiple tokens

Token Screener Example

Build a filterable token list:

async function getTokenScreener({
  sortBy = 'volume24h',
  sortOrder = 'desc',
  page = 0,
  limit = 100
} = {}) {
  const sortParam = sortOrder === 'desc' ? 'sortByDesc' : 'sortByAsc';
  
  const response = await fetch(
    `https://api.vybenetwork.com/tokens?${sortParam}=${sortBy}&limit=${limit}&page=${page}`,
    { headers: { "X-API-Key": API_KEY } }
  );
  const { data, total } = await response.json();
  
  return {
    tokens: data.map(token => ({
      mint: token.mintAddress,
      symbol: token.symbol,
      name: token.name,
      logo: token.logoUrl,
      price: parseFloat(token.price),
      priceFormatted: `$${parseFloat(token.price).toFixed(6)}`,
      change24h: token.priceChange24h,
      volume24h: parseFloat(token.volume24h),
      volumeFormatted: formatUsd(parseFloat(token.volume24h)),
      marketCap: parseFloat(token.marketCap),
      marketCapFormatted: formatUsd(parseFloat(token.marketCap)),
      holders: token.holders,
      verified: token.verified
    })),
    pagination: {
      page,
      limit,
      total,
      totalPages: Math.ceil(total / limit)
    }
  };
}

function formatUsd(n) {
  if (n >= 1e9) return `$${(n / 1e9).toFixed(2)}B`;
  if (n >= 1e6) return `$${(n / 1e6).toFixed(2)}M`;
  if (n >= 1e3) return `$${(n / 1e3).toFixed(2)}K`;
  return `$${n.toFixed(2)}`;
}

Paginated Fetch All

Retrieve all tokens across multiple pages:

async function getAllTokens(maxTokens = 5000) {
  const allTokens = [];
  let page = 0;
  const limit = 1000;
  
  while (allTokens.length < maxTokens) {
    const response = await fetch(
      `https://api.vybenetwork.com/tokens?sortByDesc=marketCap&limit=${limit}&page=${page}`,
      { headers: { "X-API-Key": API_KEY } }
    );
    const { data, total } = await response.json();
    
    allTokens.push(...data);
    
    // Stop if we've fetched everything or reached limit
    if (data.length < limit || allTokens.length >= total) break;
    page++;
    
    // Rate limit friendly
    await new Promise(r => setTimeout(r, 100));
  }
  
  return allTokens;
}

Filter by Criteria

Apply custom filters to find specific tokens:

async function filterTokens({
  minVolume,
  minHolders,
  minMarketCap,
  maxMarketCap,
  onlyVerified = true
}) {
  // Fetch top tokens by volume (most likely to match criteria)
  const response = await fetch(
    "https://api.vybenetwork.com/tokens?sortByDesc=volume24h&limit=1000",
    { headers: { "X-API-Key": API_KEY } }
  );
  const { data } = await response.json();
  
  return data.filter(token => {
    if (onlyVerified && !token.verified) return false;
    if (minVolume && parseFloat(token.volume24h) < minVolume) return false;
    if (minHolders && token.holders < minHolders) return false;
    if (minMarketCap && parseFloat(token.marketCap) < minMarketCap) return false;
    if (maxMarketCap && parseFloat(token.marketCap) > maxMarketCap) return false;
    return true;
  });
}

// Find "gems": high volume, decent holders, low market cap
const gems = await filterTokens({
  minVolume: 100000,       // $100k+ daily volume
  minHolders: 1000,        // 1k+ holders
  maxMarketCap: 10000000,  // Under $10M market cap
  onlyVerified: true
});

Watchlist Tracker

Track a list of specific tokens efficiently:

async function updateWatchlist(mintAddresses) {
  // For small watchlists, filter from bulk fetch
  if (mintAddresses.length <= 20) {
    const response = await fetch(
      "https://api.vybenetwork.com/tokens?sortByDesc=marketCap&limit=1000",
      { headers: { "X-API-Key": API_KEY } }
    );
    const { data } = await response.json();
    
    return mintAddresses.map(mint => {
      const token = data.find(t => t.mintAddress === mint);
      return token || { mintAddress: mint, notFound: true };
    });
  }
  
  // For larger watchlists, fetch individually in parallel
  return Promise.all(
    mintAddresses.map(mint =>
      fetch(`https://api.vybenetwork.com/tokens/${mint}`, {
        headers: { "X-API-Key": API_KEY }
      }).then(r => r.json()).catch(() => ({ mintAddress: mint, error: true }))
    )
  );
}

Related Endpoints

Token Details - Full data for individual tokens
Holders - Top holder analysis
Token Candles - Price charts