Q29tcHJlbmRlcmUgbGEgZGlzY2VzYTogaWwgcHJlenpvIGRpIEJpdGNvaW4gZG9wbyBsJ0hhbHZpbmc=

<p><img src="https://gimg2.gateimg.com/image/article/1715822956rdzz.jpeg" alt=""></p>
<h2 id="h2-TL20DR78091"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>L’introduzione dello spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF negli Stati Uniti hanno cambiato la dinamica dei prezzi dopo l’having di Bitcoin.</p>
<p>Quando si è verificato il dimezzamento del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> nel 2024, BTC si trovava già in una condizione di mercato ipercomprato, il che ha portato alla recente diminuzione dei prezzi.</p>
<p>Le rune e le iscrizioni ordinali potrebbero portare a una crescita del bitcoin nel prossimo futuro.</p>
<h2 id="h2-Introduzione131582"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’attivazione del dimezzamento di aprile 2024 il 20 del mese ha creato molta eccitazione nel settore delle criptovalute, con un’alta anticipazione che potremmo avere presto una corsa al toro BTC dopo quell’evento storico. Settimane dopo, il mercato delle criptovalute non è sicuro della direzione esatta che il prezzo del BTC prenderà nei periodi a breve e lungo termine.</p>
<p>Questo articolo analizzerà possibili scenari a breve e lungo termine <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> movimenti. Esploreremo anche i fattori <a href="https://www.gate.io/learn/articles/does-bitcoin-halving-truly-influence-the-price-of-btc/2798" target="_blank">influenzando la tendenza attuale del prezzo BTC</a> e concentrarsi su altri catalizzatori che possono determinare il futuro prezzo del bitcoin.</p>
<h2 id="h2-Dinamiche20del20prezzo20di20Bitcoin20dopo20lHalving41438"><a name="Dinamiche del prezzo di Bitcoin dopo l’Halving" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dinamiche del prezzo di Bitcoin dopo l’Halving</h2><p>In base alle attuali reazioni di mercato alle dinamiche dei prezzi del bitcoin nel periodo post-halving, è chiaro che le cose non sono andate come ci si aspettava dalla più ampia comunità crittografica. Fondamentalmente, ciò che molti partecipanti alla crittovaluta non hanno capito è che ci sono tre diverse possibilità in termini di movimenti dei prezzi a seguito di qualsiasi <a href="https://www.gate.io/learn/articles/-bitcoin-halving-2024-ultimate-guide/2357" target="_blank">halving di Bitcoin</a>. Discutiamone brevemente prima di analizzarli nel contesto della nostra attuale situazione di mercato Bitcoin.</p>
<p><strong>Momentum Rialzista</strong>: Molti esperti di criptovalute ritengono che un momento rialzista dovrebbe seguire un dimezzamento poiché l’offerta di BTC diminuisce immediatamente dopo l’evento. In particolare, dopo l’evento di dimezzamento del 2024, gli analisti pensavano che una forte diminuzione dell’offerta di BTC e un aumento degli investimenti istituzionali nella principale criptovaluta avrebbero portato a un forte rally di BTC.</p>
<p>I movimenti del prezzo del Bitcoin durante i precedenti periodi post dimezzamento supportano questa idea. Ad esempio, dopo il primo evento di dimezzamento che è avvenuto nel 2021, il prezzo del Bitcoin è aumentato di oltre il 1.000%. Allo stesso modo, dopo il secondo dimezzamento si è ripreso del 200%, mentre è aumentato di almeno il 600% dopo il terzo. Sulla base di tali movimenti di prezzo, alcuni massimalisti del Bitcoin si aspettavano che il prezzo del BTC si impennasse. <a href="https://www.gate.io/learn/articles/the-2024-halving-could-usher-in-a-new-era-for-bitcoin/2651" target="_blank">immediatamente dopo l’evento di dimezzamento del 20 aprile</a>.</p>
<p><strong>Correzione ribassista</strong>: Alcuni scettici sostengono che non esista una traiettoria dei prezzi definita per bitcoin dopo l’evento dell’halving. In effetti, credono fermamente che bitcoin possa subire una correzione temporanea dei prezzi o un periodo di consolidamento dopo l’halving. Tuttavia, ciò dipende dal sentimento prente del mercato cripto.</p>
<p><strong>Movimento laterale</strong> La terza possibilità è che il bitcoin possa subire un movimento laterale dei prezzi dopo l’evento di dimezzamento. Ciò avviene quando gli effetti potenziali del dimezzamento vengono mitigati da altri fattori, tra cui quelli macroeconomici. Ad esempio, le tensioni geopolitiche in Medio Oriente o un aumento dei tassi di interesse nelle principali economie globali come gli Stati Uniti o il Regno Unito potrebbero contribuire a tale scenario.</p>
<p>Tuttavia, il periodo successivo all’halving nel passato ha mostrato varie fasi che Bitcoin potrebbe attraversare. Subito dopo gli eventi di halving ci sono state fasi di espansione caratterizzate da aumenti di prezzo causati da notizie positive e dal mercato <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a>.</p>
<p>Dopo il picco di una corsa toro, seguirebbe una fase di contrazione caratterizzata da una forte pressione venditrice e da prezzi decrescenti del BTC. Infine, il bitcoin entrerebbe in una fase di consolidamento rappresentata dall’equilibrio di mercato e dalla stabilizzazione dei prezzi. Il grafico seguente mostra i movimenti dei prezzi del bitcoin durante alcuni periodi passati di post dimezzamento del bitcoin.<br><img src="https://gimg2.gateimg.com/image/article/17158231181.jpeg" alt=""><br>Cicli di dimezzamento di Bitcoin: <a href="https://s3.cointelegraph.com/uploads/2024-05/060d243c-e40d-46ee-a299-89c418765a28.jpg" rel="nofollow noopener noreferrer" target="_blank">Cointelegraph</a></p>
<p>L’immagine sopra mostra la fase di espansione, fase di contrazione e fase di correzione nei periodi post dimezzamento precedenti.</p>
<h2 id="h2-La20dinamica20attuale20del20prezzo20di20Bitcoin20nel20periodo20posthalving907859"><a name="La dinamica attuale del prezzo di Bitcoin nel periodo post-halving" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La dinamica attuale del prezzo di Bitcoin nel periodo post-halving</h2><p>Il movimento attuale del prezzo del bitcoin è influenzato da due cose, l’evento di dimezzamento e il <a href="https://www.gate.io/blog_detail/3434/bitcoin-etf-approval-potential-catalyst-for-historic-crypto-bull-run" target="_blank">lancio di ETF bitcoin spot negli Stati Uniti</a>. Prima dell’evento del dimezzamento, il principale motore del rialzo del prezzo del Bitcoin era l’afflusso di capitali degli ETF BTC spot negli Stati Uniti. In particolare, <a href="https://www.gate.io/learn/articles/spot-bitcoin-etf-approval-and-the-next-bitcoin-halving-a-catalyst-to-the-next-crypto-bull-run/2018" target="_blank">dopo l’approvazione degli ETF BTC a gennaio</a> c’è stato un forte afflusso di capitali nel mercato del bitcoin. Tuttavia, verso l’evento di dimezzamento l’afflusso di fondi si è fermato, portando a un mercato bitcoin in fase di consolidamento. Successivamente, a maggio, il prezzo del bitcoin è crollato.</p>
<p>Il recente calo del prezzo del bitcoin è iniziato alcune settimane prima dell’evento di dimezzamento. Di fatto, il prezzo del BTC è sceso a circa $63,000 prima di guadagnare marginalmente per raggiungere $65,011 il 20 aprile. Tuttavia, dopo tale data, il bitcoin ha registrato ulteriori guadagni fino a raggiungere un massimo di $67,020 il 24 aprile. Ancora una volta, ha perso molto slancio scendendo a $56,803 il 1° maggio. Da allora è rimasto principalmente compreso tra $57,000 e $64,000, come mostra l’immagine successiva.<br><img src="https://gimg2.gateimg.com/image/article/17158232052.jpeg" alt=""><br>Prezzo del BTC tra il 20 aprile e il 10 maggio - <a href="https://www.coingecko.com/en/coins/bitcoin" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Come osservato su <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">Il Grafico</a>, la linea viola indica il prezzo del BTC alla data del dimezzamento. Attualmente, il suo prezzo è molto al di sotto di quel livello, mostrando un mercato del bitcoin depresso. Tuttavia, le attuali dinamiche dei prezzi dopo il dimezzamento non sono sorprendenti, considerando che il BTC ha avuto una forte impennata per circa tre mesi prima dell’evento del dimezzamento. Durante quel periodo, ha raggiunto un massimo storico di $73,737.94 il 14 marzo. Attualmente, il prezzo del bitcoin è inferiore del 14.6% rispetto a quel massimo storico.</p>
<p>In base all’analisi attuale del mercato delle criptovalute, la principale causa dell’impennata del prezzo del bitcoin durante quel periodo <a href="https://www.gate.io/blog_detail/3839/bitcoin-etf-inflows" target="_blank">il periodo sono stati gli afflussi ETF di bitcoin</a>. Tuttavia, la caduta dei prezzi dopo l’halving del bitcoin ha sorpreso molti investitori di criptovalute che si aspettavano un rally dei prezzi a partire da aprile. Ci sono diverse ragioni per cui il prezzo del BTC è crollato durante il periodo successivo all’halving del bitcoin del 2024.</p>
<p>Come indicato sopra, il bitcoin ha avuto una forte corsa al rialzo tra metà gennaio e le prime tre settimane di aprile. È la prima volta che il bitcoin si trova ad affrontare una corsa così forte alcuni mesi prima dell’evento di dimezzamento. Mati Greenspan, fondatore di Quantum Economics, ha notato anche che un movimento del prezzo del bitcoin prima di un evento di dimezzamento è un’occasione unica.</p>
<p>In un’intervista con <a href="https://cointelegraph.com/top-people-in-crypto-and-blockchain-2021/mati-greenspan" rel="nofollow noopener noreferrer" target="_blank">Cointelegraph, Greenspan ha detto</a>“Ciò che è unico di questo ultimo halving di Bitcoin è l’incredibile corsa al toro e l’azione dei prezzi che lo ha preceduto. Anche considerando questo recente ritracciamento, Bitcoin è ancora in rialzo del 35% dall’inizio dell’anno.”</p>
<p>Secondo Greenspan, l’impatto economico sul prezzo del Bitcoin è chiaro e forte. Egli/lei ha aggiunto: “Considerando l’aspettativa di un altro cambiamento della Fed e ciò che sta accadendo nel mercato azionario, l’attuale azione del prezzo del Bitcoin è difficilmente una sorpresa.” Simili fattori macroeconomici hanno influenzato anche le prestazioni del mercato azionario, che sta anche sotto-performando.</p>
<h2 id="h2-Previsioni20degli20analisti20di20JPMorgan20per20una20diminuzione20del20prezzo20dopo20lhalving461712"><a name="Previsioni degli analisti di JPMorgan per una diminuzione del prezzo dopo l’halving" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Previsioni degli analisti di JPMorgan per una diminuzione del prezzo dopo l’halving</h2><p>Alcuni analisti di mercato crittografi hanno indicato le previsioni di prezzo di bitcoin attuali. Ad esempio, gli analisti di JPMorgan bitcoin <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">previsione del prezzo</a> indicato un ribasso di BTC nel periodo successivo all’halving del 2024. Secondo <a href="https://www.theblock.co/post/279833/jpmorgan-bitcoin-price-april-halving" rel="nofollow noopener noreferrer" target="_blank">TheBlock</a>, a marzo gli analisti di JPMorgan hanno previsto che il prezzo del bitcoin sarebbe sceso al di sotto dei $60.000 poco dopo l’evento dell’halving. Hanno persino suggerito che potesse arrivare a $52.000. Già il 1 maggio il prezzo del bitcoin è sceso a un minimo post-halving di $56.803, a poche migliaia di dollari da $52.000.</p>
<p><a href="https://www.theblock.co/post/289849/how-will-bitcoins-price-react-after-the-halving" rel="nofollow noopener noreferrer" target="_blank">Nikolaos Panigirtzoglou, un analista di investimenti di punta di JPMorgan, ha detto</a>, “Non ci aspettiamo aumenti del prezzo del bitcoin dopo l’halving in quanto è già stato incluso nel prezzo. In realtà vediamo un downside per il prezzo del bitcoin dopo l’halving per diverse ragioni.” L’analisi del trading di bitcoin degli analisti di JPMorgan si basava sul fatto che durante alcuni mesi prima dell’evento dell’halving, il BTC si trovava in condizioni di mercato ipercomprato, il che indicava un imminente ribasso.</p>
<p>Secondo la stessa fonte, Pedro Lapenta, responsabile della ricerca di Hashdex, ha condiviso sentimenti simili. <a href="https://www.theblock.co/post/289849/how-will-bitcoins-price-react-after-the-halving" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>“Con bitcoin che registra sette mesi consecutivi di guadagni, è tipico che il periodo successivo all’halving comporti modesti aumenti o correzioni, come stiamo osservando ora.”</p>
<p>Una spiegazione correlata è che l’attuale correzione è il risultato del profitto ottenuto da molti investitori di criptovalute che hanno acquistato bitcoin durante il 2022 e il 2023. Anche molti investitori di ETF spot potrebbero aver preso profitto dopo le forti apprezzamenti delle azioni da gennaio. Ad esempio, nelle ultime settimane alcuni investitori di ETF hanno abbandonato il Grayscale Bitcoin Trust ETF (GBTC).</p>
<h2 id="h2-Ruolo20degli20afflussi20di20ETF20nellultima20impennata20di20Bitcoin277159"><a name="Ruolo degli afflussi di ETF nell’ultima impennata di Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ruolo degli afflussi di ETF nell’ultima impennata di Bitcoin</h2><p>Abbiamo parlato dell’impatto degli afflussi di bitcoin ETF verso l’ultima ascesa del BTC. È vero, gli ETF di bitcoin spot hanno contribuito all’ultimo rialzo del bitcoin. Molti investitori hanno interpretato l’approvazione degli ETF di bitcoin negli Stati Uniti come un’accettazione del BTC come un legittimo asset di investimento. Di conseguenza, poco dopo il loro lancio, molti investitori al dettaglio e istituzionali hanno investito negli ETF. Alcuni hanno addirittura acquistato bitcoin sugli scambi, causando un’impennata dei prezzi.</p>
<p>Poiché la domanda di ETF di bitcoin è aumentata notevolmente nei primi tre mesi dal loro lancio, gli emittenti di ETF crittografici come BlackRock, Fidelity e ARK hanno acquistato BTC a livelli senza precedenti, portando a un picco del prezzo. Ad esempio, entro il 15 febbraio gli sponsor di bitcoin avevano acquisito oltre 251.888 BTC. Pertanto, hanno acquistato più bitcoin di quelli prodotti, risultando in una carenza che ha spinto il suo valore verso l’alto.</p>
<h2 id="h2-Oltre20allHalving20Altri20catalizzatori20per20la20crescita20di20Bitcoin726552"><a name="Oltre all’Halving: Altri catalizzatori per la crescita di Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Oltre all’Halving: Altri catalizzatori per la crescita di Bitcoin</h2><p>Nonostante le tendenze di investimento in bitcoin spiegate sopra, ci sono altri fattori che possono contribuire alla crescita di bitcoin durante il periodo successivo all’halving. Lo sviluppo che è recentemente avvenuto sulla blockchain di bitcoin, incluso il lancio di Runes e iscrizioni ordinali, ha riacceso il BTC. <a href="https://www.gate.io/bitwiki/detail/326/utility-token" target="_blank">utilità</a>.</p>
<p>Le rune, che sono token fungibili, sono state introdotte alla data dell’halving mentre gli ordinali <a href="https://www.gate.io/learn/articles/what-you-need-to-know-about-ordinals-and-brc20/507" target="_blank">sono stati lanciati nel gennaio 2023</a>. Il protocollo Runes consente agli sviluppatori di creare token fungibili come le monete meme sulla blockchain di bitcoin. Questi due prodotti on-chain hanno portato a un aumento della domanda per la rete bitcoin.</p>
<h2 id="h2-Conclusione776558"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il prendere profitto da parte degli investitori di bitcoin e ETF ha contribuito al calo del prezzo del BTC. Inoltre, il fatto che l’evento di halving 2024 sia avvenuto in un momento in cui bitcoin si trovava in una condizione di mercato ipercomprato spiega il recente calo del prezzo. Tuttavia, una ripresa degli afflussi degli ETF e un aumento della domanda di Runes e Ordinals potrebbero portare a un rinnovato interesse per bitcoin, il che potrebbe portare a futuri rally.</p>
<h2 id="h2-Domande20frequenti20su20Bitcoin917647"><a name="Domande frequenti su Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Bitcoin</h2><h3 id="h3-Perch20il20prezzo20del20bitcoin20sta20scendendo364439"><a name="Perché il prezzo del bitcoin sta scendendo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché il prezzo del bitcoin sta scendendo?</h3><p>Una delle ragioni per cui il prezzo del bitcoin sta scendendo è il prendere profitto da parte degli investitori che hanno acquisito la criptovaluta durante il 2022 e il 2023. Alcuni investitori di spot bitcoin ETF <a href="https://www.gate.io/learn/articles/bitcoin-efts-have-been-trading-around-the-world-for-years/2801" target="_blank">potrebbero anche vendere le loro azioni</a> riducendo così gli afflussi netti di capitale nel mercato degli ETF BTC.</p>
<h3 id="h3-Bitcoin20aumenter20di20nuovo706778"><a name="Bitcoin aumenterà di nuovo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin aumenterà di nuovo?</h3><p>Il prezzo del bitcoin potrebbe salire di nuovo quando sia i trader al dettaglio che gli investitori istituzionali ne richiedono di più rispetto al passato. Anche l’approvazione degli ETF BTC spot in altri paesi potrebbe spingere il suo prezzo al rialzo.</p>
<h3 id="h3-Il20prezzo20del20bitcoin20scende20dopo20il20dimezzamento33420"><a name="Il prezzo del bitcoin scende dopo il dimezzamento?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il prezzo del bitcoin scende dopo il dimezzamento?</h3><p>Dopo aver dimezzato il prezzo del bitcoin potrebbe aumentare, diminuire o muoversi lateralmente a seconda delle condizioni di mercato prenti. Tuttavia, dopo il dimezzamento del bitcoin nell’aprile 2024, il prezzo del bitcoin è salito per alcuni giorni prima di diminuire. Attualmente, il bitcoin si muove lateralmente, mostrando che potrebbe trovarsi in una fase di accumulazione di mercato.</p>
<h3 id="h3-La20riduzione20di20met20del20bitcoin20riduce20lofferta122304"><a name="La riduzione di metà del bitcoin riduce l’offerta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La riduzione di metà del bitcoin riduce l’offerta?</h3><p>Sì, la riduzione a metà del bitcoin riduce l’offerta di BTC poiché porta alla riduzione delle ricompense di mining. In effetti, la riduzione a metà del 2024 ha ridotto la ricompensa di mining da 6,25 BTC a 3,125 BTC.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di 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 il ripostaggio dell'articolo a condizione che sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>