QmVyZWlkIGplIHZvb3Igb3AgaW1wYWN0OiBFZW4gZ2lkcyB2b29yIGhldCBuYXZpZ2VyZW4gZG9vciBlZW4gY3J5cHRvY3VycmVuY3kgY3Jhc2ggaW4gMjAyMw==

<p><img src="https://gimg2.gateimg.com/blog/167117863874302594520221216-161657.jpeg" alt=""></p>
<p><strong>[TL; DR]</strong><br>🔹 Een crypto-crash doet zich voor wanneer de prijs van een cryptocurrency met 10% of meer daalt binnen 24 uur.</p>
<p>🔹 <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> en andere cryptocurrencies hebben veel crashes meegemaakt vóór 2022.</p>
<p>🔹 In 2022 waren de oorlog in Oekraïne, FUD, stijgende rentetarieven, beperkte liquiditeit en marktmanipulatie bijdragende oorzaken van cryptocrashes.</p>
<p>🔹 Belangrijke dingen om te doen tijdens een crypto-crash zijn kalm blijven, vasthouden aan uw cryptocurrency en een langetermijnbeleggingsperspectief behouden.</p>
<p><strong>Inleiding</strong><br>2022 was het slechtste jaar in de geschiedenis van cryptocurrency als gevolg van verschillende ernstige crypto-crashes. Het jaar begon slecht door de stijging van de inflatie in veel landen van de wereld, waaronder de Verenigde Staten. Als reactie daarop namen sommige landen hun toevlucht tot het verhogen van de rente in een poging de stijgende inflatie te beteugelen. De correlatie tussen cryptocurrencies en de aandelenmarkt betekent dat de effecten van volatiliteit op de aandelenmarkt ook van invloed zijn op de cryptocurrency-markt.</p>
<h2 id="h2-Oorzaken20van20cryptocrashes20in202022828351"><a name="Oorzaken van cryptocrashes in 2022" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Oorzaken van cryptocrashes in 2022</h2><p>Er is geen twijfel dat 2022 verwoestende marktcrashes had die het vertrouwen van mensen in cryptocurrencies verminderden. De oorzaken van crypto marktcrashes zijn talrijk en verschillende daarvan speelden een rol in 2022. Enkele hiervan zijn macro-economische factoren zoals stijgende inflatie, de invasie van Rusland in Oekraïne, de correlatie tussen de aandelenmarkt en cryptocurrencies, evenals marktmanipulatie.</p>
<p>Om te beginnen, laten we begrijpen wat een cryptovaluta crash is. Een crypto crash is een scherpe en plotselinge daling van de prijs van een cryptovaluta. Het verwijst in feite naar een daling van 10% of meer in de prijs van een cryptovaluta binnen 24 uur. De belangrijkste oorzaken van een crypto crash zijn het bekendmaken van nieuws dat economische omstandigheden beïnvloedt en andere belangrijke negatieve mondiale ontwikkelingen zoals oorlogsuitbraken of pandemieën.</p>
<h2 id="h2-Correlatie20tussen20de20aandelenmarkt20en20de20cryptomarkt678246"><a name="Correlatie tussen de aandelenmarkt en de cryptomarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Correlatie tussen de aandelenmarkt en de cryptomarkt</h2><p>De cryptomarkt is gecorreleerd aan de aandelenmarkt. Als gevolg hiervan is elke neerwaartse trend die zich voordoet op de aandelenmarkt waarschijnlijk ook van invloed op de cryptomarkt. In feite werd de correlatie tussen de cryptomarkt en de aandelenmarkt waargenomen in het begin van 2022, kort nadat veel regeringen de Covid-19 lockdownmaatregelen hadden versoepeld.</p>
<p>Bijvoorbeeld, aan het einde van 2021 tot begin 2022 volgden de prijzen van cryptocurrencies de trend van de aandelen. Ze stegen wanneer de prijs van aandelen steeg en vice versa. Dit betekent dat de macro-economische variabelen tegelijkertijd invloed hebben op cryptocurrencies en aandelen.</p>
<h3 id="h3-Stijgende20rentevoet774654"><a name="Stijgende rentevoet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stijgende rentevoet</h3><p>Stijgende rentetarieven zijn de belangrijkste reden waarom cryptocurrency is gecrasht in 2022. Het hele jaar was bearish door aanhoudende stijgingen in inflatie en rentetarieven.</p>
<p>De werkelijkheid is dat na de pandemie veel landen, waaronder de Verenigde Staten, te maken hebben met stijgende inflatie. Om deze stijgende inflatie te verminderen, hebben sommige landen, waaronder de Verenigde Staten, de rentetarieven verhoogd. Bovendien heeft de stijgende rente de mondiale economie onderdrukt, wat de liquiditeit op de cryptomarkt heeft verminderd.</p>
<p>Hoewel sommige andere factoren hebben bijgedragen aan de crashes van <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> USD en de ineenstorting van FTX, heeft de neergeslagen mondiale economische situatie hier indirect aan bijgedragen. Kort gezegd dwongen aanhoudende renteverhogingen door de Verenigde Staten veel investeerders om hun cryptocurrencies van de hand te doen, wat hun marktkapitalisatie verminderde en hen vatbaar maakte voor cryptocrashes.</p>
<h3 id="h3-Beperkt20nut443951"><a name="Beperkt nut" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Beperkt nut</h3><p>Een andere oorzaak van de crash op de cryptomarkt is het beperkte nut van sommige cryptocurrencies. Dit komt doordat munten en tokens met minimaal nut liquiditeitsproblemen ondervinden tijdens bearish cryptomarkten, zoals degene die we in 2022 hebben meegemaakt. Het is zeer waarschijnlijk dat lage liquiditeit en minimaal nut hebben bijgedragen aan de crash van LUNA en FTT.</p>
<p>Het punt hier is dat cryptocurrencies die niet veel overtuigende praktische toepassingen hebben, liquiditeitsuitdagingen ondervinden tijdens berenmarkten. De reden is dat er geen aanhoudende vraag is naar dergelijke tokens of munten.</p>
<p>Bovendien zullen cryptocurrencies met een grote marktkapitalisatie, zoals ETH, <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> en BTC, waarschijnlijk niet crashen tijdens bear-markten. Daarom zijn dit de cryptomunten om nu te kopen. De cryptocurrencies die de huidige bear-markt overleven, zullen de beste investeringsactiva zijn voor de komende jaren, tenzij er andere verzwarende omstandigheden ontstaan.</p>
<h3 id="h3-Angst20onzekerheid20en20twijfel874048"><a name="Angst, onzekerheid en twijfel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Angst, onzekerheid en twijfel</h3><p>Angst, onzekerheid en twijfel (FUD) is een andere belangrijke oorzaak van de crash van de cryptomarkt. De belangrijkste oorzaak van FUD is nieuws dat wijst op mogelijkheden van een neergang in de prijzen van veel cryptocurrencies.</p>
<p>Zodra FUD de markt in zijn greep heeft, kunnen veel beleggers ervoor kiezen om hun cryptocurrency te verkopen. Het nieuws van de Russische invasie van Oekraïne resulteerde bijvoorbeeld in een algemene daling van de prijzen van veel cryptocurrencies. Dit komt omdat de invasie resulteerde in stijgende prijzen van veel grondstoffen, zoals bepaalde voedingsmiddelen en brandstof. Als gevolg hiervan was er een algemene vermindering van de koopkracht van veel potentiële investeerders.</p>
<p>Uiteindelijk hebben sommige crypto-investeerders hun cryptocurrencies verkocht om hun inkomsten te verhogen. Ook kunnen negatieve berichten over een specifieke cryptocurrency of blockchainprojecten direct leiden tot cryptocrashes. Zo leidde bijvoorbeeld de gelekte informatie over FTX tot de instorting ervan.</p>
<h3 id="h3-Opeenvolgende20cryptoverkoop60728"><a name="Opeenvolgende crypto-verkoop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opeenvolgende crypto-verkoop</h3><p>Het gebruik van geleend geld bij handel is een belangrijke oorzaak van de daling van crypto. Er is sprake van margin debt of margin trading wanneer handelaren geld lenen van makelaars voor handelsdoeleinden.<br>Beleggers die geld lenen om cryptocurrency te kopen, vergroten hun kansen op een hogere winst dan anders. Ze kunnen echter ook enorme verliezen lijden. Over het algemeen lopen handelaren die hoge hefboomwerking gebruiken een groot risico op liquidatie als de prijs de tegenovergestelde richting opgaat.</p>
<p>Daarom, als veel handelaren hoge hefbomen hebben en de prijs van het actief daalt, worden ze allemaal geconfronteerd met liquidatie. Te veel liquidatie op een handelsplatform kan een scherpe daling van de prijs van een specifieke cryptocurrency veroorzaken. Aangezien veel andere handelaren de scherpe daling in de prijs zien, kunnen ze hun posities sluiten. Zo’n verkoopgolf kan zich door de markt verspreiden en leiden tot een crypto crash.</p>
<h3 id="h3-Marktmanipulatie101506"><a name="Marktmanipulatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktmanipulatie</h3><p>De daling van cryptocurrency kan het gevolg zijn van prijsmanipulatie op de markt. Sommige investeerders kunnen ervoor kiezen om FUD te verspreiden op de markt om de prijs van een cryptocurrency omlaag te dwingen.</p>
<p>Grote groepen investeerders die grote hoeveelheden cryptocurrencies bezitten (walvissen) kunnen samenspannen om gecoördineerde verkopen van cryptocurrencies uit te voeren. Dit kan leiden tot scherpe en plotselinge dalingen in hun prijzen, wat resulteert in marktcrashes.</p>
<h2 id="h2-Opmerkelijke20gebeurtenissen20en20cryptocrashes726276"><a name="Opmerkelijke gebeurtenissen en cryptocrashes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opmerkelijke gebeurtenissen en cryptocrashes</h2><p>In 2022 vonden verschillende gebeurtenissen plaats die crypto crashes veroorzaakten. In sommige glen waren de crypto crashes het gevolg van meer dan één oorzaak. Desalniettemin waren er in andere omstandigheden ketens van activiteiten die uiteindelijk resulteerden in crypto crashes.</p>
<h3 id="h3-Oorlog20in20Oekrane492139"><a name="Oorlog in Oekraïne" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Oorlog in Oekraïne</h3><p>De oorlog in Oekraïne was een van de gebeurtenissen die hebben bijgedragen aan enkele cryptocrashes. Ten eerste leidde de oorlog tot tekorten aan belangrijke producten zoals tarwe, meststoffen en brandstof. Specifiek was er na de Russische invasie van Oekraïne in februari 2022 een tekort aan gas en brandstof in Europa. Dit zorgde voor stijgingen in de prijzen van deze goederen.</p>
<p>Wanneer de prijzen van producten waar mensen grotendeels afhankelijk van zijn stijgen, geven consumenten er meer geld aan uit dan voorheen. Als gevolg hiervan neemt hun beschikbaar inkomen af, wat invloed heeft op hun investeringspatronen. Sommigen stoppen zelfs met investeren in risicovolle activa zoals cryptocurrencies. Aan de andere kant verkopen anderen hun huidige investeringsactiva om hun inkomen aan te vullen.</p>
<p>Een ander effect van de oorlog was de angst voor een wereldwijde recessie. In sommige glen kunnen geopolitieke conflicten leiden tot economische crises. Als zodanig dwong de angst voor de recessie na de Russische invasie van Oekraïne veel mensen om hun cryptocurrencies en aandelen te verkopen. Dit heeft bijgedragen aan het ontstaan van de cryptowinter.<br>Kortom, de spanning die ontstond door de invasie van Oekraïne leidde tot de val van de wereldwijde cryptomarkt met meer dan 10%. Binnen 24 uur na de invasie daalde de prijs van ETH met 12%, die van <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> met 12%, <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> met 18,2%, <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> 18%, <a href="/price/shiba-inu-shib" target="_blank" class="blog_inner_link">Shiba Inu</a> 18,9%, <a href="/price/dogecoin-doge" target="_blank" class="blog_inner_link">Dogecoin</a> 16,7% en <a href="/price/polkadot-dot" target="_blank" class="blog_inner_link">Polkadot</a> met 16,2%. In feite daalde de prijs van de meeste grote cryptocurrencies met vergelijkbare marges.</p>
<h3 id="h3-De20FTX20crash114117"><a name="De FTX crash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De FTX crash</h3><p>Naast de invasie van Rusland in Oekraïne, hebben de implosie van de Terra USD en Luna, evenals de ineenstorting van FTX bijgedragen aan de cryptowinter van 2022. Sterker nog, deze gebeurtenissen hebben paniek en angst gecreëerd op de cryptomarkt. Dit komt doordat veel mensen hun volledige investeringen hebben verloren. Bijvoorbeeld, sommige investeerders hadden hun hele levensbesparingen geïnvesteerd in FTX.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673425248111.png" alt=""></p>
<p>FTX ingestort in 2022 - Theguardian</p>
<p>Er was een spoor van gebeurtenissen die leidden tot de ineenstorting van FTX. Deze omvatten de gelekte vertrouwelijke informatie over FTX’s investering van een grote hoeveelheid van zijn native token, FTT, in zijn zusterbedrijf Alameda Research. Daarna verkocht Binance zijn grote FTT-holding, wat voor paniek in de markt zorgde. Wat volgde was een massale uitverkoop van de FTT-munt en andere cryptocurrencies op de FTX-beurs, wat leidde tot de ineenstorting ervan.</p>
<p>Bovendien was het erg gemakkelijk voor de cryptobeurs om in te storten, omdat ongeveer 93% van de FTT-tokens werden vastgehouden door slechts 10 wallets. Daarom was er een grote mogelijkheid van marktmanipulatie.</p>
<h2 id="h2-Zijn20er20eerder20cryptocrashes20voorgekomen20vr202022748249"><a name="Zijn er eerder crypto-crashes voorgekomen vóór 2022?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zijn er eerder crypto-crashes voorgekomen vóór 2022?</h2><p>Het is waar dat er vóór 2022 andere grote crypto crashes waren, waaronder de Crypto Black Thursday. Een andere opmerkelijke crash vond plaats na de sluiting van de Bitfloor-beurs in 2013.</p>
<h3 id="h3-Crypto20Zwarte20Donderdag83736"><a name="Crypto Zwarte Donderdag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Zwarte Donderdag</h3><p>Op 12 maart 2020 heeft de Wereldgezondheidsorganisatie (WHO) Covid-19 uitgeroepen tot een wereldwijde pandemie. Als gevolg hiervan hebben veel landen, zoals de Verenigde Staten, maatregelen aangekondigd om de verspreiding ervan tegen te gaan. Deze ontwikkelingen zorgden voor paniek onder beleggers die reageerden met massale uitverkoop van cryptocurrencies en andere effecten.</p>
<p>Na de verklaring daalde de prijs van BTC met meer dan 40%. Die crash was geen grote verrassing, aangezien Azië, met veel crypto-investeerders, zwaar getroffen werd door de pandemie.</p>
<h3 id="h3-Bitfloor20is20gesloten307029"><a name="Bitfloor is gesloten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitfloor is gesloten</h3><p>In 2013 vond er opnieuw een ernstige BTC-crash plaats nadat het Amerikaanse Financial Crimes Enforcement Network (FinCEN) Bitfloor, een prominente cryptocurrency exchange, had gesloten. De prijs van BTC daalde met meer dan 70% van $260 naar $70. Na dit incident, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> Pas na 6 maanden hersteld.</p>
<h2 id="h2-De20risicos20van20het20kopen20van20cryptocurrencies20tijdens20een20crypto20ineenstorting783471"><a name="De risico’s van het kopen van cryptocurrencies tijdens een crypto ineenstorting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De risico’s van het kopen van cryptocurrencies tijdens een crypto ineenstorting</h2><p>Veel beleggers willen geen cryptocurrencies kopen tijdens een crypto crash vanwege mogelijke risico’s. Het grootste risico is dat van prijsvolatiliteit. Tijdens een crash kan de prijs van de meeste cryptocurrencies meer dalen dan verwacht, wat leidt tot veel verliezen.</p>
<p>Angst, onzekerheid en paniek verergeren de gevolgen van een crash, omdat veel mensen geneigd zijn hun bezittingen te verkopen. Uit de ervaring van recente crypto crashes blijkt dat zelfs sommige geduldige investeerders geneigd zijn hun cryptocurrencies te verkopen tijdens periodes van crashes. Dit kan leiden tot de implosie van sommige cryptocurrencies en het instorten van crypto-projecten.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673425325222.png" alt=""></p>
<p>TerraUSD implodeerde in mei 2022- BBC</p>
<p>De bovenstaande grafiek toont de implosie van TerraUSD die plaatsvond op 9 mei 2022.</p>
<h2 id="h2-Wat20te20doen20tijdens20een20crypto20instorting827480"><a name="Wat te doen tijdens een crypto instorting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat te doen tijdens een crypto instorting</h2><p>Na het bespreken van de oorzaken van cryptocrashes, laten we kijken wat we kunnen doen tijdens dergelijke periodes om onze investeringen te beschermen.</p>
<p>Houd vast aan uw cryptocurrencies: Het beste is om uw cryptocurrencies vast te houden in plaats van ze onder druk te verkopen. Als je ze onder druk verkoopt, maak je vaak verliezen. Zolang u de cryptocurrencies niet verkoopt tegen prijzen die lager zijn dan de prijzen waarvoor u ze hebt gekocht, maakt u geen verlies.</p>
<h3 id="h3-Beheer20je20emoties393489"><a name="Beheer je emoties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Beheer je emoties</h3><p>Het belangrijkste om te doen tijdens een crypto crash is het beheersen van je emoties. Je moet onthouden dat markten cyclisch zijn en correcties en crashes vaak voorkomen.</p>
<h3 id="h3-Houd20een20langetermijnperspectief774412"><a name="Houd een langetermijnperspectief" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Houd een langetermijnperspectief</h3><p>Het is belangrijk dat je crypto-investeringen beschouwt als een langetermijnzaak. Op die manier zul je onthouden dat na elke dip op de cryptomarkt een herstel zal plaatsvinden. Het belangrijkste punt hier is om nooit te focussen op 24-uursgrafieken, omdat ze je angst en paniek kunnen vergroten. Kijk in plaats daarvan naar langetermijnprijsfluctuaties.</p>
<h3 id="h3-Overweeg20om20te20kopen20op20het20dieptepunt471214"><a name="Overweeg om te kopen op het dieptepunt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Overweeg om te kopen op het dieptepunt</h3><p>Crypto-crashes kunnen kansen bieden voor beleggers om de cryptocurrencies te kopen wanneer de prijzen erg laag zijn. Als gevolg hiervan zullen ze enorme winsten maken wanneer de markt opveert. Koop daarom de dip tijdens crypto crashes.</p>
<h3 id="h3-Herzie20uw20financile20strategie74437"><a name="Herzie uw financiële strategie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Herzie uw financiële strategie</h3><p>Er zijn dingen die u moet doen voordat cryptocurrency valt. Het is belangrijk om uw portefeuille te diversifiëren. Dit omvat het kopen en vasthouden van verschillende cryptocurrencies, wat de risico’s zal verminderen als sommige van hen crypto-dalingen ervaren.<br>De gemiddelde kosten van de dollar zijn een andere belangrijke strategie bij het verwerven van cryptocurrencies. Dit houdt in dat een vast bedrag wordt gebruikt om binnen bepaalde perioden cryptocurrencies te kopen. De meeste mensen kopen de cryptocurrencies wekelijks of maandelijks als ze verschillende prijzen hebben.</p>
<h2 id="h2-Conclusie779686"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De cryptosector, net als de aandelenmarkt, ervaart van tijd tot tijd marktcrashes. Enkele oorzaken van cryptomarktcrashes zijn negatieve wereldgebeurtenissen zoals oorlogen en pandemieën, macro-economische instabiliteit, marktmanipulatie en FUD. De Crypto Black Thursday en de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> crash door de sluiting van Bitfloor zijn voorbeelden van marktcrashes die zich vóór 2022 hebben voorgedaan.</p>
<h2 id="h2-Veelgestelde20vragen58709"><a name="Veelgestelde vragen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen</h2><h3 id="h3-Zal20crypto20herstellen20van20een20cryptocrash20in202022880403"><a name="Zal crypto herstellen van een cryptocrash in 2022?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zal crypto herstellen van een cryptocrash in 2022?</h3><p>Crypto is waarschijnlijk te herstellen van de marktcrash die begon in 2022. De mogelijkheid van herstel hangt echter af van andere factoren zoals de stabilisatie van het inflatiepercentage en de rentetarieven. Als de Federal Reserve stopt met het verhogen van de rentetarieven, kan de crypto-crash eindigen. De crypto-winter zal echter doorgaan in het eerste kwartaal van 2023, maar kan herstellen in het tweede kwartaal.</p>
<h3 id="h3-Welke20cryptomunt20zal20in20202320exploderen172463"><a name="Welke cryptomunt zal in 2023 exploderen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke cryptomunt zal in 2023 exploderen?</h3><p>Verschillende cryptocurrencies hebben het potentieel om in 2023 te exploderen. Over het algemeen zullen layer-2 cryptocurrencies zoals <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> (OP), Matic, SNX, OMG, LRC, RDN en INJ waarschijnlijk een rally doormaken in 2023. Hun waarden kunnen scherp stijgen als gevolg van de vraag naar de producten die ze ondersteunen.</p>
<h3 id="h3-Zal20202320een20cryptowinter20zijn775697"><a name="Zal 2023 een cryptowinter zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zal 2023 een cryptowinter zijn?</h3><p>De crypto-winter zal waarschijnlijk doorgaan tot 2023, tenzij er belangrijke veranderingen zijn in de wereldwijde economische trend. Een reden waarom de crypto-winter tot 2023 zal voortduren, is het lage vertrouwen dat momenteel op de markt bestaat, als gevolg van de ineenstorting van FTX, LUNA en TerraUSD. Momenteel zijn er verschillende crypto-projecten zoals BlockFi en Celsius die faillissement hebben aangevraagd. Dit zorgt voor angst op de markt en vermindert het marktvertrouwen.</p>
<h3 id="h3-Is20202320een20bearish20jaar914829"><a name="Is 2023 een bearish jaar?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is 2023 een bearish jaar?</h3><p>Op basis van de huidige mondiale economische vooruitzichten is de eerste helft van 2023 waarschijnlijk bearish, terwijl de tweede helft mogelijk bullish kan worden. Momenteel voorspellen veel economen een kans op een recessie die verdere schade kan toebrengen aan de opkomende cryptomarkt. De tweede helft van 2023 kan bullish worden als de Fed de renteverhogingen stopt.</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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>