Qml0Y29pbiByZWFnaXNjZSBhbCBkaXNjb3JzbyBhY2NvbW9kYW50ZSBkaSBGZWQgUG93ZWxs

2023-10-31, 05:57

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>La Federal Reserve mira a un tasso di inflazione del 2%.</p>
<p>Una pausa nell’aumento dei tassi di interesse potrebbe aumentare la domanda di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>La Federal Reserve utilizzerà i dati disponibili per stabilire quando effettuare un’altra rialzo dei tassi di interesse.</p>
<p>Parole chiave: prezzo BTC, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> movimento, prezzo bitcoin, calo del prezzo BTC, acquisto bitcoin, <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">comprare Bitcoin</a>, acquista BTC</p>
<h2 id="h2-Introduzione777655"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>I mercati crittografici e azionari hanno atteso di sentire la posizione della Federal Reserve sui tassi di interesse per il quarto trimestre del 2023. Non è stato chiaro se ci sarebbe o meno un aumento dei tassi d’interesse a settembre, ottobre, novembre e dicembre. Tuttavia, Powell ha suggerito una politica monetaria della Fed accomodante per il quarto trimestre.</p>
<p>Questo articolo esplora la posizione di Jerome Powell, il presidente della Fed <a href="https://www.gate.io/blog_detail/1388/what-is-the-impact-on-the-market-as-the-federal-reserve-continues-to-raise-interest-rates" target="_blank">sulla politica monetaria della Federal Reserve</a> Posizione per il quarto trimestre. Copriremo anche le implicazioni del discorso di Powell sull’economia degli Stati Uniti e sui mercati finanziari.</p>
<h2 id="h2-Il20discorso20di20Fed20Powell20sulla20posizione20accomodante20della20politica20monetaria582003"><a name="Il discorso di Fed Powell sulla posizione accomodante della politica monetaria" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il discorso di Fed Powell sulla posizione accomodante della politica monetaria</h2><p>Giovedì 19 ottobre, Jerome Powell, il presidente della Fed, ha tenuto un discorso accomodante sulla politica monetaria, principalmente incentrato sui tassi di interesse nel paese. Powell è stato chiaro nel suo discorso sul fatto che l’inflazione è ancora alta e deve essere domata. Gli Stati Uniti mirano a avere un tasso di inflazione del 2% o inferiore.</p>
<p>Durante un pranzo che l’Economic Club di New York ha ospitato all’Hilton Hotel, Powell ha dichiarato: “L’inflazione è ancora troppo alta e alcuni mesi di buoni dati sono solo l’inizio di ciò che servirà per creare fiducia che l’inflazione stia scendendo in modo sostenibile verso il nostro obiettivo”.</p>
<p>È stato anche rapido nel sottolineare che la Fed assumerà una posizione cautelativa sui tassi di interesse, lasciando intendere che non li aumenterà presto. Nel complesso, ha detto che il Comitato dei mercati aperti della Federal Reserve impiegherà tempo e sforzi per valutare tutti i dati disponibili ora e in futuro per valutare l’adeguatezza di un aumento dei tassi di interesse.</p>
<p>Secondo Powell e alcuni membri del Federal Open Market Committee, il paese cercherà di bilanciare il suo approccio su alcune variabili economiche per evitare una recessione, ma allo stesso tempo contenere l’inflazione.</p>
<p>Attualmente, il Federal Open Market Committee (FOMC) ha deciso di mantenere il tasso dei fondi fed tra il 5,25 e il 5,50%. Tuttavia, il FOMC ha detto che c’è ancora la possibilità di aumentare il tasso di interesse nei prossimi mesi se l’inflazione rappresenta una minaccia.</p>
<p>Un membro del comitato FOMC ha detto: “Nel determinare l’entità del rafforzamento aggiuntivo della politica che potrebbe essere appropriato per riportare l’inflazione al 2 percento nel tempo, il Comitato terrà conto del rafforzamento cumulativo della politica monetaria, dei ritardi con cui la politica monetaria influisce sull’attività economica e sull’inflazione, e degli sviluppi economici e finanziari.”</p>
<p>È fondamentale notare che il presidente della Fed, Powell, ha detto di essere felice che l’inflazione sia solo del 3,5% rispetto alla cifra dell’anno scorso. Tuttavia, teme che diversi fattori possano spingerla al rialzo nel prossimo futuro.</p>
<p>Di conseguenza, ha concluso: “Prenderemo decisioni sulla portata di un ulteriore rafforzamento delle politiche e su quanto tempo le politiche rimarranno restrittive, basandoci sull’insieme dei dati in arrivo, sulle prospettive in evoluzione e sul bilanciamento dei rischi.”</p>
<p>Non c’è dubbio che fattori come le tensioni geopolitiche in Medio Oriente possano avere un effetto sul tasso dei fondi della Fed. Ecco perché Powell ha parlato brevemente di tale sviluppo. Ha detto: “Le tensioni geopolitiche sono molto elevate e rappresentano rischi importanti per l’attività economica globale.”</p>
<p>Alcuni analisti economici hanno suggerito che se il conflitto Israele-Hamas si estendesse ad altri paesi produttori di petrolio, potrebbe influire sulla produzione di petrolio in Medio Oriente. Se ciò accadesse, i cambiamenti risultanti nei prezzi del petrolio potrebbero influire sul costo della vita negli Stati Uniti e sul tasso di inflazione.</p>
<p>Tuttavia, dopo aver valutato attentamente il discorso di Powell, Gregory Daco, Economista Capo di EY, ha concluso: “La Fed non ha fretta di stringere ulteriormente la politica monetaria. Un aumento dei tassi a novembre può essere tranquillamente escluso.”</p>
<h2 id="h2-Effetti20della20attuale20politica20monetaria20della20Federal20Reserve20sulleconomia300928"><a name="Effetti della attuale politica monetaria della Federal Reserve sull’economia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Effetti della attuale politica monetaria della Federal Reserve sull’economia</h2><p>Come detto, sia l’inflazione che i tassi di interesse sono ancora alti negli Stati Uniti, il che influisce sul potere d’acquisto dei cittadini. Ad esempio, a settembre c’è stato un aumento del 3,7% su base annua dell’indice dei prezzi al consumo a causa dell’aumento dei costi del gas. Tuttavia, quel tasso è molto inferiore al 9,1% registrato nel giugno 2022.</p>
<p>Secondo i dati recenti, c’è ancora un elevato livello di spesa dei consumatori supportato da un solido mercato del lavoro. Ad esempio, i datori di lavoro hanno aggiunto 336.000 posti di lavoro solo a settembre e il tasso di disoccupazione è stato del 3,8% nello stesso periodo. D’altra parte, c’erano oltre 9,6 milioni di posti di lavoro vacanti ad agosto, segno di un continuo crescita economica.</p>
<p>Come ha sottolineato Powell, l’aumento dei rendimenti obbligazionari potrebbe aiutare l’economia a rallentare, riducendo probabilmente le probabilità di futuri rialzi dei tassi di interesse. Tuttavia, i rendimenti dei titoli di Stato potrebbero aver raggiunto livelli record perché il mercato si aspettava che la Fed effettuasse un altro rialzo dei tassi a settembre.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/379/what-are-bitcoin-etfs-bitcoin-etfs-explained" target="_blank">Cosa sono gli ETF Bitcoin? ETF Bitcoin spiegati</a></p>
<h2 id="h2-Limpatto20del20discorso20accomodante20di20Powell20su20Bitcoin605932"><a name="L’impatto del discorso accomodante di Powell su Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’impatto del discorso accomodante di Powell su Bitcoin</h2><p><a href="https://www.gate.io/bitwiki/detail/60/bitcoin" target="_blank">Bitcoin</a> ha registrato un forte slancio al rialzo alcuni giorni prima del discorso accomodante di Powell. Ad esempio, un giorno prima che Powell tenesse il suo discorso, il prezzo del BTC è salito sopra i 28,5 mila dollari.</p>
<p>E il 20 ottobre, 24 ore dopo il discorso di Powell, il <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">prezzo del bitcoin</a> è salito a $29.846 come indica il seguente grafico.<br><img src="https://gimg2.gateimg.com/image/article/16987317621.png" alt=""><br>Movimento del prezzo del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> - CoinGecko</p>
<p>Come mostra il grafico dei movimenti dei prezzi del bitcoin sopra, il suo valore è aumentato in modo significativo il 20 ottobre. Da allora, è rimasto abbastanza alto. Attualmente, gli investitori possono <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">acquista bitcoin</a> a circa $34,427. Tuttavia, c’è stato un calo del prezzo del BTC da $34,977 il 25 ottobre al valore attuale.</p>
<h2 id="h2-Prospettive20future20di20Bitcoin20dopo20il20discorso20rilassante20di20Powell573610"><a name="Prospettive future di Bitcoin dopo il discorso rilassante di Powell" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future di Bitcoin dopo il discorso rilassante di Powell</h2><p>Poiché è improbabile che la Fed aumenti il tasso di interesse mensilmente, significa che il potere d’acquisto dei consumatori rimarrà relativamente alto. Di conseguenza, gli investitori possono avere un reddito aggiuntivo per l’acquisto di asset ad alto rischio come il bitcoin. Pertanto, è probabile che la domanda di bitcoin aumenti nel prossimo futuro, il che potrebbe far salire il suo prezzo.</p>
<p>Di recente, c’è stato un aumento del numero di indirizzi del portafoglio di bitcoin a causa delle recenti notizie positive come la posizione accomodante della politica monetaria della SEC e la prospettiva di approvazioni di ETF di bitcoin. Alcuni investitori sono <a href="https://www.gate.io/buy_crypto" target="_blank">probabilmente acquistare BTC</a> quando subisce ritiri.</p>
<h2 id="h2-Recenti20salti20di20prezzo20di20Bitcoin978460"><a name="Recenti salti di prezzo di Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recenti salti di prezzo di Bitcoin</h2><p>Abbiamo assistito a diversi balzi di prezzo del bitcoin da metà luglio, quando Ripple ha avuto una vittoria parziale sulla SEC. Infatti, dopo quella sentenza, il prezzo del Bitcoin è salito a $31,809.</p>
<p>Inoltre, martedì 24 ottobre il prezzo del bitcoin ha raggiunto i $35.000, un nuovo massimo da maggio 2022. Il sentiment positivo <a href="https://www.gate.io/blog_detail/3289/sec-postpones-decision-on-spot-bitcoin-etfs-from-blackrock-and-others" target="_blank">sentimento di una possibile approvazione di un ETF bitcoin spot</a> ha portato a un tale aumento dei prezzi.</p>
<p>Tuttavia, il 16 ottobre il prezzo del BTC è salito a $28.500 in seguito al rifiuto della SEC di appellarsi alla sentenza del tribunale che la invitava a rivedere la sua decisione. <a href="https://www.gate.io/es/blog_detail/3357" target="_blank">rifiuto della richiesta di ETF BTC spot di Grayscale</a>. Il mercato ha interpretato il rifiuto della SEC di appellarsi alla sentenza del tribunale come un’indicazione che l’autorità di regolamentazione potrebbe <a href="https://www.gate.io/de/blog_detail/3312/what-are-bitcoin-etfs-and-why-investors-are-lining-up-gate-learn-offer-insight" target="_blank">approverà presto l’ETF BTC</a>.</p>
<h2 id="h2-Conclusione399290"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Powell ha riconosciuto che la Fed potrebbe mettere in pausa le sue aumenti dei tassi di interesse nei prossimi mesi. Tuttavia, ha detto che il Federal Open Market Committee continuerà a valutare i dati rilevanti per determinare quando aumentare nuovamente il tasso dei fondi fed. Tuttavia, l’obiettivo delle Riserve Federali è quello di raggiungere un tasso d’interesse del 2%.</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, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>