V2F0IGlzIE1WUlY/IEVlbiBiZWxhbmdyaWprIGtlbmdldGFsIHZvb3IgZGUgd2FhcmRlcmluZyB2YW4gY3J5cHRvLWFjdGl2YSBiZWdyaWpwZW4=

2025-06-27, 09:45

<p><img src="https://gimg2.gateimg.com/image/mvrv202506271743221376627750.png" alt="">
</p><p>In de zeer volatiele cryptocurrency-markt is het bepalen wanneer een activum overgewaardeerd of ondergewaardeerd is een kernuitdaging voor investeerders. De MVRV-ratio (Market Value to Realized Value) is een belangrijke on-chain metriek die is ontwikkeld om dit probleem aan te pakken. Het werd voor het eerst geïntroduceerd door analisten Murad Mahmudov en David Puell in 2018 en is sindsdien een standaardtool in de industrie geworden voor het meten van de waarderingsniveaus van cryptocurrency-activa zoals Bitcoin.</p>
<h2 id="h2-Kernprincipe20van20MVRV20Marktwaarde20versus20Werkelijke20Kosten508092"><a name="Kernprincipe van MVRV: Marktwaarde versus Werkelijke Kosten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kernprincipe van MVRV: Marktwaarde versus Werkelijke Kosten</h2><p>Het begrijpen van MVRV vereist het uiteenvallen van de twee belangrijkste componenten:</p>
<ul>
<li><p>Marktwaarde (MV): Dit is de marktcapitalisatie in traditionele zin, berekend als:</p>
<blockquote>
<p>Huidige prijs × Circulerende voorraad<br>Het weerspiegelt de totale waarde van activa in realtime handel en fluctueert aanzienlijk met de marktsentiment.
</p></blockquote>
</li><li><p>Gerealiseerde Waarde (RV): Ook bekend als “werkelijke marktwaarde”, de berekening is gebaseerd op on-chain gegevens van de blockchain:</p>
<blockquote>
<p>∑ (prijs bij de laatste on-chain beweging van elke token × hoeveelheid)<br>Het volgt de marktprijs bij de laatste overdracht van elke token en aggregeert om de gemiddelde kostprijsbasis van houders over het netwerk af te leiden. Bijvoorbeeld, als een <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> werd laatst overgedragen voor $30.000, ongeacht of de huidige prijs stijgt naar $60.000 of daalt naar $20.000, blijft de bijdrage aan de RV $30.000.</p>
</blockquote>
</li></ul>
<h3 id="h3-MVRV20Ratio2020MV2020RV141495"><a name="MVRV Ratio = MV / RV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MVRV Ratio = MV / RV</h3><p>Deze ratio onthult een kernfeit:</p>
<ul>
<li>Wanneer MVRV &gt; 1: De marktprijs is hoger dan de gemiddelde kosten, investeren zijn over het algemeen winstgevend, en de neiging om te verkopen neemt toe;</li><li>Wanneer MVRV &lt; 1: De marktprijs is lager dan de gemiddelde kosten, investeren zijn over het algemeen verliesgevend, en het kan dicht bij de marktbodem zijn.</li></ul>
<h3 id="h3-Waarom20is20MVRV20effectiever20dan20traditionele20indicatoren970881"><a name="Waarom is MVRV effectiever dan traditionele indicatoren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom is MVRV effectiever dan traditionele indicatoren?</h3><p>In tegenstelling tot traditionele maatstaven zoals de koers-winstverhouding, maakt MVRV direct gebruik van de transparantie van blockchain om werkelijke kosten te volgen. De voordelen zijn onder andere:</p>
<ol>
<li>Filteren van interferentie van “zombie tokens”: Verloren of langdurig onverhuurde tokens (goed voor ongeveer 15% van Bitcoin) vervormen de werkelijke waarde schatting niet;</li><li>Weerspiegelen van psychologische spelletjes: Extreme waarden van de maatstaf komen vaak overeen met keerpunten in de groepsemoties van “gierigheid” of “angst,” en volgen het investeringsprincipe van “wees gierig wanneer anderen bang zijn”;</li><li>Identificeren van marktfase stadia:<ul>
<li>Top van de bullmarkt: MVRV &gt; 3 (bijvoorbeeld, het bereiken van 3.7 in 2017, gevolgd door een crash van 80%);</li><li>Bodem van de bear market: MVRV &lt; 1 (bijvoorbeeld, dalend naar 0.85 in maart 2020, daarna een rebound van 600%).</li></ul>
</li></ol>
<h2 id="h2-MVRV20Geavanceerde20Toepassingen20Zscore20en20Houderssegmentatie238372"><a name="MVRV Geavanceerde Toepassingen: Z-score en Houderssegmentatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MVRV Geavanceerde Toepassingen: Z-score en Houderssegmentatie</h2><p>Om de nauwkeurigheid van de beoordeling te verbeteren, hebben analisten een afgeleide indicator van MVRV ontwikkeld:</p>
<h3 id="h3-MVRVZ20Score947992"><a name="MVRV-Z Score" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MVRV-Z Score</h3><p>Het concept van standaarddeviatie uit de statistiek wordt geïntroduceerd op basis van MVRV om de mate te meten waarin de huidige waarde afwijkt van het historische gemiddelde. De betekenis is:</p>
<ul>
<li>Z &gt; 6.9: Ernstig overgewaardeerd, wat wijst op verkooprisico (nauwkeurigheid van meer dan 94%);</li><li>Z &lt; 0: Ernstig ondergewaardeerd, een koopkans aan de linkerkant (bijv. gemiddelde opbrengst van 480% na aankoop tijdens de berenmarkt van 2022).</li></ul>
<h3 id="h3-LTHMVRV20en20STHMVRV623732"><a name="LTH-MVRV en STH-MVRV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LTH-MVRV en STH-MVRV</h3><p>Gelaagde analyse op basis van houdduur:</p>
<ul>
<li>Langetermijnhouders (LTH, &gt;155 dagen): Kosten stabiel, accumuleren tokens wanneer MVRV laag is;</li><li>Kortetermijnhouders (STH, &lt;155 dagen): Kosten dicht bij de huidige prijs, aanzienlijke verkoopdruk wanneer MVRV hoog is.</li></ul>
<p>Deze classificatie kan de richting van “slim geld” voorspellen. Bijvoorbeeld, een toename van LTH tijdens een lage MVRV-fase geeft vaak aan dat er een bodem wordt gevormd.</p>
<h2 id="h2-Praktijkgeval20Hoe20leidt20MVRV20Investeringen681860"><a name="Praktijkgeval: Hoe leidt MVRV Investeringen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Praktijkgeval: Hoe leidt MVRV Investeringen?</h2><h3 id="h3-Onderkant20Identificatie20Bitcoin20als20Voorbeeld740230"><a name="Onderkant Identificatie (Bitcoin als Voorbeeld)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderkant Identificatie (Bitcoin als Voorbeeld)</h3><ul>
<li>2018 Bear Market: MVRV-Z werd negatief in november, wat 4 maanden aanhield, met een maximale daling van 28%, maar de rebound in het volgende jaar zorgde voor een rendement van 250%;</li><li>2022 Bear Market: MVRV viel onder 1, met Ethereum’s MVRV rond 0.9 in dezelfde periode, beiden triggerden koop signalen.</li></ul>
<h3 id="h3-Top20Waarschuwing944187"><a name="Top Waarschuwing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Top Waarschuwing</h3><ul>
<li>2021 Stierenmarkt: MVRV-Z brak 7, de marktkapitalisatie van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> daalde nadat deze $3,7 biljoen had bereikt;</li><li><a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> (DOGE): Nadat MVRV in augustus 2024 1 benaderde, steeg het met 400%, terwijl een hoge MVRV een risico op correctie aangeeft.</li></ul>
<h2 id="h2-Beperkingen20van20MVRV20en20Gebruik20Aanbevelingen626980"><a name="Beperkingen van MVRV en Gebruik Aanbevelingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Beperkingen van MVRV en Gebruik Aanbevelingen</h2><p>Ondanks zijn kracht is MVRV geen “magische sleutel” en is voorzichtigheid geboden:</p>
<ol>
<li>Tijd blinde vlekken: De duur van bear/bull markten kan niet voorspeld worden (de onderste range kan variëren van 1 week tot 1 jaar);</li><li>Toepassingsbeperkingen: Effectiever voor mainstream munten met rijke on-chain gegevens (BTC, ETH), minder referentiewaarde voor kleine munten;</li><li>Indicator botheid: Naarmate het gebruik wijdverbreid wordt, kan het kritieke punt falen door zelfvervullende verwachtingen.</li></ol>
<p>Aanbevelingen voor best practices:</p>
<ul>
<li>Combineer met andere indicatoren: zoals SOPR (Spent Output Profit Ratio), netto-uitwisselingstroom, enz. om signalen te valideren;</li><li>Bouw posities in batches op: investeer regelmatig over 6 - 12 maanden in de MVRV-Z &lt; 0 regio om het risico op kortetermijnvolatiliteit te verminderen;</li><li>Langetermijnperspectief: vermijd gebruik voor kortetermijnhandel, focus op cyclische timing.</li></ul>
<p>De kernwaarde van MVRV ligt in het kwantificeren van marktsentiment in betrouwbare gegevens, doordringend in prijsruis om onderliggende waarde te onthullen. Zoals het on-chain analytics bedrijf Glassnode het verwoordt: het is de “thermometer van markcycli.” Bij crypto-investeringen is het beter om niet achter kortetermijnfluctuaties aan te jagen, maar MVRV te gebruiken om inzicht te krijgen in de cycluspositie—wanneer de indicator de groene ondergewaardeerde zone binnenkomt, kan dat het moment zijn van “anderen zijn bang, ik ben hebberig.”</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blog Team</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u enige 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>