V2FsbCBTdHJlZXQgZSBsZSBjcmlwdG92YWx1dGUgZGltaW51aXNjb25vIGEgY2F1c2EgZGVsbGUgcHJlb2NjdXBhemlvbmkgcGVyIGwnYXVtZW50byBkZWkgdGFzc2k=

2023-07-18, 09:02

<p><img src="https://gimg2.gateimg.com/image/article/1684401663RDZZ.jpeg" alt=""><br>Il Dow Jones è sceso di 506 punti mentre il prezzo di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è sceso a $30,600 nella prima settimana di luglio.</p>
<p>L’aumento della retribuzione privata di giugno ha aumentato la probabilità di un quarto di punto nel meeting del 26 luglio della Fed al 95%.</p>
<p>I commercianti hanno previsto che ci saranno altri tre rialzi dei tassi della Fed durante il resto dell’anno.</p>
<p><strong>Parole chiave</strong>: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo del Bitcoin</a>, prezzo BTC, investitori Bitcoin, investitori cripto, mercato azionario, politica monetaria, tasso di interesse della Federal Reserve, incontro cripto della Fed</p>
<h2 id="h2-Introduzione111160"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Ci sono momenti in cui i fondamentali economici influenzano i valori degli asset di investimento come criptovalute, materie prime e azioni. Le variazioni del reddito disponibile delle famiglie, dei posti di lavoro e dei tassi di crescita possono promuovere o scoraggiare gli investimenti negli asset.</p>
<p>In questo articolo, discutiamo come il recente rapporto di lavoro degli Stati Uniti ha influenzato i valori delle azioni e delle criptovalute.</p>
<h2 id="h2-I20valori20di20Bitcoin20e20Dow20Jones20diminuiscono169706"><a name="I valori di Bitcoin e Dow Jones diminuiscono" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I valori di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e Dow Jones diminuiscono</h2><p>Nella prima settimana di luglio 2023 le azioni di Wall Street e le criptovalute hanno registrato forti diminuzioni di prezzo poiché il mercato si aspettava ulteriori aumenti dei tassi. Ad esempio, il <a href="https://www.gate.io/blog_detail/2443/daily-news-us-cpi-report-draws-close-attention-from-investors-as-shapella-triggers-staked-ether-reshuffle-and-btc-reaches-10-month-high-of-30k" target="_blank">Il prezzo del Bitcoin è sceso a $30.600</a> mentre il Dow Jones Industrial Average è sceso di 506 punti, che rappresenta un calo del 1,5%.</p>
<p>Il mercato ha semplicemente reagito alla possibilità di un aumento dei tassi della Fed imminente a seguito dei robusti dati sul mercato del lavoro. Dopo il <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">Federal Reserve ha messo in pausa il tasso di interesse</a> Dato l’aumento a giugno, è molto probabile che continuerà a stringere la sua politica monetaria nei prossimi mesi.</p>
<h2 id="h2-Come20hanno20risposto20i20mercati20azionari20e20cripto20allemergente20situazione20economica20negli20Stati20Uniti936069"><a name="Come hanno risposto i mercati azionari e cripto all’emergente situazione economica negli Stati Uniti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come hanno risposto i mercati azionari e cripto all’emergente situazione economica negli Stati Uniti?</h2><p>Come già affermato in precedenza, i valori dei principali asset azionari, tra cui il Dow Jones, sono diminuiti in modo significativo nella prima settimana di luglio. Ad esempio, il Dow Jones è crollato di 33.782, mentre il Nasdaq e lo S&amp;P 500 hanno perso rispettivamente il 1,6% e l’1,4%.</p>
<p>Allo stesso modo, il calo nel <a href="https://www.gate.io/price-prediction/bitcoin-btc" target="_blank">Il prezzo del BTC indica</a> come il settore delle criptovalute è sceso anche durante quel periodo a causa del peggioramento della situazione economica in economie chiave come gli Stati Uniti. I dati sull’occupazione che mostrano un mercato del lavoro robusto hanno iniettato paura negli investitori.</p>
<p>Il rapporto mostra che i salari privati sono aumentati più del previsto, il che indica la resilienza del mercato del lavoro di fronte a una recessione prevista e un aumento dei tassi di interesse.</p>
<p>Secondo l’Ufficio di statistica del lavoro degli Stati Uniti, sono stati aggiunti 209.000 posti di lavoro all’economia degli Stati Uniti a giugno, il che ha portato il tasso di disoccupazione a scendere dal 3,7% al 3,6%. Tuttavia, il numero di posti di lavoro di giugno è stato inferiore a quello di maggio, che ne contava 306.000.</p>
<p>Il fatto che il guadagno medio orario per giugno sia aumentato dello 0,4%, lo stesso di maggio, indica che l’inflazione salariale è ancora persistente. Inoltre, la crescita media degli guadagni orari su base annua è rimasta al 4,4%. Di conseguenza, le statistiche mostrano che il mercato del lavoro e i guadagni salariali non si sono rallentati come previsto.</p>
<p>In sostanza, il mercato del lavoro rimane vivace nonostante la recessione molto attesa negli Stati Uniti. Inoltre, la società di paghe ADP ha affermato che le paghe private sono aumentate a 497.000, molto più di quanto gli economisti si aspettassero. Si prevedeva che le paghe private aumentassero di 228.000.</p>
<p>Un’altra sorprendente evoluzione è l’aumento del numero di persone che hanno richiesto sussidi di disoccupazione nella prima settimana di luglio. Il Dipartimento del Lavoro ha dichiarato che le richieste di sussidi di disoccupazione statali sono aumentate a 12.000, risultando in una cifra stagionalmente adeguata di 248.000 nella settimana scorsa di giugno.</p>
<p>Questo è contrario alle aspettative della Fed, qualcosa che probabilmente influenzerà la sua decisione di aumentare il tasso della Fed a luglio. In modo significativo, la Federal Reserve mira a vedere il mercato del lavoro rallentare a livelli sostenibili che possano portarlo a un “migliore equilibrio.”</p>
<p>Tuttavia, affinché il mercato del lavoro possa trovare un migliore equilibrio, la crescita della retribuzione dovrebbe variare tra 70.000 e 100.000. Inoltre, ogni crescita nella percentuale di occupazione dovrebbe essere in linea con la crescita della popolazione del paese. D’altra parte, la disoccupazione dovrebbe aumentare in base alle previsioni economiche.</p>
<p>È sullo sfondo degli sviluppi sopra riportati che ci si aspetta che la Fed aumenti il tasso della Fed. Dave Gilbertson, un economista del lavoro presso la società di software per la gestione delle retribuzioni UKG, ha informato CNN che la Fed probabilmente aumenterà il tasso di interesse a luglio.<br>Gilbertson ha detto: ‘Si tratta chiaramente di un mercato del lavoro molto stretto, quindi mi aspetto che la Fed guardi questi dati e dica che c’è una giustificazione qui per continuare con piccoli aumenti del tasso perché il mercato del lavoro non si sta raffreddando abbastanza’.</p>
<p>D’altra parte, il Direttore Generale di Charles Schwab, Randy Frederick, ha detto: ‘Dal momento che il numero ADP è stato quasi il doppio di quanto previsto, ciò implica generalmente la possibilità di ulteriori aumenti dei tassi in futuro’.</p>
<h2 id="h2-9520di20probabilit20di20un20quarto20di20punto20al20meeting20della20Fed833553"><a name="95% di probabilità di un quarto di punto al meeting della Fed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>95% di probabilità di un quarto di punto al meeting della Fed</h2><p>Secondo lo strumento CME FedWatch, c’è una probabilità del 95% di un rialzo dei tassi della Fed di un quarto di punto alla prossima riunione della Fed crittografica prevista per il 26 luglio. D’altra parte, i trader stanno considerando una probabilità del 75% di altri 3 rialzi dei tassi entro la fine dell’anno.</p>
<p>In generale, alcuni analisti sostengono che la politica monetaria della Fed rimarrà un fattore chiave per determinare le prestazioni dei mercati criptati e azionari durante le prossime settimane e mesi.</p>
<h2 id="h2-Considerazioni20finali638777"><a name="Considerazioni finali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Considerazioni finali</h2><p>Le azioni che la Federal Reserve prenderà durante il resto dell’anno dipendono dalle performance dell’economia. Finora, l’economia resiliente, l’inflazione persistente e un mercato del lavoro in crescita sono probabili per potenziare l’aggressività della Fed. Questo potrebbe influenzare gli investitori di Bitcoin e altre criptovalute a ridurre i loro investimenti in criptovalute e nel mercato azionario.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2331/will-the-continuous-failures-of-american-banks-have-a-positive-impact-on-the-virtual-currency-market" target="_blank">Le continue fallimenti delle banche americane avranno un impatto positivo sul mercato delle valute virtuali?</a></p>
<p>Come abbiamo notato in precedenza, molte aziende stanno ancora assumendo e la spesa dei consumatori continua a guidare la crescita economica, il che probabilmente continuerà a spingere l’inflazione al rialzo. Tuttavia, Ryan Sweet, economista capo di Oxford Economics, ritiene che la Fed possa avere altre opzioni oltre all’aumento dei tassi.</p>
<p>Commentando le possibili mosse della Fed, l’economista RSM Tuan Nguyen ha detto: “È importante per la Fed al momento avere tutte le opzioni sul tavolo. Che si tratti della riunione di luglio o di settembre, tutte quelle riunioni saranno attive, il che significa che la Fed avrà l’opzione di mettere in pausa o aumentare.”</p>
<p>In conclusione, la paura dei rialzi dei tassi ha determinato la caduta dei punti del Dow Jones, così come la diminuzione dei prezzi di diverse criptovalute, tra cui Bitcoin. Già ora, le attuali condizioni del mercato del lavoro hanno costretto gli investitori di Bitcoin e altri operatori a considerare una probabilità del 75% di altri tre rialzi dei tassi durante il resto dell’anno.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1884" target="_blank">Previsione dell’Halving di BTC dal 2024 al 2031</a></p>
<h2 id="h2-Domande20frequenti20sulleffetto20dellaumento20dei20tassi20della20Fed20sul20mercato20delle20criptovalute20e20azionario219121"><a name="Domande frequenti sull’effetto dell’aumento dei tassi della Fed sul mercato delle criptovalute e azionario" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sull’effetto dell’aumento dei tassi della Fed sul mercato delle criptovalute e azionario</h2><h3 id="h3-Qual2020la20situazione20attuale20di20Bitcoin584623"><a name="Qual è la situazione attuale di Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la situazione attuale di Bitcoin?</h3><p>Bitcoin sta scambiando a circa $30,336 e sta mostrando potenziale per <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">ulteriore aumento dei prezzi</a>. Per gli ultimi tre mesi, ha trascorso la maggior parte del tempo oscillando tra $27.000 e $28.000.</p>
<h3 id="h3-Un20tasso20di20interesse20alto2020buono20per20le20criptovalute754422"><a name="Un tasso di interesse alto è buono per le criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un tasso di interesse alto è buono per le criptovalute?</h3><p>Tassi di interesse elevati non sono buoni per le criptovalute perché costringono gli investitori a mettere i loro fondi in asset meno rischiosi come le materie prime. È importante notare che le criptovalute sono asset ad alto rischio.</p>
<h3 id="h3-Quali20sono20le20azioni20di20aumento20dei20tassi20della20Fed421739"><a name="Quali sono le azioni di aumento dei tassi della Fed?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono le azioni di aumento dei tassi della Fed?</h3><p>Un rialzo della Fed è un aumento del tasso di politica degli interessi principale degli Stati Uniti che influisce sul valore di diversi asset di investimento. In altre parole, il tasso della Fed è il tasso di interesse che la banca centrale degli Stati Uniti addebita per il prestito di denaro.</p>
<h3 id="h3-Come20influenzer20laumento20dei20tassi20della20Fed20la20criptovaluta988937"><a name="Come influenzerà l’aumento dei tassi della Fed la criptovaluta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come influenzerà l’aumento dei tassi della Fed la criptovaluta?</h3><p>Un aumento del tasso della Fed è probabile che riduca gli investimenti nelle criptovalute poiché gli investitori sposteranno i loro fondi verso asset meno volatili. Questo perché le criptovalute sono asset ad alto rischio di investimento.</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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>