TWV0YSBzbHVpdCBORlQncyBhZiBvcCBGYWNlYm9vayBlbiBJbnN0YWdyYW0=

2023-03-30, 04:11

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR905159"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Meta heeft aangekondigd dat het de integratie van NFT’s op Facebook en Instagram gaat stopzetten.</p>
<p>Het heeft tot doel investeringen te verschuiven van NFT’s naar projecten die betere waarde creëren voor haar gemeenschap van gebruikers.</p>
<p>De noodzaak voor Meta om te stoppen met zijn Facebook NFT- en Instagram NFT-projecten valt samen met een afname van de vraag naar niet-vervangbare tokens.</p>
<p>Toch belooft Meta ondersteuning te bieden aan individuen en groepen die te maken hebben met NFT’s die deel uitmaken van haar gemeenschap.</p>
<h2 id="h2-Introductie591411"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De huidige NFT-fase zal bepalen of NFT’s een rage zijn of blijvend zijn en een significante bijdrage leveren aan de blockchain-economie. Op dit moment vinden zowel positieve als negatieve ontwikkelingen plaats in de sector. Zo lanceren veel tech-startups nieuwe NFT-projecten. Desalniettemin zijn er andere bestaande NFT-projecten die hun activiteiten afbouwen om de industrie te verlaten. Een dergelijk project is Meta, dat onlangs heeft aangekondigd dat het stopt met NFT’s op Facebook en Instagram.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/854/instagram-to-welcome-nft-features" target="_blank">Instagram om NFT-functies te verwelkomen</a></p>
<h2 id="h2-Meta20streeft20ernaar20om20investeringen20te20verschuiven20van20NFTs268016"><a name="Meta streeft ernaar om investeringen te verschuiven van NFTs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meta streeft ernaar om investeringen te verschuiven van NFTs</h2><p>De belangrijkste reden waarom Meta <a href="https://twitter.com/skasriel/status/1635386565487898624" rel="nofollow noopener noreferrer" target="_blank">is bezig met het afbouwen van zijn NFT</a> Het project is om zijn middelen te herverdelen naar andere strategische projecten zoals “Meta Pay.”</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680149357411680149091_.pic.jpg" alt=""><br>Meta Facebook en Instagram - Gazetengr</p>
<p>Stephane Kasriel, hoofd van handel en financiële diensten bij Meta, zei op Twitter: “We stoppen voorlopig met digitale verzamelobjecten (NFT’s) om ons te richten op andere manieren om makers, mensen en bedrijven te ondersteunen… Trots op de relaties die we hebben opgebouwd. En we kijken ernaar uit om de vele NFT-makers te blijven ondersteunen die Instagram en Facebook blijven gebruiken om hun werk te versterken.”</p>
<p>Kasriel voegde eraan toe: “We blijven investeren in fintech-tools die mensen en bedrijven in de toekomst nodig zullen hebben. We stroomlijnen betalingen met Meta Pay, waardoor afrekenen en uitbetalingen gemakkelijker worden, en investeren in berichtenbetalingen via Meta.”</p>
<p>De verklaarde reden om te stoppen met NFT’s is dat het bedrijf zich wil richten op andere belangrijke bedrijfsgebieden, zoals het ondersteunen van makers en de bijbehorende bedrijfseenheden. Sommige analisten geloven echter dat er ontwikkelingen zijn geweest die Meta ertoe hebben gebracht om die beslissing te nemen.</p>
<p>Belangrijk is dat Meta al gestopt is <a href="https://www.gate.io/uk/blog_detail/510?lang=en" target="_blank">het slaan en testen van NFT’s</a> en de bijbehorende producten. Bovendien zal het geen NFT-functies integreren op Facebook of Instagram die de communityleden in staat zullen stellen om NFT’s te kopen <a href="https://www.gate.io/help/nft/nfts/22845/how-to-sell-nft-works-and-set-the-selling-method-on-app" target="_blank">of verkoop NFT’s</a>.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2286" target="_blank">NFT-tijdlijn: Een beknopte geschiedenis van NFT’s en waar we nu staan</a></p>
<p>Volgens zijn verklaring zal Meta zich richten op gebieden die veel van zijn gemeenschapsleden beïnvloeden. Bijvoorbeeld, het zal zich richten op berichten, monetisering van inhoud en verbetering van Meta Pay.</p>
<h2 id="h2-Andere20factoren20die20mogelijk20hebben20bijgedragen20aan20het20stopzetten20van20Meta20NFTs912259"><a name="Andere factoren die mogelijk hebben bijgedragen aan het stopzetten van Meta NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Andere factoren die mogelijk hebben bijgedragen aan het stopzetten van Meta NFT’s</h2><p>Er bestaat geen twijfel dat de openbaar gemaakte redenen van Meta om te stoppen met de integratie van NFT’s met Facebook en Instagram de belangrijkste zijn. Desalniettemin zijn er andere factoren die aan die conclusie hebben kunnen bijdragen.</p>
<p>Ten eerste lijkt het erop dat de opwinding rond NFT’s is afgenomen omdat veel NFT-volgers hebben ingezien dat <a href="https://www.gate.io/uk/article/20083" target="_blank">meeste NFT’s</a> zijn slechts JPEG’s zonder enig nut. De situatie is verergerd door de introductie van kunstmatige technologie NFT-generatoren. Dit betekent simpelweg dat de NFT-koper een individu betaalt voor alleen het schrijven van een <a href="https://www.gate.io/blog_detail/2342/bicasso-the-ai-powered-nft-generator" target="_blank"> bij Binance Bicasso</a>, DALL-E of een andere AI NFT-generator.</p>
<p>De onderstaande grafiek toont de afname van de vraag naar NFT’s tussen april 2022 en januari 2023.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680149478421680149108_.pic.jpg" alt=""><br>Afname van de handelsvolume van NFT’s - Non-fungible.com</p>
<p>Zoals blijkt uit de grafiek is de verkoop van NFT’s in de periode afgenomen. Een andere factor die bijdraagt is dat het voor NFT-makers heel eenvoudig is om andere NFT’s te kopiëren. Desalniettemin is het essentieel om op te merken dat er NFT’s zijn die waarde hebben, met name die ondersteund worden door fysieke activa.</p>
<p>Ten tweede kan Meta vanwege financiële moeilijkheden stoppen met Facebook NFT’s en Instagram NFT’s. Het bedrijf heeft al in november 2022 11.000 werknemers ontslagen om de operationele kosten te verlagen.</p>
<p>De langdurige bear market kan ook druk hebben gelegd op het bedrijf. Het is duidelijk dat het verlies van $ 13,7 miljard dat Meta’s Reality Labs, de divisie van Meta die zich richtte op augmented reality (AR) en virtual reality (VR), vorig jaar heeft geleden, laat zien dat het bedrijf mogelijk in financiële moeilijkheden verkeert.</p>
<p>Een andere opmerkelijke ontwikkeling was het vertrek van David Marcus, de voormalige hoofd van betalingen en cryptocurrencies. Op dit moment is het niet duidelijk of zijn vertrek invloed heeft gehad op de verandering van standpunt van het bedrijf met betrekking tot NFT’s.</p>
<p>Meta heeft niet alleen de integratie van NFT met Facebook en Instagram stopgezet, maar heeft ook haar Novi-project in september 2022 gesloten. Overigens was Novi het zakelijke project van Meta dat werd gebruikt voor internationale geldtransfers en remittances-transacties.</p>
<h2 id="h2-Conclusie220724"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Meta heeft aangekondigd dat het van plan is om de integratie van NFT’s op Facebook en Instagram stop te zetten. De belangrijkste motivatie hiervoor is om haar investeringen te verschuiven naar projecten die een grotere impact hebben op haar gebruikers. Het heeft echter beloofd om waardevolle NFT-initiatieven te blijven ondersteunen.</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 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 genoemd. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>