Skip to main content

leadingVaults

Get information about leading vaults on the platform, including performance metrics, total value locked (TVL), and annual percentage yield (APY).

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 leadingVaults endpoint is essential for investors, vault aggregators, and analytics platforms who need to:

  • Discover Top Performers — Find the best-performing vaults based on returns
  • Compare Vault Strategies — Analyze different vault strategies and their performance
  • Track Vault Rankings — Monitor vault leaderboard and relative performance
  • Build Vault Aggregators — Create vault discovery and comparison tools

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 "leadingVaults"

Example Request#

{
  "type": "leadingVaults"
}

Response#

Success Response#

[
  {
    "vaultAddress": "0x1234567890abcdef1234567890abcdef12345678",
    "name": "Alpha Strategy Vault",
    "tvl": "5000000.00",
    "apy": "45.2",
    "monthlyReturn": "3.5",
    "weeklyReturn": "0.8",
    "sharpeRatio": "2.1",
    "maxDrawdown": "12.5",
    "performanceFee": "20",
    "managementFee": "2"
  },
  {
    "vaultAddress": "0xabcdef1234567890abcdef1234567890abcdef12",
    "name": "Delta Neutral Vault",
    "tvl": "3500000.00",
    "apy": "28.7",
    "monthlyReturn": "2.3",
    "weeklyReturn": "0.5",
    "sharpeRatio": "1.8",
    "maxDrawdown": "8.2",
    "performanceFee": "15",
    "managementFee": "1.5"
  }
]

Response Fields#

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

FieldTypeDescription
vaultAddressstringEthereum address of the vault contract
namestringName of the vault
tvlstringTotal value locked in USD
apystringAnnual percentage yield
monthlyReturnstringMonthly return percentage
weeklyReturnstringWeekly return percentage
sharpeRatiostringRisk-adjusted return metric
maxDrawdownstringMaximum drawdown percentage
performanceFeestringPerformance fee percentage
managementFeestringManagement fee percentage

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": "leadingVaults"
  }'

Common Use Cases#

1. Find Best Performing Vaults#

Identify vaults with the highest returns:

async function findBestPerformers(minTvl = 1000000) {
  const vaults = await getLeadingVaults();

  // Filter by minimum TVL and sort by APY
  const qualifiedVaults = vaults
    .filter(v => parseFloat(v.tvl) >= minTvl)
    .sort((a, b) => parseFloat(b.apy) - parseFloat(a.apy));

  return qualifiedVaults.map(v => ({
    name: v.name,
    apy: parseFloat(v.apy),
    tvl: parseFloat(v.tvl),
    sharpeRatio: parseFloat(v.sharpeRatio),
    riskAdjustedReturn: parseFloat(v.apy) / parseFloat(v.maxDrawdown)
  }));
}

// Usage
const topVaults = await findBestPerformers(1000000);
console.log('Top performers with >$1M TVL:', topVaults.slice(0, 5));

2. Compare Vault Risk Profiles#

Analyze risk-adjusted returns:

async function analyzeVaultRisk() {
  const vaults = await getLeadingVaults();

  const riskAnalysis = vaults.map(v => {
    const apy = parseFloat(v.apy);
    const sharpe = parseFloat(v.sharpeRatio);
    const maxDrawdown = parseFloat(v.maxDrawdown);

    let riskLevel;
    if (maxDrawdown < 10 && sharpe > 2) {
      riskLevel = 'LOW';
    } else if (maxDrawdown < 20 && sharpe > 1.5) {
      riskLevel = 'MEDIUM';
    } else {
      riskLevel = 'HIGH';
    }

    return {
      name: v.name,
      apy: apy,
      sharpe: sharpe,
      maxDrawdown: maxDrawdown,
      riskLevel: riskLevel,
      score: (apy * sharpe) / maxDrawdown // Risk-adjusted score
    };
  });

  // Sort by risk-adjusted score
  return riskAnalysis.sort((a, b) => b.score - a.score);
}

// Usage
const analysis = await analyzeVaultRisk();
console.log('\n=== Risk-Adjusted Rankings ===');
analysis.forEach((v, i) => {
  console.log(`${i + 1}. ${v.name} (${v.riskLevel} RISK)`);
  console.log(`   APY: ${v.apy}% | Sharpe: ${v.sharpe} | Max DD: ${v.maxDrawdown}%`);
});

3. Calculate Total Market Metrics#

Compute aggregate vault statistics:

async function getMarketMetrics() {
  const vaults = await getLeadingVaults();

  const metrics = {
    totalVaults: vaults.length,
    totalTVL: vaults.reduce((sum, v) => sum + parseFloat(v.tvl), 0),
    avgAPY: vaults.reduce((sum, v) => sum + parseFloat(v.apy), 0) / vaults.length,
    avgSharpe: vaults.reduce((sum, v) => sum + parseFloat(v.sharpeRatio), 0) / vaults.length,
    avgDrawdown: vaults.reduce((sum, v) => sum + parseFloat(v.maxDrawdown), 0) / vaults.length,
    highestAPY: Math.max(...vaults.map(v => parseFloat(v.apy))),
    lowestDrawdown: Math.min(...vaults.map(v => parseFloat(v.maxDrawdown)))
  };

  return {
    ...metrics,
    totalTVL: metrics.totalTVL.toFixed(2),
    avgAPY: metrics.avgAPY.toFixed(2),
    avgSharpe: metrics.avgSharpe.toFixed(2),
    avgDrawdown: metrics.avgDrawdown.toFixed(2)
  };
}

// Usage
const metrics = await getMarketMetrics();
console.log('Vault Market Metrics:');
console.log(`Total TVL: $${parseFloat(metrics.totalTVL).toLocaleString()}`);
console.log(`Average APY: ${metrics.avgAPY}%`);
console.log(`Average Sharpe Ratio: ${metrics.avgSharpe}`);

4. Filter Vaults by Strategy Type#

Find vaults matching specific criteria:

async function findVaultsByStrategy(criteria) {
  const vaults = await getLeadingVaults();

  return vaults.filter(v => {
    const apy = parseFloat(v.apy);
    const sharpe = parseFloat(v.sharpeRatio);
    const drawdown = parseFloat(v.maxDrawdown);
    const tvl = parseFloat(v.tvl);

    // Conservative strategy
    if (criteria === 'conservative') {
      return drawdown < 10 && sharpe > 2 && tvl > 1000000;
    }

    // Aggressive strategy
    if (criteria === 'aggressive') {
      return apy > 40 && tvl > 500000;
    }

    // Balanced strategy
    if (criteria === 'balanced') {
      return apy > 25 && drawdown < 15 && sharpe > 1.5;
    }

    return false;
  });
}

// Usage
const conservative = await findVaultsByStrategy('conservative');
console.log(`Found ${conservative.length} conservative vaults`);

const aggressive = await findVaultsByStrategy('aggressive');
console.log(`Found ${aggressive.length} aggressive vaults`);

5. Build Vault Leaderboard#

Create a comprehensive vault ranking:

async function buildLeaderboard() {
  const vaults = await getLeadingVaults();

  // Calculate composite score
  const leaderboard = vaults.map(v => {
    const apy = parseFloat(v.apy);
    const sharpe = parseFloat(v.sharpeRatio);
    const tvl = parseFloat(v.tvl);
    const drawdown = parseFloat(v.maxDrawdown);

    // Weighted scoring: APY (40%), Sharpe (30%), TVL (20%), Low Drawdown (10%)
    const score = (
      (apy / 100) * 0.4 +
      (sharpe / 3) * 0.3 +
      (Math.log10(tvl) / 10) * 0.2 +
      ((100 - drawdown) / 100) * 0.1
    ) * 100;

    return {
      rank: 0, // Will be assigned after sorting
      name: v.name,
      vaultAddress: v.vaultAddress,
      score: score.toFixed(2),
      apy: apy,
      tvl: tvl,
      sharpe: sharpe,
      drawdown: drawdown
    };
  }).sort((a, b) => parseFloat(b.score) - parseFloat(a.score));

  // Assign ranks
  leaderboard.forEach((vault, index) => {
    vault.rank = index + 1;
  });

  return leaderboard;
}

// Usage
const leaderboard = await buildLeaderboard();
console.log('\n=== Vault Leaderboard ===');
leaderboard.slice(0, 10).forEach(v => {
  console.log(`\n#${v.rank} ${v.name}`);
  console.log(`Score: ${v.score} | APY: ${v.apy}% | TVL: $${v.tvl.toLocaleString()}`);
});

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 safeGetLeadingVaults(maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await getLeadingVaults();
    } catch (error) {
      if (error.response?.status === 429) {
        // Rate limit - exponential backoff
        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 — Leading vaults data can be cached for 5-15 minutes
  2. Compare holistically — Don't focus only on APY; consider risk metrics
  3. Monitor trends — Track vault performance over time, not just snapshots
  4. Validate fees — Account for performance and management fees in returns
  5. Check TVL — Larger TVL often indicates more established vaults

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