V2F0IGlzIEZEVj8gQmVyZWtlbmluZywgUmlzaWNvXCdzICYgSW52ZXN0ZWVyZGVyc2ltcGFjdA==

2025-06-23, 10:19

<p><img src="https://gimg2.gateimg.com/image/marketnews2202506150113125567162553.png" alt=""><br>Als de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> wordt in 2025 geavanceerder, vragen meer investeerders: Wat is FDV, en waarom is het zo belangrijk bij het evalueren van tokens? FDV, kort voor Fully Diluted Valuation, is een belangrijke maatstaf geworden bij het analyseren van de on-chain tokenwaardering en het langetermijnrisico. Dit artikel legt het concept van FDV uit, hoe het wordt berekend, welke risico’s het met zich meebrengt, en hoe je het effectief kunt toepassen in je investeringsbeslissingen.</p>
<h2 id="h2-Wat20is20FDV20Het20kernconcept20achter20de20volledig20verwaterde20waardering486006"><a name="Wat is FDV? Het kernconcept achter de volledig verwaterde waardering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is FDV? Het kernconcept achter de volledig verwaterde waardering</h2><p>FDV (Volledig Verduningswaardering) is de totale verwachte marktkapitalisatie van een token als de gehele maximale voorraad in omloop zou zijn. Het gaat ervan uit dat alle vergrendelde, verworven of niet-uitgegeven tokens zijn vrijgegeven en gewaardeerd tegen de huidige marktprijs.</p>
<p>FDV-formule:</p>
<ul>
<li>FDV = Huidige Tokenprijs × Maximale Aanvoer</li></ul>
<p>Bijvoorbeeld, als een token geprijsd is op $1 en de maximale voorraad 1 miljard is, is de FDV $1 miljard, zelfs als er momenteel slechts 100 miljoen tokens in omloop zijn.</p>
<h2 id="h2-FDV20vs20Marktkapitalisatie20Wat20is20het20verschil155239"><a name="FDV vs. Marktkapitalisatie: Wat is het verschil?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FDV vs. Marktkapitalisatie: Wat is het verschil?</h2><p>Veel investeerders verwarren FDV met Market Cap, maar ze zijn fundamenteel verschillend:</p>
<ul>
<li>Market Cap = Tokenprijs × Circulerende Aanvoer</li><li>FDV = Tokenprijs × Maximale Aanvoer</li></ul>
<p>Bijvoorbeeld, een token kan bij de lancering slechts 10% van zijn aanbod hebben vrijgegeven. Bij $1 per token en 100 miljoen tokens in omloop, zou de marktkapitalisatie $100 miljoen zijn - maar de FDV zou $1 miljard zijn. Dit creëert vaak een valse indruk dat de token ondergewaardeerd is, terwijl in werkelijkheid een groot deel van het aanbod nog vergrendeld is en geleidelijk kan worden vrijgegeven, wat leidt tot verwatering.</p>
<h2 id="h2-FDV20en20Dilutie20Risico20Wat20Beleggers20Moeten20Overwegen432911"><a name="FDV en Dilutie Risico: Wat Beleggers Moeten Overwegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FDV en Dilutie Risico: Wat Beleggers Moeten Overwegen</h2><p>FDV is een cruciaal hulpmiddel om investeerders te helpen:</p>
<ul>
<li>Beoordeel het risico op verwatering: Een hoge FDV in vergelijking met de Marktkapitalisatie suggereert dat er een groot volume aan tokens ontgrendeld kan worden, wat de verkoopdruk kan verhogen.</li><li>Vergelijk projecten effectiever: Twee projecten met vergelijkbare marktkapitalisaties maar verschillende FDV’s kunnen zeer verschillende token-distributiestructuren hebben.</li><li>Beoordeel de marktsentiment: Projecten met opgeblazen FDV’s maar beperkte echte nut kunnen als overgewaardeerd worden beschouwd en negatieve markreacties ervaren.</li></ul>
<p>Inzicht in wat FDV is, helpt investeerders te voorkomen dat ze te veel betalen voor tokens die nog grote aanvoerreleases moeten ondergaan.</p>
<h2 id="h2-Veelvoorkomende20Misverstanden20Over20FDV693969"><a name="Veelvoorkomende Misverstanden Over FDV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelvoorkomende Misverstanden Over FDV</h2><p>FDV is nuttig - maar het kan ook misleidend zijn als het niet correct wordt gebruikt. Hier zijn veelvoorkomende valkuilen:</p>
<ul>
<li>Lage marktkapitalisatie, hoge FDV illusie: Veel tokens in een vroeg stadium hebben een lage circulerende voorraad en lijken “goedkoop”, maar de FDV vertelt een ander verhaal.</li><li>Gebrek aan transparantie over het ontgrendelingsschema: Als een project niet duidelijk openbaar maakt wanneer en hoe vergrendelde tokens zullen worden vrijgegeven, wordt het moeilijker om de FDV te contextualiseren.</li><li>Kunstmatig opgeblazen vroege prijzen: Projecten die tegen hoge prijzen met een kleine float worden gelanceerd, kunnen zien dat hun FDV de miljarden bereikt - zonder een voltooid product.</li></ul>
<p>Bij het onderzoeken van nieuw gelanceerde tokens op Gate, overweeg altijd de FDV naast de tokenomics en vesting schema’s.</p>
<h2 id="h2-FDV20in20202520Een20nieuwe20standaard20voor20Web3waardering704862"><a name="FDV in 2025: Een nieuwe standaard voor Web3-waardering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FDV in 2025: Een nieuwe standaard voor Web3-waardering</h2><p>In 2025 passen investeerders steeds vaker FDV toe in geavanceerde waarderingsmodellen, waaronder:</p>
<ul>
<li>FDV vs. TVL (Totaal Waarde Vergrendeld): Vooral voor DeFi-protocollen.</li><li>FDV per actieve gebruiker: Om de waardering ten opzichte van de netgrootte te meten.</li><li>FDV vs. omzet: Relevant voor projecten met on-chain omzet (bijv. DEX’s, GameFi, L1-blockchains).</li></ul>
<p>Gate biedt transparante FDV-metrics voor toonaangevende tokens zoals ARB (Arbitrum), OP (Optimism), APT (Aptos) en SUI—een essentiële factor tijdens vroege listings wanneer tokenontsluitingen de prijsontdekking aanzienlijk kunnen beïnvloeden.</p>
<h2 id="h2-Hoe20FDV20te20gebruiken20in20uw20cryptoinvesteringsstrategie169093"><a name="Hoe FDV te gebruiken in uw crypto-investeringsstrategie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe FDV te gebruiken in uw crypto-investeringsstrategie</h2><p>Om FDV effectief te gebruiken, overweeg dan de volgende stappen:</p>
<ol>
<li>Benchmark FDV binnen sectoren<br>Vergelijk FDV tussen projecten in dezelfde categorie. Als een Layer 1-keten bijvoorbeeld een FDV van $10 miljard heeft maar geen actief ecosysteem of ontwikkelaarstractie, kan het overgewaardeerd zijn in vergelijking met vergelijkbare blockchains.</li><li>Houd token-unlockschema’s in de gaten<br>Tokens met aanstaande unlocks kunnen verhoogde verkoopdruk ervaren. Gebruik tools en dashboards om deze evenementen te volgen.</li><li>Pas FDV aan voor kortetermijnanalyse<br>In plaats van de volledige maximale voorraad te gebruiken, bereken een “kortetermijn FDV” op basis van tokens die naar verwachting binnen de komende 6–12 maanden worden ontgrendeld voor praktischere planning.</li></ol>
<p>Het combineren van FDV met de marktkapitalisatie, handelsvolume, TVL en gemeenschapsmetrics creëert een sterkere basis voor het nemen van geïnformeerde investeringsbeslissingen.</p>
<h2 id="h2-Conclusie103866"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Weten wat FDV is, kan het verschil maken tussen een berekende investering en het lopen in een verdunningstrap. FDV weerspiegelt meer dan alleen de toekomstige waardering van een token - het onthult de volledige economische voetafdruk van het tokenmodel, het tempo van ontgrendelingen en de eerlijkheid van de distributie. Voordat je investeert in nieuwe tokens - of ze nu van Launchpad-evenementen komen, nieuw genoteerde projecten zijn of opkomende Layer 1s - controleer altijd de FDV en begrijp wat het betekent voor toekomstige prijsacties. Op Gate kunnen gebruikers FDV-metrics, token ontgrendelingsgegevens en liquiditeits-tools raadplegen, waardoor het gemakkelijker wordt om met vertrouwen te handelen in een snel bewegende. <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> markt.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, verzoek of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="3">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>