TWV0YSBjaGl1ZGUgZ2xpIE5GVCBzdSBGYWNlYm9vayBlIEluc3RhZ3JhbQ==

2023-03-30, 04:11

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR224228"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Meta ha annunciato che sta per interrompere l’integrazione degli NFT su Facebook e Instagram.</p>
<p>Aim to shift investments from NFTs to projects that create better value for its community of users.</p>
<p>La necessità per Meta di interrompere i progetti NFT di Facebook e Instagram coincide con una diminuzione della domanda di token non fungibili.</p>
<p>Tuttavia, Meta promette di sostenere individui e gruppi che si occupano di NFT che fanno parte della sua comunità.</p>
<h2 id="h2-Introduzione393322"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La fase attuale degli NFT determinerà se gli NFT sono una moda passeggera o se sono qui per restare e apportare contributi significativi all’economia della blockchain. Al momento, si stanno verificando sviluppi positivi e negativi nel settore. Ad esempio, molte startup tecnologiche stanno lanciando nuovi progetti NFT. Tuttavia, ci sono altri progetti NFT esistenti che stanno chiudendo le loro attività per uscire dall’industria. Uno di questi progetti è Meta, che ha annunciato di interrompere gli NFT su Facebook e Instagram.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/854/instagram-to-welcome-nft-features" target="_blank">Instagram Accoglierà le Funzionalità NFT</a></p>
<h2 id="h2-Meta20mira20a20spostare20gli20investimenti20dagli20NFT194340"><a name="Meta mira a spostare gli investimenti dagli NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meta mira a spostare gli investimenti dagli NFT</h2><p>Il motivo chiave per cui Meta <a href="https://twitter.com/skasriel/status/1635386565487898624" rel="nofollow noopener noreferrer" target="_blank">sta terminando il suo NFT</a> Il progetto consiste nel riallocare le sue risorse in altri progetti strategici come “Meta Pay.”</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680149357411680149091_.pic.jpg" alt=""><br>Meta Facebook e Instagram - Gazetengr</p>
<p>Pubblicando su Twitter, Stephane Kasriel, responsabile del commercio e dei servizi finanziari di Meta, ha detto: “Per ora stiamo ridimensionando le collezioni digitali (NFT) per concentrarci su altri modi per sostenere creatori, persone e imprese… Orgogliosi delle relazioni che abbiamo costruito. E non vediamo l’ora di sostenere i molti creatori di NFT che continuano a utilizzare Instagram e Facebook per amplificare il loro lavoro.”</p>
<p>Kasriel ha aggiunto: “Continueremo a investire in strumenti fintech di cui le persone e le imprese avranno bisogno per il futuro. Stiamo semplificando i pagamenti con Meta Pay, rendendo il checkout e i pagamenti più semplici e investendo nei pagamenti tramite messaggistica su Meta.”</p>
<p>La ragione dichiarata per la discontinuazione degli NFT è che l’azienda intende concentrarsi su altre aree chiave dell’attività aziendale, come il supporto ai creatori e le relative unità commerciali. Tuttavia, alcuni analisti ritengono che ci siano sviluppi che potrebbero aver influenzato Meta a prendere questa decisione.</p>
<p>Significativamente, Meta ha già smesso <a href="https://www.gate.io/uk/blog_detail/510?lang=en" target="_blank">emissione e test di NFT</a> e i prodotti correlati. Inoltre, non integrerà funzionalità NFT su Facebook o Instagram che consentiranno ai membri della comunità di acquistare NFT <a href="https://www.gate.io/help/nft/nfts/22845/how-to-sell-nft-works-and-set-the-selling-method-on-app" target="_blank">o vendere NFT</a>.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2286" target="_blank">Cronologia NFT: Una breve storia degli NFT e dove siamo ora</a></p>
<p>Secondo la sua dichiarazione, Meta si concentrerà su aree che interessano molti dei suoi membri della comunità. Ad esempio, si concentrerà sulla messaggistica, sulla monetizzazione dei contenuti e sul miglioramento di Meta Pay.</p>
<h2 id="h2-Altri20fattori20che20potrebbero20aver20influenzato20la20discontinuit20delle20Meta20NFT40545"><a name="Altri fattori che potrebbero aver influenzato la discontinuità delle Meta NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altri fattori che potrebbero aver influenzato la discontinuità delle Meta NFT</h2><p>Non c’è dubbio che le ragioni pubblicizzate da Meta per interrompere l’integrazione degli NFT con Facebook e Instagram siano quelle principali. Tuttavia, ci sono altri fattori che potrebbero aver contribuito a questa conclusione.</p>
<p>In primo luogo, sembra che l’entusiasmo associato agli NFT sia diminuito perché molti seguaci degli NFT hanno capito che <a href="https://www.gate.io/uk/article/20083" target="_blank">la maggior parte degli NFT</a> sono semplici JPEG senza alcuna utilità. La situazione è peggiorata ulteriormente con l’introduzione dei generatori di NFT basati su intelligenza artificiale. Ciò significa semplicemente che l’acquirente di NFT sta pagando un individuo solo per scrivere un <a href="https://www.gate.io/blog_detail/2342/bicasso-the-ai-powered-nft-generator" target="_blank"> su Binance Bicasso</a>, DALL-E o qualsiasi altro generatore di AI NFT.</p>
<p>Il grafico qui sotto mostra la diminuzione della domanda di NFT tra aprile 2022 e gennaio 2023.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680149478421680149108_.pic.jpg" alt=""><br>Diminuzione del volume di scambio degli NFT - Non-fungible.com</p>
<p>Come osservato dal grafico, il volume delle vendite di NFT è diminuito durante il periodo. Un altro fattore contributivo è che è molto facile per i creatori di NFT copiare altri NFT. Tuttavia, è essenziale notare che ci sono NFT che hanno valore, in particolare quelli supportati da asset fisici.</p>
<p>Secondo, Meta potrebbe chiudere su Facebook NFT e Instagram NFT a causa di alcuni problemi finanziari. Già l’azienda ha licenziato 11.000 dipendenti nel novembre 2022 come mezzo per ridurre i costi operativi.</p>
<p>Il mercato orso prolungato potrebbe aver anche appesantito l’azienda. Chiaramente, la perdita di $13,7 miliardi subita lo scorso anno da Meta’s Reality Labs, la divisione di Meta che si concentrava sulla realtà aumentata (AR) e sulla realtà virtuale, indica che l’azienda potrebbe trovarsi in difficoltà finanziarie.</p>
<p>Un’altra sviluppo degno di nota è stata la partenza di David Marcus, l’ex responsabile dei pagamenti e delle criptovalute. Al momento, non è chiaro se la sua partenza abbia potuto influenzare il cambiamento di posizione dell’azienda sugli NFT.</p>
<p>Meta non solo ha interrotto l’integrazione NFT con Facebook e Instagram, ma ha anche chiuso il suo progetto Novi a settembre 2022. A proposito, Novi era il progetto commerciale di Meta utilizzato per trasferimenti di denaro internazionali e transazioni di rimesse.</p>
<h2 id="h2-Conclusione76935"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Meta ha annunciato la sua intenzione di interrompere l’integrazione degli NFT su Facebook e Instagram. Il suo principale motivo per farlo è di spostare i suoi investimenti per sostenere progetti che hanno un maggiore impatto sugli utenti. Tuttavia, ha promesso di continuare a sostenere iniziative NFT meritevoli.</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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>