Skip to main content

vaultSummaries

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

Why Hyperliquid? Build on the dominant perpetuals DEX with 70% market share, $2.7T+ lifetime volume, and $2B TVL with 200K orders/second throughput, zero gas fees, sub-second finality, and fully onchain Central Limit Order Book (CLOB).

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

Request#

Endpoint#

POST https://api-hyperliquid-mainnet-info.n.dwellir.com/info

Headers#

HeaderValueRequired
Content-Typeapplication/jsonYes
X-Api-KeyYour API keyYes

Parameters#

ParameterTypeRequiredDescription
typestringYesMust be "vaultSummaries"

Example Request#

{
  "type": "vaultSummaries"
}

Response#

Success Response#

[
  {
    "vaultAddress": "0x1234567890abcdef1234567890abcdef12345678",
    "name": "Alpha Strategy Vault",
    "tvl": "5000000.00",
    "apy": "45.2",
    "totalDeposits": "4800000.00",
    "totalWithdrawals": "200000.00",
    "netDeposits": "4600000.00",
    "sharePrice": "1.15",
    "totalShares": "4347826.09",
    "inception": "2024-01-15",
    "performanceFee": "20",
    "managementFee": "2",
    "minDeposit": "1000.00",
    "depositLockup": "7"
  },
  {
    "vaultAddress": "0xabcdef1234567890abcdef1234567890abcdef12",
    "name": "Delta Neutral Vault",
    "tvl": "3500000.00",
    "apy": "28.7",
    "totalDeposits": "3200000.00",
    "totalWithdrawals": "100000.00",
    "netDeposits": "3100000.00",
    "sharePrice": "1.09",
    "totalShares": "3211009.17",
    "inception": "2024-02-20",
    "performanceFee": "15",
    "managementFee": "1.5",
    "minDeposit": "500.00",
    "depositLockup": "3"
  }
]

Response Fields#

The response is an array of vault summary objects, each containing:

FieldTypeDescription
vaultAddressstringEthereum address of the vault contract
namestringName of the vault
tvlstringTotal value locked in USD
apystringAnnual percentage yield
totalDepositsstringCumulative deposits in USD
totalWithdrawalsstringCumulative withdrawals in USD
netDepositsstringNet deposits (deposits - withdrawals)
sharePricestringCurrent share price
totalSharesstringTotal shares outstanding
inceptionstringVault creation date (ISO 8601)
performanceFeestringPerformance fee percentage
managementFeestringManagement fee percentage
minDepositstringMinimum deposit amount in USD
depositLockupstringLockup period in days

Code Examples#

curl -X POST 'https://api-hyperliquid-mainnet-info.n.dwellir.com/info' \
  -H 'X-Api-Key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "type": "vaultSummaries"
  }'

Common Use Cases#

1. Find Vaults by Investment Criteria#

Filter vaults based on specific requirements:

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:

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:

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:

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:

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}`);
});

Error Handling#

Common Errors#

ErrorCauseSolution
401 UnauthorizedInvalid API keyVerify your API key is correct
429 Too Many RequestsRate limit exceededImplement request throttling
500 Internal Server ErrorServer issueRetry with exponential backoff

Error Response Example#

{
  "error": "Rate limit exceeded",
  "code": "RATE_LIMIT_EXCEEDED"
}

Robust Error Handling#

async function safeGetVaultSummaries(maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await getVaultSummaries();
    } catch (error) {
      if (error.response?.status === 429) {
        const delay = Math.pow(2, i) * 1000;
        await new Promise(r => setTimeout(r, delay));
      } else if (i === maxRetries - 1) {
        throw error;
      }
    }
  }
}

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 →