QW5hbHlzZTogUmVsYXRpZSB0dXNzZW4gQml0Y29pbiBlbiBUcmFkRmkgQXNzZXQgVHlwZXM=

2023-09-06, 08:07

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR364449"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De correlatie tussen Amerikaanse aandelen en beleggingswaardige obligaties nam toe tijdens de eerste twee weken van augustus.</p>
<p>Bitcoin is al meer dan twee jaar gecorreleerd met edelmetalen zoals goud en zilver.</p>
<p>Een toename van de institutionele adoptie van cryptocurrencies resulteert in een sterkere correlatie tussen crypto en traditionele beleggingsactiva.</p>
<h2 id="h2-Introductie699078"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Tijdens <a href="https://www.gate.io/learn/course/bitcoin-fundamental" target="_blank">de beginjaren van bitcoin tussen 2009 en 2010</a> het ontbrak aan correlatie met de meeste activa, wat het zeer uniek maakte. Het was echt onafhankelijk van de onrust die verschillende soorten activa zoals aandelen, forexmarkten en grondstoffen beïnvloedde.</p>
<p>Echter, de toenemende bewustwording van de essentie van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en institutionele adoptie hebben geleid tot correlaties tussen <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> en andere soorten activa. Dit artikel onderzoekt de correlaties van bitcoin met andere activa, waaronder aandelen en grondstoffen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2110/crypto-funds-101-fund-classification" target="_blank">Crypto Fonds 101: Fondsklassificatie</a></p>
<h2 id="h2-Bitcoin20correlaties20met20traditionele20financile20activa958446"><a name="Bitcoin correlaties met traditionele financiële activa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin correlaties met traditionele financiële activa</h2><p>In de afgelopen jaren is bitcoin steeds meer gecorreleerd geraakt met verschillende soorten activa. Bijvoorbeeld, het is gecorreleerd met grote aandelen, edelmetalen en andere cryptocurrencies zoals ETH. Er zijn verschillende verklaringen waarom bitcoin gecorreleerd is met deze activa.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1275/why-many-crypto-assets-are-falling" target="_blank">Waarom vallen veel crypto-activa?</a></p>
<p>In oktober 2022 legde het Multidisciplinair Digitaal Publicatie-instituut de correlatie uit tussen crypto-activa en verschillende traditionele beleggingsinstrumenten. Ten eerste concludeerde het dat de correlatie van BTC met andere soorten activa sterker is op de lange termijn dan op de korte termijn. De belangrijkste reden hiervoor is dat bitcoin een hoge prijsvolatiliteit heeft.</p>
<p>De correlaties van crypto met traditionele financiële activa kwamen naar voren tijdens het Covid-19-tijdperk. Volgens het rapport van het Multidisciplinary Digital Publishing Institute is bitcoin positief gecorreleerd met verschillende risicovolle activa, maar negatief gecorreleerd met de Amerikaanse dollar. Deze conclusies kunnen echter veranderen naarmate er nieuwe prijsgegevens komen en opkomende trends zich voordoen.</p>
<h2 id="h2-Mogelijke20redenen20waarom20Bitcoin20correleert20met20verschillende20risicofactoren279426"><a name="Mogelijke redenen waarom Bitcoin correleert met verschillende risicofactoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mogelijke redenen waarom Bitcoin correleert met verschillende risicofactoren</h2><p>Voor <a href="https://www.gate.io/article/28405" target="_blank">we onderzoeken de correlatie van bitcoin</a> laten we eens kijken naar de mogelijke oorzaken van de correlaties met andere specifieke soorten activa.</p>
<p>Allereerst correleert bitcoin nu met andere soorten activa omdat het voorkomt op de balans van veel institutionele beleggingsfirma’s. Als gevolg hiervan nemen ze hun bitcoin-investeringsbeslissingen op basis van macro-economische fundamenten die ook van invloed zijn op de prijzen van andere soorten activa.</p>
<p>Als voorbeeld, aangezien bitcoin is geëvolueerd tot een klasse-activa diverse economische factoren zoals rentetarieven en inflatie van invloed zijn op de prijsbewegingen. Zoals we weten, zijn dit ook de factoren die de prijzen van andere soorten activa zoals grondstoffen, aandelen en indices bepalen. In de onderstaande tabel worden de factoren getoond die van invloed kunnen zijn op de prijzen van cryptocurrencies en aandelen.</p>
<p>Lees ook: <a href="https://www.gate.io/explore/bitcoin-halving-countdown" target="_blank">Bitcoin-halvering: aftellen naar Crypto Bull Market</a><img src="https://gimg2.gateimg.com/image/article/16939874118441693987355_.pic.jpg" alt=""><br>Factoren die de prijzen van de aandelenmarkt en cryptocurrencies beïnvloeden - Investopedia</p>
<p>Zoals Investopedia laat zien, beïnvloeden bovengenoemde factoren de waarde van verschillende activa, waaronder cryptocurrencies en aandelen. Veranderingen in het bruto binnenlands product van toonaangevende economieën zoals de Verenigde Staten hebben bijvoorbeeld invloed op de waarde van verschillende activa zoals bitcoin en grondstoffen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1429/bitcoin-becomes-an-asset-class-with-positive-correlation-with-stock-market" target="_blank">Bitcoin wordt een activaklasse met een positieve correlatie met de aandelenmarkt</a></p>
<p>Als er bijvoorbeeld een wereldwijde recessie komt, kunnen de waarden van activa zoals aandelen, cryptocurrencies en grondstoffen dalen. Dit betekent echter niet dat hun prijzen met vergelijkbare marges veranderen.</p>
<p>Sommige traditionele financiële instellingen hebben digitale activa geïntroduceerd die gekoppeld zijn aan bitcoin. Zo hebben dergelijke bedrijven crypto-gerelateerde beleggingsactiva gelanceerd, zoals <a href="https://www.gate.io/blog_detail/207/why-do-people-choose-crypto-etfs-what-are-the-advantages-and-disadvantages &quot;as crypto exchange traded funds (ETFs" rel="nofollow noopener noreferrer" target="_blank">als crypto-uitwisselings verhandelde fondsen (ETF’s)</a> Het feit dat veel vermogensbeheerinstellingen cryptogerelateerde beleggingsinstrumenten aanbieden, stelt particulieren en bedrijven in staat om te investeren in cryptocurrencies, waaronder bitcoin.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-are-leveraged-etf-token/243" target="_blank">Wat zijn Leveraged ETF-tokens?</a></p>
<h2 id="h2-Correlatie20tussen20Cryptogerelateerde20aandelen20en20Bitcoin884729"><a name="Correlatie tussen Crypto-gerelateerde aandelen en Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Correlatie tussen Crypto-gerelateerde aandelen en Bitcoin</h2><p>Laten we onze aandacht richten op specifieke soorten activa die gecorreleerd zijn met bitcoin. Er zijn verschillende crypto-gerelateerde aandelen zoals COIN, RIOT en MSTR die positief gecorreleerd zijn met bitcoin. Als voorbeeld is de correlatiecoëfficiënt van BTC/MSTR, BTC/RIOT en BTC/COIN de afgelopen maanden bijna 1 geweest.</p>
<p>Ter illustratie, de correlatiecoëfficiënt tussen bitcoin en MicroStrategy (MSTR) is sinds september 2022 nooit lager geweest dan 0,68. Aan de andere kant daalde de correlatie van ROIT naar 0,75 in juni van dit jaar, terwijl die van Coinbase (COIN) bijna nul was in mei en juni.</p>
<p>De volgende grafiek toont bitcoin 90-daagse correlatiecoëfficiënten met COIN, ROIT en MSTR. Dit jaar hebben al deze aandelen echter beter gepresteerd dan bitcoin.<br><img src="https://gimg2.gateimg.com/image/article/16939874988451693987370_.pic.jpg" alt=""><br>Bitcoin correlaties met COIN, ROIT en MSTR - TradingView</p>
<p>De belangrijkste reden waarom de bovenstaande aandelen correleren met Bitcoin is dat de betrokken bedrijven zoals MicroStrategy en Coinbase grote hoeveelheden BTC bezitten. Specifiek tonen de nieuwste on-chain gegevens aan dat MicroStrategy 152.333 Bitcoin bezit, Coinbase 10.766 BTC en Riot 7.094 BTC.</p>
<h2 id="h2-Bitcoin20vs20Edelmetalen858547"><a name="Bitcoin vs Edelmetalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin vs Edelmetalen</h2><p>Op dezelfde manier, de <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">Bitcoin prijs</a> is gecorreleerd aan de waarden van bepaalde edelmetalen zoals zilver en goud die onder grondstoffen vallen. Echter, in vergelijking, sinds 2019 is bitcoin meer gecorreleerd aan zilver dan aan goud. Volgens Jordan Doyle en Urav Soni van het CFA Institute heeft zilver een correlatiecoëfficiënt van 0,26 terwijl goud 0,15 heeft ten opzichte van BTC.</p>
<h2 id="h2-BTC20Correlatie20met20actieve20aandelenfondsen20en20obligaties291890"><a name="BTC Correlatie met actieve aandelenfondsen en obligaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC Correlatie met actieve aandelenfondsen en obligaties</h2><p>Over het algemeen is er een correlatie tussen groeifondsen en bitcoin. Tijdens de eerste twee weken van augustus nam de correlatie tussen bitcoin en Amerikaanse aandelen en beleggingskwaliteit obligaties opmerkelijk toe.</p>
<p>Volgens Kaiko, een onderzoeksbureau, is de correlatie tussen bitcoin en Amerikaanse aandelen met 40% toegenomen. Op dezelfde manier steeg de correlatie tussen BTC en Amerikaanse beleggingswaardige obligaties met 33%, zoals blijkt uit de volgende grafiek.<br><img src="https://gimg2.gateimg.com/image/article/16939875538461693987384_.pic.jpg" alt=""><br>Correlatie tussen Bitcoin en Traditionele Activia - Kaiko</p>
<p>Zoals <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> Het blijkt dat sinds maart de correlatie tussen Bitcoin en de S&amp;P500 hoger is dan die tussen BTC en obligaties. Niettemin blijft het niveau van correlatie tussen BTC en traditionele beleggingsactiva niet constant. De volatiliteit van bitcoin, die met de tijd verandert, kan dit beïnvloeden.</p>
<p>Over het algemeen impliceert de correlatie dat de prijs van BTC in dezelfde richting beweegt als die van aandelen of obligaties. De correlatie tussen bitcoin en deze traditionele financiële activa zal waarschijnlijk toenemen wanneer veel institutionele beleggers meer cryptocurrencies, waaronder bitcoin, accumuleren.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/bitcoin-btc" target="_blank">BTC Prijsvoorspelling &amp; Voorspelling voor 2023, 2025, 2030</a></p>
<h2 id="h2-Conclusie215290"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Recente on-chain gegevens hebben aangetoond dat er een correlatie is tussen bitcoin en sommige traditionele investeringsactiva zoals aandelen, edele metalen en obligaties. De mate van correlatie varieert echter van tijd tot tijd op basis van verschillende factoren zoals de volatiliteit van BTC en de institutionele adoptie van cryptocurrencies.</p>
<h2 id="h2-Veelgestelde20vragen20over20Bitcoincorrelatie140905"><a name="Veelgestelde vragen over Bitcoin-correlatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Bitcoin-correlatie</h2><h3 id="h3-Wat20is20de20meest20gecorreleerde20cryptocurrency100714"><a name="Wat is de meest gecorreleerde cryptocurrency?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de meest gecorreleerde cryptocurrency?</h3><p>Bitcoin is de meest gecorreleerde cryptocurrency. Het is gecorreleerd met aandelen, investment-grade obligaties, grondstoffen zoals zilver en andere cryptocurrencies, met name Ether (ETH).</p>
<h3 id="h3-Wat20is20correlatieanalyse20van20cryptocurrency718769"><a name="Wat is correlatieanalyse van cryptocurrency?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is correlatieanalyse van cryptocurrency?</h3><p>De correlatieanalyse van cryptocurrency is de studie van de relatie tussen de prijsbeweging van een specifiek crypto-activum en de waarden van andere beleggingsinstrumenten zoals aandelen, obligaties en grondstoffen. Bijvoorbeeld, bitcoin correleert met aandelen, edele metalen zoals zilver en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> munt.</p>
<h3 id="h3-Welke20crypto20correleert20met20bitcoin727550"><a name="Welke crypto correleert met bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke crypto correleert met bitcoin?</h3><p>Meestal is de prijs van bitcoin gecorreleerd met die van Ether (ETH). De correlatie tussen deze twee belangrijke cryptocurrencies verandert echter in de loop van de tijd. Op bepaalde momenten is het hoog, terwijl het op andere momenten erg laag is.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>