R2xpIE5GVCBub24gc29ubyBtb3J0aTogdW5vIHNndWFyZG8gYWwgZnV0dXJvIGRlaSBjb2xsZXppb25hYmlsaSBkaWdpdGFsaQ==

<p><img src="https://gimg2.gateimg.com/image/article/1698339434SDFX 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR777422"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Avidità e speculazione sono stati responsabili dell’impazzimento degli NFT negli ultimi anni.</p>
<p>L’inverno crittografico del 2022 e l’eccesso di offerta di NFT hanno comportato la perdita di valore di molti token non fungibili.</p>
<p>Molte persone hanno perso interesse per gli NFT che non hanno un valore intrinseco.</p>
<p>L’emergere di nuovi casi d’uso riaccenderà l’interesse per gli NFT.</p>
<h2 id="h2-Introduzione256423"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>I token non fungibili stanno affrontando un periodo difficile al momento, poiché il numero di acquirenti è diminuito notevolmente. A causa delle attività di trading molto basse nel mercato NFT, alcune persone hanno dichiarato che gli NFT sono morti. Lo scopo di questo articolo è giustificare che gli NFT non sono morti in quanto hanno molti casi d’uso nel mondo reale.</p>
<h2 id="h2-Lo20stato20attuale20degli20NFT960266"><a name="Lo stato attuale degli NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo stato attuale degli NFT</h2><p>Il mercato <a href="https://www.gate.io/learn/articles/what-are-nfts/4" target="_blank">per NFT</a> non è più robusto come prima a causa di vari motivi. In effetti, l’entusiasmo per le NFT si è raffreddato durante l’inverno cripto del 2022, quando la domanda per la maggior parte degli asset digitali, inclusa la criptovaluta, è diminuita notevolmente.</p>
<p>Tuttavia, alcune persone credono che gli NFT siano morti a causa della diminuzione della loro popolarità. Va notato che non è la prima volta che si sente parlare della morte di determinati asset digitali. In passato, c’è stato un momento in cui alcune persone hanno dichiarato “ <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> di solito sono gli inverni criptici a essere responsabili dell’emergere di tali sentimenti.</p>
<p>Per quanto riguarda il bitcoin, ha registrato una forte crescita anche dopo una proclamazione che lo dava per morto. Allo stesso modo, gli NFT potrebbero seguire quella stessa traiettoria considerando che anch’essi vivono cicli di mercato proprio come le criptovalute. Ora, diamo un’occhiata a <a href="https://www.gate.io/nft/drops" target="_blank">cosa ha reso popolari gli NFT</a> in primo luogo e come quell’entusiasmo è svanito.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/static-vs-dynamic-nfts/515" target="_blank">NFT statici vs dinamici</a></p>
<h2 id="h2-Il209520degli20NFT2020morto271759"><a name="Il 95% degli NFT è morto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il 95% degli NFT è morto</h2><p>Secondo uno studio recente di dappGambl, il 95% delle collezioni NFT che più di 23 milioni di persone possiedono sono ora senza valore. In modo ancora più interessante, dappGambl ha scoperto che 69.795 su 73.257 collezioni NFT hanno capitalizzazioni di mercato pari a zero (0) ETH.</p>
<p>Ha anche concluso che a luglio gli NFT hanno avuto un volume di trading settimanale medio di $80 milioni, il che rappresenta un aumento del 3% rispetto al picco registrato nel 2021. Il 3% non è un modesto aumento considerando che migliaia di nuovi NFT sono entrati sul mercato dal 2021.</p>
<p>Il rapporto di studio dappGambl ha affermato: “Le statistiche significano efficacemente che il 95% delle persone che detengono collezioni NFT attualmente detengono investimenti senza valore.” Può questo significare che gli NFT sono veramente morti?</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-nft-lending/775" target="_blank">Cos’è il prestito NFT?</a></p>
<h2 id="h2-Fattori20che20hanno20contribuito20allaumento20della20popolarit20degli20NFT764697"><a name="Fattori che hanno contribuito all’aumento della popolarità degli NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fattori che hanno contribuito all’aumento della popolarità degli NFT</h2><p>Un fattore che ha contribuito alla popolarità degli NFT durante i primi giorni era il basso ostacolo all’ingresso nel mercato. Chiunque fosse creativo o artistico avrebbe creato i suoi NFT su varie piattaforme. Anche il costo di coniare gli NFT è stato molto basso. Inoltre, una persona <a href="https://www.gate.io/article/27611" target="_blank">potrebbe creare un NFT in molto poco tempo.</a></p>
<p>Un altro catalizzatore per la crescita precoce dei valori degli NFT è stata l’avidità. Il fatto che i primi NFT abbiano raggiunto un alto valore ha attirato molti artisti e collezionisti a entrare nel mercato con l’obiettivo di generare grandi profitti.</p>
<p>Qualcuno che possiede un NFT cercherebbe un “folle” disposto a comprarlo a un prezzo più alto. C’erano molte persone, compresi celebrità, che hanno acquistato gli NFT con la speranza di venderli quando il loro valore aumentasse. Ad esempio, Eminem ha acquistato una Bored Ape che assomigliava a lui.</p>
<p>Celebrità come il rapper KSI sono stati responsabili di alimentare l’entusiasmo per le NFT, aumentandone così la popolarità. Lo screenshot seguente illustra questo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1698339891NFTs 1.png" alt=""><br>Frenesia per gli NFT - Twitter</p>
<p>Come si può vedere sopra, molte persone di spicco hanno pubblicizzato gli NFT di cui erano proprietari ai loro seguaci. Ciò ha generato molto interesse per questi asset digitali e ha portato ad un aumento dei prezzi. Come puoi anche notare, le offerte avevano valori elevati come $101,692.07 e $99,504.85.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/nftapplicationneedtoknow/50" target="_blank">7 Applicazioni NFT che Devi Conoscere</a></p>
<h2 id="h2-Motivi20per20il20raffreddamento20della20popolarit20degli20NFT883317"><a name="Motivi per il raffreddamento della popolarità degli NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Motivi per il raffreddamento della popolarità degli NFT</h2><p>Fondamentalmente, la frenesia degli NFT è aumentata nel 2021, il che ha portato a una forte risposta del mercato. Di conseguenza, molti NFT sono arrivati sul mercato nel corso del 2021 e del 2022. Sembra che nel corso del 2022 il mercato si sia reso conto che alcuni degli NFT non hanno alcun valore intrinseco, cosa che ha creato un sentimento negativo nei confronti di questi asset digitali in alcuni trimestri.</p>
<p>Alcune persone hanno iniziato a etichettare gli NFT come semplici JPEG che non hanno alcun valore. Da lì l’entusiasmo per gli NFT è diminuito a causa dell’interesse crescente per loro. Di conseguenza, il valore degli NFT popolari è crollato. Ad esempio, il valore di un NFT di Bored Ape, acquistato dal cantante Justin Bieber per un record di 1,3 milioni di dollari, è sceso del 97% a 37.000 dollari.</p>
<p>Nel marzo 2021 Sina Estavi ha acquistato un NFT per 2,9 milioni di dollari. Tuttavia, quando ha provato a rivenderlo un anno dopo, ha ricevuto un’offerta massima di 6.800 dollari.</p>
<p>Un eccesso di offerta di NFT sul mercato ha portato alla graduale perdita di interesse nei loro confronti. Fondamentalmente, molti artisti e celebrità hanno creato i loro NFT che hanno invaso il mercato digitale. Secondo la ricerca di dappGambl, il 79% degli NFT è rimasto invenduto entro luglio 2023. Ciò è dovuto all’eccedenza del mercato.</p>
<p>Il rapporto di ricerca dappGambl ha anche affermato: ‘Di conseguenza, i progetti privi di chiari casi d’uso, narrazioni convincenti o valore artistico genuino trovano sempre più difficoltà a attirare attenzione e vendite’.</p>
<p>Ha aggiunto: “È un duro promemoria che, sebbene lo spazio NFT abbia introdotto un nuovo modello rivoluzionario per la proprietà e la monetizzazione degli asset digitali, rimane un mercato altamente speculativo e volatile.”</p>
<h2 id="h2-Segni20che20gli20NFT20non20sono20morti75442"><a name="Segni che gli NFT non sono morti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Segni che gli NFT non sono morti</h2><p>Ci sono sviluppi convincenti nel mondo digitale che dimostrano che gli NFT non sono affatto morti. Ci sono aziende ben consolidate che mirano a coinvolgersi negli NFT. Ad esempio, un recente rapporto mostra che PayPal ha presentato una domanda di brevetto per facilitare il trasferimento di NFT.</p>
<p>Doodles ha anche stretto una partnership con Crocs, un marchio di calzature casual, per offrire sia beni fisici che NFT. Le collaborazioni tra Veefriends di Gary Vee e Reebok faciliteranno anche l’uso di NFT. D’altra parte, le principali case d’asta come Christies continuano a portare nuovi artisti di NFT sul mercato.</p>
<p>Molte aziende hanno elaborato modi per incorporare gli NFT nei loro modelli di business. Alcune <a href="https://www.gate.io/bitwiki/detail/147/non-fungible-token" target="_blank">piano di utilizzare NFT</a> come certificati di autenticità e di proprietà. Inoltre, la tokenizzazione di beni reali come l’immobiliare aumenterà l’utilità delle NFT.</p>
<h2 id="h2-Il20futuro20degli20NFT165008"><a name="Il futuro degli NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il futuro degli NFT</h2><p>In futuro, è probabile che avremo progetti NFT che sono commercialmente sostenibili. I loro asset digitali offriranno probabilmente utilità a un’ampia parte dell’economia. Naturalmente, è probabile che gli NFT che non avranno casi d’uso nel mondo reale scompaiano dal mercato.</p>
<p>Ad esempio, le agenzie governative possono produrre le proprie NFT che offrono utilità ai cittadini. In particolare, i governi possono utilizzare le NFT come certificati digitali che supportano documenti importanti come l’identità digitale, la proprietà immobiliare, i record sanitari, nonché le licenze e le certificazioni.</p>
<p>Gli artisti, i collezionisti e altri appassionati di NFT svolgeranno un ruolo significativo nel settore NFT. Gli artisti emergenti e esistenti porteranno NFT preziosi sul mercato, dimostrando innovazione e creatività.</p>
<p>Vedremo probabilmente più collezionisti individuali e istituzionali che acquistano <a href="https://nftandgamefi.com/2022/02/06/value-of-nfts-how-it-is-formed/" rel="nofollow noopener noreferrer" target="_blank">NFT preziosi</a>. Inoltre, i collezionisti dovrebbero trovare artisti veri, il cui lavoro avrà un impatto in futuro. La collaborazione di questi partecipanti al mercato ricreerà un mercato NFT vibrante.</p>
<h2 id="h2-Conclusione83076"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La diminuzione della vivacità del mercato NFT a causa di vari fattori, tra cui l’inverno crittografico, ha portato molte persone a concludere che gli NFT sono morti. L’eccesso di offerta di NFT e la loro mancanza di valori intrinseci hanno portato al raffreddamento del mercato. Tuttavia, un aumento dei loro casi d’uso probabilmente riaccenderà l’interesse delle persone per loro.</p>
<h2 id="h2-Domande20frequenti20su20NFT237843"><a name="Domande frequenti su NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su NFT</h2><h3 id="h3-20morta20la20tendenza20degli20NFT675464"><a name="È morta la tendenza degli NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>È morta la tendenza degli NFT?</h3><p>Il trend degli NFT non è morto in quanto ci sono ancora molti token non fungibili redditizi sul mercato. Diverse grandi aziende come PayPal sono disposte a unirsi ai settori degli NFT, il che potrebbe migliorarne le prestazioni. In futuro potremmo avere nuovi casi d’uso per gli NFT, che probabilmente aumenteranno la loro domanda.</p>
<h3 id="h3-C20davvero20un20futuro20nelle20NFT177845"><a name="C’è davvero un futuro nelle NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>C’è davvero un futuro nelle NFT?</h3><p>Il settore NFT probabilmente continuerà nel futuro imprevedibile se nuovi casi d’uso entreranno sul mercato. Una maggiore adozione degli NFT in settori chiave dell’economia come il settore pubblico potrebbe accendere l’entusiasmo nell’industria.</p>
<h3 id="h3-Le20persone20investono20ancora20in20NFT654532"><a name="Le persone investono ancora in NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le persone investono ancora in NFT?</h3><p>Ci sono ancora molte persone che investono in NFT. Anche se il volume di scambio degli NFT sulle borse e sui mercati degli NFT è relativamente basso, <a href="https://www.gate.io/blog_detail/1681/how-to-buy-and-store-non-fungible-tokens" target="_blank">gli investitori continuano a comprare e vendere NFT</a>. Altri creatori stanno ancora unendosi al settore.</p>
<h3 id="h3-Gli20NFT20sono20ancora20redditizi20nel202023935401"><a name="Gli NFT sono ancora redditizi nel 2023?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli NFT sono ancora redditizi nel 2023?</h3><p>Anche se il trading di attività digitali come criptovalute e NFT è rischioso, molti investitori partecipano ancora al mercato. Alcuni di loro ottengono profitto quando scambiano NFT. La bassa domanda e il volume di trading degli NFT non significano che i trader non possano ottenere profitto.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>