QmxhY2tSb2NrJ3MgT3BtZXJrZWxpamtlIFJlaXMgdmFuIDAgbmFhciAxMjIuNjAwIEJpdGNvaW4gKEJUQykgaW4gU2xlY2h0cyBaZXMgV2VrZW4=

2024-03-06, 03:40

<p><img src="https://gimg2.gateimg.com/image/article/1709696134sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR582294"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Na de lancering van spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s, BlackRock heeft meer dan $122,600 BTC verworven.</p>
<p>BlackRock’s agressieve investering in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> zal waarschijnlijk andere traditionele financiële instellingen aantrekken om te investeren in BTC.</p>
<p>BlackRock staat nu op de eerste plaats onder de 22 guru strategieën gerangschikt.</p>
<p><strong>trefwoorden</strong>: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a>, bitcoin investeringen, bitcoin aanbod, cryptomarkt, circulerende voorraad van Bitcoin, BlackRock bitcoin ETF, BTC ETF’s, digitale activa, <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">koop Bitcoin</a>, investeer in bitcoin, bitcoin investeerders</p>
<h2 id="h2-Introductie339411"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Bitcoin heeft sinds de lancering ongeveer 15 jaar geleden vele ontwikkelingen doorgemaakt. Aan het begin van 2023 werden bitcoin-ordinaals geïntroduceerd op de blockchain. Nu, in 2024 <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">De Verenigde Staten hebben 11 bitcoin ETF’s goedgekeurd.</a> die heeft geholpen om de instroom van middelen in het activum te verhogen. Vandaag richten we ons op hoe BlackRock 122.600 bitcoin heeft verworven voor zijn BTC ETF binnen 6 weken.</p>
<h2 id="h2-BlackRocks20overname20nu20gerangschikt20als2011e20met2063120miljard20aan20bezittingen603490"><a name="BlackRock’s overname: nu gerangschikt als 11e met $6,31 miljard aan bezittingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlackRock’s overname: nu gerangschikt als 11e met $6,31 miljard aan bezittingen</h2><p>BlackRock, ‘s werelds nummer één vermogensbeheerder, heeft enkele weken geleden het record voor bitcoinacquisities verbroken <a href="https://www.gate.io/learn/articles/before-the-bitcoin-spot-etf-is-launched/1524" target="_blank">na de lancering van zijn BTC ETFs</a>. Het bedrijf bezit nu 6% van de circulerende voorraad van bitcoin. Bovendien heeft BlackRock’s aankoop van bitcoin het tot de op elf na grootste BTC-bezitter gemaakt.</p>
<p>In feite, <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf-and-why-does-everyone-from-blackrock-to-grayscale-want-one/1702" target="_blank">BlackRock is erin geslaagd om binnen zes weken 122.600 bitcoin te kopen</a>. Het bedrijf begon de reis om een van de grootste bitcoinbezitters ter wereld te worden toen het 228 BTC kocht als een zaad voor zijn bitcoin ETF.</p>
<p>De tweede aankoop van 2.621 BTC, ter waarde van ongeveer $110,91 miljoen in de eerste week na de goedkeuring van het BlackRock Bitcoin ETF, was een indicatie van zijn investeringsappetijt in gedecentraliseerde digitale activa. Nu verwacht de crypto-markt dat het … <a href="https://www.gate.io/blog_detail/3803/-sec-discusses-eth-etf-approval" target="_blank">zal ook investeren in Ethereum ETF’s</a> en vervolgens ETH zelf.</p>
<p>Interessant genoeg had het vermogensbeheerbedrijf tegen het einde van de tweede week na de lancering van de BlackRock Bitcoin ETF in totaal 26.002 BTC verworven, met een marktwaarde van meer dan $1 miljard op dat moment.</p>
<p>Het was duidelijk op dat moment dat BlackRock van plan was om bitcoin een belangrijk onderdeel te maken van zijn investeringsportefeuille. De agressieve verwerving van BTC duidt op de brede acceptatie van het digitale actief als een waardevol beleggingsinstrument. Dit zou andere bitcoinbeleggers moeten verleiden om de hoeveelheid munten die ze bezitten te verhogen.</p>
<h2 id="h2-BlackRocks20Strategische20Investering20in20de20Zesde20Week20en20de20Marktopleving20van20Bitcoin36308"><a name="BlackRock’s Strategische Investering in de Zesde Week en de Marktopleving van Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlackRock’s Strategische Investering in de Zesde Week en de Marktopleving van Bitcoin</h2><p>BlackRock zette zijn bitcoin-aankoopreeks voort in de derde week en voegde meer dan 41.000 BTC toe aan zijn bezittingen, waardoor de totale waarde op $1,7 miljard kwam. Hoewel bitcoin zich terugtrok in de vijfde week, verwierf BlackRock nog eens 12.510 BTC-munten.</p>
<p>Gedurende de zesde week steeg de bitcoinprijs naar $50.000, wat BlackRock ertoe aanzette om nog eens 33.474 BTC te kopen, ter waarde van ongeveer $692 miljoen. Als we kijken naar hoe de zaken zich binnen 6 weken hebben ontwikkeld, zal het bedrijf waarschijnlijk zijn belang in de cryptomarkt blijven vergroten.</p>
<h2 id="h2-Bitcoin20vergelijkbaar20met20goud20dient20als20een20beschermend20bezit20vooral20tijdens20perioden20van20geopolitieke20onzekerheden171337"><a name="Bitcoin vergelijkbaar met goud, dient als een beschermend bezit, vooral tijdens perioden van geopolitieke onzekerheden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin vergelijkbaar met goud, dient als een beschermend bezit, vooral tijdens perioden van geopolitieke onzekerheden</h2><p>De intrede van BlackRock in de cryptosector via bitcoininvesteringen heeft vertrouwen gecreëerd, wat waarschijnlijk zal leiden tot een grotere adoptie van crypto-activa. En dat zou een goede lokvogel moeten zijn voor andere grote financiële instellingen om te investeren in bitcoin en andere digitale activa.</p>
<p>Larry Fin, de CEO van BlackRock, heeft bitcoin vergeleken met goud en gelooft dat het een toonaangevend waardebeschermend bezit is, vooral in tijden van geopolitieke onrust. Aangezien de voorraad bitcoin beperkt is, heeft het potentieel om meer rendement op investeringen te genereren dan goud.</p>
<p>Fin vertelde BeInCrypto dat bitcoin een waardevol bezit is voor het opslaan van waarde. Hij zei <a href="https://beincrypto.com/blackrock-larry-fink-bitcoin-ethereum-tokenization/" rel="nofollow noopener noreferrer" target="_blank">naar BeinCrypto</a> Ik ben een gelovige omdat ik denk dat het een alternatieve bron is voor het vasthouden van rijkdom. Ik geloof niet dat [Bitcoin] ooit een valuta zal zijn. Ik denk dat het een vermogensklasse is. Maar we zullen digitale valuta’s maken en we zullen blockchain gebruiken.”</p>
<p>Een andere X-gebruiker en crypto-enthousiasteling, Island Destination, gelooft dat het nu onmogelijk is voor de waarde van bitcoin om naar nul te dalen zoals sommige crypto-pessimisten hadden verwacht. Hij/zij <a href="https://twitter.com/idestin/status/1755965746386002086" rel="nofollow noopener noreferrer" target="_blank">zei op X</a>“Het scenario van Bitcoin dat naar nul gaat bestaat niet meer. BTC speelt nu min of meer dezelfde rol als goud deed in de vroege dagen van het bankwezen.”</p>
<p>Bovendien gelooft Andrew Lokenauth, een crypto commentator, dat veel institutionele beleggers waarschijnlijk zullen investeren in bitcoin, in navolging van BlackRock. Hij <a href="https://twitter.com/FluentInFinance/status/1672236975233826817" rel="nofollow noopener noreferrer" target="_blank">zei op X</a>“De Bitcoin ETF van BlackRock is een grote deal voor Crypto, het zou de $BTC-markt openstellen voor een bredere groep investeerders en zou kunnen leiden tot verhoogde liquiditeit en prijsstabiliteit.”</p>
<p>Evenzo bevestigde BlackRock in zijn recente blogpost het vertrouwen dat het heeft in bitcoin. Het plaatste <a href="https://twitter.com/BlackRock/status/1755964925598486748" rel="nofollow noopener noreferrer" target="_blank">op X.com</a> De lancering van spot bitcoin exchange-traded funds in de VS vertegenwoordigt een schaalbare brug van traditionele financiën naar bitcoin, waardoor mainstream toegang tot bitcoin mogelijk wordt.</p>
<h2 id="h2-BlackRock20Tops20Multifactor20Investor20Model14925"><a name="BlackRock Tops Multifactor Investor Model" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlackRock Tops Multifactor Investor Model</h2><p>BlackRock’s reeks aan investeringen heeft het in staat gesteld om de eerste plek te verdienen onder de top 22 guru strategieën na een score van 87% te behalen op basis van het Multi-Factor Investor model, een geesteskind van Pim van Vliet. Die erkenning geeft aan dat BlackRock sterke fundamentele en waarderingsaspecten heeft, voortkomend uit zijn conservatieve factor investeringen.</p>
<p>Dit geeft ook aan dat het vermogensbeheerbedrijf op zoek is naar beleggingshavens met een hoog netto uitbetalingsrendement, lage volatiliteit en sterke vraag. Het is vermeldenswaard dat BlackRock een trackrecord heeft van het vermijden van producten met hoge volatiliteit die gewone mensen ontmoedigen om erin te investeren.</p>
<p>Het feit dat BlackRock de eerste plaats heeft verdiend op basis van het Multi-Factor Investor model bevestigt dat het ‘s werelds marktleider is, het is dan ook niet verwonderlijk dat bitcoin-investeerders geïnteresseerd zijn in zijn positie. <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf-and-why-does-everyone-from-blackrock-to-grayscale-want-one/1702" target="_blank">bitcoin ETFs</a>. Veel individuen en institutionele beleggers staan klaar om bitcoin op een grotere schaal te kopen dan voorheen.</p>
<h2 id="h2-Conclusie749209"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>BlackRock is na het kopen van meer dan 122.600 bitcoin in zes weken een van de belangrijkste bitcoin-houders geworden. Hierdoor heeft het bitcoin-bezit een waarde van bijna $2 miljard. Ondertussen heeft BlackRock onlangs de hoogste rang behaald onder de 22 guru-strategieën.</p>
<h2 id="h2-Veelgestelde20vragen20over20BlackRock20Bitcoin20ETFs430936"><a name="Veelgestelde vragen over BlackRock Bitcoin ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over BlackRock Bitcoin ETF’s</h2><h3 id="h3-Wat20is20BlackRock432663"><a name="Wat is BlackRock?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is BlackRock?</h3><p>BlackRock is ‘s werelds toonaangevende vermogensbeheermaatschappij. Het beheert investeringen en fondsen voor verschillende instellingen. Ook biedt het verschillende beleggingsactiva aan, waaronder spot bitcoin ETF’s. <a href="https://www.gate.io/blog_detail/2154/cryptocurrency-futures-work-exchanges" target="_blank">en crypto-futures</a>.</p>
<h3 id="h3-Wat20is20de20vraag20en20aanbod20van20Bitcoin676356"><a name="Wat is de vraag en aanbod van Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de vraag en aanbod van Bitcoin?</h3><p>De voorraad bitcoin is de hoeveelheid BTC die op elk moment in omloop is. Het verwijst ook naar bitcoin die verkopers bereid zijn te verkopen. De totale voorraad bitcoin is echter beperkt tot 21 miljoen. Aan de andere kant is de vraag naar bitcoin de hoeveelheid munten die kopers bereid zijn te kopen binnen een bepaalde periode.</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 mening van de onderzoeker en vormt geen beleggingsvoorstellen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>