Qml0Y29pbiB2ZXJsYWF0IHVpdHdpc3NlbGluZ2VuOiBkZSBncm9vdHN0ZSB1aXRzdHJvb20gb3Agw6nDqW4gZGFnLCBnZXdhYXJkZWVyZCBvcCAkMSBtaWxqYXJkIGluIDEyIG1hYW5kZW4=

2024-01-10, 07:43

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR639611"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Op 29 december <a href="/price/vechain-vet" rel="nofollow noopener noreferrer" target="_blank">Koop VeChain</a> registreerde de grootste dagelijkse uitstroom van ongeveer 28.000.</p>
<p>Een afname in de hoeveelheid van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> op beurzen laat een mogelijkheid zien dat de prijs binnenkort kan stijgen.</p>
<p>Er is een toename geweest van institutionele <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> on-chain activiteit.</p>
<h2 id="h2-Inleiding345642"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De aanvankelijke cryptomarktsentiment voor 2024 is afhankelijk van de prestaties van de verschillende categorieën cryptocurrencies in 2023. Beleggers beoordelen vaak de verandering in prijs van bitcoin en belangrijke altcoins zoals <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en <a href="https://www.gate.io/price-prediction/ethereum-eth &quot;Ether (ETH" rel="nofollow noopener noreferrer" target="_blank">Ether (ETH) te voorspellen</a> om de momentum voor het nieuwe jaar te voorspellen. Tot nu toe zijn er duidelijke tekenen dat bitcoin het goed kan doen in 2024.</p>
<p>In dit artikel analyseren we de recente bitcoin on-chain activiteiten, inclusief de instroom en uitstroom van de beurs. De reden hiervoor is dat de instroom op de beurs de mogelijke richting aangeeft <a href="https://www.gate.io/price-prediction/bitcoin-btc" target="_blank">Prijs van bitcoin zal stijgen in 2024</a>. Desalniettemin zijn er nog verschillende andere belangrijke gebeurtenissen <a href="https://www.gate.io/blog_detail/1800/bitcoin-se-reducir%C3%A1-a-la-mitad-en-2024-tendr%C3%A1-btc-otra-carrera-alcista" target="_blank">zoals BTC halvering</a> dat zal plaatsvinden gedurende het jaar.</p>
<h2 id="h2-Grootste20Eendaagse20Uitstroom20van20Bitcoin20in20Maanden470349"><a name="Grootste Eendaagse Uitstroom van Bitcoin in Maanden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Grootste Eendaagse Uitstroom van Bitcoin in Maanden</h2><p>De on-chain activiteit van bitcoin toont aan dat de BTC-markt bullish is, wat crypto-investeringen aanmoedigt. Zo is er recentelijk bijvoorbeeld een afname geweest van de hoeveelheid bitcoin op zowel gecentraliseerde als gedecentraliseerde beurzen als gevolg van een toename van de uitstroom ervan.</p>
<p>Zo was er bijvoorbeeld op woensdag 29 december 2023 een uitstroom van meer dan 28.000 BTC ter waarde van ongeveer $1 miljard van beurzen. Dat was de <a href="https://studio.glassnode.com/metrics?a=BTC&amp;category=&amp;m=transactions.TransfersVolumeExchangesNet&amp;s=1464073154&amp;u=1703721600&amp;zoom=" rel="nofollow noopener noreferrer" target="_blank">enkelvoudig grootste BTC-uitstroom</a> sinds december 2022.</p>
<p>Een grote uitstroom van bitcoin uit beurzen is een bullish indicatie vanwege de vermindering van het aanbod op de markt. Dit geeft ook aan dat bitcoin-walvissen en andere bitcoin-houders bereid zijn om BTC vast te houden in plaats van te verhandelen. In dat g zijn ze mogelijk bereid om een langetermijn-houdstrategie te adopteren. Op basis van de huidige marktsituatie kan dit het beste moment zijn om te <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">koop Bitcoin</a>.</p>
<p>Zoals per <a href="https://cryptoquant.com/asset/btc/chart/exchange-flows/exchange-netflow-total?exchange=coinbase_advanced&amp;window=DAY&amp;sma=0&amp;ema=0&amp;priceScale=log&amp;metricScale=linear&amp;chartStyle=column" rel="nofollow noopener noreferrer" target="_blank">CryptoQuant</a>, een analytics bedrijf, Coinbase, een gecentraliseerde exchange, die de bewaarder is geworden van de 12 verwachte spot bitcoin exchange traded funds (ETF’s) in de Verenigde Staten, registreerde een uitstroom van 18.000 BTC.</p>
<p>Het stijgende BTC-uitstroom heeft de speculatie over een mogelijke toename van institutionele activiteit aangewakkerd vóór de verwachte datum van goedkeuring van spot bitcoin ETF-aanvragen. Als gevolg van een dergelijke grote uitstroom is het saldo van BTC op beurzen gedaald naar 2.327.025 BTC, het laagste niveau sinds april 2018.</p>
<p>Een afname van het volume van bitcoin op beurzen geeft aan dat er een daling is van de verkoopdruk, wat kan leiden tot een waardering van de BTC-prijs. Verschillende factoren zoals het vakantieseizoen en de verwachting van verandering in regelgeving kunnen leiden tot een afname van de hoeveelheid bitcoin op beurzen.</p>
<p>Het is belangrijk om op te merken dat Coinbase de bewering van een uitstroom van meer dan 18.000 BTC van de beurs heeft weerlegd. In een reactie op X Brian Armstrong, de CEO van Coinbase, zei: “Dit is onjuist. Ver van onze interne gegevens.”<br><img src="https://gimg2.gateimg.com/image/article/1704872443img_v3_026v_1d7d8ddf-83ea-4e77-8214-8b698ce51bix.jpg" alt=""><br>Bron: x.com</p>
<h2 id="h2-Toename20van20institutionele20activiteit20vr20de20verwachte20goedkeuringsdatum20van20Spot20Bitcoin20ETFs739559"><a name="Toename van institutionele activiteit vóór de verwachte goedkeuringsdatum van Spot Bitcoin ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toename van institutionele activiteit vóór de verwachte goedkeuringsdatum van Spot Bitcoin ETF’s</h2><p>Er wordt gespeculeerd dat veel instellingen mogelijk veel bitcoin zullen verwerven vóór de datum van de <a href="https://www.gate.io/learn/articles/these-are-the-high-profile-spot-bitcoin-etf-applications-currently-in-pllay/1258" target="_blank">verwachte lancering van spot Bitcoin ETF’s</a>. De goedkeuring van de crypto ETF’s door de SEC wordt verwacht tijdens de tweede week van januari van dit jaar.</p>
<p>MicroStrategy is een instelling die al lange tijd bitcoin koopt. Onlangs heeft het bitcoin ter waarde van $615,7 miljoen gekocht, wat aangeeft dat er steeds meer instellingen zijn die geloven dat bitcoin een waardevol langetermijnbeleggingsactivum is.</p>
<p>Aan de andere kant hebben verschillende instellingen maatregelen genomen om te investeren in bitcoin en de bijbehorende afgeleiden. Zo heeft ARK Invest zich teruggetrokken uit GBTC om te investeren in BITO Bitcoin futures ETF’s. Analisten zien dit als een strategische zet om zichzelf te positioneren voor mogelijke regelgevingswijzigingen.</p>
<h2 id="h2-Bitcoin20reageert20positief20op20veranderingen20in20de20markt704453"><a name="Bitcoin reageert positief op veranderingen in de markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin reageert positief op veranderingen in de markt</h2><p>Als de cryptogemeenschap <a href="https://www.gate.io/learn/articles/pse-trading-the-nature-impact-and-prospects-of-bitcoin-spot-etf/1319" target="_blank">verwacht de lancering van spot bitcoin ETF’s, de markt heeft positief gereageerd</a>. De <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> is al wekenlang aan een stijgende trend. Zo heeft de prijs op dinsdag 1 januari de $45.000 overschreden. Dat was de eerste keer dat de bitcoinprijs sinds april 2022 die grens overschreed.</p>
<p>Bovendien vond die stijging van de bitcoinprijs plaats nadat de Securities and Exchange Commission had gemeld dat zij haar beslissing over de spot bitcoin ETF mogelijk aan de aanvragers bekend zou maken op dinsdag of woensdag vóór de deadline van 10 januari.</p>
<p>Justin d’Anethan, hoofd van APAC business development van Keyrock, een <a href="/price" target="_blank" class="blog_inner_link">crypto market</a> maker, heeft gereageerd op de recente BTC prijsbeweging en de vooruitzichten op de goedkeuring van spot bitcoin ETFs.</p>
<p>Hij <a href="https://www.theblock.co/post/265684/institutional-investors-poised-for-increased-crypto-activity-in-2024-analysts-say" rel="nofollow noopener noreferrer" target="_blank">zei</a> Er gebeurt niet veel aan de macrokant dat iemand zou doen geloven dat het iets anders is dan een <a href="/price/optimism-op" target="_blank" class="blog_inner_link">op crypto</a> gerelateerde dynamiek. In dit g hebben we nieuws gehad over Blackrock, Fidelity en andere aanvragers van spot bitcoin ETF. <a href="https://www.bloomberg.com/news/articles/2023-12-29/blackrock-names-jane-street-jpmorgan-as-bitcoin-etf-authorized-participants" rel="nofollow noopener noreferrer" target="_blank">bevestigend</a> namen van de makelaars die hun BTC-operaties zouden ondersteunen.”</p>
<p>Hij vervolgde: “De meeste investeerders verwachten dat er in de eerste helft van deze maand een officiële beslissing wordt genomen, dus binnenkort.”</p>
<p>Nog een crypto-commentator, <a href="https://x.com/ali_charts/status/1740671046582149381?s=46&amp;t=qzsvHvtDB3yjTaoaylh-2g" rel="nofollow noopener noreferrer" target="_blank">Ali Charts heeft voorspeld</a> dat bitcoin voor een lange periode bullish zal blijven. Hij baseerde de analyse op de 3-jarige bullish periode, gevolgd door een jaar durende bearish correctietrend. In deze context heeft Alichart de volgende grafiek gepresenteerd om de mogelijke prijsbeweging van bitcoin te laten zien.<img src="https://gimg2.gateimg.com/image/article/1704872563img_v3_026v_12ccaf4f-d2f3-417b-b0d9-794a5a63e0ix.jpg" alt=""><br>Prognose van de Bitcoin-prijsbeweging - Alicharts</p>
<p>Zoals u opmerkte, is de bitcoinprijs waarschijnlijk in 2024 blijven stijgen.</p>
<h2 id="h2-Conclusie131538"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Bitcoin heeft een grote enkele dagelijkse uitstroom van ongeveer 28.000 gezien, wat duidt op de bereidheid van bitcoin-walvissen om een langetermijn-houdstrategie te hanteren. De vermindering van bitcoin op beurzen laat een afname van de verkoopdruk zien en een hoge kans op een sterke prijsstijging. Al met al verwacht de cryptogemeenschap dat de waarde van bitcoin zal toenemen <a href="https://www.gate.io/blog_detail/3646/grayscale-suggestion-_s-sec-s-re-_uation-of-bitcoin-etfs" target="_blank">als de SEC spot bitcoin ETF’s goedkeurt</a>.</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 visie van de onderzoeker en vormt geen beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt genoemd. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>