QmVsYW5ncmlqa2UgcmVkZW5lbiBhY2h0ZXIgZGUgb25kZXJwcmVzdGF0aWUgdmFuIEV0aGVyIEVURidzIGluIHZlcmdlbGlqa2luZyBtZXQgQml0Y29pbiBFVEYncw==

2024-10-23, 02:26

<p><img src="https://gimg2.gateimg.com/image/article/17296501161692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR962522"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> heeft het eerste mover-voordeel ten opzichte van ETH sinds het in 2009 werd gelanceerd, zes jaar eerder dan <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>Veel particuliere en institutionele beleggers investeren in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">bitcoin</a> aangezien het een waardeopslag is die zich indekt tegen inflatie.</p>
<p>Sinds de lancering van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ETF’s is de waarde van BTC met ongeveer 20% gestegen.</p>
<p>Na de lancering van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Bij ETF’s daalde de waarde van ETH met ongeveer 30%.</p>
<h2 id="h2-Introductie590108"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Naarmate cryptocurrencies meer legitimiteit krijgen dan voorheen, zoeken veel investeerders naar mogelijkheden om in hen te investeren. Een manier waarop investeerders blootstelling aan cryptocurrencies kunnen krijgen, is via Exchange Traded Funds (ETF’s). Dergelijke beleggingsinstrumenten stellen individuen en instellingen in staat om te… <a href="https://www.gate.io/how-to-buy/bitcoin-btc" target="_blank">investeren in bitcoin</a> en ETH via hun derivaten. Spot bitcoin ETF’s en ETH ETF’s zijn de twee toonaangevende crypto exchange traded funds. Vandaag zullen we een vergelijking maken tussen de prestaties van bitcoin ETF’s en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s.</p>
<h2 id="h2-Prestaties20van20Crypto20ETFs20Vergelijking20van20instroom20tussen20Bitcoin20en20Ether20ETFs393956"><a name="Prestaties van Crypto ETF’s: Vergelijking van instroom tussen Bitcoin en Ether ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prestaties van Crypto ETF’s: Vergelijking van instroom tussen Bitcoin en Ether ETF’s</h2><p>Terwijl bitcoin ETF’s waren <a href="https://www.gate.io/blog_detail/380/the-first-ever-bitcoin-etfs-is-here" target="_blank">gelanceerd in januari 2024</a> Ethereum ETF’s werden in juli geïntroduceerd nadat de Amerikaanse SEC ze in mei had goedgekeurd. Tot nu toe hebben ETH ETF’s en Bitcoin ETF’s zich verschillend gedragen. Bij hun <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf/3693" target="_blank">lanceren van bitcoin ETFs</a> hebben veel instroom aangetrokken. Daarentegen hebben ETH ETF’s veel uitstroom gezien. Sommige analisten schrijven de slechte prestaties van ETH echter toe aan het tijdstip van hun lancering. Ze werden allemaal gelanceerd tijdens kwartaal 3 (Q3), een periode waarin cryptovaluta onder de verwachting presteren.</p>
<p>Zonder twijfel is de prestatie van ETH ETF’s teleurstellend geweest. Bitcoin heeft bijvoorbeeld ongeveer $19 miljard aan kapitaalinstroom geregistreerd gedurende de eerste 10 maanden na hun oprichting. Momenteel hebben BTC ETF’s meer dan $61 miljard aan kapitaalinstroom gegenereerd. BlackRock, Fidelity en ARK Bitcoin ETF’s hebben de leiding genomen wat betreft kapitaalinstroom. De prestatie van Bitcoin ETF’s verschilt enigszins van die van ETH ETF’s, die gezamenlijk slechts $7 miljard hebben opgebracht. Zelfs de toonaangevende ETH ETF’s zoals BlackRock’s ETHA hebben onder de verwachtingen gepresteerd, aangezien ze voor het grootste deel van de tijd uitstroom hebben geregistreerd.</p>
<h2 id="h2-Het20plaatsen20van20de20Crypto20ETFs20in20context235434"><a name="Het plaatsen van de Crypto ETF’s in context" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het plaatsen van de Crypto ETF’s in context</h2><p>Het is essentieel om te beseffen dat ETH ETF’s ondermaats presteren terwijl bitcoin ETF’s floreren. De Bitcoin ETF’s hebben al veel records gebroken, een reden <a href="https://www.gate.io/learn/articles/pros-and-cons-of-investing-in-bitcoin-etfs/2541" target="_blank">waarom veel investeerders erin geïnteresseerd zijn</a>. Als voorbeeld verzamelden de Bitcoin ETF’s van BlackRock en Fidelity elk meer dan $4,2 miljard en $3,5 miljard binnen 30 dagen na hun lancering. Ze hebben zelfs de prestaties van het Climate Conscious fonds van BlackRock overtroffen, dat $2,2 miljard heeft gegenereerd in zijn eerste maand, augustus 2023. Ondanks dat de ETH ETF’s er niet in slaagden deze records te overtreffen, behoren er drie van hen tot de top 25 best presterende ETF’s voor 2024. In het bijzonder hadden BlackRock’s ETHE, Fidelity’s FBTC en Bitwise’s ETHW respectievelijk $1 miljard, $367 miljoen en $239 miljoen aan activa binnen hun eerste drie maanden.</p>
<p>Wat de situatie zo somber heeft gemaakt, is de rampzalige prestaties van Grayscale ETHE. Sinds de oprichting heeft het hoge uitstroom geregistreerd, wat een zeer negatief beeld heeft gecreëerd van de ETH ETF-sector. ETHE, oorspronkelijk gelanceerd als een Trust in 2017, stond de investeerders niet toe om hun aandelen in te wisselen. Daarom zat het geld vast in de aandelen. Als gevolg daarvan heeft Grayscale het op 23 juli omgezet in een ETH ETF, wat een kans bood voor de investeerders om hun aandelen in te wisselen. Dat is de belangrijkste reden waarom het sinds de lancering veel uitstroom heeft geregistreerd. Ten tijde van de lancering van de Ethereum ETF’s had Grayscale ongeveer $10 miljard aan Ether. Hoewel het een deel van het kapitaal heeft verplaatst naar zijn andere fonds - ether mini ETF - heeft de ETHE-waardering ongeveer $3 miljard aan uitstroom geregistreerd. Over het algemeen is er sinds hun oprichting geen verbetering geweest in de instroom van Ethereum ETF’s.</p>
<p>Hetzelfde scenario ontvouwde zich met de bitcoin ETF van Grayscale, GBTC. Dit beleggingsinstrument heeft sinds de omzetting in januari een uitstroom van ongeveer $20 miljard gehad. Interessant genoeg heeft de bovengemiddelde prestatie van de spot Bitcoin ETF’s van BlackRock en Fidelity geholpen om stabiliteit binnen de sector te verbeteren.</p>
<h2 id="h2-Ethereum20Vs20Bitcoin20ETFs20Prestaties315768"><a name="Ethereum Vs. Bitcoin ETF’s Prestaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum Vs. Bitcoin ETF’s Prestaties</h2><p>Gezien de bovenstaande discussie willen veel mensen weten waarom de bitcoin ETF’s tot nu toe beter hebben gepresteerd dan de Ethereum ETF’s. En inderdaad, er zijn verschillende redenen voor hun verschillende fortuinen op de markt. Zo hebben bitcoin ETF’s bijvoorbeeld een eerste-mover-voordeel en heeft bitcoin zelf een hogere waardering en een betere reputatie dan Ether (ETH). Laten we kort kijken naar de redenen waarom de meeste beleggers de voorkeur geven aan Bitcoin ETF’s boven Ethereum ETF’s.</p>
<p>Staking Opbrengsten - De Gemiste Kans in Ether ETF’s: Wat betreft de onderliggende activa is er een aanzienlijk verschil tussen ETH en bitcoin dat bijdraagt aan hun aantrekkelijkheid op de markt. Primair heeft Ethereum een staking functie die bitcoin niet heeft. Dienovereenkomstig heeft het staken van ETH een hogere beloning dan het aanhouden ervan in andere vormen, zoals derivaten. Momenteel lijken ETH-investeerders de Ethereum staking opbrengst meer te waarderen dan rendementen uit ETH-derivaten zoals ETF’s. De ETH staking beloningen zijn ongeveer 3,5%. In tegenstelling tot staking hebben ETH ETF’s een lager rendement en wordt het negatieve effect versterkt door de beheerskosten die variëren tussen 0,15% en 2,5%. Met ETF’s is er geen ruimte voor de <a href="https://www.gate.io/learn/articles/how-to-stake-eth/209" target="_blank">investeerders om de ETH te staken</a> Dit komt doordat de Amerikaanse SEC niet heeft toegestaan ​​dat de ETH in bewaring wordt gesteld om gestaked te worden. Daarom heeft de weigering van de SEC om beleggers toe te staan ​​hun ETH te staken geleid tot een lage vraag naar de ETF’s.</p>
<p>Marketinguitdagingen voor Ethereum: De andere reden waarom veel investeerders de voorkeur geven aan BTC ETF’s boven ETH ETF’s is dat het gemakkelijker is om bitcoin te vermarkten dan ETH. Allereerst is een van de belangrijkste voordelen dat bitcoin een beperkte voorraad van $21 miljoen heeft, waardoor het een ‘digitaal goud’ is. Het is ook de nummer één cryptocurrency qua marktkapitalisatie. Ten slotte is het een goede hedge tegen inflatie. Als gevolg hiervan verwerven en houden mensen in landen met hoge inflatie het in grote hoeveelheden in bezit.</p>
<p>Aan de andere kant heeft ETH geen vastgestelde praktische toepassing in de echte wereld. Daarom is het moeilijk om veel mensen de essentie van een gedecentraliseerd, open-source smart contract platform te laten begrijpen. Bovendien zijn er geen overtuigende redenen waarom ETH waarde krijgt. Daarom wordt Ethereum marketing geconfronteerd met uitdagingen. Het is bijvoorbeeld erg moeilijk om de waardepropositie over te brengen om nieuwe investeerders aan te trekken. Er zijn immers veel andere cryptocurrencies die dezelfde rol als ETH vervullen. De populaire Ethereum-killers zijn <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a>, <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a>, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a> en <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> keten.</p>
<h2 id="h2-Ethereum20vs20Bitcoin20Bitcoin20presteert20beter20dan20Ether443076"><a name="Ethereum vs. Bitcoin: Bitcoin presteert beter dan Ether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum vs. Bitcoin: Bitcoin presteert beter dan Ether</h2><p>Een andere reden waarom beleggers de voorkeur geven aan Bitcoin ETF’s boven ETH ETF’s is dat bitcoin beter presteert dan ETH tijdens het huidige jaar. Bijvoorbeeld, de Ether waardering is slechts met 1% gestegen sinds januari. Echter, de waarde van bitcoin is tijdens dezelfde periode met meer dan 42% gestegen. Het is vermeldenswaardig dat de bitcoin waardering met ongeveer 20% is gestegen sinds de lancering van zijn ETF’s. Op het moment van schrijven zweeft de prijs van bitcoin dicht bij zijn all-time high van $73.737, bereikt in maart. Dus, met een huidige prijs van $67.865 is de waarde ervan 8% lager dan zijn ATH.</p>
<p>Daarentegen wordt ETH dat wordt verhandeld op $2,637 ongeveer 46% lager dan zijn all-time high van $4,878. Deze prestatieverschillen hebben BTC ETF’s gepositioneerd als betere beleggingsactiva dan ETH ETF’s. Vanwege de hoge prestaties van bitcoin storten veel investeerders hun geld in de derivaten uit angst om iets te missen (FOMO). Aan de andere kant hebben de 30% prijsdaling van ETH sinds de lancering van de ETF’s investeerders afgeschrikt om te investeren in zijn derivaten.</p>
<p>Onaantrekkelijke Ether Waardering: Momenteel is de waardering van Ether niet aantrekkelijk voor veel investeerders. Sterker nog, veel traditionele investeerders vinden de <a href="https://www.gate.io/learn/articles/the-impact-of-the-ethereum-etf-etf-an-analysis/3473" target="_blank">waardering van ETH zeer aantrekkelijk</a>. Ten eerste heeft ETH een marktkapitalisatie van ongeveer $290 miljard, wat hoger is dan die van de meeste banken. Ten tweede vertellen de investeerders niet waarom de waardering van Ether zo hoog is. Als gevolg hiervan zouden veel investeerders investeren in ETH als de waardering aanzienlijk daalt om overeen te komen met de bijdrage ervan in de gedecentraliseerde sector.</p>
<p>Het eerste bewegingsvoordeel van Bitcoin: Een van de dingen die bitcoin ETF’s zo populair hebben gemaakt, is het eerste bewegingsvoordeel. Afgezien van het feit dat bitcoin het toonaangevende activum is in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a>, het was de eerste digitale valuta die op de markt kwam, aangezien het in 2009 werd gelanceerd. Als een van de baanbrekende cryptocurrency-activa geven veel beleggers er de voorkeur aan om er geld in te steken. Daarentegen werd Ether ongeveer zes jaar later gelanceerd in 2015. Aangezien de oudere generatie crypto-investeerders voor het eerst kennismaakte met bitcoin, blijven ze eraan vasthouden als de nummer één digitale activa. Ook het feit dat de waarde van bitcoin, die in 2010 minder dan 1 cent waard was, 14 jaar later boven de $60.000 geprijsd staat, maakt het een van de meest gewilde crypto-investeringsactiva aller tijden.</p>
<h2 id="h2-Conclusie947753"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Het is niet verrassend dat bitcoin ETF’s beter presteren dan Ethereum ETF’s. Ten eerste heeft bitcoin het voordeel van de eerste mover ten opzichte van ETH. Ten tweede is de waarde van bitcoin met meer dan 20% gestegen sinds de lancering van zijn ETF’s. Aan de andere kant, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">ETH prijs</a> is sinds de introductie van zijn ETF’s in juli met ongeveer 30% gedaald. Bovendien is het gemakkelijker om bitcoin te vermarkten als een opslag van waarde en een hedge tegen inflatie dan ETH, dat alleen bekend staat als een utility token voor het Ethereum-netwerk.</p>
<h2 id="h2-Veelgestelde20vragen20over20de20prestaties20van20ETH20ETFs410290"><a name="Veelgestelde vragen over de prestaties van ETH ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over de prestaties van ETH ETF’s</h2><h3 id="h3-Waarom20presteren20ETH20ETFs20slechter20in20vergelijking20met20Bitcoin20ETFs123376"><a name="Waarom presteren ETH ETF’s slechter in vergelijking met Bitcoin ETF’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom presteren ETH ETF’s slechter in vergelijking met Bitcoin ETF’s?</h3><p>Bitcoin heeft het voordeel van de eerste mover, omdat het eerder werd gelanceerd dan ETH ETF’s. Op de spotmarkt presteert Bitcoin beter dan Ether, wat invloed heeft op de prijzen van hun respectievelijke ETF’s.</p>
<h3 id="h3-Hoe20hebben20de20producten20van20Grayscale20de20perceptie20van20ETH20ETFs20benvloed659727"><a name="Hoe hebben de producten van Grayscale de perceptie van ETH ETF’s beïnvloed?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe hebben de producten van Grayscale de perceptie van ETH ETF’s beïnvloed?</h3><p>Sinds hun lancering hebben de Grayscale-producten voor het grootste deel van de tijd uitstroom geregistreerd. Deze ontwikkeling resulteerde in negatieve netto ETH ETF-uitstroom, wat resulteerde in een pessimistisch sentiment ten opzichte van de beleggingsproducten.</p>
<h3 id="h3-Waarom20bieden20ETH20ETFs20geen20staking20beloningen20aan144684"><a name="Waarom bieden ETH ETF’s geen staking beloningen aan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom bieden ETH ETF’s geen staking beloningen aan?</h3><p>De Amerikaanse SEC heeft de aanvraag van de ETH-uitgevers afgewezen om het stakingelement op de ETF’s op te nemen. Helaas heeft het ontbreken van stakingbeloningen bijgedragen aan de lage vraag naar de Ethereum ETF’s.</p>
<h3 id="h3-Wat20maakt20het20vermarkten20van20Ethereum20uitdagender20dan20bitcoin409346"><a name="Wat maakt het vermarkten van Ethereum uitdagender dan bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat maakt het vermarkten van Ethereum uitdagender dan bitcoin?</h3><p>Bitcoin wordt zeer gewaardeerd als een opslag van waarde en een hedge tegen inflatie. Ether heeft echter geen goed gevestigd gebruik behalve dat het een gedecentraliseerd, open-source smart contract platform ondersteunt waar ontwikkelaars hun smart contracts kunnen opzetten.</p>
<h3 id="h3-Kan20de20onderprestatie20van20Ether20ETFs20in20de20toekomst20veranderen443386"><a name="Kan de onderprestatie van Ether ETF’s in de toekomst veranderen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan de onderprestatie van Ether ETF’s in de toekomst veranderen?</h3><p>Het is waarschijnlijk dat de onderprestatie van Ether ETF’s in de toekomst kan veranderen als er een toename is in de vraag naar Ethereum-producten en -diensten. Als de waarde van ETH in de toekomst stijgt, zullen veel beleggers mogelijk hun geld in Ether ETF’s steken.</p>
<div class="blog-details-info"><br><div>Auteur: Mashell C., Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling. Alle beleggingen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<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 zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>