V2F0IGlzIGhldCBlZmZlY3QgdmFuIGRlIGVjb25vbWlzY2hlIHJlY2Vzc2llIG9wIGRlIGNyeXB0b21hcmt0Pw==

2024-08-15, 07:34

<p><img src="https://gimg2.gateimg.com/image/article/17237070011692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR435855"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De recente zwakke gegevens dat de Amerikaanse economie in een recessie kan belanden, heeft paniek veroorzaakt op financiële markten, waardoor investeerders risicovolle activa verkopen. The <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> wordt bijzonder getroffen door wereldwijde marktrisico-aversie en heeft ook recente aanpassingen ondergaan.</p>
<p>De markt verwacht over het algemeen dat de Federal Reserve de rentevoeten minstens twee keer zal verlagen, in totaal 75 basispunten, in de tweede helft van 2024 om de druk van de vertragende economische groei het hoofd te bieden.</p>
<p>De markt zal zowel een handelsdaling als prijsdalingen ervaren, die worden bepaald door zijn speculatieve aard en waarde-opslageigenschappen.</p>
<h2 id="h2-Introductie513469"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Steeds meer instellingen voorspellen dat de Federal Reserve de rente in september zal verlagen, maar dit mogelijke voordeel werd al snel overschaduwd door de angst van investeerders voor een recessie in de VS, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, en zelfs aanzienlijke dalingen ervaren op 5 augustus.</p>
<p>Dit artikel zal de complexe en tegenstrijdige situatie onderzoeken waarmee de cryptomarkt wordt geconfronteerd tijdens de economische recessie in de Verenigde Staten.</p>
<h2 id="h2-Voorspelling20Diverse20indicatoren20geven20aan20dat20de20Amerikaanse20economie20een20recessiestadium20heeft20bereikt193740"><a name="Voorspelling: Diverse indicatoren geven aan dat de Amerikaanse economie een recessiestadium heeft bereikt." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voorspelling: Diverse indicatoren geven aan dat de Amerikaanse economie een recessiestadium heeft bereikt.</h2><p>Het afgelopen jaar zijn er discussies gaande geweest over of de Amerikaanse economie een zachte landing of recessie zal doormaken als gevolg van langdurig hoge rentetarieven. Toch lijken recente beweringen over een economische recessie stevig gevestigd te zijn.</p>
<p>Volgens het laatste rapport van Affirm in juni gelooft bijna 60% van de Amerikanen ten onrechte dat de Verenigde Staten te maken heeft met een economische recessie als gevolg van de stijgende kosten van levensonderhoud en toenemende economische druk. Volgens de ‘Federal Reserve Watch’ van CME is de waarschijnlijkheid dat de Federal Reserve in september de rente met 25 basispunten verlaagt 63%, en de waarschijnlijkheid van een renteverlaging met 50 basispunten is 37%.</p>
<p>Vanuit historisch perspectief heeft de Amerikaanse economie de neiging om achteruit te gaan na voorspoed, voornamelijk als gevolg van de afname van de consumptiecapaciteit veroorzaakt door vermogensschuim, schuldaccumulatie en inkomensongelijkheid. Een van de tekenen van een economische recessie is de voortdurende stijging van de werkloosheid, met name de teleurstellende werkgelegenheidsgegevens die begin augustus zijn vrijgegeven, die investeerders op de Amerikaanse aandelenmarkt verder hebben geschrokken en mensen hebben herinnerd aan de patronen in eerdere economische recessies.<img src="https://gimg2.gateimg.com/image/article/17237070611.jpg" alt=""><br>Bron: AICoin</p>
<p>Zoals we al vermeldden in “ <a href="https://www.gate.io/blog/4407/with-sudden-plunge-when-will-the-market-rebound" target="_blank">Met een plotselinge duik, wanneer zal de markt herstellen?</a>”, volgens de Sahm-regel voorgesteld door voormalig econoom van de Federal Reserve Sahm, wanneer het gemiddelde van de Amerikaanse werkloosheidscijfers in de afgelopen drie maanden hoger is dan het dieptepunt van de afgelopen 12 maanden met meer dan 0,5%, betekent dit dat de VS het beginstadium van economische recessie is ingegaan.<img src="https://gimg2.gateimg.com/image/article/17237070972.jpg" alt=""><br>Bron: NYTimes.com</p>
<p>In feite is Sam’s Law sinds 1950 11 keer geactiveerd, waarbij telkens achteraf werd aangegeven dat de Verenigde Staten inderdaad in de beginfase van een economische recessie verkeerden op dat moment; kijkend naar het heden, zal deze regel in juni 2024 voor de 12e keer geactiveerd worden.</p>
<p>In deze context verwachten instellingen over het algemeen dat de Federal Reserve de rentetarieven minstens twee keer zal verlagen, met in totaal 75 basispunten, in de tweede helft van 2024 als reactie op de verwachte vertraging van de economie.</p>
<p>Het is echter vermeldenswaard dat ondanks de zorgen over recessie de Amerikaanse arbeidsmarkt nog steeds een zekere mate van veerkracht en vitaliteit vertoont. Zo steeg de Amerikaanse CPI voor juli die gisteravond werd aangekondigd met 2,9% op jaarbasis, lager dan de geschatte 3%. Handelaren verlaagden hun verwachtingen voor renteverlagingen omdat de inflatiegegevens niet meer afnamen. Vanuit een macro-perspectief trekken de bestaande hoge rentetarieven nog steeds wereldwijd kapitaal aan. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> naar de Verenigde Staten, en de arbitragehandel van de Japanse yen tegen de Amerikaanse dollar heeft de liquiditeit van de Amerikaanse dollar op de markt vergroot. De Amerikaanse economische gegevens tonen nog steeds een zekere mate van sterke elasticiteit.</p>
<h2 id="h2-Recensie20Het20effect20van20economische20recessie20op20financile20markten392103"><a name="Recensie: Het effect van economische recessie op financiële markten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recensie: Het effect van economische recessie op financiële markten</h2><p>De ‘Zwarte Maandag’ die wereldwijde aandelenmarkten vorige week beleefden, toonde ongetwijfeld de enorme impact van de Amerikaanse economische recessie op wereldwijde financiële markten aan.</p>
<p>De impact van de economische recessie op de aandelenmarkt is de afgelopen decennia aanzienlijk en complex geweest. De belangrijkste redenen hiervoor zijn divers, met name monetaire verkrapping (de centrale bank heeft in totaal 14 keer de rente verhoogd), externe schokken (zoals oorlog, epidemie, enz., 7 keer in totaal), de vermindering van de Amerikaanse overheidsuitgaven (5 keer), hoge leverage (hoge persoonlijke of bedrijfsschuld, 2 keer) en de scherpe daling van de aandelenmarkt zelf (bijvoorbeeld de ineenstorting van de Nasdaq-schuimindex in 2000 ging gepaard met het incident van 11 september, 2 keer in totaal).</p>
<p>Geschiedenis is altijd verbazingwekkend vergelijkbaar. In de afgelopen decennia zijn economische neergangen in de Verenigde Staten doorgaans gepaard gegaan met correcties op de aandelenmarkt of bearmarkten. Tijdens de periode van diepe recessie (meer dan 3% daling van het bbp, in totaal 10 keer), bereikte de gemiddelde maximale daling van de Amerikaanse S&amp;P 500-index -44%, en zelfs in een milde recessie (minder dan 3% daling van het bbp, in totaal 8 keer), bereikte de gemiddelde maximale daling -19%, wat wijst op de enorme druk waarmee de aandelenmarkt wordt geconfronteerd in een economische recessie.<br><img src="https://gimg2.gateimg.com/image/article/17237071563.jpg" alt=""><br>Bron: SOOCHOW SECURITIES</p>
<p>Natuurlijk heeft het rentebeleid van de Federal Reserve een belangrijke rol gespeeld bij het reageren op economische neergangen, maar de effectiviteit ervan hangt nauw samen met het tijdstip. Sinds 2000 heeft de Federal Reserve drie significante renteverlagingen meegemaakt, elk vergezeld van specifieke economische achtergronden en prestaties op de aandelenmarkt.</p>
<p>Bijvoorbeeld, in de periode van het barsten van de technologiebubbel in 2000-2003 en de renteverlaging na het incident van 11 september, schommelde de aandelenmarkt, maar de algehele correctie was significant. Een scherpe daling op de aandelenmarkt ging gepaard met de renteverlaging tijdens de wereldwijde financiële crisis van 2007-2008. De renteverlaging in 2019-2020 viel samen met de passieve vrijlating van geld tegen de achtergrond van de wereldwijde verspreiding van COVID-19 om de economie te redden.</p>
<p>De analyse van het rentebeleid van de Federal Reserve en de prestaties van de Amerikaanse aandelenmarkt kunnen niet in een paar woorden worden samengevat. Er zijn talloze en complexe factoren om rekening mee te houden, maar hoe dan ook, het negatieve effect van een economische recessie op de Amerikaanse aandelenmarkt is duidelijk uit beperkte historische gegevens. In de huidige context waarin <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> steeds meer verbonden is met de traditionele financiële wereld, zullen een reeks beleidsbewegingen van de Federal Reserve daar natuurlijk invloed op hebben.</p>
<h2 id="h2-Perspectief20Richting20van20Bitcoin20kijken20naar20recessie20of20renteverlagingen269965"><a name="Perspectief: Richting van Bitcoin, kijken naar recessie of renteverlagingen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perspectief: Richting van Bitcoin, kijken naar recessie of renteverlagingen?</h2><p>Hier presenteren we eerst ons standpunt dat de markt zowel handelsdalingen als boekhoudkundige prijsdalingen zal ervaren als gevolg van de speculatieve en waarde-opslagkenmerken van Bitcoin.</p>
<p>Hoe moeten we dit begrijpen? De cryptomarkt is gevoelig voor veranderingen in liquiditeit. Wanneer de verwachting van een wereldwijde economische recessie toeneemt of instabiele factoren toenemen, vooral in de vroege stadia van deze economische verschuiving, zal de risicobereidheid van beleggers afnemen. Hoogrisico-activa zoals Bitcoin zijn vatbaar voor verkoop en daling, en zelfs met langetermijnondersteuning zoals ETF’s zal de markt kort dalen om deze paniek in realtime te prijzen. De ineenstorting in maart 2020 vond plaats op een moment dat COVID-19 hevig woedde en de wereldwijde aandelenmarkten kelderden, wat vrij vergelijkbaar is met de huidige situatie.<br><img src="https://gimg2.gateimg.com/image/article/17237071894.jpg" alt=""><br>Bron: glassnode</p>
<p>Integendeel, wanneer de Federal Reserve de rentetarieven verlaagt en geld vrijgeeft, neemt de marktliquiditeit toe en stromen er meer fondsen over naar hoogrisico-, hoogrendements- en hoogvisieactiva zoals Bitcoin, waardoor de prijs stijgt.</p>
<p>De bullmarkt op de cryptomarkt van 2020 tot 2021 was te wijten aan de overvloedige fondsen die werden veroorzaakt door de onbeperkte QE op dat moment, en deze bullmarkt profiteerde ook van de instroom van traditionele fondsen die werden veroorzaakt door de adoptie van Bitcoin en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s.</p>
<p>Kijkend naar de huidige marktsituatie, is de prestatie van BTC in augustus en september in de afgelopen 14 jaar meestal slecht geweest, maar het vierde kwartaal liet vaak uitstekende prestaties zien. Onder de verwachting van de eerste renteverlaging die in september begint, kan de marktsituatie fluctueren en momentum opbouwen.</p>
<p>Op de lange termijn leiden scherpe dalingen in de cryptomarkt, zoals 312, 94, 519 en de recente daling van 85 als gevolg van de economische recessie, vaak snel tot paniek en leiden ze tot meer positieve prijsontdekkingen naarmate de marktacceptatie toeneemt, de infrastructuur verbetert en het vertrouwen van investeerders versterkt.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten van dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>