Docs

vaultSummaries - HyperCore Info Endpoint

Get comprehensive summary information for all vaults on Hyperliquid including TVL, APY, performance metrics, and vault details.

Get comprehensive summary information for all vaults on the platform, including performance metrics, total value locked, and vault characteristics.

Why Hyperliquid? Build on the trading-focused EVM and HyperCore ecosystem built for onchain perpetuals and market data with HyperCore market structure, sub-second finality, and direct access to trading-focused data services.

Authenticate HyperCore Info requests by sending your Dwellir API key in the x-api-key header to https://api-hyperliquid-mainnet-info.n.dwellir.com/info.

When to Use This Endpoint

The vaultSummaries endpoint is essential for vault aggregators, analytics platforms, and DeFi dashboards who need to:

  • Aggregate Vault Data — Get complete overview of all available vaults
  • Build Vault Explorers — Create searchable vault directories
  • Track Market Growth — Monitor total vault ecosystem metrics
  • Portfolio Diversification — Discover vaults across different strategies

Common Use Cases

1. Find Vaults by Investment Criteria

Filter vaults based on specific requirements:

JavaScript
async function findVaultsByCriteria(criteria) {
  const vaults = await getVaultSummaries();

  return vaults.filter(v => {
    const tvl = parseFloat(v.tvl);
    const apy = parseFloat(v.apy);
    const minDeposit = parseFloat(v.minDeposit);
    const lockup = parseInt(v.depositLockup);
    const perfFee = parseFloat(v.performanceFee);

    // Check all criteria
    if (criteria.minTVL && tvl < criteria.minTVL) return false;
    if (criteria.minAPY && apy < criteria.minAPY) return false;
    if (criteria.maxMinDeposit && minDeposit > criteria.maxMinDeposit) return false;
    if (criteria.maxLockup && lockup > criteria.maxLockup) return false;
    if (criteria.maxPerformanceFee && perfFee > criteria.maxPerformanceFee) return false;

    return true;
  });
}

// Usage
const suitableVaults = await findVaultsByCriteria({
  minTVL: 1000000,        // At least $1M TVL
  minAPY: 25,             // At least 25% APY
  maxMinDeposit: 5000,    // Max $5k minimum deposit
  maxLockup: 7,           // Max 7 days lockup
  maxPerformanceFee: 20   // Max 20% performance fee
});

console.log(`Found ${suitableVaults.length} vaults matching criteria`);
suitableVaults.forEach(v => {
  console.log(`${v.name}: ${v.apy}% APY, $${v.tvl} TVL`);
});

2. Analyze Vault Growth Metrics

Track vault growth and capital flows:

JavaScript
async function analyzeVaultGrowth() {
  const vaults = await getVaultSummaries();

  const analysis = vaults.map(v => {
    const tvl = parseFloat(v.tvl);
    const netDeposits = parseFloat(v.netDeposits);
    const sharePrice = parseFloat(v.sharePrice);

    // Calculate returns from share price
    const returns = ((sharePrice - 1) / 1) * 100;

    // Calculate growth from trading vs deposits
    const tradingGains = tvl - netDeposits;
    const growthFromTrading = (tradingGains / netDeposits) * 100;

    return {
      name: v.name,
      tvl: tvl,
      netDeposits: netDeposits,
      tradingGains: tradingGains,
      returns: returns.toFixed(2),
      growthFromTrading: growthFromTrading.toFixed(2),
      depositorCount: Math.round(netDeposits / parseFloat(v.minDeposit))
    };
  });

  return analysis.sort((a, b) => b.growthFromTrading - a.growthFromTrading);
}

// Usage
const growth = await analyzeVaultGrowth();
console.log('\n=== Vaults with Highest Trading Gains ===');
growth.slice(0, 5).forEach((v, i) => {
  console.log(`\n${i + 1}. ${v.name}`);
  console.log(`   Trading Gains: $${v.tradingGains.toLocaleString()}`);
  console.log(`   Growth from Trading: ${v.growthFromTrading}%`);
  console.log(`   Total Returns: ${v.returns}%`);
});

3. Compare Fee Structures

Analyze and compare vault fee models:

JavaScript
async function analyzeFeeStructures() {
  const vaults = await getVaultSummaries();

  const feeAnalysis = vaults.map(v => {
    const apy = parseFloat(v.apy);
    const perfFee = parseFloat(v.performanceFee);
    const mgmtFee = parseFloat(v.managementFee);
    const tvl = parseFloat(v.tvl);

    // Estimate annual fees
    const annualMgmtFee = tvl * (mgmtFee / 100);
    const estimatedPerfFee = tvl * (apy / 100) * (perfFee / 100);
    const totalAnnualFees = annualMgmtFee + estimatedPerfFee;

    // Net APY after fees
    const grossReturns = tvl * (apy / 100);
    const netReturns = grossReturns - totalAnnualFees;
    const netAPY = (netReturns / tvl) * 100;

    return {
      name: v.name,
      grossAPY: apy,
      netAPY: netAPY.toFixed(2),
      perfFee: perfFee,
      mgmtFee: mgmtFee,
      totalFeesUSD: totalAnnualFees.toFixed(2),
      feeImpact: ((apy - netAPY) / apy * 100).toFixed(2)
    };
  });

  // Sort by net APY
  return feeAnalysis.sort((a, b) => parseFloat(b.netAPY) - parseFloat(a.netAPY));
}

// Usage
const feeAnalysis = await analyzeFeeStructures();
console.log('\n=== Best Net Returns After Fees ===');
feeAnalysis.slice(0, 5).forEach((v, i) => {
  console.log(`\n${i + 1}. ${v.name}`);
  console.log(`   Gross APY: ${v.grossAPY}%`);
  console.log(`   Net APY: ${v.netAPY}%`);
  console.log(`   Fee Impact: ${v.feeImpact}%`);
});

4. Track Market Concentration

Analyze TVL distribution across vaults:

JavaScript
async function analyzeMarketConcentration() {
  const vaults = await getVaultSummaries();

  // Sort by TVL
  const sortedVaults = [...vaults].sort((a, b) =>
    parseFloat(b.tvl) - parseFloat(a.tvl)
  );

  const totalTVL = vaults.reduce((sum, v) => sum + parseFloat(v.tvl), 0);

  // Calculate concentration metrics
  const top5TVL = sortedVaults.slice(0, 5).reduce((sum, v) =>
    sum + parseFloat(v.tvl), 0
  );
  const top10TVL = sortedVaults.slice(0, 10).reduce((sum, v) =>
    sum + parseFloat(v.tvl), 0
  );

  const concentration = {
    totalVaults: vaults.length,
    totalTVL: totalTVL,
    top5Share: ((top5TVL / totalTVL) * 100).toFixed(2),
    top10Share: ((top10TVL / totalTVL) * 100).toFixed(2),
    avgTVL: (totalTVL / vaults.length).toFixed(2),
    medianTVL: parseFloat(sortedVaults[Math.floor(vaults.length / 2)].tvl)
  };

  return {
    ...concentration,
    topVaults: sortedVaults.slice(0, 5).map(v => ({
      name: v.name,
      tvl: parseFloat(v.tvl),
      marketShare: ((parseFloat(v.tvl) / totalTVL) * 100).toFixed(2)
    }))
  };
}

// Usage
const concentration = await analyzeMarketConcentration();
console.log('\n=== Market Concentration ===');
console.log(`Total TVL: $${concentration.totalTVL.toLocaleString()}`);
console.log(`Top 5 control: ${concentration.top5Share}%`);
console.log(`Top 10 control: ${concentration.top10Share}%`);

console.log('\n=== Top 5 Vaults ===');
concentration.topVaults.forEach((v, i) => {
  console.log(`${i + 1}. ${v.name}: ${v.marketShare}% market share`);
});

5. Build Vault Comparison Tool

Create a comprehensive vault comparison:

JavaScript
async function compareVaults(vaultAddresses) {
  const allVaults = await getVaultSummaries();

  const selectedVaults = allVaults.filter(v =>
    vaultAddresses.includes(v.vaultAddress)
  );

  const comparison = selectedVaults.map(v => {
    const tvl = parseFloat(v.tvl);
    const apy = parseFloat(v.apy);
    const sharePrice = parseFloat(v.sharePrice);
    const perfFee = parseFloat(v.performanceFee);
    const mgmtFee = parseFloat(v.managementFee);

    // Calculate net APY after fees
    const grossReturns = tvl * (apy / 100);
    const annualFees = tvl * (mgmtFee / 100) + grossReturns * (perfFee / 100);
    const netAPY = ((grossReturns - annualFees) / tvl) * 100;

    return {
      name: v.name,
      address: v.vaultAddress,
      tvl: tvl,
      apy: apy,
      netAPY: netAPY.toFixed(2),
      sharePrice: sharePrice,
      returns: ((sharePrice - 1) * 100).toFixed(2),
      minDeposit: parseFloat(v.minDeposit),
      lockup: parseInt(v.depositLockup),
      fees: `${perfFee}% perf / ${mgmtFee}% mgmt`,
      inception: v.inception
    };
  });

  return comparison;
}

// Usage
const vaultsToCompare = [
  '0x1234567890abcdef1234567890abcdef12345678',
  '0xabcdef1234567890abcdef1234567890abcdef12'
];

const comparison = await compareVaults(vaultsToCompare);
console.log('\n=== Vault Comparison ===');
comparison.forEach(v => {
  console.log(`\n${v.name}`);
  console.log(`TVL: $${v.tvl.toLocaleString()}`);
  console.log(`Gross APY: ${v.apy}% | Net APY: ${v.netAPY}%`);
  console.log(`Returns: ${v.returns}%`);
  console.log(`Min Deposit: $${v.minDeposit} | Lockup: ${v.lockup} days`);
  console.log(`Fees: ${v.fees}`);
});

Best Practices

  1. Cache appropriately — Vault summaries can be cached for 5-15 minutes
  2. Consider fees — Always calculate net returns after fees
  3. Check liquidity — Verify TVL is sufficient for your deposit size
  4. Review lockups — Ensure lockup periods match your investment timeline
  5. Monitor growth — Track both deposit growth and trading performance

Access comprehensive Hyperliquid vault data with Dwellir's HyperCore Info Endpoint. Get your API key →

validatorL1Votes

Get validator voting information for L1 operations on Hyperliquid. Monitor consensus, voting patterns, and validator participation.

webData2

Get the Hyperliquid `webData2` envelope for a user. This response can be sparse and is best treated as a lightweight, web-client-oriented payload rather than a guaranteed full dashboard snapshot.

On this page

When to Use This Endpoint
Common Use Cases
1. Find Vaults by Investment Criteria
2. Analyze Vault Growth Metrics
3. Compare Fee Structures
4. Track Market Concentration
5. Build Vault Comparison Tool
Best Practices
Related Endpoints