V2FsbCBTdHJlZXQgZW4gQ3J5cHRvY3VycmVuY2llcyBkYWxlbiBhbHMgZ2V2b2xnIHZhbiB6b3JnZW4gb3ZlciByZW50ZXZlcmhvZ2luZw==

2023-07-18, 09:02

<p><img src="https://gimg2.gateimg.com/image/article/1684401663RDZZ.jpeg" alt=""><br>De Dow Jones daalde met 506 punten terwijl de prijs van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> daalde tot $30.600 in de eerste week van juli.</p>
<p>De stijging van de particuliere loonlijst in juni heeft de waarschijnlijkheid van een kwart punt op de bijeenkomst van de Fed op 26 juli verhoogd tot 95%.</p>
<p>Handelaren hebben verwacht dat er nog drie renteverhogingen van de Fed zullen zijn gedurende de rest van het jaar.</p>
<p><strong>Sleutelwoorden</strong>: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a>, BTC-prijs, Bitcoin-investeerders, crypto-investeerders, aandelenmarkt, monetair beleid, rentetarief van de Federal Reserve, crypto-Fed-vergadering</p>
<h2 id="h2-Introductie193543"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Er zijn momenten waarop economische fundamenten van invloed zijn op de waarden van beleggingsactiva zoals cryptocurrencies, grondstoffen en aandelen. Veranderingen in het beschikbare inkomen van huishoudens, banen en groeicijfers kunnen investeringen in activa bevorderen of ontmoedigen.</p>
<p>In dit artikel bespreken we hoe het recente banenrapport van de Verenigde Staten de waarden van aandelen en cryptocurrencies heeft beïnvloed.</p>
<h2 id="h2-Waarden20van20Bitcoin20en20Dow20Jones20dalen2494"><a name="Waarden van Bitcoin en Dow Jones dalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarden van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en Dow Jones dalen</h2><p>In de eerste week van juli 2023 kenden Wall Street-aandelen en cryptocurrencies scherpe prijsdalingen omdat de markt meer renteverhogingen verwachtte. Bijvoorbeeld, de <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">Bitcoin prijs daalde naar $30.600</a> terwijl de Dow Jones Industrial Average met 506 punten daalde, wat een daling van 1,5% vertegenwoordigt.</p>
<p>De markt reageerde simpelweg op de mogelijkheid van een spoedige renteverhoging door de Fed als gevolg van sterke arbeidsmarktcijfers. Na de <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 heeft de rentevoet gepauzeerd</a> Als de Fed de rente verhoogt in juni, is het zeer waarschijnlijk dat zij haar monetair beleid de komende maanden zal blijven aanscherpen.</p>
<h2 id="h2-Hoe20hebben20de20aandelen20en20cryptomarkt20gereageerd20op20de20opkomende20economische20situatie20in20de20Verenigde20Staten835310"><a name="Hoe hebben de aandelen- en cryptomarkt gereageerd op de opkomende economische situatie in de Verenigde Staten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe hebben de aandelen- en cryptomarkt gereageerd op de opkomende economische situatie in de Verenigde Staten?</h2><p>Zoals eerder vermeld, daalden de waarden van de belangrijkste aandelenactiva, waaronder de Dow Jones, opmerkelijk in de eerste week van juli. Zo daalde de Dow Jones met 33.782 punten, terwijl de Nasdaq en de S&amp;P 500 respectievelijk met 1,6% en 1,4% verloren.</p>
<p>Op dezelfde manier is de daling in de <a href="https://www.gate.io/price-prediction/bitcoin-btc" target="_blank">BTC prijs geeft aan</a> hoe de crypto-sector ook tijdens die periode daalde als gevolg van de verslechterende economische situatie in belangrijke economieën zoals de Verenigde Staten. De gegevens over werkgelegenheid die een robuuste arbeidsmarkt laten zien, injecteerden angst bij investeerders.</p>
<p>Het rapport toont aan dat particuliere salarissen met grotere marges zijn gestegen dan verwacht, wat wijst op de veerkracht van de arbeidsmarkt in het gezicht van een verwachte recessie en een stijging van de rentetarieven.</p>
<p>Volgens het Bureau of Labor Statistics van de VS werden er in juni 209.000 banen toegevoegd aan de Amerikaanse economie, waardoor de werkloosheid daalde van 3,7% naar 3,6%. Het banencijfer van juni was echter lager dan dat van mei, dat 306.000 banen had.</p>
<p>Het feit dat het gemiddelde uurloon voor juni met 0,4% is gestegen, wat hetzelfde is als in mei, geeft aan dat looninflatie nog steeds aanhoudt. Bovendien bleef de jaar-op-jaar groei van het gemiddelde uurloon op 4,4%. Uit de statistieken blijkt dan ook dat de arbeidsmarkt en loonstijgingen niet zijn vertraagd zoals verwacht.</p>
<p>In feite blijft de arbeidsmarkt levendig ondanks de zeer verwachte recessie in de VS. Ook meldde payrollbedrijf ADP dat particuliere salarissen zijn gestegen tot 497.000, wat veel hoger is dan wat economen hadden verwacht. Ze hadden verwacht dat de particuliere salarissen zouden toenemen met 228.000.</p>
<p>Een andere verrassende ontwikkeling is de toename van het aantal mensen dat in de eerste week van juli een werkloosheidsuitkering heeft aangevraagd. Het ministerie van Arbeid zei dat de aanvragen voor werkloosheidsuitkeringen van de staat zijn gestegen tot 12.000, resulterend in een seizoensgecorrigeerd cijfer van 248.000 in de laatste week van juni.</p>
<p>Dit staat haaks op de verwachtingen van de Fed, iets dat naar verwachting van invloed zal zijn op haar beslissing om de Fed-rente in juli te verhogen. Opvallend genoeg streeft de Federal Reserve ernaar om de arbeidsmarkt te laten vertragen tot duurzame niveaus die het naar een ‘betere balans’ kunnen brengen.</p>
<p>Echter, om de arbeidsmarkt in evenwicht te brengen, moet de groei van het aantal werknemers tussen 70.000 en 100.000 liggen. Bovendien moet elke groei van de werkgelegenheid in lijn zijn met de bevolkingsgroei in het land. Aan de andere kant moet de werkloosheid toenemen op basis van economische voorspellingen.</p>
<p>Het is tegen de achtergrond van deze ontwikkelingen dat verwacht wordt dat de Fed de Fed-rente zal verhogen. Dave Gilbertson, een arbeidseconoom bij payroll-softwarebedrijf UKG, informeerde CNN dat de Fed waarschijnlijk de rente in juli zal verhogen.<br>Gilbertson zei: ‘Dit is duidelijk een zeer krappe arbeidsmarkt, dus ik verwacht dat de Fed naar deze gegevens zal kijken en zal zeggen dat er rechtvaardiging is voor voortdurende kleine renteverhogingen omdat de arbeidsmarkt niet voldoende afkoelt.’</p>
<p>Aan de andere kant zei de Managing Director bij Charles Schwab, Randy Frederick: “Aangezien het ADP-cijfer bijna twee keer zo hoog was als verwacht, impliceert dit over het algemeen dat er potentieel is voor meer renteverhogingen in de toekomst.”</p>
<h2 id="h2-9520Kans20op20een20kwart20punt20tijdens20de20Fedvergadering865616"><a name="95% Kans op een kwart punt tijdens de Fed-vergadering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>95% Kans op een kwart punt tijdens de Fed-vergadering</h2><p>Volgens de CME FedWatch Tool is er een kans van 95% op een renteverhoging van de Fed met een kwart punt tijdens de volgende crypto Fed-vergadering die gepland staat voor 26 juli. Aan de andere kant houden handelaren rekening met een kans van 75% op nog 3 renteverhogingen tegen het einde van het jaar.</p>
<p>Over het algemeen beweren sommige analisten dat het monetaire beleid van de Fed een belangrijke factor zal blijven in het bepalen van de prestaties van zowel de crypto- als de aandelenmarkten gedurende de komende weken en maanden.</p>
<h2 id="h2-Laatste20gedachten782856"><a name="Laatste gedachten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Laatste gedachten</h2><p>De acties die de Federal Reserve zal ondernemen gedurende de rest van het jaar, zijn afhankelijk van de prestaties van de economie. Tot nu toe zullen de veerkrachtige economie, aanhoudende inflatie en een bloeiende arbeidsmarkt waarschijnlijk de agressie van de Fed versterken. Dit kan van invloed zijn op Bitcoin en andere cryptobeleggers om hun investering in cryptocurrencies en de aandelenmarkt te verminderen.</p>
<p>Lees ook: <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">Zullen de voortdurende mislukkingen van Amerikaanse banken een positieve invloed hebben op de virtuele valutamarkt?</a></p>
<p>Zoals we hierboven hebben opgemerkt, zijn veel bedrijven nog steeds aan het inhuren en blijft de consumentenbesteding de economische groei stimuleren, wat waarschijnlijk de inflatie blijft opdrijven. Echter, Ryan Sweet, hoofdeconoom bij Oxford Economics, gelooft dat de Fed mogelijk andere opties heeft dan het verhogen van de rente.</p>
<p>In zijn commentaar op mogelijke stappen van de Fed zei RSM-econoom Tuan Nguyen: “Het is belangrijk voor de Fed op dit moment om alle opties op tafel te hebben. Of het nu de vergadering in juli of de vergadering in september is, al die vergaderingen zullen live zijn, wat betekent dat de Fed de optie heeft om al dan niet te pauzeren of te verhogen.”</p>
<p>Concluderend resulteerde de angst voor renteverhogingen in de daling van de Dow Jones-punten en de daling van de prijzen van verschillende cryptocurrencies die Bitcoin bevatten. De heersende arbeidsmarktomstandigheden hebben Bitcoin-investeerders en andere handelaren al gedwongen om rekening te houden met een kans van 75% op nog drie renteverhogingen in de rest van het jaar.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1884" target="_blank">Voorspelling van BTC-halvering van 2024 tot 2031</a></p>
<h2 id="h2-Veelgestelde20vragen20over20het20effect20van20de20Fedrentevoerhoging20op20de20cryptocurrency20en20aandelenmarkt126627"><a name="Veelgestelde vragen over het effect van de Fed-rentevoerhoging op de cryptocurrency- en aandelenmarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over het effect van de Fed-rentevoerhoging op de cryptocurrency- en aandelenmarkt</h2><h3 id="h3-Wat20is20de20huidige20situatie20van20Bitcoin463058"><a name="Wat is de huidige situatie van Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de huidige situatie van Bitcoin?</h3><p>Bitcoin wordt verhandeld tegen ongeveer $30,336 en toont potentieel voor <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">verdere prijsstijging</a>. De afgelopen drie maanden schommelde het voornamelijk tussen $27.000 en $28.000.</p>
<h3 id="h3-Is20een20hoge20rente20goed20voor20crypto345350"><a name="Is een hoge rente goed voor crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is een hoge rente goed voor crypto?</h3><p>Hoge rentetarieven zijn niet goed voor cryptocurrency omdat ze investeerders dwingen hun geld in minder risicovolle activa zoals grondstoffen te steken. Het is belangrijk op te merken dat cryptocurrencies investeringen met een hoog risico zijn.</p>
<h3 id="h3-Wat20zijn20Fed20Rate20hike20aandelen577811"><a name="Wat zijn Fed Rate hike aandelen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn Fed Rate hike aandelen?</h3><p>Een renteverhoging van de Fed is een verhoging van het belangrijkste rentetarief van de Verenigde Staten, dat van invloed is op de waarde van verschillende beleggingsactiva. Met andere woorden, de Fed-rente is het rentetarief dat de centrale bank van de Verenigde Staten in rekening brengt voor het lenen van geld.</p>
<h3 id="h3-Hoe20zal20een20renteverhoging20door20de20Fed20de20cryptomarkt20benvloeden314870"><a name="Hoe zal een renteverhoging door de Fed de cryptomarkt beïnvloeden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe zal een renteverhoging door de Fed de cryptomarkt beïnvloeden?</h3><p>Een verhoging van de Fed-rente zal waarschijnlijk de investeringen in cryptocurrencies verminderen, aangezien beleggers hun geld zullen verplaatsen naar minder volatiele activa. Dit komt omdat cryptocurrencies hoog risicovolle investeringsactiva zijn.</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 mening van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen mits 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>