Qml0Y29pbiByZWFnZWVydCBvcCBlZW4gdG9lc3ByYWFrIHZhbiBEb3Zpc2ggRmVkIFBvd2VsbA==

2023-10-31, 05:57

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>De Federal Reserve streeft naar een inflatie van 2%.</p>
<p>Een pauze in de renteverhoging kan de vraag naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Gate.io product name] verhogen. [Bitcoin</a>.</p>
<p>De Federal Reserve zal beschikbare gegevens gebruiken om te bepalen wanneer ze de rente weer zullen verhogen.</p>
<p>Trefwoorden: BTC-prijs, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> beweging, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> prijs, BTC prijsdaling, bitcoin kopen, <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin kopen</a>, koop BTC</p>
<h2 id="h2-Introductie412031"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De crypto- en aandelenmarkten wachten al op de positie van de Federal Reserve ten opzichte van de rentetarieven voor het vierde kwartaal van 2023. Het is niet duidelijk of er al dan niet een renteverhoging zal zijn in september, oktober, november en december. Powell heeft echter gehint op een voorzichtige Fed-monetair beleid voor het vierde kwartaal.</p>
<p>Dit artikel onderzoekt de positie van Jerome Powell, de voorzitter van de 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">over het monetair beleid van de Federal Reserve</a> standpunt voor het vierde kwartaal. We zullen ook de implicaties van Powell’s toespraak voor de Amerikaanse economie en financiële markten bespreken.</p>
<h2 id="h2-Dovish20Speech20van20Fed20Powell20over20monetaire20beleidspositie992119"><a name="Dovish Speech van Fed Powell over monetaire beleidspositie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dovish Speech van Fed Powell over monetaire beleidspositie</h2><p>Op donderdag 19 oktober presenteerde Jerome Powell, de voorzitter van de Fed, een dovish speech over het monetair beleid, voornamelijk gericht op de rentetarieven in het land. Powell was duidelijk in zijn speech dat de inflatie nog steeds hoog is en onder controle moet worden gehouden. De Verenigde Staten streeft naar een inflatiepercentage van 2% of lager.</p>
<p>Tijdens een lunch die werd gehouden door de Economic Club of New York in het Hilton Hotel zei Powell: ‘De inflatie is nog steeds te hoog, en een paar maanden goede gegevens zijn slechts het begin van wat nodig is om het vertrouwen op te bouwen dat de inflatie duurzaam naar ons doel beweegt.’</p>
<p>Hij was er ook snel bij om te benadrukken dat de Fed een voorzichtige positie zal innemen ten aanzien van de rentetarieven, waarbij wordt gesuggereerd dat ze deze niet snel zullen verhogen. Over het geheel genomen zei hij dat het Federal Reserve Open Markets Committee de tijd zal nemen en moeite zal doen om alle beschikbare gegevens nu en in de toekomst te ueren om de geschiktheid van een renteverhoging te beoordelen.</p>
<p>Volgens Powell en sommige leden van de Federal Open Market Committee zal het land proberen zijn aanpak op enkele economische variabelen in evenwicht te brengen om een recessie te vermijden, maar ook om inflatie onder controle te houden.</p>
<p>Op dit moment heeft het Federal Open Market Committee (FOMC) besloten om de fed-fondsenrente tussen 5,25 en 5,50% te handhaven. Desalniettemin heeft het FOMC gezegd dat er nog steeds een mogelijkheid is om de rente te verhogen in de komende maanden als inflatie een bedreiging blijft.</p>
<p>Een lid van het FOMC-comité zei: “Bij het bepalen van de mate van verdere beleidsverstrakking die nodig kan zijn om de inflatie op de lange termijn weer op 2 procent te brengen, zal het Comité rekening houden met de cumulatieve verkrapping van het monetair beleid, de vertragingen waarmee monetair beleid van invloed is op economische activiteit en inflatie, en economische en financiële ontwikkelingen.”</p>
<p>Het is belangrijk om op te merken dat de voorzitter van de Fed, Powell, heeft gezegd dat hij blij is dat de inflatie slechts 3,5% hoger is dan het cijfer van vorig jaar. Hij is echter bang dat verschillende factoren het in de nabije toekomst omhoog kunnen duwen.</p>
<p>Als gevolg hiervan concludeerde hij: “We zullen beslissingen nemen over de mate van aanvullende beleidsverstrakking en hoelang het beleid restrictief zal blijven op basis van de totaliteit van de binnenkomende gegevens, de evoluerende vooruitzichten en de risicoverhoudingen.”</p>
<p>Er is geen twijfel dat factoren zoals geopolitieke spanningen in het Midden-Oosten invloed kunnen hebben op de Fed Funds-rente. Daarom sprak Powell kort over een dergelijke ontwikkeling. Hij zei: ‘Geopolitieke spanningen zijn zeer hoog en vormen belangrijke risico’s voor de mondiale economische activiteit.’</p>
<p>Sommige economische analisten hebben gesuggereerd dat als het conflict tussen Israël en Hamas zich verspreidt naar andere olieproducerende landen, dit invloed kan hebben op de olieproductie in het Midden-Oosten. Mocht dat gebeuren, dan kunnen de resulterende veranderingen in de olieprijzen van invloed zijn op de kosten van levensonderhoud en inflatie in de Verenigde Staten.</p>
<p>Niettemin concludeerde Gregory Daco, hoofdeconoom van EY, na zorgvuldige uatie van de toespraak van Powell: ‘De Fed heeft geen haast om het monetaire beleid verder aan te scherpen. Een renteverhoging in november kan veilig worden uitgeprijsd.’</p>
<h2 id="h2-Effecten20van20het20huidige20monetaire20beleid20van20de20Federal20Reserve20op20de20economie359002"><a name="Effecten van het huidige monetaire beleid van de Federal Reserve op de economie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Effecten van het huidige monetaire beleid van de Federal Reserve op de economie</h2><p>Zoals gezegd zijn zowel de inflatie als de rentetarieven nog steeds hoog in de Verenigde Staten, wat van invloed is op de koopkracht van de burgers. Bijvoorbeeld, in september was er een jaar-op-jaar stijging van 3,7% in de Consumentenprijsindex als gevolg van stijgende benzinekosten. Die snelheid is echter veel lager dan de 9,1% die in juni 2022 werd geregistreerd.</p>
<p>Volgens recente gegevens is er nog steeds hoge consumentenbestedingen gesteund door een sterke arbeidsmarkt. Zo voegden werkgevers alleen al in september 336.000 banen toe en bedroeg de werkloosheidsgraad tijdens dezelfde periode 3,8%. Aan de andere kant waren er in augustus meer dan 9,6 miljoen vacatures, een teken van voortdurende economische groei.</p>
<p>Zoals Powell opmerkte, kan de stijging van de obligatierendementen helpen om de economie te vertragen, wat waarschijnlijk zal leiden tot minder incidenten van toekomstige renteverhogingen. Desalniettemin kunnen de rendementen op staatsleningen zijn gestegen omdat de markt verwachtte dat de Fed in september een nieuwe renteverhoging zou hebben.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/379/what-are-bitcoin-etfs-bitcoin-etfs-explained" target="_blank">Wat zijn Bitcoin ETF’s? Uitgelegd Bitcoin ETF’s</a></p>
<h2 id="h2-De20impact20van20Powells20duifachtige20toespraak20op20Bitcoin769912"><a name="De impact van Powell’s duifachtige toespraak op Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De impact van Powell’s duifachtige toespraak op Bitcoin</h2><p><a href="https://www.gate.io/bitwiki/detail/60/bitcoin" target="_blank">Bitcoin</a> ervoer een sterke opwaartse trend enkele dagen voor Powell’s dovish toespraak. Bijvoorbeeld, een dag voor Powell zijn toespraak hield, steeg de BTC-prijs boven de $28,5K.</p>
<p>En op 20 oktober, 24 uur na de toespraak van Powell, de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">bitcoin prijs</a> steeg naar $29.846 zoals blijkt uit de volgende grafiek.<br><img src="https://gimg2.gateimg.com/image/article/16987317621.png" alt=""><br>Bitcoin Prijsbeweging - CoinGecko</p>
<p>Zoals blijkt uit de bovenstaande grafiek van de bitcoin prijsbeweging, is de waarde ervan op 20 oktober drastisch gestegen. Sindsdien is het redelijk hoog gebleven. Momenteel kunnen investeerders <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">koop bitcoin</a> op ongeveer $34,427. Desalniettemin is er een BTC prijsdaling geweest van $34,977 op 25 oktober naar de huidige waarde.</p>
<h2 id="h2-Toekomstperspectief20van20Bitcoin20na20de20toespraak20van20Powell20over20duiven41065"><a name="Toekomstperspectief van Bitcoin na de toespraak van Powell over duiven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstperspectief van Bitcoin na de toespraak van Powell over duiven</h2><p>Aangezien de Fed naar verwachting niet maandelijks de rente zal verhogen, betekent dit dat de koopkracht van de consument relatief hoog zal blijven. Als gevolg hiervan kunnen investeerders extra inkomen hebben om risicovolle activa zoals bitcoin te kopen. Daardoor is het waarschijnlijk dat de vraag naar bitcoin in de nabije toekomst zal toenemen, wat de prijs kan opdrijven.</p>
<p>Onlangs is er een toename geweest in het bezit van bitcoin walletadressen als gevolg van het recente positieve nieuws, zoals de dovish monetair beleidspositie van de SEC en een vooruitzicht op goedkeuring van bitcoin ETF’s. Sommige investeerders zijn <a href="https://www.gate.io/buy_crypto" target="_blank">waarschijnlijk om BTC te kopen</a> wanneer het terugtrekkingen ervaart.</p>
<h2 id="h2-Recente20Sprongen20in20Bitcoin20Prijs615211"><a name="Recente Sprongen in Bitcoin Prijs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recente Sprongen in Bitcoin Prijs</h2><p>We hebben sinds half juli verschillende sprongen gezien in de bitcoin prijs, toen Ripple een gedeeltelijke overwinning behaalde tegen de SEC. Sterker nog, na die uitspraak steeg de Bitcoin prijs naar $31.809.</p>
<p>Bovendien bereikte de prijs van bitcoin op dinsdag 24 oktober $35.000, een nieuw hoogtepunt sinds mei 2022. De positieve <a href="https://www.gate.io/blog_detail/3289/sec-postpones-decision-on-spot-bitcoin-etfs-from-blackrock-and-others" target="_blank">sentiment van een mogelijke goedkeuring van een spot bitcoin ETF</a> resulteerde in zo’n prijsstijging.</p>
<p>Toch steeg op 16 oktober de BTC-prijs naar $28,500 nadat de SEC had besloten om niet in beroep te gaan tegen de gerechtelijke uitspraak dat zij deze moest herzien. <a href="https://www.gate.io/es/blog_detail/3357" target="_blank">afwijzing van de aanvraag voor de Grayscale spot BTC ETF</a>. De markt interpreteerde de weigering van de SEC om in beroep te gaan tegen de uitspraak van de rechtbank als een indicatie dat de toezichthouder mogelijk <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">binnenkort goedkeuren van de BTC ETF</a>.</p>
<h2 id="h2-Conclusie216855"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Powell erkende dat de Fed zijn renteverhogingen de komende maanden zou kunnen onderbreken. Hij zei echter dat het Federal Open Market Committee de relevante gegevens zal blijven beoordelen om te bepalen wanneer de federale fondsrente opnieuw verhoogd moet worden. Toch is het doel van de Federal Reserve om een rente van 2% te bereiken.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>