QW5hbGlzaTogUmVsYXppb25lIHRyYSBCaXRjb2luIGUgVGlwaSBkaSBBc3NldCBUcmFkRmk=

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR823762"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La correlazione tra le azioni statunitensi e le obbligazioni investment grade è aumentata durante le prime due settimane di agosto.</p>
<p>Il <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è stato correlato a minerali preziosi come l’oro e l’argento da oltre due anni adesso.</p>
<p>Un aumento dell’adozione istituzionale delle criptovalute comporta una correlazione più forte delle criptovalute con gli asset di investimento tradizionali.</p>
<h2 id="h2-Introduzione931822"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Durante <a href="https://www.gate.io/learn/course/bitcoin-fundamental" target="_blank">Gli albori di Bitcoin tra il 2009 e il 2010</a> mancava di correlazione con la maggior parte degli asset, il che lo rendeva molto unico. Era veramente indipendente dalla turbolenza che ha colpito diversi tipi di asset come azioni, mercati forex e materie prime.</p>
<p>Tuttavia, la crescente consapevolezza dell’essenza di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e l’adozione istituzionale hanno portato a correlazioni tra bitcoin e altri tipi di asset. Questo articolo esplora le correlazioni di bitcoin con altri asset, tra cui azioni e materie prime.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2110/crypto-funds-101-fund-classification" target="_blank">Crypto Funds 101: Classificazione dei fondi</a></p>
<h2 id="h2-Correlazioni20del20Bitcoin20con20gli20asset20finanziari20tradizionali760321"><a name="Correlazioni del Bitcoin con gli asset finanziari tradizionali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Correlazioni del Bitcoin con gli asset finanziari tradizionali</h2><p>Negli ultimi anni il bitcoin è diventato sempre più correlato con diversi tipi di asset. Ad esempio, è correlato con le azioni principali, i metalli preziosi e altre criptovalute come ETH. Ci sono diverse spiegazioni del perché il bitcoin sia correlato a questi asset.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1275/why-many-crypto-assets-are-falling" target="_blank">Perché molti asset crittografici stanno cadendo</a></p>
<p>Nell’ottobre 2022, l’Istituto di Pubblicazione Digitale Multidisciplinare ha spiegato la correlazione tra gli asset crittografici e diversi strumenti di investimento tradizionali. In primo luogo, ha concluso che la correlazione del BTC con altri tipi di asset è più forte nel periodo a lungo termine rispetto a quello a breve termine. Il motivo principale di ciò è che il bitcoin ha un’alta volatilità dei prezzi.</p>
<p>Le correlazioni crittografiche con gli asset finanziari tradizionali sono emerse durante l’era Covid-19. Secondo il rapporto dell’Istituto di Pubblicazioni Digitali Multidisciplinari, il bitcoin è correlato positivamente con diversi asset a rischio ma negativamente correlato con il dollaro statunitense. Tuttavia, queste conclusioni potrebbero cambiare con l’arrivo di nuovi dati sui prezzi e l’emergere di nuove tendenze.</p>
<h2 id="h2-Possibili20motivi20per20cui20Bitcoin20correla20con20diversi20fattori20di20rischio842344"><a name="Possibili motivi per cui Bitcoin correla con diversi fattori di rischio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Possibili motivi per cui Bitcoin correla con diversi fattori di rischio</h2><p>Prima <a href="https://www.gate.io/article/28405" target="_blank">esploriamo la correlazione del bitcoin</a> con altri tipi di asset specifici vediamo le possibili cause delle correlazioni.</p>
<p>Innanzitutto, il bitcoin ora si correla con altri tipi di asset perché esiste nei bilanci di molte società di investimento istituzionali. Di conseguenza, prendono le loro decisioni di investimento in bitcoin basandosi sui fondamentali macroeconomici che influenzano anche i prezzi di altri tipi di asset.</p>
<p>Ad esempio, poiché il bitcoin si è evoluto in una classe di attività, vari fattori economici come i tassi di interesse e l’inflazione influenzano i suoi movimenti di prezzo. Come sappiamo, questi sono i fattori che determinano anche i prezzi di altri tipi di asset come le materie prime, le azioni e gli indici. La seguente tabella mostra i fattori che possono influenzare i prezzi delle criptovalute e delle azioni.</p>
<p>Leggi anche: <a href="https://www.gate.io/explore/bitcoin-halving-countdown" target="_blank">Bitcoin Halving: Conto alla rovescia per il mercato rialzista delle criptovalute</a><img src="https://gimg2.gateimg.com/image/article/16939874118441693987355_.pic.jpg" alt=""><br>Fattori che influenzano i prezzi del mercato azionario e delle criptovalute - Investopedia</p>
<p>Come Investopedia mostra i fattori sopra influenzano i valori di diversi asset, inclusi criptovalute e azioni. Ad esempio, le variazioni del prodotto interno lordo delle principali economie come gli Stati Uniti hanno un impatto sui valori dei diversi asset come bitcoin e materie prime.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1429/bitcoin-becomes-an-asset-class-with-positive-correlation-with-stock-market" target="_blank">Bitcoin diventa una classe di attività con correlazione positiva con il mercato azionario</a></p>
<p>Se c’è una recessione globale, ad esempio, i valori di asset come azioni, criptovalute e materie prime potrebbero diminuire. Tuttavia, ciò non significa che i loro prezzi cambino con margini simili.</p>
<p>Alcune istituzioni finanziarie tradizionali hanno introdotto asset digitali collegati a bitcoin. Ad esempio, tali società hanno lanciato asset di investimento legati alla crittografia. <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">come fondi negoziati in borsa (ETF) di scambio di criptovalute</a> Il fatto che molte istituzioni di gestione del patrimonio forniscono strumenti di investimento legati alle criptovalute ha permesso a individui e aziende di investire in criptovalute, compreso il Bitcoin.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-are-leveraged-etf-token/243" target="_blank">Cosa sono i Token ETF a Leva?</a></p>
<h2 id="h2-Correlazione20tra20azioni20legate20alle20criptovalute20e20Bitcoin746565"><a name="Correlazione tra azioni legate alle criptovalute e Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Correlazione tra azioni legate alle criptovalute e Bitcoin</h2><p>Diamo ora un’occhiata a tipi di asset specifici che sono correlati al bitcoin. Ci sono diversi titoli cripto correlati come COIN, RIOT e MSTR che sono positivamente correlati al bitcoin. Ad esempio, il coefficiente di correlazione di BTC/MSTR, BTC/RIOT e BTC/COIN è stato vicino a 1 nei mesi scorsi.</p>
<p>Per illustrare, il coefficiente di correlazione tra bitcoin e MicroStrategy (MSTR) non è mai stato inferiore a 0,68 da settembre 2022. D’altra parte, la correlazione di ROIT è scesa a 0,75 nel giugno di quest’anno, mentre quella di Coinbase (COIN) è stata vicina allo zero durante maggio e giugno.</p>
<p>Il grafico seguente mostra i coefficienti di correlazione a 90 giorni del bitcoin con COIN, ROIT e MSTR. Tuttavia, quest’anno tutte queste azioni hanno superato il bitcoin.<br><img src="https://gimg2.gateimg.com/image/article/16939874988451693987370_.pic.jpg" alt=""><br>Correlazioni Bitcoin con COIN, ROIT e MSTR - TradingView</p>
<p>Il motivo principale per cui le azioni sopra correlate a bitcoin è che le aziende coinvolte come MicroStrategy e Coinbase detengono grandi quantità di BTC. In particolare, gli ultimi dati on-chain mostrano che MicroStrategy detiene 152.333 Bitcoin, Coinbase 10.766 BTC e Riot 7.094 BTC.</p>
<h2 id="h2-Bitcoin20vs20Metalli20Preziosi380447"><a name="Bitcoin vs Metalli Preziosi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin vs Metalli Preziosi</h2><p>Allo stesso modo, il <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">Prezzo del Bitcoin</a> è correlato ai valori di alcuni metalli preziosi come l’argento e l’oro che rientrano tra le materie prime. Tuttavia, dal 2019 il bitcoin è più correlato all’argento che all’oro. Secondo Jordan Doyle e Urav Soni del CFA Institute, l’argento ha un coefficiente di correlazione di 0,26 mentre l’oro ha 0,15 contro BTC.</p>
<h2 id="h2-Correlazione20BTC20con20fondi20azionari20attivi20e20obbligazioni725019"><a name="Correlazione BTC con fondi azionari attivi e obbligazioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Correlazione BTC con fondi azionari attivi e obbligazioni</h2><p>In generale, c’è una correlazione tra i fondi di crescita e bitcoin. Durante le prime due settimane di agosto, la correlazione tra bitcoin, azioni statunitensi e obbligazioni di investimento di grado elevato è aumentata notevolmente.</p>
<p>Secondo Kaiko, una società di ricerca, la correlazione tra bitcoin e azioni statunitensi è aumentata del 40%. Allo stesso modo, la correlazione tra BTC e obbligazioni di grado d’investimento statunitensi è aumentata del 33% come illustrato nel seguente grafico.<br><img src="https://gimg2.gateimg.com/image/article/16939875538461693987384_.pic.jpg" alt=""><br>Correlazione tra Bitcoin e asset tradizionali - Kaiko</p>
<p>Come <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> Mostra, da marzo, la correlazione tra Bitcoin e S&amp;P500 è stata più alta rispetto a quella tra BTC e obbligazioni. Tuttavia, il livello di correlazione tra BTC e asset di investimento tradizionali non rimane costante per sempre. La volatilità del bitcoin, che cambia nel tempo, potrebbe influenzarlo.</p>
<p>In generale, la correlazione implica che il prezzo di BTC si muove in una direzione simile a quella delle azioni o delle obbligazioni. La correlazione tra bitcoin e questi asset finanziari tradizionali è probabile che aumenti quando molti investitori istituzionali accumulano più criptovalute, inclusi bitcoin.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/bitcoin-btc" target="_blank">Previsione del prezzo di BTC &amp; Forecast per il 2023, 2025, 2030</a></p>
<h2 id="h2-Conclusione619863"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Recenti dati on-chain hanno mostrato che c’è una correlazione tra bitcoin e alcuni asset di investimento tradizionali come azioni, metalli preziosi e obbligazioni. Tuttavia, il livello di correlazione varia nel tempo in base a diversi fattori come la volatilità di BTC e l’adozione istituzionale delle criptovalute.</p>
<h2 id="h2-Domande20frequenti20sulla20correlazione20del20Bitcoin24620"><a name="Domande frequenti sulla correlazione del Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulla correlazione del Bitcoin</h2><h3 id="h3-Qual2020la20criptovaluta20pi20correlata60039"><a name="Qual è la criptovaluta più correlata?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la criptovaluta più correlata?</h3><p>Bitcoin è la criptovaluta più correlata. È correlato con azioni, obbligazioni di grado di investimento, commodities come l’argento e altre criptovalute, in particolare Ether (ETH).</p>
<h3 id="h3-Cos20lanalisi20di20correlazione20delle20criptovalute7375"><a name="Cos’è l’analisi di correlazione delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è l’analisi di correlazione delle criptovalute?</h3><p>L’analisi di correlazione delle criptovalute è lo studio della relazione tra il movimento dei prezzi di un determinato cripto-asset e i valori di altri strumenti di investimento come azioni, obbligazioni e materie prime. Ad esempio, il bitcoin è correlato con le azioni, le materie prime preziose come l’argento e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> moneta.</p>
<h3 id="h3-Quale20criptovaluta2020correlata20al20bitcoin913270"><a name="Quale criptovaluta è correlata al bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quale criptovaluta è correlata al bitcoin?</h3><p>Nella maggior parte dei casi, il prezzo di bitcoin è correlato a quello di Ether (ETH). Tuttavia, la correlazione tra queste due principali criptovalute cambia nel tempo. In certe occasioni è alto mentre in altre è molto basso.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>