TkZUJ3MgemlqbiBuaWV0IGRvb2Q6IGVlbiBibGlrIG9wIGRlIHRvZWtvbXN0IHZhbiBkaWdpdGFsZSB2ZXJ6YW1lbG9iamVjdGVu

2023-10-26, 17:05

<p><img src="https://gimg2.gateimg.com/image/article/1698339434SDFX 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR576714"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Gierigheid en speculatie waren verantwoordelijk voor de NFT-rage in de afgelopen jaren.</p>
<p>De cryptowinter van 2022 en de oververzadiging van NFT’s hebben geleid tot waardeverlies van veel niet-fungibele tokens.</p>
<p>Veel mensen hebben hun interesse verloren in NFT’s die geen intrinsieke waarde hebben.</p>
<p>De opkomst van nieuwe gebruiksscenario’s zal de interesse in NFT’s opnieuw aanwakkeren.</p>
<h2 id="h2-Introductie851563"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Non-fungible tokens staan op dit moment voor een moeilijke periode, omdat het aantal kopers aanzienlijk is afgenomen. Vanwege de zeer lage handelsactiviteiten op de NFT-markt hebben sommige mensen verklaard dat NFT’s dood zijn. Het doel van dit artikel is om te rechtvaardigen dat NFT’s niet dood zijn, omdat ze vele toepassingen hebben in de echte wereld.</p>
<h2 id="h2-De20huidige20stand20van20zaken20rondom20NFTs926589"><a name="De huidige stand van zaken rondom NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige stand van zaken rondom NFT’s</h2><p>De markt <a href="https://www.gate.io/learn/articles/what-are-nfts/4" target="_blank">voor NFT’s</a> is door verschillende redenen niet meer zo robuust als voorheen. In feite begon de hype rond NFT’s af te nemen tijdens de crypto winter van 2022, toen de vraag naar de meeste digitale activa, waaronder cryptocurrencies, aanzienlijk daalde.</p>
<p>Desalniettemin geloven sommige mensen dat NFT’s dood zijn door de afname van hun populariteit. Opmerkelijk genoeg is dit niet de eerste keer dat we horen van de dood van bepaalde digitale activa. In het verleden was er een tijd waarin sommige mensen verklaarden: “ <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>“Dood”. Meestal zijn crypto-winters verantwoordelijk voor het ontstaan van dergelijke sentimenten.</p>
<p>Wat betreft bitcoin, het steeg zelfs nadat er was verklaard dat het dood was. Op dezelfde manier kunnen NFT’s die traject volgen, gezien ze ook marktcycli ervaren, net als cryptocurrencies. Laten we nu eens kijken naar <a href="https://www.gate.io/nft/drops" target="_blank">wat NFT’s populair maakte</a> in de eerste plaats en hoe die hype vervaagde.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/static-vs-dynamic-nfts/515" target="_blank">Statische vs Dynamische NFT’s</a></p>
<h2 id="h2-9520van20de20NFTs20is20dood37100"><a name="95% van de NFT’s is dood" class="reference-link"></a><span class="header-link octicon octicon-link"></span>95% van de NFT’s is dood</h2><p>Volgens een recent onderzoek van dappGambl is 95% van de NFT-collecties die door meer dan 23 miljoen mensen worden vastgehouden, nu waardeloos. Nog interessanter is dat dappGambl heeft ontdekt dat 69.795 van de 73.257 NFT-collecties een marktkapitalisatie hebben van nul (0) ETH.</p>
<p>Het concludeerde ook dat NFT’s in juli een gemiddeld wekelijks handelsvolume hadden van $80 miljoen, wat een stijging van 3% betekent ten opzichte van de piek die in 2021 werd geregistreerd. 3% is geen bescheiden toename gezien het feit dat er sinds 2021 duizenden nieuwe NFT’s op de markt zijn gekomen.</p>
<p>Het onderzoeksrapport van dappGambl zei: “De statistiek betekent effectief dat 95% van de mensen die NFT-collecties vasthouden, momenteel waardeloze investeringen vasthouden.” Kan dit betekenen dat NFT’s echt dood zijn?</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-is-nft-lending/775" target="_blank">Wat is NFT-lenen?</a></p>
<h2 id="h2-Factoren20die20hebben20bijgedragen20aan20de20toename20van20de20populariteit20van20NFTs880352"><a name="Factoren die hebben bijgedragen aan de toename van de populariteit van NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Factoren die hebben bijgedragen aan de toename van de populariteit van NFT’s</h2><p>Een factor die bijdroeg aan de populariteit van NFT’s in de beginperiode was de lage toetredingsdrempel op de markt. Iedereen die creatief of artistiek was, zou zijn/haar NFT’s op verschillende platforms creëren. Ook de kosten voor het maken van NFT’s waren erg laag. Ook een persoon <a href="https://www.gate.io/article/27611" target="_blank">kon in zeer korte tijd een NFT creëren.</a></p>
<p>Een andere katalysator voor de vroege stijging van de waarden van NFT’s was hebzucht. Het feit dat de vroegste NFT’s veel waarde opleverden, lokte veel kunstenaars en verzamelaars naar de markt met als doel veel winst te genereren.</p>
<p>Iemand die een NFT bezit, zou op zoek gaan naar een ‘dwaas’ die bereid was om het tegen een hogere prijs te kopen. Er waren veel mensen, waaronder beroemdheden, die de NFT’s hadden verworven in de hoop ze te verkopen wanneer hun waarde steeg. Bijvoorbeeld, Eminem kocht een Bored Ape die op hem leek.</p>
<p>Beroemdheden zoals Rapper KSI waren verantwoordelijk voor het hypen van NFT’s, waardoor hun populariteit toenam. De volgende schermafbeelding illustreert dit.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698339891NFTs 1.png" alt=""><br>NFT Hype - Twitter</p>
<p>Zoals hierboven te zien is, adverteerden veel prominente mensen de NFT’s die ze bezaten aan hun volgers. Dit zorgde voor veel interesse in deze digitale activa, wat leidde tot prijsstijgingen. Zoals u ook kunt opmerken, hadden de aanbiedingen hoge waarden zoals $101,692.07 en $99,504.85.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/nftapplicationneedtoknow/50" target="_blank">7 NFT-toepassingen die je moet kennen</a></p>
<h2 id="h2-Redenen20voor20de20afname20van20de20populariteit20van20NFTs575826"><a name="Redenen voor de afname van de populariteit van NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Redenen voor de afname van de populariteit van NFT’s</h2><p>In feite nam de NFT-gekte toe in 2021, wat leidde tot een sterke marktreactie. Als gevolg hiervan kwamen er in 2021 en 2022 veel NFT’s op de markt. Het leek erop dat de markt in 2022 besefte dat sommige van de NFT’s geen intrinsieke waarde hebben, wat een negatief sentiment creëerde tegen deze digitale activa in sommige kringen.</p>
<p>Sommige mensen begonnen NFT’s af te schilderen als simpele JPEG’s zonder waarde. Daardoor nam de NFT-hype af te midden van groeiende desinteresse. Als gevolg daarvan kelderde de waarde van populaire NFT’s. Zo daalde de waarde van een Bored Ape NFT, die zanger Justin Bieber kocht voor een recordbedrag van $1,3 miljoen, met 97% tot $37.000.</p>
<p>In maart 2021 kocht Sina Estavi een NFT voor US$2,9 miljoen. Toen hij het echter een jaar later probeerde te verkopen, was het hoogste bod US$6.800.</p>
<p>Een overschot aan NFT’s op de markt leidde tot een geleidelijk verlies van interesse in hen. Veel kunstenaars en beroemdheden creëerden in feite hun NFT’s die de digitale markt overspoelden. Volgens het onderzoek van dappGambl bleef 79% van de NFT’s onverkocht tot juli 2023. Dat kwam door het overschot op de markt.</p>
<p>Het onderzoeksrapport van dappGambl zei ook: “Als gevolg hiervan wordt het steeds moeilijker voor projecten zonder duidelijke gebruikstoepassingen, overtuigende verhalen of echte artistieke waarde om aandacht en verkoop te krijgen.”</p>
<p>Het voegde eraan toe: “Het is een scherpe herinnering dat, hoewel de NFT-ruimte een revolutionair nieuw model heeft geïntroduceerd voor eigendom en de monetisering van digitale activa, het nog steeds een zeer speculatieve en volatiele markt is.”</p>
<h2 id="h2-Tekenen20dat20NFTs20niet20dood20zijn239318"><a name="Tekenen dat NFT’s niet dood zijn" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tekenen dat NFT’s niet dood zijn</h2><p>Er zijn overtuigende ontwikkelingen in de digitale wereld die aantonen dat NFT’s helemaal niet dood zijn. Er zijn gevestigde bedrijven die zich willen bezighouden met NFT’s. Zo laat een recent rapport zien dat PayPal een octrooiaanvraag heeft ingediend om de overdracht van NFT’s te vergemakkelijken.</p>
<p>Doodles heeft ook een partnerschap gesloten met Crocs, een merk voor informele schoenen, om zowel fysieke activa als NFT’s aan te bieden. De samenwerkingen tussen Gary Vee’s Veefriends en Reebok zullen ook het gebruik van NFT’s faciliteren. Aan de andere kant blijven topveilinghuizen zoals Christies nieuwe NFT-kunstenaars op de markt brengen.</p>
<p>Veel bedrijven hebben manieren bedacht om NFT’s in hun bedrijfsmodellen op te nemen. Sommige <a href="https://www.gate.io/bitwiki/detail/147/non-fungible-token" target="_blank">plan om NFT’s te gebruiken</a> als certificaten van authenticiteit en eigendom. Ook zal de tokenisatie van echte wereld activa zoals vastgoed de bruikbaarheid van NFTs verhogen.</p>
<h2 id="h2-De20toekomst20van20NFTs51614"><a name="De toekomst van NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De toekomst van NFT’s</h2><p>In de toekomst zullen we waarschijnlijk NFT-projecten hebben die commercieel levensvatbaar zijn. Hun digitale activa zullen waarschijnlijk nut bieden aan een breed scala van de economie. Natuurlijk zullen NFT’s die geen praktische toepassingen hebben waarschijnlijk verdwijnen van de markt.</p>
<p>Bijvoorbeeld kunnen overheidsinstanties hun eigen NFT’s produceren die nut bieden aan de burgers. Met name kunnen overheden NFT’s gebruiken als digitale certificaten die belangrijke documenten ondersteunen, zoals digitale identiteit, eigendom van onroerend goed, gezondheidsgegevens, evenals licenties en certificeringen.</p>
<p>De kunstenaars, verzamelaars en andere NFT-liefhebbers zullen een belangrijke rol spelen in de NFT-sector. Opkomende en bestaande kunstenaars zullen waardevolle NFT’s op de markt brengen die innovatie en creativiteit tonen.</p>
<p>We zullen waarschijnlijk meer individuele en institutionele verzamelaars zien die verwerven <a href="https://nftandgamefi.com/2022/02/06/value-of-nfts-how-it-is-formed/" rel="nofollow noopener noreferrer" target="_blank">waardevolle NFT’s</a> Bovendien moeten de verzamelaars kunstenaars vinden die echt zijn, van wie het werk in de toekomst impact zal hebben. De samenwerking van deze marktdeelnemers zal een levendige NFT-markt opnieuw creëren.</p>
<h2 id="h2-Conclusie612622"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De afname van de levendigheid van de NFT-markt als gevolg van verschillende factoren, waaronder de cryptowinter, heeft veel mensen doen concluderen dat NFT’s dood zijn. De overvloed aan NFT’s en hun gebrek aan intrinsieke waarde hebben geleid tot de afkoeling van de markt. Een toename in hun toepassingsmogelijkheden zal echter waarschijnlijk het interesse van mensen in hen weer aanwakkeren.</p>
<h2 id="h2-Veelgestelde20vragen20over20NFTs586146"><a name="Veelgestelde vragen over NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over NFT’s</h2><h3 id="h3-Is20de20NFTtrend20dood234123"><a name="Is de NFT-trend dood?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is de NFT-trend dood?</h3><p>De NFT-trend is niet dood, aangezien er nog steeds veel winstgevende niet-vervangbare tokens op de markt zijn. Verschillende grote bedrijven zoals PayPal zijn bereid om toe te treden tot de NFT-sectoren, wat de prestaties ervan kan stimuleren. In de toekomst kunnen we nieuwe toepassingen hebben voor NFT’s, wat waarschijnlijk hun vraag zal vergroten.</p>
<h3 id="h3-Is20er20echt20een20toekomst20in20NFT118437"><a name="Is er echt een toekomst in NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is er echt een toekomst in NFT?</h3><p>Als er nieuwe gebruiksmogelijkheden op de markt komen, zal de NFT-sector waarschijnlijk doorgaan in de onvoorspelbare toekomst. De grotere adoptie van NFT’s in belangrijke gebieden van de economie, zoals de publieke sector, kan de hype in de branche aanwakkeren.</p>
<h3 id="h3-Investeren20mensen20nog20steeds20in20NFTs509165"><a name="Investeren mensen nog steeds in NFT’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investeren mensen nog steeds in NFT’s?</h3><p>Er zijn nog steeds veel mensen die investeren in NFT’s. Hoewel het handelsvolume van NFT’s op beurzen en NFT-marktplaatsen in vergelijking laag is, <a href="https://www.gate.io/blog_detail/1681/how-to-buy-and-store-non-fungible-tokens" target="_blank">investeerders kopen en verkopen nog steeds NFT’s</a>. Meer makers sluiten zich nog steeds aan bij de sector.</p>
<h3 id="h3-Is20NFT20nog20steeds20winstgevend20in202023416074"><a name="Is NFT nog steeds winstgevend in 2023?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is NFT nog steeds winstgevend in 2023?</h3><p>Hoewel de handel in digitale activa zoals cryptocurrencies en NFT’s risicovol is, nemen veel investeerders nog steeds deel aan de markt. Sommigen van hen maken winst bij het handelen in NFT’s. De lage vraag naar NFT’s en het handelsvolume betekenen niet dat handelaren geen winst kunnen maken.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Onderzoeker Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten 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 zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>