UTQgQ3J5cHRvIFJhbGx5IFByb3NwZWN0cyBTY2hpZXRlbiBPbWhvb2cgbWV0IEJpdGNvaW4ncyBTcHJvbmcgT3ZlciAkNjVL

2024-10-09, 07:19

<p><img src="https://gimg2.gateimg.com/image/article/17284578221690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR482469"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> Een stijging boven de $65.000 zal waarschijnlijk een bull run in Q4, 2024 teweegbrengen.</p>
<p>Veranderingen in monetair beleid in de Verenigde Staten en China kunnen helpen om liquiditeit in te brengen in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>.</p>
<p>Voorbeelden van altcoins die waarschijnlijk een altcoin stierenmarkt zullen veroorzaken zijn Sui, Bittensor, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, <a href="/price/helium-hnt" rel="nofollow noopener noreferrer" target="_blank">Helium</a>, <a href="/price/celo-celo" rel="nofollow noopener noreferrer" target="_blank">Celo</a> en UMA Protocol.</p>
<h2 id="h2-Introductie31308"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>2024 is een speciaal jaar geweest voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">bitcoin</a> gezien het feit dat de Verenigde Staten <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf/3693" target="_blank">spot bitcoin ETFs in januari</a>. Deze ontwikkeling heeft traditionele investeerders in staat gesteld om te investeren in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">bitcoin</a> via gereguleerde kanalen. Naast het aantrekken van institutionele investeringen, hebben ETF’s de legitimiteit van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> vergroot en het vertrouwen in de cryptosector vergroot. De goedkeuring van de U.S SEC van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF’s hebben de acceptatie van cryptocurrencies verder verbeterd. Met de <a href="https://www.gate.io/learn/articles/gate-research-bitcoin-spot-etf-sees-net-inflow-of-360-million-market-strongly-rebounds-with-significant-gains-across-multiple-sectors/4241" target="_blank">stijging van kapitaalinstroom in bitcoin ETF’s</a> en de renteverlagingen van de Federal Reserve waar de markt op anticipeert, wordt verwacht dat er in het vierde kwartaal van dit jaar een crypto-rally zal plaatsvinden.</p>
<h2 id="h2-De20doorbraak20van20Bitcoin20boven20de202065K20toont20het20marktoptimisme883967"><a name="De doorbraak van Bitcoin boven de $ 65K toont het marktoptimisme" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De doorbraak van Bitcoin boven de $ 65K toont het marktoptimisme</h2><p>Bitcoin eindigde september met een overall maandelijkse winst van 7,35%. Het werd daarmee een recordmaand, aangezien bitcoin in voorgaande jaren meestal slecht presteerde in dezelfde maand. Aan de andere kant presteert bitcoin vaak indrukwekkend in oktober. Volgens <a href="https://www.coinglass.com/today" rel="nofollow noopener noreferrer" target="_blank">Coinglass</a> De basis van de geweldige prestaties van Bitcoin werd gelegd tijdens kwartaal 1 (Q1) toen het een recordrendement van 68,68% behaalde. Desalniettemin won bitcoin in Q3 met slechts 0,96%. Wat echter indrukwekkend is aan de prestaties van bitcoin in Q3, is dat de waarde ervan in september met 7,9% is gestegen. Dit was een van de grootste winsten die de nummer één cryptocurrency in de maand september had. In vele jaren registreerde het in dezelfde periode een negatief rendement. Volgens Coinglass is het gemiddelde rendement van bitcoin voor de maanden september 3,77%.</p>
<p>Om de maand september af te sluiten <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> overschreed $65.000 toen het $66.236 bereikte op de 27e. Over het algemeen lag de waarde van bitcoin boven de $65.000 tussen 27 en 29 september. Op 30 september daalde bitcoin echter tot onder de $65.000. De korte termijn <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">bitcoin crypto</a> De rally die plaatsvond tussen 27 en 30 september bracht veel <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">optimisme</a> in het geheel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a>. Als gevolg hiervan verwacht de markt dat we mogelijk een bitcoin-rally zullen zien in dit kwartaal.</p>
<h2 id="h2-Crypto20Market20Insights20Waarom20investeerders20een20Bitcoinrally20in20202420verwachten280023"><a name="Crypto Market Insights: Waarom investeerders een Bitcoin-rally in 2024 verwachten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Market Insights: Waarom investeerders een Bitcoin-rally in 2024 verwachten</h2><p>Er zijn verschillende redenen waarom de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> verwacht een <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin-cryptovaluta</a> Rally in Q4. Ten eerste heeft de introductie van spot bitcoin ETF’s in de Verenigde Staten traditionele beleggers in staat gesteld blootstelling aan bitcoin te krijgen zonder het te bezitten. Op basis van de huidige trends op de crypto markt, heeft het gemak van beleggen in bitcoin en de legitimiteit die de ETF’s hebben gecreëerd geleid tot een toename van de interesse in bitcoin. De kapitaalinstroom in bitcoin via ETF’s in Q4 kan bijdragen aan de verbetering van de prestaties ervan.</p>
<p>De marktimpact van het halveringsevenement van 2024, waarbij de beloningen van de bitcoin-blockchain werden verlaagd van 6,25 BTC naar 3,125 BTC, kan in het vierde kwartaal merkbaar zijn. Gewoonlijk kan de vermindering van het aanbod van bitcoin leiden tot een stijging van bitcoin in de komende maanden. De afname van het aanbod van bitcoin, ondersteund door een stijging van de vraag als gevolg van spot BTC ETF’s, kan resulteren in een BTC-rally.</p>
<p>Op basis van inzichten in de cryptohandel hebben verschillende experts voorspeld dat er een bitcoin-rally kan plaatsvinden in het vierde kwartaal. Bijvoorbeeld, <a href="https://x.com/CryptoCon_/status/1837522315988377778" rel="nofollow noopener noreferrer" target="_blank">CryptoCon, een crypto-analist zei</a> De stierenmarkt voor Bitcoin komt eraan, simpel en duidelijk. Geen recessie, geen berenmarkt, of enige andere sombere prijsactie. De fasen op de Puell Multiple maken het overduidelijk dat we ons in het midden van de mid-top correctie bevinden, die net voor de echte stierenloop komt.</p>
<p>Hij voegde eraan toe: ‘Hetzelfde als we zagen in september 2012, 2016 en 2020. De Halving Cycles Theory Red Year (Bull Market) begint na 28 november 2024 en duurt tot 28 november 2025.’ Een van de bullish indicatoren voor cryptocurrencies CryptoCon gebruikt om tot die voorspelling te komen, is de Puell Multiple, zoals weergegeven in de volgende grafiek.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/why-should-you-pay-attention-to-fractal-bitcoin/4287" target="_blank">Waarom zou u aandacht besteden aan Fractal Bitcoin?</a><img src="https://gimg2.gateimg.com/image/article/17284580531.jpg" alt=""><br>Puell Multiple Phases - x.com/CryptoCon</p>
<p>Crypto Con heeft betoogd dat het huidige patroon vergelijkbaar is met wat er is gebeurd in 2012, 2016 en 2020, waar sterke crypto-rally’s waren.</p>
<h2 id="h2-Altcoin20FOMO20Analyse20van20de20toename20in20speculatie483198"><a name="Altcoin FOMO: Analyse van de toename in speculatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altcoin FOMO: Analyse van de toename in speculatie</h2><p>De recente stijging van de bitcoinprijs voorbij $65.000 heeft veel altcoin FOMO gegenereerd (wat is <a href="https://www.gate.io/post/CoinDesk/status/7112743" target="_blank">Bitcoin FOMO - lees hier</a>). Veel beleggers zijn bereid om hun cryptoinvesteringsstrategieën aan te passen in lijn met de verwachte bullrun van altcoins. De <a href="https://capriole.com/charts/" rel="nofollow noopener noreferrer" target="_blank">Capriole Investments’ Altcoin Speculation Index</a> is een van de metrieken die een grote kans laat zien dat altcoin beter presteert dan bitcoin. Als voorbeeld steeg deze index van 13% naar 23% binnen 30 dagen. Deze index laat in feite de mogelijkheid zien dat altcoins beter presteren dan bitcoin, aangezien de stijging een grote kans op een afname van de dominantie van bitcoin laat zien.</p>
<p>De recente stijging van de prijzen van sommige altcoins heeft geleid tot een daling van de bitcoin dominantie. Volgens <a href="https://www.tradingview.com/symbols/BTC.D/" rel="nofollow noopener noreferrer" target="_blank">TradingView</a> de bitcoin dominantie daalde met 1,57% naar 57,51% tijdens de laatste week van september. Die metriek helpt analisten en investeerders om de mogelijkheid van de herplaatsing van kapitaal van bitcoin naar altcoins te beoordelen. De volgende grafiek toont de daling in <a href="https://www.gate.io/learn/articles/what-is-bitcoin-dominance/872" target="_blank">bitcoin dominantie</a> tijdens de laatste week van september.</p>
<p>Lees ook: <a href="https://www.gate.io/blog/1306/the-calculation-and-the-significance-of-bitcoin-dominance" target="_blank">De berekening en de betekenis van Bitcoin dominantie</a><img src="https://gimg2.gateimg.com/image/article/17284581582.jpg" alt=""><br>Dominantie van Bitcoin met 1,57% gedaald - TradingView</p>
<p>Ook steeg in dezelfde periode de Crypto Angst &amp; Gierigheidsindex met 11% tot een score van 61. Een score tussen 56 en 75 duidt op hebzucht, wat betekent dat investeerders meer van het activum kopen dan voorheen, wat de prijs kan opdrijven. Tijdens die periode is de volatiliteit van de cryptomarkt meestal echter zeer hoog.</p>
<p>Verschillende altcoins hebben het al goed gedaan, wat zou kunnen bijdragen aan de altcoin-rally. SEI presteerde bijvoorbeeld sterk tussen 20 en 30 september, waarbij het met 37,79% steeg. Op dezelfde manier steeg Wormhole (W) met 32,83%, terwijl… <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> had een prijsstijging van 32,08%. Ook de <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> handelsvolume nam opmerkelijk toe tijdens die periode. <a href="/price/shiba-inu-shib" target="_blank" class="blog_inner_link">Shiba Inu</a> is in sommige regio’s, zoals Azië, erg populair. Als voorbeeld is het erg populair in Zuid-Korea.</p>
<h2 id="h2-Hoe20economisch20beleid20van20invloed20is20op20cryptoinvesteringen104025"><a name="Hoe economisch beleid van invloed is op crypto-investeringen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe economisch beleid van invloed is op crypto-investeringen</h2><p>De wereldwijde macro-economische omstandigheden dragen bij aan de prestaties van de crypto-sector. Expansionaire beleidsmaatregelen resulteren in een stijging van de macro-liquiditeit, terwijl samentrekkende monetaire maatregelen de wereldwijde liquiditeit verminderen. Zo kunnen de renteverlagingen van de Federal Reserve op 19 september de macro-liquiditeit helpen verhogen, wat waarschijnlijk prijsstijgingen zal veroorzaken gedurende de rest van het jaar. De Federal Reserve verlaagde namelijk de rente met 50 basispunten om de Fed-fondsenrente te brengen naar een bereik van 4,75% tot 5%. Renteverlagingen in de Verenigde Staten leiden vaak tot een stijging van de marktmomentum in de crypto-sector. Daarom kunnen de recente agressieve renteverlagingen in de VS en de prospect van verdere verlagingen het vertrouwen in de crypto-markt opwekken, wat kan leiden tot crypto-rally’s.</p>
<p>Rond dezelfde periode introduceerde China ook maatregelen die kunnen helpen om de wereldwijde liquiditeit te vergroten. Zo lanceerde het land de grootste economische stimulans sinds het hoogtepunt van de Covid-19 pandemie. Naast een breder dan verwacht economisch pakket om de vastgoedsector te ondersteunen, heeft China ook zijn rentetarieven fors verlaagd. Bovendien introduceerde de People’s Bank of China (PBOC) nieuwe financiële instrumenten om de kapitaalmarkt te stimuleren. Zo lanceerde het een swap-programma met een initiële hoeveelheid van een initiële 500 miljard yuan, waardoor fondsen, makelaars en verzekeraars geld kunnen krijgen om aandelen te kopen. Dergelijke maatregelen hebben liquiditeit in de beleggingssector geïnjecteerd, die kan worden gericht op het kopen van cryptocurrencies zoals bitcoin. De dominante crypto <a href="https://www.gate.io/learn/articles/cryptocurrency-investment-guide-in-the-bear-market/1549" target="_blank">beleggingsstrategie tijdens die periode</a> is het dollar-kosten-gemiddelde.</p>
<h2 id="h2-Het20voorspellen20van20de20Altcoin20Bull20Run251935"><a name="Het voorspellen van de Altcoin Bull Run" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het voorspellen van de Altcoin Bull Run</h2><p>De markt zal waarschijnlijk een altcoin bull run zien, afhankelijk van de dominante crypto-investeringsstrategie die slimme investeerders zullen aannemen. Een van de factoren die hieraan bijdraagt, is <a href="https://www.gate.io/learn/articles/what-is-the-altcoin-season-index/674" target="_blank">een altcoin-rally is seizoensgebondenheid</a> Op basis van eerdere trends presteren bijvoorbeeld cryptocurrencies het beste tijdens het vierde kwartaal. Volgens <a href="https://x.com/milesdeutscher/status/1835023046291476783" rel="nofollow noopener noreferrer" target="_blank">Duitse</a>, een prominente cryptanalist, Q4 is het beste seizoen gebleken voor aandelen en andere beleggingsactiva. Als voorbeeld, sinds 1945 is de S&amp;P 500 gemiddeld met 3,8% gestegen tijdens Q4. Een vergelijkbare trend is waargenomen bij bitcoin en andere toonaangevende cryptocurrencies zoals ETH en SOL. Bitcoin heeft een gemiddeld rendement van 88% in Q4 sinds het uitzonderlijk goed presteerde tijdens 2016 en 2020.</p>
<p>Op basis van het concept van seizoensgebondenheid en verschillende macro-economische ontwikkelingen is er een grote kans op een altcoin-rally in Q4. Al eerder, <a href="https://www.grayscale.com/research/market-commentary/grayscale-research-insights-crypto-sectors-in-q4-2024" rel="nofollow noopener noreferrer" target="_blank">Grayscale</a> heeft enkele cryptocurrencies geïdentificeerd die mogelijk kunnen bijdragen aan een altcoin-stierenloop in Q4. Deze omvatten Sui, Bittensor, Optimism, <a href="/price/helium-hnt" rel="nofollow noopener noreferrer" target="_blank">Helium</a>, <a href="/price/celo-celo" rel="nofollow noopener noreferrer" target="_blank">Celo</a> en UMA Protocol. De volgende tabel toont enkele van de cryptocurrencies waarvan Grayscale verwacht dat ze buitengewoon zullen presteren binnen die periode.<br><img src="https://gimg2.gateimg.com/image/article/17284582923.jpg" alt=""><br>Grayscale Research Top 20 Cryptocurrencies for Q4 – Grayscale</p>
<p>Zoals waargenomen in de tabel, kunnen de andere altcoins die de altcoin bull run kunnen triggeren, onder andere Pendle, Illuvium, <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Weergeven</a>, <a href="/price/thorchain-rune" rel="nofollow noopener noreferrer" target="_blank">ThorChain</a>, Raydium en Mantle. Aan de andere kant heeft Deutscher de mogelijke top performers tijdens Q4 genoteerd als Near, FET, TAO, PRIME, ATH, WMT, FTM en SOL. Ook zal er volgens Michael Van Pope waarschijnlijk een altcoin plaatsvinden in Q4, zoals blijkt uit de volgende afbeelding.<br><img src="https://gimg2.gateimg.com/image/article/17284583164.jpg" alt=""><br>Altcoins kunnen een rally doormaken - x.com/MichaelvandePoppe</p>
<p>Deutscher, hierboven genoemd, gelooft ook sterk dat er een altcoin bull run op komst is. <a href="https://x.com/milesdeutscher/status/1838862362302185709" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a>“Altcoins staan op het punt om uit een multi-maanden durende neerwaartse trend te breken. Q4 belooft een opwindend kwartaal te worden, maar als je het wilt maximaliseren, MOET je de juiste altcoins vasthouden.” Op basis van deze opmerkingen en het algemene marktsentiment kan er tijdens Q4 2024 een altcoin-rally beginnen.</p>
<h2 id="h2-Conclusie796120"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Tijdens de laatste week van september steeg de bitcoin-prijs boven de $65.000, wat hoop genereerde dat er in Q4 2024 een altcoin bull run zou kunnen beginnen. Sui, Bittensor, Optimism, Helium, <a href="/price/celo-celo" target="_blank" class="blog_inner_link">Celo</a> en UMA Protocol zijn enkele van de altcoins die in die periode mogelijk indrukwekkend zullen presteren. De FOMO die kan volgen op een sterke Bitcoin-rally zal waarschijnlijk leiden tot de altcoin bull run. Bovendien zal macro-liquiditeit waarschijnlijk toenemen tijdens de periode na de renteaanpassingen in de Verenigde Staten en China.</p>
<div class="blog-details-info"><br><div>Auteur: Mashell C., Onderzoeker bij Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>