QXBlY29pbiAoQVBFKSBkYWFsdCBtZXQgMTAlIG5hIG9udGdyZW5kZWxpbmcgdmFuICQ0MCBtaWxqb2VuIGFhbiB0b2tlbnM=

2023-03-02, 09:59

<p><img src="https://gimg2.gateimg.com/blog/1648604234661497992_Gate.io_%E7%83%AD%E7%82%B9%E8%BF%BD%E8%B8%AA_web_en.jpg" alt=""><br>Bored Ape Yacht Club (BAYC) ontgrendelde op 16 februari 2023 4,3 miljoen Ape-munten.</p>
<p>De recente muntenontgrendeling resulteerde in een prijsdaling van 10% voor ape-munten.</p>
<p>Er zullen op 17 maart 2023 40,6 miljoen ape coins worden ontgrendeld.</p>
<p>De totale voorraad aapmunten is 1 miljard.</p>
<p>Trefwoorden: Ape Coins, aapmunt prijs, <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a>, staking, Yuga Labs, unlock tokens, token unlock, Bored Ape Yacht Club, BAYC, Andreessen Horowitz, Animoca Brands, FTX Ventures</p>
<h2 id="h2-Inleiding385484"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De voorraad van een cryptocurrency is een belangrijke bepalende factor voor de prijs, een reden waarom sommige projecten hun tokens/munten vergrendelen. De meeste projectteams kiezen ervoor om hun cryptocurrencies geleidelijk te ontgrendelen om hun prijsvolatiliteit onder controle te houden. Bored Ape Yacht Club (BAYC) is een van de crypto-projecten die zijn token in februari 2023 heeft ontgrendeld. In dit artikel bespreken we het effect van het ontgrendelen van tokens op de prijs, evenals het identificeren van het ontgrendelingsschema van Ape coin.</p>
<h2 id="h2-Ape20Coin20prijs20zakt20door20ontgrendeling20van20batch20tokens235170"><a name="Ape Coin prijs zakt door ontgrendeling van batch tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ape Coin prijs zakt door ontgrendeling van batch tokens</h2><p>Op 16 februari 2023 <a href="https://www.gate.io/article/23175" target="_blank">Bored Ape Yacht Club</a>(BAYC) ontgrendelde 4,3 miljoen Ape-munten, ongeveer 0,7% van de totale voorraad, wat resulteerde in een daling van 10% in de prijs. Op het moment van ontgrendelen was de totale waarde van de ontgrendelde apecoins $41,7 miljoen.</p>
<p>Als gevolg van het ontgrendelen van de tokens daalde de prijs van $5,70 naar $5,15 op 17 februari, wat een daling van 9,7% in waarde vertegenwoordigt. De munt heeft echter sindsdien waarde gewonnen en wordt verhandeld op $5,54 per 23 februari.<br><img src="https://gimg2.gateimg.com/image/article/16777509311.png" alt=""><br>Prijs van <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> vanaf 23 februari 2023 - CoinMarketCap</p>
<p>Zoals het diagram laat zien, is de prijs van <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> is enorm gestegen vanaf de waarde van $5.15 op 17 februari.</p>
<p><strong>Lees ook: <a href="https://www.gate.io/blog_detail/1054/nfts-stolen-as-bayc-instagram-account-gets-hacked" target="_blank">NFT’s gestolen als BAYC Instagram-account wordt gehackt</a></strong></p>
<p>Volgens <a href="https://www.gate.io/learn/articles/what-is-apecoin/94" target="_blank">naar Apecoin</a> ontgrendelingsschema, het volgende ontgrendelingsevenement zal plaatsvinden op 17 maart 2023, waar 40,6 miljoen apecoins, ongeveer 4% van de totale voorraad, op de markt zullen worden vrijgegeven. Analisten verwachten dan ook dat een dergelijke ontgrendeling van tokens zal leiden tot een grote daling van <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin prijs</a>.<br><img src="https://gimg2.gateimg.com/image/article/16777509762.png" alt=""><br>Token ontgrendelingsschema - Unlocks.app</p>
<p>Zoals u kunt zien op de afbeelding hierboven, zullen er in maart meer dan 40,6 miljoen tokens worden vrijgegeven. Momenteel is slechts 38,3% van de apecoins op de markt. Het andere ontgrendelingsevenement zal het aanbod van <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> zal plaatsvinden in september 2023. Desalniettemin zullen er tot 2026 regelmatig meer apecoins worden ontgrendeld.</p>
<p>Het diagram hieronder toont een samenvatting van tokens die beschikbaar zijn op de markt, evenals de vergrendelde tokens.<br><img src="https://gimg2.gateimg.com/image/article/16777509933.png" alt=""><br>Ontgrendelde en vergrendelde Ape-munttokens - Unlocks.app</p>
<p>Zoals u op het diagram opmerkt, is slechts ongeveer 38% van de <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> zijn op de markt, wat betekent dat 62% nog steeds vergrendeld is.</p>
<h2 id="h2-De20reden20voor20het20ontgrendelen20van20apecoins186426"><a name="De reden voor het ontgrendelen van apecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De reden voor het ontgrendelen van apecoins</h2><p><a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> Het DAO-schatkist ontgrendelde de tokens die waren toegewezen aan de ‘lanceerbijdragers’. Volgens de website zijn de ‘lanceerbijdragers’ de bedrijven en personen die hebben bijgedragen aan de succesvolle lancering en voortzetting van het project.</p>
<p>Hoewel de website en het team de identiteit van de bijdragers niet hebben bekendgemaakt, heeft Delphi Digital, een crypto-onderzoeksfirma, gesuggereerd dat de bijdragers individuen en bedrijven kunnen zijn die Bored Ape Yacht Club ondersteunen, zoals Andreessen Horowitz, Animoca Brands en FTX Ventures. Het is belangrijk op te merken dat <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> DAO beheert <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> terwijl de <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> De stichting is de ‘beheerder’ ervan.</p>
<p>Het effect van het ontgrendelen <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> in de toekomst kan de prijs ervan op dit moment niet worden voorspeld. Dit komt doordat het niet duidelijk is hoe de houders van de tokens, de lancering bijdragers, ze zullen gebruiken. Als ze ze op de markt vrijgeven, zal de prijs waarschijnlijk stijgen.</p>
<p>Er is echter nog een mogelijkheid. Ze kunnen ervoor kiezen om hun tokens vast te houden, aangezien het plan is om te introduceren. <a href="https://www.gate.io/margin/lend/APE?coin=APE" target="_blank">Apecoin staking</a> is in een vergevorderd stadium. Al, de <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> geselecteerde houders <a href="/price/horizen-zen" rel="nofollow noopener noreferrer" target="_blank">Horizen</a> Labs om het stakingplatform te creëren. Daarom kunnen investeerders in de toekomst veel Ape-munten kopen met de bedoeling ze te staken. Dit kan leiden tot een waardestijging.</p>
<h2 id="h2-Wat20is20token20ontgrendelen981211"><a name="Wat is token ontgrendelen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is token ontgrendelen?</h2><p>Token-ontgrendeling is een proces waarbij aan het einde van een verstreken periode een bepaalde hoeveelheid cryptocurrency op de markt wordt vrijgegeven. Meestal resulteert een token-ontgrendeling in een toename van het aanbod van die specifieke token. Let op: het totale aanbod van <a href="/price/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">ApeCoin</a> zijn 1 miljard tokens, waarvan op dit moment slechts ongeveer 318 miljoen op de markt zijn.</p>
<h2 id="h2-hoe20een20aap20te20kopen2020Munt20op20Gateio305503"><a name="hoe een aap te kopen  Munt op Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/how-to-buy/apecoin-ape" rel="nofollow noopener noreferrer" target="_blank">hoe een aap te kopen</a> Munt op Gate.io</h2><p>Het is erg gemakkelijk om <a href="https://www.gate.io/price/apecoin-ape" target="_blank">Koop APE munten op Gate.io</a>. De eerste stap is om een account aan te maken en geverifieerd te worden bij de beurs. Daarna kunt u het account financieren met USDT. Als alternatief kunt u <a href="/how-to-buy/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">koop usdt</a> met een creditcard betalen.</p>
<p>Zodra u USDT in uw handelsportemonnee heeft, kunt u elke cryptocurrency kopen, inclusief APE. U selecteert gewoon APE omdat het is gekoppeld aan USDT, in de <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">spot handelssectie</a> Op dezelfde manier kunt u elke van de belangrijkste cryptocurrencies zoals BTC omzetten naar APE.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16777510944.png" alt=""></p>
<p>Zodra je op het APE/USDT-paar klikt, kun je het bedrag invoeren dat je wilt kopen, dan <a href="https://www.gate.io/how-to-buy/apecoin-ape" target="_blank">klik op “Koop APE”</a>.</p>
<h2 id="h2-Conclusie838036"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Token ontgrendeling is een proces waarbij een team een deel van zijn tokens op de markt vrijgeeft. Tot nu toe is 38% van de 1 miljard apecoins op de markt, terwijl de rest tussen 2023 en 2026 zal worden vrijgegeven. Token ontgrendeling verhoogt het circulerende aanbod van cryptocurrency, wat kan leiden tot een daling van de waarde ervan.</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 beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Herpublicatie van het artikel is toegestaan mits Gate.io wordt vermeld. In alle gevallen wordt juridische actie ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>