V2F0IGlzIFRWTD8gV2Fhcm9tIGlzIGRlIGJlbGFuZ3JpamtlIFRWTC1pbmRleCBpbiBEZUZpPw==

<p><img src="https://gimg2.gateimg.com/image/mn202505270718069061968753.png" alt=""><br>In de wereld van gedecentraliseerde financiën (DeFi), waar protocollen strijden om kapitaal en vertrouwen, staat TVL (Total Value Locked) als een van de meest cruciale metingen voor het evalueren van de gezondheid en tractie van een op blockchain gebaseerde toepassing. Of je nu een ontwikkelaar, investeerder, of iemand bent die onderzoek doet naar airdrops en DeFi-trends, het begrijpen van wat TVL is en hoe het werkt kan je helpen om slimmere beslissingen te nemen.
</p><p>Dit artikel van Gate duikt diep in de betekenis van TVL in crypto, het belang ervan, en hoe het effectief te volgen om kansen in de DeFi-ruimte te beoordelen.</p>
<h2 id="h2-Wat20is20TVL20in20Crypto65563"><a name="Wat is TVL in Crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is TVL in Crypto?</h2><p>TVL (Total Value Locked) verwijst naar het totale bedrag aan activa - meestal gemeten in USD - die zijn gedeponeerd of ingezet in een DeFi-protocol. Het vertegenwoordigt hoeveel kapitaal momenteel ‘geblokkeerd’ is in slimme contracten, zoals uitleenpools, inzetplatforms, liquiditeitspools en opbrengstboerderijen.</p>
<p>In eenvoudiger bewoordingen laat TVL zien hoeveel geld mensen vertrouwen hebben in een DeFi-protocol.</p>
<p>Bijvoorbeeld:</p>
<ul>
<li>Een uitleenplatform zoals <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> met $5B aan TVL betekent dat gebruikers $5B aan activa hebben gestort om uit te lenen of rente te verdienen.</li><li>Een gedecentraliseerde exchange (DEX) zoals <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> met een TVL van $3 miljard betekent dat er $3 miljard aan liquiditeit is ter ondersteuning van handelsparen.</li></ul>
<h2 id="h2-Waarom20TVL20Belangrijk20is20in20DeFi470862"><a name="Waarom TVL Belangrijk is in DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom TVL Belangrijk is in DeFi</h2><p>TVL is meer dan alleen een getal - het is een indicator van de adoptie, liquiditeit en kapitaalefficiëntie van een protocol. Hoe hoger de TVL, hoe actiever en betrouwbaarder het project doorgaans is.</p>
<p><strong>Hier is waarom TVL belangrijk is:</strong></p>
<ul>
<li>Liquiditeitsgezondheid: Een hoog TVL betekent diepe liquiditeit, wat de slippage voor handelaren vermindert en grotere transacties mogelijk maakt.</li><li>Verdienkansen: Projecten met groeiende TVL bieden vaak stabielere en aantrekkelijkere APY’s, waardoor yield-farmers en LP’s worden aangetrokken.</li><li>Investeerdersvertrouwen: Een sterke TVL geeft vertrouwen vanuit de gemeenschap aan en kan verdere institutionele interesse aantrekken.</li><li>Airdrop Potentieel: Veel projecten gebruiken met TVL gerelateerde metrieken (bijv. gebruikersdeposito’s) om de airdrop-eligibiliteit voor vroege gebruikers te bepalen.</li></ul>
<h2 id="h2-Hoe20TVL20wordt20berekend527008"><a name="Hoe TVL wordt berekend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe TVL wordt berekend</h2><p>TVL wordt berekend op basis van de huidige marktwaarde van alle tokens vergrendeld in een protocol, omgerekend naar USD. Het omvat tokens in:</p>
<ul>
<li>Staking</li><li>Uitleenpools</li><li>Liquiditeitsverschaffing</li><li>Governance of kluisjes</li></ul>
<p>Hieronder volgt een vereenvoudigde uiteenzetting van hoe TVL eruit zou kunnen zien voor een DeFi-protocol:</p>
<table>
<thead>
<tr>
<th>Component</th>
<th>Token vergrendeld</th>
<th>Prijs (USD)</th>
<th>Totale waarde (USD)</th>
</tr>
</thead>
<tbody>
<tr>
<td>ETH bij staking</td>
<td>50,000 ETH</td>
<td>$2,000</td>
<td>$100,000,000</td>
</tr>
<tr>
<td>USDC in uitleenpool</td>
<td>80,000,000 USDC</td>
<td>$1</td>
<td>$80,000,000</td>
</tr>
<tr>
<td>DAI in vaults</td>
<td>20.000.000 DAI</td>
<td>$1</td>
<td>$20,000,000</td>
</tr>
<tr>
<td>Totale TVL</td>
<td>-</td>
<td>-</td>
<td>$200,000,000</td>
</tr>
</tbody>
</table>
<p>Het bovenstaande is een vereenvoudigd voorbeeld, maar echte DeFi-protocollen zoals Curve, Lido en MakerDAO gebruiken vaak meerdere activa en ketens.</p>
<h2 id="h2-Beperkingen20van20TVL197375"><a name="Beperkingen van TVL" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Beperkingen van TVL</h2><p>Hoewel wat TVL is een eenvoudig concept, is het geen perfecte metriek. Hier zijn een paar beperkingen:</p>
<ul>
<li>TVL is prijsafhankelijk: als tokenprijzen dalen, daalt TVL, zelfs als het aantal vergrendelde tokens hetzelfde blijft.</li><li>Kan worden gemanipuleerd: Tijdelijke liquiditeitsinjecties (bijv. voor airdrop farming) kunnen de TVL verhogen zonder echte gebruikersbetrokkenheid.</li><li>Laat het aantal gebruikers niet zien: Een protocol kan een hoge TVL hebben van een paar walvissen, maar weinig gemeenschapsgebruik.</li></ul>
<p>Daarom moet TVL worden beschouwd naast andere metrieken zoals actieve gebruikers, transactievolume en totale protocolopbrengsten.</p>
<h2 id="h2-Hoe20u20TVL20op20Gate20kunt20volgen545278"><a name="Hoe u TVL op Gate kunt volgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe u TVL op Gate kunt volgen</h2><p>Bij Gate kunnen gebruikers trending DeFi-tokens verkennen, tokenstatistieken bekijken en TVL-gegevens ontdekken via:</p>
<ul>
<li>Gate DeFi Zone: Volg DeFi-tokens met realtime prestaties en liquiditeitsupdates</li><li>Token Info Pagina’s: Bekijk marktkapitalisatie, prijs, TVL (indien beschikbaar) en staking APRs</li><li>Gate Learn: Vind gidsen over het begrijpen van TVL, DeFi-protocollen en hoe passief inkomen te verdienen</li><li>Gate Startup &amp; Airdrops: Doe mee aan vroege projecten waar TVL-groei vaak beloond wordt</li></ul>
<p>Door TVL te combineren met echte gebruiksgegevens, helpt Gate gebruikers om weloverwogen DeFi-beslissingen te nemen.</p>
<h2 id="h2-Conclusie864838"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>TVL (Total Value Locked) is een belangrijke prestatie-indicator die de sterkte, populariteit en betrouwbaarheid van een DeFi-protocol weerspiegelt. Hoewel het niet de enige te overwegen metriek is, geeft het begrijpen van wat TVL is je een krachtige kijk op de DeFi-economie.</p>
<p>Als u een cryptogebruiker bent die luchtdaalkansen, inzetbeloningen of opbrengstboerderijen verkent, kan het bijhouden van TVL u helpen om vroege trends en hoogpotentiële protocollen te ontdekken.</p>
<p>Begin vandaag met het verkennen van DeFi-tokens en TVL-ranglijsten op Gate, waar innovatie inzicht ontmoet in de gedecentraliseerde wereld.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blog Team</strong><br><div class="info-tips"><em>De inhoud hiervan vormt geen aanbod, verzoek of aanbeveling. U moet altijd onafhankelijk professioneel advies inwinnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de diensten van Beperkte Locaties kan beperken of verbieden. Voor meer informatie kunt u de Gebruiksovereenkomst via lezen<a href="https://www.gate.com/legal/user-agreement" data-index="3">https://www.gate.com/legal/gebruikersovereenkomst</a>.<br><p></p><br></em></div></div></div>