Qml0Y29pbiBIYWx2ZXJpbmc6IDg1JSBWb2x0b29pZCwgVm9vcnJhYWQgdmFuIExhbmdlIFRlcm1pam4gSG91ZGVycyBCZXdlZWd0IFppY2ggUmljaHRpbmcgUmVjb3JkaG9vZ3Rlcw==

2023-10-10, 06:19

<p><img src="https://gimg2.gateimg.com/image/article/1692587501guide.jpeg" alt=""><br>We zijn ongeveer 85% dichter bij de volgende <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> halvering die zal plaatsvinden in april 2024.</p>
<p>Ongeveer 76% van de circulerende voorraad van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> is in handen van langetermijn BTC-houders.</p>
<p>De prijs van bitcoin zal waarschijnlijk schommelen tussen $45.000 en $180.000 in 2024.</p>
<p>Trefwoorden: bitcoin halvering data, bitcoin halvering aftellen, volgende bitcoin halvering, Bitcoin blok beloning, Bitcoin economisch model, Bitcoin aanbod vermindering, Bitcoin halvering geschiedenis, Bitcoin halveringseffecten</p>
<h2 id="h2-Inleiding728309"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De cryptogemeenschap kijkt uit naar <a href="https://www.gate.io/blog_detail/2330/bitcoin-halving-preview-in-2024" target="_blank">naar het bitcoin-halveringsevenement van 2024</a>, met de verwachte voordelen, waaronder het potentieel voor het begin van de volgende bullmarkt. Sommige langetermijn bitcoinbezitters houden nog steeds vast aan hun BTC omdat ze verwachten dat de prijs ervan in de komende maanden zal stijgen.</p>
<p>Deze analyse beoordeelt hoe ver we zijn van het volgende bitcoin halveringsgebeurtenis. We zullen ook kijken naar BTC’s <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">prijsvoorspelling</a> voor 2024.</p>
<h2 id="h2-8520van20de20tijd20is20verstreken20sinds20de20vorige20Bitcoinhalvering431980"><a name="85% van de tijd is verstreken sinds de vorige Bitcoin-halvering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>85% van de tijd is verstreken sinds de vorige Bitcoin-halvering</h2><p>De <a href="https://www.gate.io/explore/bitcoin-halving-countdown" target="_blank">De volgende Bitcoin halving zal rond medio 2024 plaatsvinden</a>. De recente on-chain data geeft aan dat we meer dan 85% op weg zijn naar het volgende halveringsgebeurtenis die naar verwachting plaatsvindt in april 2024.</p>
<p>Er heeft ook iets interessants plaatsgevonden. Volgens een crypto-expert, met de X (voorheen Twitter) gebruikersnaam @therationalroot, is de bitcoinvoorraad die in handen is van langetermijnhouders bijna op recordhoogte, bereikt in 2015, wat erop wijst dat bitcoin zijn bodem nadert. Na de bitcoin macro-laag is het waarschijnlijk dat BTC een nieuwe fase ingaat, het begin van de volgende cyclus.</p>
<p>Langdurige bitcoin-houders hebben hun eigen manier van handelen. Meestal houden ze vast aan bitcoin, zelfs wanneer de markt op zijn laagste punt is, aangeduid als de marktbodem. Ook verwerven ze het grootste deel van hun bitcoin tijdens ernstige bearmarkten wanneer de prijs laag is. Op dit moment zijn de meeste langdurige BTC hodlers niet bereid te verkopen terwijl ze wachten op betere rendementen die ze kunnen krijgen nadat de cryptomarkt zich herstelt.</p>
<p>Daarentegen gedragen ze zich anders tijdens een bullmarkt wanneer de BTC prijs hoog is. Tijdens die periode verleidt de stijgende BTC prijs de lange termijn houders om hun bezittingen te verkopen. Op hun beurt kopen de korte termijn bitcoin houders de BTC tijdens de bullmarkt omdat ze snelle winsten nastreven. Daarom zullen tijdens bullmarkten de korte termijn houders de meeste BTC hebben.</p>
<p>Het volgende diagram toont het percentage van bitcoin dat momenteel in handen is van langetermijnbeleggers.<br><img src="https://gimg2.gateimg.com/image/article/16969186161.png" alt=""><br>Percentage van de Bitcoin Supply die in handen is van langdurige houders - Twitter</p>
<p>Zoals <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a>, gepubliceerd door een crypto-analist (door X gebruikersnaam @therationalroot), blijkt dat langetermijn Bitcoin-houders ongeveer 76% van de circulerende Bitcoin bezitten. Deze hoge verhouding komt bijna overeen met die van 2015, een paar maanden voor de Bitcoin-halvering in 2016.</p>
<p>Je kunt de verhouding van Bitcoin die langetermijnhouders in het verleden hadden vergelijken naarmate we dichter bij het volgende halveringsevenement komen. Dit komt omdat @therationalroot de halveringsevenementperioden op de grafiek heeft gelegd. In het verleden verzamelden de langetermijn BTC-houders dergelijke Bitcoin enkele maanden voor het evenement.</p>
<p>Na de piek duurt het echter ongeveer 12 maanden voordat de herverdeling van de munten is voltooid. Wanneer de lange termijn BTC-houders hun BTC-posities beginnen te verkopen, is dit een teken van het begin van de volgende bullmarkt.</p>
<p>Charles Edwards, met de gebruikersnaam @caprioleio, zei: “De enorme groei van lange termijn Bitcoin-houders is alleen vergelijkbaar met 2016. Deze stapsgewijze sprong in Hodl <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Golven</a> Zal grote gevolgen hebben in 2024. Iets wat we niet zagen in de laatste bull-run. Dat maakt deze cyclus meer vergelijkbaar met 2017, waarbij de prijswaardering van 2020 10X hoger was.” Naarmate we naar de volgende Bitcoin-halvering gaan, kan BTC gedurende een periode van 12 maanden zijwaarts bewegen.</p>
<h2 id="h2-202420Bitcoin20Halving20Datums663634"><a name="2024 Bitcoin Halving Datums" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2024 <a href="/explore/bitcoin-halving-countdown" target="_blank" class="blog_inner_link">Bitcoin Halving</a> Datums</h2><p>Volgens het economische model van Bitcoin vindt er een halvering plaats na het minen van 210.000 blokken. Het duurt ongeveer vier jaar om zo’n aantal blokken te minen. Sinds de laatste bitcoin-halvering in 2020 zal de volgende plaatsvinden in 2024.</p>
<p>Hoewel het moeilijk is om de exacte data van toekomstige bitcoin halveringsevenementen te bepalen, kunnen we het jaar van tevoren schatten. We hebben al een duidelijke aftelling voor de bitcoin halvering, zoals de volgende afbeelding laat zien.<br><img src="https://gimg2.gateimg.com/image/article/16969186342.png" alt=""><br>Bitcoin Halving Countdown- Binanceacademy</p>
<p>Zoals het diagram aangeeft, zijn er 197 dagen tot de volgende bitcoin-halvering, die naar verwachting in april 2024 zal plaatsvinden. Zoals u ook opmerkt, zijn er 811.075 blokken gedolven terwijl er slechts 28.925 over zijn.</p>
<p>Het halveringsevenement leidt in feite tot een vermindering van het aanbod van bitcoin. Bijvoorbeeld, bij het volgende halveringsevenement zal de beloning van het bitcoin-blok dalen van 6,25 naar 3,125.</p>
<h2 id="h2-Eerdere20en20toekomstige20Bitcoin20Halvingevenementen129937"><a name="Eerdere en toekomstige Bitcoin Halving-evenementen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Eerdere en toekomstige Bitcoin Halving-evenementen</h2><p>De geschiedenis van de bitcoin halvering toont aan dat we al drie halveringen hebben gehad die plaatsvonden in 2012, 2016 en 2020, zoals het volgende diagram illustreert.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16969186503.png" alt=""><br>Bitcoin Halveringsgeschiedenis - Bybit</p>
<p>De afbeelding toont de vorige drie bitcoin-halveringsevenementen. Op 3 januari 2009 vond er echter geen bitcoin-halvering plaats, het was de lanceringsdatum van BTC. De eerste BTC-halvering vond plaats op 28 november 2012, terwijl de laatste plaatsvond op 11 mei 2020.</p>
<p>Volgens de bitcoin-algoritmes verwachten we nog steeds in totaal 33 halveringen die zouden moeten plaatsvinden tussen nu en het jaar 2.140.</p>
<p>Gerelateerd nieuws:<br><a href="https://www.gate.io/learn/articles/What-is-Bitcoin-Halving-and-Why-is-it-Important/175" target="_blank">Wat is Bitcoin Halving en waarom is het belangrijk?</a> <a href="https://www.gate.io/blog_detail/1896/understanding-of-the-fourth-btc-halving" target="_blank">Begrip van de vierde BTC-halvering</a> <a href="https://www.gate.io/blog_detail/1892/when-btc-is-halved-where-is-the-best-safe-haven" target="_blank">Waar is de beste veilige haven wanneer BTC wordt gehalveerd?</a></p>
<h2 id="h2-Bitcoin20Halvering20Geschiedenis387339"><a name="Bitcoin Halvering Geschiedenis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin Halvering Geschiedenis</h2><p>Laten we eens kijken naar meer details over de geschiedenis van de bitcoin-halvering. Het eerste blok op de bitcoin-blockchain, genaamd het Genesisblok, werd op 3 januari 2009 gedolven door Satoshi Nakamoto, de oprichter ervan. Op dat moment was de beloning voor een bitcoinblok 50 BTC.</p>
<p>Het is belangrijk op te merken dat 50% van de bestaande bitcoin werd gedolven tussen 3 januari 2009 en de eerste bitcoin halvering die plaatsvond op 28 november 2012 zoals de volgende foto aangeeft.<br><img src="https://gimg2.gateimg.com/image/article/16969187204.png" alt=""><br>De eerste Bitcoin Halvering - Stormgain</p>
<p>De halvering van 2012 verminderde de beloning voor het bitcoinblok van 50 BTC naar 25 BTC. Het tweede halveringsevenement dat plaatsvond op 9 juli 2016 resulteerde in een verdere vermindering van het aanbod van bitcoin van 25 BTC naar 12,5 BTC. Aan de andere kant resulteerde de derde en meest recente halvering die plaatsvond op 11 mei 2020 in een verlaging van de mijnbeloning van 12,5 BTC naar de huidige 6,25 BTC.</p>
<h2 id="h2-Effecten20van20Bitcoin20Halving554035"><a name="Effecten van Bitcoin Halving" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Effecten van Bitcoin Halving</h2><p>Alle bitcoin-halveringsevenementen hebben geleid tot sterke rallies. In elke situatie begon de BTC-rally vóór de halvering en duurde meer dan een jaar na die datum. De volgende tabel toont de veranderingen in de BTC-prijs na de halveringen.<br><img src="https://gimg2.gateimg.com/image/article/16969187345.png" alt=""><br>Effecten van Bitcoin Halving - Bybit</p>
<p>Zoals u kunt zien, steeg de BTC-prijs na elke bitcoin-halvering aanzienlijk. Na de halvering van 2012 bijvoorbeeld de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> steeg in iets meer dan een jaar met meer dan 8.500% van $12 naar ongeveer $1.031,95.</p>
<p>Na de halvering van 2016 steeg de prijs van $650,96 naar $20.089 gedurende een periode van ongeveer 526 dagen. Op vergelijkbare wijze steeg de prijs van bitcoin na de halvering in 2020 van $8.787 tot meer dan $66.000. Deze cijfers geven bitcoin-investeerders hoop dat de prijs van BTC met een vergelijkbare marge zal stijgen na de volgende halvering van bitcoin.</p>
<h2 id="h2-Bitcoin20Prijsvoorspelling20voor202024934389"><a name="Bitcoin Prijsvoorspelling voor 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin Prijsvoorspelling voor 2024</h2><p>Veel cryptodeskundigen en analisten voorspellen dat de prijs van bitcoin in 2024 aanzienlijk zal stijgen als gevolg van de volgende bitcoinhalvering.</p>
<p>Bijvoorbeeld, Tom Lee, mede-oprichter van Fundstrat Global Advisors, denkt dat bitcoin in 2024 $180.000 zal bereiken als de Amerikaanse Securities and Exchange Commission bitcoin ETF’s goedkeurt.</p>
<p>Arthur Hayes, mede-oprichter van cryptocurrency exchange BitMEX, voorziet dat Bitcoin in 2024 meer dan $70.000 zal bereiken. JPMorgan Chase, het vermogensbeheerbedrijf, schat echter dat de bitcoin prijs $45.000 zal bereiken.</p>
<p>Andere grote crypto- en beleggingsmaatschappijen zoals Pantera Capital en Standard Chartered hebben een sterke BTC-rally voorspeld. Specifiek schat Pantera Capital dat de BTC-prijs rond de $148.000 zal liggen, terwijl Standard Chartered Bank, via Zodia Custody, zijn dochteronderneming, onlangs heeft verklaard dat de BTC-prijs in 2024 boven de $120.000 zal stijgen.</p>
<h2 id="h2-Conclusie777481"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De on-chain data toont aan dat we meer dan 85% verwijderd zijn van de recente halvering tot de volgende die zal plaatsvinden in 2024. Al langdurige bitcoin-houders hebben ondertussen ongeveer 76% van de huidige BTC-voorraad vergaard, wat de voorbereidheid van de cryptomarkt op de volgende BTC-halvering laat zien. Ondertussen geloven sommige analisten dat de waarde van bitcoin zal variëren tussen $45.000 en $180.000 in 2024.</p>
<h2 id="h2-Veelgestelde20vragen20over20de20Bitcoinhalvering37711"><a name="Veelgestelde vragen over de Bitcoin-halvering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over de Bitcoin-halvering</h2><h3 id="h3-Wat20is20bitcoin20halvering912101"><a name="Wat is bitcoin halvering?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is bitcoin halvering?</h3><p><a href="https://www.gate.io/blog_detail/1067/bitcoin-halving-what-it-is." target="_blank">Bitcoin halvering is een geprogrammeerde vermindering</a> in de blokbeloning die de validators krijgen voor het verifiëren van transacties. De blokbeloning wordt gehalveerd nadat er 210.000 blokken aan de bitcoin blockchain zijn toegevoegd. Dit gebeurt meestal na 4 jaar.</p>
<h3 id="h3-Hoeveel20steeg20bitcoin20na20de20laatste20halvering550933"><a name="Hoeveel steeg bitcoin na de laatste halvering?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel steeg bitcoin na de laatste halvering?</h3><p>De prijs van bitcoin steeg van $8.787 naar ongeveer $69.000 na de halvering in 2020. Het bereikte een all-time-high van $68.789,63 in november 2021. Op dezelfde manier steeg de prijs van bitcoin na de halvering in 2016 van $650,96 naar $20.089.</p>
<h3 id="h3-Hoeveel20bitcoinhalveringen20zijn20er20nog20over269592"><a name="Hoeveel bitcoin-halveringen zijn er nog over?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel bitcoin-halveringen zijn er nog over?</h3><p>We verwachten in totaal 33 bitcoin-halveringen die tussen nu en 2.140 jaar zouden moeten plaatsvinden. Sinds 2009 tot op heden zijn er drie bitcoin-halveringen geweest, die de blokbeloning hebben verminderd van 50 BTC naar 6,25 BTC.</p>
<h3 id="h3-Is20de20halvering20goed20of20slecht334832"><a name="Is de halvering goed of slecht?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is de halvering goed of slecht?</h3><p>Bitcoin-halvering is goed omdat het de voorraad vermindert, wat helpt om de inflatie onder controle te houden. Het helpt ook om de waarde op lange termijn te verhogen, wat mensen motiveert om erin te investeren.</p>
<h3 id="h3-Waarom20past20bitcoin20elke20vier20jaar20halvering20toe508264"><a name="Waarom past bitcoin elke vier jaar halvering toe?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom past bitcoin elke vier jaar halvering toe?</h3><p>Een bitcoin-halvering vindt plaats nadat er 210.000 blokken aan de blockchain zijn toegevoegd. Meestal duurt het ongeveer vier jaar om zo’n aantal blokken aan de blockchain toe te voegen. Halvering creëert deflationaire druk, wat helpt om de prijs van BTC in de loop van de tijd omhoog te duwen.</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 opvattingen van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>