U3RyYXRlZ2lzY2hlIHZlcmtvb3A6IEJpdGNvaW4gbWluZXJzIHZlcmtvcGVuIG1lZXN0ZXJsaWprIGh1biB2b29ycmFhZCB2bGFrIHZvb3IgaGV0IGdyb3RlIGhhbHZlcmluZ3NmZWVzdA==

2024-02-08, 16:23

<p><img src="https://gimg2.gateimg.com/image/article/1707408700SDFXnew.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen839280"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Sinds januari 2024 <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Miners hebben grote hoeveelheden BTC verkocht naarmate we dichter bij het halveringsevenement komen, dat verwacht wordt in april.</p>
<p>De reserves van de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> miner zijn momenteel zeer laag.</p>
<p>Op dit moment, de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> schommelt rond de $43.000.</p>
<h2 id="h2-Introductie720012"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Met het langverwachte bitcoin-halveringsevenement dat snel nadert, hebben verschillende bitcoin-miners hun BTC-aandelen afgestoten, wat de prijs sinds half januari heeft gedrukt. Analisten geloven dat <a href="https://www.gate.io/blog_detail/1866/btc-halved-for-the-fourth-time-how-does-it-affect-the-supply-of-btc" target="_blank">het halveringsevenement zal in april van dit jaar plaatsvinden</a> en zal de mijnbeloning verlagen van 6,25 naar 3,125 BTC per blok.</p>
<p>Vandaag richten we ons op de belangrijkste redenen voor bitcoin miners om de nummer één cryptocurrency op de markt te dumpen tijdens januari. We zullen ook de effecten van de grote verkoop van bitcoin op zijn waarde analyseren.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3286/bitcoin-halving-85-done-long-term-holders-supply-inches-toward-record-highs" target="_blank">Bitcoin Halvering: 85% Voltooid</a></p>
<h2 id="h2-Bitcoin20miners20lossen20grote20hoeveelheden20BTC20op20de20markt20uit982595"><a name="Bitcoin miners lossen grote hoeveelheden BTC op de markt uit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin miners lossen grote hoeveelheden BTC op de markt uit</h2><p>De bitcoin miners hebben veel BTC op de markt gelost, waardoor de verkoopdruk is toegenomen. Dat is een van de redenen waarom de bitcoinprijs sinds half januari is gedaald.</p>
<p>Als voorbeeld hebben bitcoin miners alleen al op 17 januari meer dan 10.000 BTC verkocht, wat resulteerde in de grootste dagelijkse daling van de mijnreserves binnen een periode van één jaar. Volgens <a href="https://cryptoquant.com/asset/btc/chart/miner-flows/miner-reserve?miner=all_miner&amp;window=DAY&amp;sma=0&amp;ema=0&amp;priceScale=log&amp;metricScale=linear&amp;chartStyle=line" rel="nofollow noopener noreferrer" target="_blank">CryptoQuant</a> Op 17 januari verkochten de mijnwerkers 10.233 BTC, ter waarde van ongeveer $450 miljoen tegen de heersende prijs op dat moment, een on-chain analytics provider.</p>
<p>Op basis van de vorige trend is er een grote kans dat slimme Bitcoin miners de komende maanden Bitcoin blijven verkopen tot aan de halveringsdatum. Sterker nog, sommige miners verkopen Bitcoin als een strategische zet naarmate we dichterbij komen. <a href="https://www.gate.io/blog_detail/1067/bitcoin-halving-what-it-is." target="_blank">naar het halveringsevenement</a>.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707409268btcMINERS1.png" alt=""><br>Bron: <a href="https://twitter.com/cryptoquant_com/status/1750654514263114197" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>In reactie op de bovenstaande post legde een andere X-gebruiker uit waarom de miners hun bezittingen in grote hoeveelheden zouden kunnen verkopen. Natnah el zei: ‘Als miner is het een zeer slimme zet om jezelf te beschermen tegen de onzekerheid van de prijs/waarde, omdat het zeker is dat de beloningen minder zullen worden, maar er geen zekerheid is over waar de prijs zal zijn tegen de tijd dat het halveringsevenement plaatsvindt.’</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707409289btcMINERS2.png" alt=""><br>Bron: <a href="https://twitter.com/effo_suave/status/1750657685836485081" rel="nofollow noopener noreferrer" target="_blank">X.com</a></p>
<p>Als gevolg hiervan nemen de mijnwerkers winst voordat het halveringsevenement plaatsvindt om operationele kosten te dekken en zich voor te bereiden. <a href="https://www.gate.io/learn/articles/bitcoin-mining-a-path-to-electrifying-the-world/1367" target="_blank">voor andere ontwikkelingen met betrekking tot bitcoin-mining</a> Bijvoorbeeld, sommige van de mijnwerkers moeten meer efficiënte bitcoin mijnbouwapparatuur aanschaffen omdat ze een toename in de mijnbouwmoeilijkheid verwachten na het halveringsevenement.</p>
<p>Aangezien de beloning voor bitcoin mining zal halveren, zal het inkomen van de mijnwerkers waarschijnlijk dalen, tenzij de prijs van BTC stijgt tijdens de post-halvering periode.</p>
<p>Opnieuw, zoals u opmerkt uit de uitleg van Natnah, kunnen de mijnwerkers hun bitcoin-posities verkopen uit angst voor sterke prijsvolatiliteit na het halveringsevenement. In een gerelateerde ontwikkeling heeft CryptoQuant vastgesteld dat de instroom van bitcoin van mijnwerkers naar beurzen meer dan driemaal is toegenomen, wat wijst op sterke verkoopdruk.</p>
<p>Het effect van de stijging van de verkoopdruk van bitcoin was duidelijk <a href="https://www.gate.io/blog_detail/3698/spot-bitcoin-etfs-approval-becomes-a-milestone-how-the-crypto-price-will-move-in-the-future" target="_blank">een paar dagen na de goedkeuring van de ETF door de SEC</a>. Afgezien van de mijnwerkers die veel bitcoin hebben verkocht, hebben sommige walvissen ook hun BTC-posities verkocht.</p>
<p>Wat de situatie ook verergerde <a href="https://www.gate.io/blog_detail/158/the-1st-cryptocurrency-investments-grayscale-what-is-gbtc" target="_blank">werd de verkoop van Grayscale Bitcoin Trust</a> van ongeveer 106.575 BTC na de goedkeuring van de spot bitcoin ETF’s. Belangrijk is dat bitcoin op 12 januari $40.000 heroverde nadat het in voorgaande dagen onder dat niveau was gezakt.</p>
<p>Ook heeft de instroom van bitcoin naar beurzen geleid tot een afname van de BTC-mijnbouwreserves. Momenteel bedragen de bitcoin-mijnbouwreserves ongeveer 1,83 miljoen, met een waarde van ongeveer $73,4 miljard.</p>
<p>Hoewel de mijnbouwreserves sinds 2021 stabiel waren, zijn ze in de afgelopen 12 maanden met 22.800 BTC afgenomen. Desalniettemin op 15 januari de <a href="https://cryptoquant.com/asset/btc/chart/flow-indicator/miners-position-index-mpi?window=DAY&amp;sma=0&amp;ema=0&amp;priceScale=log&amp;metricScale=linear&amp;chartStyle=line &quot;Bitcoin Miners’ Position Index (MPI" rel="nofollow noopener noreferrer" target="_blank">Bitcoin Miners’ Position Index (MPI)</a> begon te duiden dat het tijd was voor de mijnwerkers om hun BTC te verkopen.</p>
<h2 id="h2-Bitcoinmining20gaat20in20cycli131295"><a name="Bitcoin-mining gaat in cycli." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin-mining gaat in cycli.</h2><p>De huidige actie van de bitcoinminer is niet verrassend, gezien dat er verschillende fasen of cycli zijn waar ze doorheen gaan. Volgens de Bitfinex <a href="https://blog.bitfinex.com/wp-content/uploads/2023/08/Bitfinex-Alpha-67-1.pdf" rel="nofollow noopener noreferrer" target="_blank">2023 rapport</a> De bitcoin miners waren de munt aan het verzamelen sinds medio 2023, toen de prijs ervan laag was. Naarmate de waarde van bitcoin stijgt, blijven de miners hun munten verkopen. Ze begonnen een groot deel van hun bezittingen te verkopen in december 2023.</p>
<p>Desalniettemin nam het verkoopmomentum toe in januari, toen de prijs van bitcoin schommelde tussen $42.000 en $49.000, zoals blijkt uit het volgende diagram.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707409355btcMINERS3.png" alt=""><br>Bitcoin-prijs, januari &amp; februari 2024 – <a href="https://www.coingecko.com/en/coins/bitcoin" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Zoals de bovenstaande afbeelding laat zien, schommelde de prijs van bitcoin tussen $40.000 en $47.000 gedurende het grootste deel van de genoemde periode. Op het moment van schrijven wordt bitcoin verhandeld tegen $43.083, wat impliceert dat de meeste cryptoinvesteerders die BTC hebben verworven tijdens 2023 winst kunnen maken als ze het nu verkopen. Voor miners wordt de periode waarin ze winst kunnen maken na het verkopen van hun bezittingen aangeduid als de verkoopfase.</p>
<h2 id="h2-Huidige20Bitcoin20Prijs20Volatiliteit754541"><a name="Huidige Bitcoin Prijs Volatiliteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Huidige Bitcoin Prijs Volatiliteit</h2><p>In januari maakte bitcoin een sterke prijscorrectie door van ongeveer $49.000 op de 11e. In zijn prijsdaling passeerde het de ondersteuningsniveaus van $45.000, $43.500 en $40.000 om zich te vestigen rond $38.572. Vanaf dat punt begon de prijs te herstellen naar zijn huidige handelsniveau, $43.083.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707409371btcMINERS4.png" alt=""><br>Bitcoin prijs dagelijkse grafiek - <a href="https://www.tradingview.com/symbols/BTCUSD/" rel="nofollow noopener noreferrer" target="_blank">TradingView.com</a></p>
<p>Zoals je kunt zien in <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a> Bovenstaand herstelt bitcoin momenteel van zijn recente dip. In feite is de waarde ervan gestegen boven het 50-daags eenvoudig voortschrijdend gemiddelde. Ook is er een omgekeerd hoofd-en-schouderkaarspatroon gevormd, wat aangeeft dat de prijs de komende dagen mogelijk verder zal stijgen.</p>
<p>Als BTC erin slaagt om boven de $43.500 te sluiten, kan het richting het prijsniveau van $44.850 gaan en waarschijnlijk voorbijgaan aan $45.000, $46.500 en $47.000. Zodra het die prijs bereikt, kan het mikken op het niveau van $48.750 voordat het $50.000 opnieuw test.</p>
<h2 id="h2-Conclusie301457"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Bitcoin-mijnwerkers hebben <a href="https://www.gate.io/blog_detail/451/btc-whale-holders-is-it-possible-to-know-who-they-are" target="_blank">verkocht hun BTC holdings</a> gedurende de tijd is de prijs tussen $42.000 en $49.000 blijven schommelen. Met een dergelijke prijsklasse zouden ze winst kunnen maken met hun verkopen. Als gevolg van de grote bitcoinverkopen zijn de reserves van de mijnwerkers tot zeer lage niveaus gedaald.</p>
<h2 id="h2-Veelgestelde20vragen20over20Bitcoinmining820759"><a name="Veelgestelde vragen over Bitcoin-mining" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Bitcoin-mining</h2><h3 id="h3-Hoe20heeft20de20goedkeuring20van20ETF20invloed20gehad20op20de20bitcoin20miningsector455811"><a name="Hoe heeft de goedkeuring van ETF invloed gehad op de bitcoin miningsector?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe heeft de goedkeuring van ETF invloed gehad op de bitcoin miningsector?</h3><p>De goedkeuring van spot bitcoin ETF’s zal de vraag naar de munt verhogen, wat kan leiden tot aanhoudende prijsstijgingen. De stijging van de prijs van bitcoin betekent dat BTC-mijnwerkers hogere marges krijgen wanneer ze de cryptocurrency verkopen. Zo was er bijvoorbeeld na de goedkeuring van bitcoin ETF’s op 10 januari een toename van BTC-verkopen door de mijnwerkers.</p>
<h3 id="h3-Wat20is20bitcoin20halvering202024588341"><a name="Wat is bitcoin halvering 2024?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is bitcoin halvering 2024?</h3><p>Bitcoin halvering is een proces waarbij de beloning voor het minen van een bitcoinblok wordt gehalveerd. Bitcoin halvering 2024, die in april zal plaatsvinden, zal de mijnbeloning verlagen van 6,25 naar 3,125 BTC.</p>
<h3 id="h3-Wat20is20een20factor20voor20succesvolle20bitcoin20mining682336"><a name="Wat is een factor voor succesvolle bitcoin mining?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een factor voor succesvolle bitcoin mining?</h3><p>Er zijn verschillende factoren die van invloed zijn op het succes van bitcoin mining, waaronder de mijnbouwmoeilijkheid, de kosten van elektriciteit en de efficiëntie van de mijnbouwapparatuur. Bijvoorbeeld, bitcoinmijnwerkers die zich bevinden op plaatsen waar de prijs van elektriciteit laag is, genereren meer winst dan degenen in regio’s waar de kosten van stroom hoger zijn.</p>
<h3 id="h3-Wat20is20het20voordeel20van20bitcoin20ETF3890"><a name="Wat is het voordeel van bitcoin ETF?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het voordeel van bitcoin ETF?</h3><p>Spot bitcoin ETF’s zijn gereguleerde beleggingsinstrumenten waarvan de waarde correleert met die van bitcoin. Ook degene die <a href="https://www.gate.io/ar/blog_detail/3728/what-does-bitcoin-etf-introduction-mean-for-investors" target="_blank">mensen die investeren in BTC ETF’s worden niet geconfronteerd met de uitdagingen</a> geassocieerd met de aankoop en opslag van bitcoin.</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 schending van het auteursrecht.<br></div><p></p><br></div></div></div>