TmFkZXJlbmRlIG9udGdyZW5kZWxpbmcgdmFuICQxNTYgbSBhYW4gQXhpZSBJbmZpbml0eS10b2tlbiBrb210IGVyYWFuIHRlcndpamwgQVhTIHZlcmxpZXplbiBsaWpkdA==

<p><img src="https://gimg2.gateimg.com/image/article/1682586049RDZZ.jpeg" alt=""><br>De prijs van AXS daalde met 10,4% twee weken voor het vrijgeven van 18,89 miljoen tokens.<br>De algemene marktaversie kan de daling van de waarde van de AXS-munt hebben veroorzaakt.<br>De waarde van AXS zal naar verwachting schommelen tussen $10,65 en $14,28 tegen het einde van het jaar.</p>
<p>Trefwoorden: prijsdaling van AXS, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> Scherfjes, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a>, AXS munt, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">axs prijs</a> prognose, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> nieuws</p>
<h2 id="h2-Introductie726588"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Het vergrendelen en ontgrendelen van tokens kan de prijs van een cryptocurrency op opmerkelijke wijze beïnvloeden. Het vergrendelen van een bepaalde hoeveelheid tokens vermindert het aanbod, terwijl ontgrendelen het verhoogt. De ontgrendeling van $156 miljoen aan AXS-tokens komt tegen de achtergrond van een scherpe daling van de prijs van AXS. In dit artikel onderzoeken we de mogelijke oorzaken van de recente daling van de prijs van AXS en de gerelateerde <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> nieuws.</p>
<h2 id="h2-AXS20verpleegt20verliezen20na20een20scherpe20prijsdaling418283"><a name="AXS verpleegt verliezen na een scherpe prijsdaling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AXS verpleegt verliezen na een scherpe prijsdaling</h2><p>Een paar dagen voor het ontgrendelen van AXS daalde de prijs scherp, wat resulteerde in ernstig verlies. Specifiek, op 22 april daalde de prijs van AXS naar $7.85 en sinds die periode beweegt het zijwaarts als. <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> geeft aan.<br><img src="https://gimg2.gateimg.com/image/article/16832786021.png" alt=""><br>AXS-muntprijs - CoinGecko</p>
<p><a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a> laat zien hoe de prijs van AXS op 19 april scherp daalde en daarna een laag momentum behield. Op het moment van schrijven wordt AXS, met een handelsvolume van meer dan $48 miljoen, gewaardeerd op $7,88. In feite is de prijs in twee weken tijd met meer dan 10,4% gedaald.</p>
<p><a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">axs crypto</a> met een totale waardering van $941,7 miljoen, is de op twee na best geplaatste token in de play-to-earn- en gamingcategorie. Volgens TokenUnlocks, <a href="https://www.gate.io/bitwiki/detail/732/axie-infinity" target="_blank">Axie Infinity</a> is ingesteld om 18.89 miljoen te ontgrendelen <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> Shards (AXS) ter waarde van ongeveer $155 miljoen.</p>
<p><a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> begon in 2020 met het ontgrendelen van zijn tokens en heeft tot nu toe 176,55 miljoen tokens ontgrendeld. De 18,89 miljoen tokens die het van plan is te ontgrendelen, vormen ongeveer 7% van de totale voorraad van 270 miljoen AXS. Volgens het schema <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> zal in 2025 nog eens 77,76 miljoen tokens ontgrendelen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/796/axie-infinity-and-its-mission-to-be-decentralized" target="_blank">Axie Infinity en zijn missie om gedecentraliseerd te zijn</a></p>
<h2 id="h2-Mogelijke20redenen20van202020axs20prijs2020neerzetten902248"><a name="Mogelijke redenen van   axs prijs  neerzetten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mogelijke redenen van <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">axs prijs</a> neerzetten</h2><p>Over het algemeen kunnen muntenontgrendelingen leiden tot prijsdalingen doordat ze het aanbod van de cryptocurrency vergroten. Als gevolg hiervan kunnen de muntbezitters ze verkopen, waardoor er verkoopdruk ontstaat. Gewoonlijk kunnen sommige nieuwe cryptoprojecten een deel van hun tokens vergrendelen en deze periodiek vrijgeven naarmate de vraag toeneemt.</p>
<p>Lees ook: <a href="https://www.gate.io/price/view/axie-infinity" target="_blank">Top axie-infinity Crypto Munten &amp; Tokens op basis van Marktkapitalisatie</a></p>
<p>Het is belangrijk op te merken dat sommige unlocks niet leiden tot verkoopdruk en de daaropvolgende daling van hun prijzen. Bijvoorbeeld, AXS ondervond niet veel verkoopdruk naar aanleiding van eerdere unlock evenementen. In feite steeg AXS naarmate de unlock evenementen dichterbij kwamen.<br>De recente prijsdaling van AXS kan veroorzaakt zijn door de risico-aversie van de markt. Dit komt omdat er over het algemeen verkoopdruk was voor de belangrijkste cryptocurrencies zoals ETH en BTC. Als voorbeeld verloor BTC 8%. Ook het sluiten van bullish posities in plaats van bearish inzetten kan hebben bijgedragen aan de daling van de prijs.</p>
<h2 id="h2-Wat20is20AXS20Axie267763"><a name="Wat is AXS Axie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is AXS Axie?</h2><p><a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> shards (AXS) zijn de inheemse <a href="https://www.gate.io/learn/articles/what-is-axie-infinity/148" target="_blank">tokens van Axie Infinity</a>, een populair play-to-earn spel, gebouwd op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. Dit gamingplatform stelt spelers in staat om Axie-wezens te verwerven, te fokken en groot te brengen, die de spelers gebruiken in gevechten.<br><img src="https://gimg2.gateimg.com/image/article/16832787032.png" alt=""><a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> token - Vecteezy</p>
<p>De AXS-munt is ook <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> Het governance-token van Gate.io stelt houders in staat beslissingen te nemen over kwesties met betrekking tot de ontwikkeling of verbetering van het gamingprotocol.</p>
<p>Om deel te nemen aan het bestuur, moeten AXS-houders hun inzet doen. <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> Shards. Naast deelname aan het bestuur, verdienen AXS-houders ook een beloning voor het staken van de tokens.</p>
<h2 id="h2-prognose20van20AXS20Coin994048"><a name="prognose van AXS Coin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>prognose van AXS Coin</h2><p>Op het moment van schrijven bevindt de AXS-token zich in een opwaartse trend met een huidige waarde van $7,91. Over het algemeen is de prijs echter met 4% gedaald in de afgelopen 7 dagen. Ook bereikte het de hoogste waarde van $8,59 in de afgelopen 24 uur en een dieptepunt van $7,26.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/axie-infinity-axs" target="_blank">Axie Infinity (AXS) Prijsvoorspelling 2023-2030</a></p>
<p>AXS’ huidige aanbod is 116.136.529 met een totale marktkapitalisatie van $920.922.007. Bovendien is de waarde ervan in de afgelopen 30 dagen met 6,07% gedaald, wat aangeeft dat de neerwaartse trend al geruime tijd aanhoudt. <a href="https://bitnation.co/forecast/axie-infinity-price-prediction/" rel="nofollow noopener noreferrer" target="_blank">Volgens Bitnation</a>, de waarde ervan is in de afgelopen 3 maanden met 30,69% gedaald.</p>
<p>Ondanks het huidige verlies in waarde, verwacht de markt dat de prijs van AXS zal stijgen gedurende het jaar. Bijvoorbeeld, Bitnation voorspelt dat de <a href="https://www.gate.io/price/axie-infinity-axs" target="_blank">gemiddelde prijs van AXS</a> voor 2023 zal $11.90 zijn, terwijl de verwachte maximale prijs $14.28 is.</p>
<p><a href="https://priceprediction.net/en/price-prediction/axie-infinity/2023" rel="nofollow noopener noreferrer" target="_blank">Prijsvoorspelling geeft vergelijkbare voorspellingen</a> met kleine variaties. Het verwacht dat de gemiddelde prijs van AXS $ 10,65 zal zijn met een maximum van $ 11,93. Aangezien AXS aan het begin van het jaar een waarde van ongeveer $ 6,00 had, is het mogelijk dat het tegen het einde van het jaar een prijs tussen $ 10,65 en $ 14,28 zal bereiken.</p>
<h2 id="h2-Conclusie354935"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De prijs van AXS daalde een paar dagen aanzienlijk in de richting van de ontgrendeling van 18,89 miljoen tokens. Sommige analisten zijn echter van mening dat de algemene marktafkeer de daling van de prijs van AXS heeft veroorzaakt in plaats van de aanstaande ontgrendeling. Ook verwacht de markt dat de waarde van AXS tegen het einde van het jaar zal variëren tussen $ 10,65 en $ 14,28.</p>
<h3 id="h3-Zal20AXS2010020bereiken445488"><a name="Zal AXS $100 bereiken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zal AXS $100 bereiken?</h3><p>AXS zal waarschijnlijk tegen het jaar 2030 een waarde van $100 bereiken. Tijdens 2023 zal de prijs van AXS waarschijnlijk schommelen tussen $6,00 en $14,28. De waarde kan echter stijgen naar ongeveer $25 in 2025 en $65,05 tegen 2030.</p>
<h3 id="h3-Hoeveel20kost20AXS347775"><a name="Hoeveel kost AXS?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel kost AXS?</h3><p>De huidige prijs van AXS is $ 7,91 en zal naar verwachting de komende dagen stijgen. Marktanalisten verwachten echter dat de prijs van AXS tegen het einde van 2023 tussen $ 10,65 en $ 14,28 zal fluctueren.</p>
<h3 id="h3-Wat20is20de20laagste20prijs20van20AXS179587"><a name="Wat is de laagste prijs van AXS?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de laagste prijs van AXS?</h3><p>De laagste prijs van AXS in 2023 was $6,00, aan het begin van het jaar. Sindsdien is de waarde echter voortdurend gestegen, ondanks enkele pieken en terugtrekkingen.</p>
<h3 id="h3-Is20AXS20coin20een20goede20investering507983"><a name="Is AXS coin een goede investering?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is AXS coin een goede investering?</h3><p>AXS-munten zijn een goed investeringsmiddel omdat het de drijvende kracht is achter de <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> gamingprotocol dat momenteel gerangschikt is <a href="https://www.gate.io/price/view/play-to-earn" target="_blank">Nummer drie in de play-to-earn</a> en gaming categorie. De houders kunnen het inzetten om een beloning te verdienen.</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 visie van de onderzoeker en vormt geen beleggingsadvies.<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>