RGUgd2VyZWxkd2lqZGUgbWFya3QgaGVlZnQgMjAgYWN0aWV2ZSBCaXRjb2luIEVURidzIHZlcnphbWVsZCwgbWV0IGVlbiBnZXphbWVubGlqa2Ugd2FhcmRlIHZhbiAkNCwxNiBtaWxqYXJkLg==

2023-11-22, 03:25

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""><br>De derivatenmarkt heeft 20 actieve plekken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> beursgenoteerde fondsen (ETF’s).</p>
<p>Canada heeft 7 spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ETF’s ter waarde van $2.003 miljoen.</p>
<p>De Verenigde Staten ueert momenteel verschillende aanvragen voor spot bitcoin ETFs.</p>
<p>Trefwoorden: spot bitcoin exchange traded fund, BTC ETF’s, bitcoin ETF, bitcoin ETF goedkeuring, SEC vs. spot bitcoin ETF, crypto ETF</p>
<h2 id="h2-Kennismaking120020"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>De crypto sector ondergaat verschillende veranderingen, waaronder de introductie van crypto exchange traded funds (ETF’s). <a href="https://www.gate.io/blog_detail/207/why-do-people-choose-crypto-etfs-what-are-the-advantages-and-disadvantages" target="_blank">Crypto ETFs</a> spelen een belangrijke rol in de sector van digitale activabeleggingen omdat ze helpen om de vraag naar de onderliggende activa te vergroten.</p>
<p>Hoewel de wereld <a href="https://www.gate.io/blog_detail/3427/daily-news-bitcoin-spot-etfs-may-be-approved-in-january-next-year-india-is-in-a-leading-position-in-crypto-cyber-ape-and-rose-will-unlock-large-amounts-this-week" target="_blank">heeft 20 actieve spot bitcoin ETF’s meer zijn waarschijnlijk binnenkort op de markt te komen</a>, vooral in de Verenigde Staten</p>
<p>Dit artikel bespreekt de 20 actieve spot bitcoin ETF’s en hun impact op de cryptocurrency sector. We zullen ook de obstakels beoordelen waar de Verenigde Staten mee te maken hebben op hun weg naar goedkeuring van bitcoin ETF’s.</p>
<h2 id="h2-De20wereld20heeft202020actieve20spot20Bitcoin20ETFs217835"><a name="De wereld heeft 20 actieve spot Bitcoin ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De wereld heeft 20 actieve spot Bitcoin ETF’s</h2><p>Op dit moment zijn er wereldwijd in totaal 20 actieve Bitcoin Exchange Traded Funds (ETF’s) met een totale waarde van $4,16 miljard. Helaas heeft de Verenigde Staten dit niet. <a href="https://www.gate.io/fr/blog_detail/3076/can-spot-bitcoin-etfs-become-market-catalysts-if-approved" target="_blank">Op dit moment geen BTC ETF beschikbaar</a>, ondanks dat er meer dan 10 aanvragen zijn.</p>
<p>Opmerkelijk genoeg zijn de 20 actieve BTC ETF’s alleen verspreid over 8 landen, waaronder<br><strong>Canada, Duitsland, Liechtenstein, Guernsey, Brazilië, Australië, Jersey en de Kaaimaneilanden</strong>. Daarom zal de Verenigde Staten, indien zij één of meer spot bitcoin ETF’s goedkeuren, het 9e land worden dat dit doet.</p>
<h2 id="h2-Historische20ontwikkeling20van20Spot20Bitcoin20ETFs20op20het20wereldtoneel551405"><a name="Historische ontwikkeling van Spot Bitcoin ETF’s op het wereldtoneel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Historische ontwikkeling van Spot Bitcoin ETF’s op het wereldtoneel</h2><p>De fysieke Bitcoin van ETC Group van Duitsland, geïntroduceerd op de markt in juni 2020, was het eerste spot bitcoin ETF. De volgende spot bitcoin exchange traded funds waren 3iQ The Bitcoin Fund en VanEck Bitcoin ETN, gelanceerd in kwartaal 4 van hetzelfde jaar.</p>
<p>Zoals je kunt zien, zijn er in 2020 in totaal 3 BTC ETF’s gelanceerd. Overigens werden deze spot BTC ETF’s geïntroduceerd tijdens de vroege stadia van een grote Bull Run in de cryptomarkt. Opmerkelijk genoeg werd 2021 een belangrijk jaar voor crypto ETF’s, omdat er in die periode 14 van hen werden gelanceerd.</p>
<p>Bijvoorbeeld, Purpose Bitcoin ETF, CI Galaxy Bitcoin ETF (BTCX) in Canada, en CoinShares Physical Bitcoin (BITC) werden gelanceerd in het eerste kwartaal van 2021. Aan de andere kant werd in het tweede kwartaal van 2022 slechts één spot BTC ETF, Global X 21Shares Bitcoin ETF (EBTC), gelanceerd, geïncorporeerd in Australië.</p>
<p>Eindelijk werden er in 2023 2 BTC ETF’s geïntroduceerd, de Jacobi FT Wilshire Bitcoin ETF (BCOIN) en Valour Bitcoin Carbon Neutral (1VBT). In de volgende tabel worden meer details gegeven van de bestaande spot crypto ETF’s.<br><img src="https://gimg2.gateimg.com/image/article/17006232991.png" alt=""><br>20 Actieve Spot Bitcoin ETF’s - CoinGecko</p>
<p>Zoals hierboven aangegeven, zijn de 20 actieve bitcoin ETF’s verdeeld over 8 landen, vermeld in de volgende tabel.<br><img src="https://gimg2.gateimg.com/image/article/17006233142.png" alt=""><br>Verdeling van Spot Bitcoin ETF’s onder 8 landen - CoinGecko</p>
<p>Zoals u in de tabel opmerkt, is Canada het land met het hoogste aantal spot BTC ETF’s. Sterker nog, het heeft 7 van dergelijke spot bitcoin exchange traded funds, met een totale investering van $2 miljard. Hiermee vertegenwoordigt de waarde van de spot BTC ETF’s van Canada 48,2% van de totale markt.</p>
<p>Jersey heeft met 4 ETF’s het op één na hoogste aantal BTC ETF’s ter waarde van $748 miljoen. Op de volgende plaats staat de in Duitsland gevestigde ETC Group Physical Bitcoin (BTCE), gelanceerd in 2020 en gewaardeerd op $803. De resterende spot crypto ETF’s hebben relatief kleinere waarden variërend van $5 miljoen tot $296 miljoen elk.</p>
<h2 id="h2-De20Verenigde20Staten20wacht20op20goedkeuring20van20Bitcoin20ETF484952"><a name="De Verenigde Staten wacht op goedkeuring van Bitcoin ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Verenigde Staten wacht op goedkeuring van Bitcoin ETF</h2><p>Met landen als Canada, Duitsland, Australië en Brazilië die ten minste één plek bitcoin ETF hebben, vraagt de markt zich af waarom de Verenigde Staten geen enkele plek bitcoin exchange traded fund hebben. Op dit moment ueert de Securities and Exchange Commission echter ten minste 10 aanvragen voor spot bitcoin ETFs.</p>
<p><a href="https://www.gate.io/blog_detail/3434/bitcoin-etf-approval-potential-catalyst-for-historic-crypto-bull-run" target="_blank">Als de SEC goedkeuring verleent voor een bitcoin ETF</a> hun mondiale waarde kan aanzienlijk toenemen en andere landen beïnvloeden om hetzelfde te doen. Het is belangrijk op te merken dat de Verenigde Staten een voorzichtige aanpak hanteren voordat crypto-ETF’s worden geïntroduceerd.</p>
<p>Het geschil tussen de SEC en spot bitcoin draait om de kwestie van transparantie en verantwoording op de markt. Specifiek wil de SEC ervoor zorgen dat er geen mogelijkheid tot marktmanipulatie is voordat ze instemmen met het goedkeuren van crypto-ETF’s. Momenteel is de SEC al in gesprek met diverse vermogensbeheerbedrijven zoals BlackRock.</p>
<p>Desalniettemin is er een grote kans dat de SEC de spot BTC ETFS zal goedkeuren. <a href="https://twitter.com/Grayscale/status/1684681713962921986" rel="nofollow noopener noreferrer" target="_blank">Grayscale zegt</a>,<br><strong>“De SEC moet spot bitcoin ETF’s goedkeuren om in de VS te verhandelen. Bovendien toont hun eerdere goedkeuring van bitcoin futures ETF’s aan dat ze al in staat zijn om dit te doen.”</strong></p>
<h2 id="h2-Bitcoin20ETFgoedkeuring20Katalysator20voor20de20grootste20cryptobullrun518128"><a name="Bitcoin ETF-goedkeuring: Katalysator voor de grootste crypto-bullrun" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin ETF-goedkeuring: Katalysator voor de grootste crypto-bullrun</h2><p>De goedkeuring van de bitcoin ETF in de Verenigde Staten zal waarschijnlijk de prijs van BTC omhoog stuwen, wat kan leiden tot een stierenmarkt. We zullen de <a href="https://www.gate.io/blog_detail/3424/how-the-highly-anticipated-spot-bitcoin-etf-impacts-the-market" target="_blank">mogelijke impact van de goedkeuring van spot bitcoin op de BTC-prijs</a> aan de hand van het voorbeeld van goud.</p>
<p>In maart 2003 werd ‘s werelds eerste Gold ETF gelanceerd in Sydney, Australië. Ook keurde de SEC in oktober 2004 StreetTracks Gold Trust (GLD) goed. Dat resulteerde in een voortdurende stijging van de goudprijs.</p>
<p>De situatie veranderde echter vanaf november 2004 toen de Amerikaanse Gold ETF werd genoteerd aan de New York Stock Exchange (NYSE). De prijs van goud daalde met 9% tijdens de marktconsolidatieperiode. De waarde steeg echter aanzienlijk in de loop der jaren.</p>
<p>Volgens DGF resulteerde de introductie van goud-ETF’s in een marktbull-run die 10 jaar duurde. Daarom heeft DGF geconcludeerd dat de lancering van spot bitcoin-ETF’s in de Verenigde Staten waarschijnlijk een vergelijkbaar effect zal hebben. Met name de goedkeuring van goud-ETF’s stelde particulieren en zakelijke investeerders in staat om te investeren in goud zonder het vast te houden.</p>
<p>Dus, na de <a href="https://www.gate.io/blog_detail/3415" target="_blank">goedkeuring van bitcoin ETF’s in de Verenigde Staten</a> de markt zal waarschijnlijk een consolidatieperiode ondergaan om meer kapitaal op te nemen. Dit zal resulteren in een daling van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a>. Echter, op de lange termijn zullen er meer investeerders de markt betreden en veel kapitaal injecteren, wat de prijs zal doen stijgen en leiden tot een mogelijke Bull Run. Aangezien de prijs van bitcoin gecorreleerd is met die van de meeste altcoins, zal dat resulteren in een crypto bull markt.</p>
<h2 id="h2-Conclusie454610"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Er zijn nu 20 actieve bitcoin ETF’s op de markt wereldwijd. Canada, Duitsland, Liechtenstein, Guernsey, Brazilië, Australië, Jersey en de Kaaimaneilanden zijn de landen die BTC ETF’s hebben. Ondertussen is de Amerikaanse SEC bezig met het ueren van verschillende crypto ETF’s.</p>
<h2 id="h2-Veelgestelde20vragen20over20Bitcoin20ETFs441727"><a name="Veelgestelde vragen over Bitcoin ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Bitcoin ETF’s</h2><h3 id="h3-Wat20is20een20spot20bitcoin20ETF136211"><a name="Wat is een spot bitcoin ETF?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een spot bitcoin ETF?</h3><p>Een spot bitcoin is een beleggingsactivum waarvan de waarde is gebaseerd op de prijs van bitcoin. Dit is een gereguleerd traditioneel beleggingsvoertuig dat wordt verhandeld op effectenbeurzen. Als zodanig wordt het niet verhandeld op cryptocurrency-uitwisselingen.</p>
<h3 id="h3-Welke20ETF20is20het20beste20voor20bitcoin433669"><a name="Welke ETF is het beste voor bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke ETF is het beste voor bitcoin?</h3><p>Een spotbeurs verhandeld fonds (ETF) volgt rechtstreeks de prijs van bitcoin. Het beste spot bitcoin ETF op dit moment is het Purpose Bitcoin ETF (BTCC) dat gewaardeerd wordt op $819,11 miljoen. Andere populaire spot bitcoin ETF’s zijn onder meer ETC Group Physical Bitcoin (BTCE), CI Galaxy Bitcoin ETF (BTCX), CoinShares Physical Bitcoin (BITC), Hashdex Nasdaq Bitcoin ETF (BITH11) en WisdomTree Physical Bitcoin (BTCW).</p>
<h3 id="h3-Is20een20ETF20goed20voor20bitcoin746860"><a name="Is een ETF goed voor bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is een ETF goed voor bitcoin?</h3><p>Spot bitcoin ETF’s zijn goed voor bitcoin omdat ze de vraag naar de munt vergroten. Ze zorgen er ook voor dat er meer financiële instroom in de munt komt, wat waarschijnlijk de prijs ervan zal opdrijven.</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 beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herposten van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden genomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>