QlRDIE1pbmVycyB2ZXJob2dlbiBkZSB2ZXJrb29wZHJ1azogJDQxIE0gU2VsbC1vZmY=

2023-08-29, 09:40

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>Een toename in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> verkoop tijdens de laatste twee maanden heeft de marktwaarde ervan verlaagd.</p>
<p>De toename van de moeilijkheid van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> heeft misschien veel mijnwerkers gedwongen om veel BTC te verkopen.</p>
<p>Vanwege de hoge verkoopdruk <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> is onder de $27.000.</p>
<p>Trefwoorden: bitcoin-mining, BTC-mining, BTC-miners, BTC delven, BTC kopen, bitcoin-prijs</p>
<h2 id="h2-Inleiding799369"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De activiteit van Bitcoin miners heeft invloed gehad op <a href="https://www.gate.io/price" target="_blank">de prijs van de cryptocurrency</a> Vaak, wanneer mijnwerkers hun munten op de markt dumpen, kan dat leiden tot een daling van de prijs. Onlangs uitten Bitcoin-investeerders bezorgdheid over de toename van de hoeveelheid BTC die mijnwerkers op de markt dumpen. Dit artikel bekijkt de impact van de recente massale verkoop door bitcoinmijnwerkers.</p>
<h2 id="h2-Bitcoinminers20verhogen20de20hoeveelheid20BTC20op20de20markt22057"><a name="Bitcoin-miners verhogen de hoeveelheid BTC op de markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin-miners verhogen de hoeveelheid BTC op de markt</h2><p>De <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">prijs van bitcoin</a> is sinds het begin van het jaar gestegen ondanks uitdagingen zoals de crypto-crackdown in de Verenigde Staten. Desalniettemin is de bitcoinprijs er niet in geslaagd om boven de $32.500 uit te stijgen vanwege verschillende factoren, waaronder de massale dumping van de munt door BTC-miners op de markt.</p>
<p>Sinds juni hebben veel Bitcoin-mijnwerkers de hoeveelheden BTC die ze hebben gelost op de beurzen verhoogd, waardoor er meer verkoopdruk is ontstaan dan voorheen. Volgens Glassnode, het blockchain-analysebedrijf, hebben veel Bitcoin-mijnbouwbedrijven grote hoeveelheden BTC naar de beurzen gestuurd.</p>
<p>Ook gegevens van Glassnode geven aan dat de totale hoeveelheid bitcoin die de mijnwerkers naar de beurzen brachten op 3 juni een driejarig hoogtepunt bereikte, een niveau dat voor het laatst werd bereikt tijdens de stierenmarkt van 2021.</p>
<p>Deze informatie is in overeenstemming met de gegevens van Coin Metrics, die wijst op een scherpe daling in de metrische eenhopige aanbod van mijnwerkers, die de hoeveelheid bitcoin bijhoudt die wordt opgeslagen in digitale portefeuilles die BTC ontvangen van verschillende mijnbouwpools. De metriek toont een toename van de bitcoinreserves van mijnwerkers sinds mei van dit jaar. Echter, vanaf de tweede week van juni begon het aantal bitcoins in de portefeuilles van mijnwerkers af te nemen.</p>
<p>Als voorbeeld hebben bitcoin miners gedurende een periode van 24 uur die van 12 tot 13 juli duurde meer dan 14.000 BTC, ter waarde van ongeveer $41,2 miljoen, gelost op beurzen. De toename van de verkoopdruk van BTC is gepaard gegaan met een lage volatiliteit gedurende de laatste 40 dagen. Gedurende het grootste deel van die periode schommelde de bitcoin-prijs rond de $30.000.<br><img src="https://gimg2.gateimg.com/image/article/16933018561.png" alt=""><br>Bitcoin Verkoopdruk - CryptoQuant</p>
<p>Zoals uit het bovenstaande diagram blijkt, waren er meer BTC-verkopers dan kopers.</p>
<p>Op dat moment merkte Maartun op: ‘De verkoopvolume van de nemers overtreft nog steeds aanzienlijk de kopers van de nemers. Daarom wordt de prijs nog steeds onderdrukt onder de $30.000.’ Echter, als de BTC-prijs de $32.000 overschrijdt, kunnen de miners stoppen met het verkopen van hun bitcoin-voorraad, wat de prijs kan opdrijven.</p>
<h2 id="h2-Effecten20van20BTC20ERFsoptimisme20op20de20Bitcoinprijs91941"><a name="Effecten van BTC ERFs-optimisme op de Bitcoin-prijs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Effecten van BTC ERFs-optimisme op de Bitcoin-prijs</h2><p>Ondanks de recente grote BTC-verkoop laat Glassnode zien dat er nog steeds veel bitcoin-investeerders zijn die grote hoeveelheden van de munt vasthouden. Sterker nog, het heeft aangegeven dat langetermijn bitcoin-houders een nieuw record hebben bereikt van 14,59 miljoen munten, wat neerkomt op ongeveer 75% van de circulerende voorraad van bitcoin. Dit toont hun bereidheid aan om BTC vast te houden ondanks de korte termijn depressieve markt. De volgende grafiek toont de verandering in de hoeveelheid BTC die langetermijn investeerders dit jaar hebben verzameld.<br><img src="https://gimg2.gateimg.com/image/article/16933018682.png" alt=""><br>Bitcoin Holding - Glassnode</p>
<p>Zoals getoond door de blauwe lijngrafiek in het bovenstaande diagram, is er een toename geweest in de hoeveelheid bitcoin die de langetermijnbeleggers vasthouden.</p>
<p>Sommige analisten zijn echter van mening dat een sterke katalysator zoals de <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf/218" target="_blank">goedkeuring van BTC ETF’s</a> kan de prijs mogelijk boven de $30.000 - $32.000 zone duwen. In de afgelopen maand trok de prijs van bitcoin vaak terug naar $29.000, zelfs als het voor een korte periode was gestegen.</p>
<p>Volgens analisten verwachten de meeste van deze langetermijn Bitcoin-houders dat de Amerikaanse Securities and Exchange Commission (SEC) de bitcoin ETF’s zal goedkeuren. Onlangs heeft de SEC er veel ontvangen <a href="https://www.gate.io/blog_detail/379/what-are-bitcoin-etfs-bitcoin-etfs-explained" target="_blank">aanvragen voor BTC ETF’s</a> van verschillende gerenommeerde traditionele financiële instellingen <a href="https://www.gate.io/blog_detail/1643/blackrock-launches-blockchain-related-etf-for-european-markets." target="_blank">zoals BlackRock</a>.</p>
<p>Desalniettemin heeft de SEC geen commentaar gegeven op BTC ETF’s. In plaats daarvan heeft het een venster van 21 dagen geopend om de mening van het publiek hierover te krijgen. Enkele belangrijke spelers in de sector zoals Ark Invest Cathie Wood en Galaxy Digital Mike Novogratz hebben echter gezegd dat ze verwachten dat de SEC ze op elk moment zal goedkeuren.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/207/why-do-people-choose-crypto-etfs-what-are-the-advantages-and-disadvantages" target="_blank">Waarom kiezen mensen voor Crypto ETF’s? Wat zijn de voordelen en nadelen?</a></p>
<h2 id="h2-Redenen20voor20de20hoge20verkoop20van20BTCminers172272"><a name="Redenen voor de hoge verkoop van BTC-miners" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Redenen voor de hoge verkoop van BTC-miners</h2><p>Er zijn verschillende geprojecteerde redenen waarom de topbedrijven die BTC delven hun bezittingen in grote hoeveelheden verkopen. De Bitcoin miners verkopen de munten mogelijk om winst te nemen.</p>
<p>De <a href="https://www.gate.io/learn/articles/what-is-btc-mining/287" target="_blank">BTC-mining</a> Bedrijven zouden hun bezittingen kunnen hebben verkocht om de stijgende operationele kosten te verdoezelen die voortvloeien uit de langdurige berenmarkten die in 2022 zijn begonnen. Hoewel de cryptomarkt probeert de berenloop van zich af te schudden, blijven de prijzen van de meeste cryptocurrencies, waaronder BTC, gedrukt. Ze zijn nergens in de buurt van hun hoogste niveaus, die voornamelijk in 2021 zijn vastgelegd.</p>
<p>De mijnwerkers verkopen mogelijk hun bezittingen als gevolg van de stijging van de bitcoin-moeilijkheid, een metriek die de moeilijkheidsgraad meet waarmee de mijnwerkers nieuwe blokken vinden. Een stijging van de bitcoin-moeilijkheid leidt tot een vermindering van de inkomsten van de mijnwerkers, wat hun winst kan verminderen of zelfs hun verliezen kan vergroten. De afname van de inkomsten kan hen dwingen om meer bitcoin dan voorheen te verkopen om aan hun operationele kosten te voldoen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/359/understanding-cryptocurrency-mining" target="_blank">Begrijpen van cryptocurrency mining</a></p>
<p>De afname van de activiteit van bitcoin-ordinals heeft de mijnwerkers mogelijk gedwongen om meer BTC te verkopen. Voor een groot deel van de eerste helft van het jaar kwam de omzet van de mijnwerkers uit de activiteit van BTC-ordinals. De daling in mei kan ertoe hebben geleid dat bedrijven die Bitcoin delven een deel van hun bezittingen moesten verkopen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/250/gate.io-observation-how-to-use-cloud-mining-to-mine-bitcoin-in-just-one-click" target="_blank">Hoe gebruik je cloud mining om Bitcoin in slechts één klik te delven?</a></p>
<h2 id="h2-Wat20zou20er20gebeuren20als20Bitcoinminers20zouden20stoppen20met20het20massaal20verkopen20van20BTC778973"><a name="Wat zou er gebeuren als Bitcoin-miners zouden stoppen met het massaal verkopen van BTC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zou er gebeuren als Bitcoin-miners zouden stoppen met het massaal verkopen van BTC?</h2><p>In de afgelopen maanden is de prijs van bitcoin binnen een klein kanaal geschommeld, $27.000 tot $31.500. Momenteel is de bitcoin prijs echter lager dan dit bereik, omdat deze wordt verhandeld op $26.095.</p>
<p>Als de BTC-miners de hoeveelheid bitcoin verminderen, kan dit leiden tot schaarste op de markt, wat waarschijnlijk de prijs boven de $32.000 zal opdrijven. Niettemin is er geen garantie dat de prijs in de nabije toekomst zal stijgen. Daarom moeten beleggers zelfstandig onderzoek doen en alleen het bedrag investeren dat ze zich kunnen veroorloven te verliezen.</p>
<p>Het is ook belangrijk om op te merken dat <a href="https://www.gate.io/how-to-buy/bitcoin-btc" target="_blank">veel investeerders kopen BTC</a> wanneer de prijs laag is om hogere winsten te genereren wanneer de waarde stijgt.</p>
<p>Lees ook over <a href="https://www.gate.io/learn/articles/best-mining-software-in-2023/523" target="_blank">Beste Mining Software in 2023</a></p>
<h2 id="h2-Conclusie222347"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Bitcoin miners hebben sinds juni veel bitcoin verkocht, wat heeft geleid tot een hoge verkoopdruk. Als gevolg hiervan bleef de prijs relatief laag, aangezien deze fluctueerde tussen $27.000 en $31.500. Momenteel ligt de prijs van Bitcoin echter onder de $27.000, aangezien deze wordt verhandeld op $26.095.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1671/bitcoin-mining-profit-squeezed-in-face-of-surging-hash-rate-and-mining-difficulty" target="_blank">Bitcoin-miningwinst geperst in het gezicht van een stijgende hash-snelheid en mijnbouw-moeilijkheid</a></p>
<h2 id="h2-Veelgestelde20vragen20over20Bitcoin664744"><a name="Veelgestelde vragen over Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Bitcoin</h2><h3 id="h3-Kan20optimisme20over20ETFs20een20BTCuitbraak20veroorzaken103411"><a name="Kan optimisme over ETF’s een BTC-uitbraak veroorzaken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan optimisme over ETF’s een BTC-uitbraak veroorzaken?</h3><p>De goedkeuring van bitcoin ETF’s door de SEC zal waarschijnlijk een sterke stijging van de BTC-prijs veroorzaken. De mate waarin de BTC-prijs kan stijgen is echter afhankelijk van andere marktvariabelen, zoals rentetarieven, inflatieniveau en de huidige regelgevingsomgeving.</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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>