TWV0YXZlcnNlUGx1cyBsYW5jZWVyZGUgQWVyb1BheCwgZWVuIE5GVC1jb2xsZWN0aWUgdmFuIDMwLjAwMCB1bmlla2UgYXZhdGFycw==

2023-04-06, 22:29

<p><img src="https://gimg2.gateimg.com/image/article/1680819786YDKP.jpeg" alt=""></p>
<h2 id="h2-TL20DR149996"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Aeropostale lanceerde in maart een NFT-collectie van 30.000 unieke avatars.</p>
<p>Tiny Tops, de kleding van Aeropostale voor jonge vrouwen en mannen, werd populair via Tik Tok en Instagram.</p>
<p>De hype die Tik Tok heeft gegenereerd voor Aeropostale heeft ertoe geleid dat het zijn metaverse heeft geïntroduceerd.</p>
<p>NFT-liefhebbers kunnen trending NFT’s kopen op Gate.io.</p>
<h2 id="h2-Inleiding730704"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Er bestaat geen twijfel dat NFT’s en de metaverse-technologie verschillende merken, waaronder modeverkopers, ten goede zullen komen. Sinds 2022 hebben veel mode-merken de NFT-technologie aangenomen en zijn ze ook de metaverse binnengegaan. Vandaag bespreken we hoe Aeropostate heeft geprofiteerd van Tik Tok op een manier die het heeft aangemoedigd om zijn metaverse te lanceren.</p>
<h2 id="h2-Tik20Tok20heeft20Aeropostale20gered958372"><a name="Tik Tok heeft Aeropostale gered" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tik Tok heeft Aeropostale gered</h2><p>Het verhaal van Aeropostale, een modemerk, dat door Tik Tok van de ondergang werd gered, klinkt als een sprookje; maar het is echt. Om te beginnen was Aeropostale een failliete modeverkoper die in 2016 faillissement aanvroeg. Als gevolg daarvan kocht Authentic Brands Group het voor $240 miljoen en redde het van het faillissement.</p>
<p>Sinds het begin van 2022 zijn de verkopen van Aeropostale echter verdrievoudigd als gevolg van de publiciteit die het kreeg van Tik Tok- en Instagram-gebruikers. De belangrijkste reden voor het faillissement was dat de eerder populaire producten van het bedrijf, skinny jeans en grafische T-shirts, niet meer in de smaak vielen bij de klanten, wat resulteerde in zeer lage verkoopvolumes.</p>
<p>Het was op dat kritieke moment dat zijn ‘Tiny Top’ viraal ging op Tik Tok, waardoor het veel klanten uit de jonge generatie aantrok. Er was ook veel interesse op Instagram. Het project kreeg meer dan 7.000 Instagram-volgers en meer dan 500 nieuwkomers in zijn Discord-kanaal.</p>
<p>Op Tik Tok gebruikten de mensen die bewonderaars waren van de Tiny Top de hashtag ‘Tiny Tops’. Er werden daar ook meer dan 500 video’s geplaatst. Het is echter belangrijk op te merken dat deze hashtag niet exclusief was voor Aeropostale. Het werd ook gebruikt met andere merken zoals American Eagle en Targets. Desalniettemin waren er meer dan 33 miljoen vermeldingen van Aeropostale met betrekking tot de Tiny Tops.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680820080Aeropostale.png" alt=""></p>
<p>Bovenstaande afbeelding toont voorbeelden van het populaire kledingmerk “Tiny Top,” geschikt voor dames tussen de 18 en 22 jaar.<br>De populariteit die Aeropostale kreeg van Tik Tok beïnvloedt het om zich te wagen in de metaverse, met als doel een grotere gemeenschap van volgers aan te trekken dan op Tik Tok. Sterker nog, Aeropostale streeft ernaar zijn metaverse, genaamd AeroWorld, te ontwikkelen via vier fasen die een meeslepende winkel-, sociale en game-ervaring omvatten.</p>
<h2 id="h2-AeroWorld20Metaverse162012"><a name="AeroWorld Metaverse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AeroWorld Metaverse</h2><p>Aeropostale, een gespecialiseerde detailhandelaar in casual kleding en bijbehorende accessoires, heeft een partnerschap gesloten met MetaversePlus, een Web3-ontwikkelingsbedrijf, om een metaverse-mode te ontwikkelen met als doel zijn online aanwezigheid te vergroten en meer klanten aan te trekken. In feite bedient Aeropostale jonge vrouwen en mannen tussen 18 en 22 jaar.</p>
<p>Authentic Brands Group, een toonaangevend wereldwijd merkontwikkelings- en entertainmentbedrijf, dat eigenaar is van Aeropostale, heeft als doel zijn merkbekendheidsprogramma uit te breiden via NFT’s en de metaverse. Naast NFT’s en de metaverse zal Aeropostale verschillende voordelen en promoties gebruiken om verschillende klanten aan te spreken.</p>
<h2 id="h2-MetaversePlus20lanceerde20AeroPax13462"><a name="MetaversePlus lanceerde AeroPax" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MetaversePlus lanceerde AeroPax</h2><p>De eerste ontwikkeling van AeroWorld, de metaverse van Aeropostale, was de lancering van AeroPax, een NFT-collectie van 30.000 unieke avatars. Het merk gebruikt de NFT’s om zijn leden voordelen te bieden, zoals exclusieve voordelen, VIP-promoties en limited edition kleding.</p>
<h2 id="h2-Aeropostale20Metaverse20Sourcingjournal778932"><a name="Aeropostale Metaverse- Sourcingjournal" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aeropostale Metaverse- Sourcingjournal</h2><p>Over het algemeen zal het metaversum het merk helpen bij het opbouwen van een interactieve en meeslepende ervaring voor de AeroWorld-gebruikers. De verzameling van de 30.000 avatars heeft unieke eigenschappen, vaardigheden en stijlen. Daarnaast fungeert de AeroPax als de digitale pas van de gebruikers naar de virtuele werelden en als een interactieve avatar.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680820108Aeropostale 2.png" alt=""></p>
<p>De tweede fase van de metaverse stelt gebruikers in staat om de avatars te verzamelen en deel te nemen aan verschillende interactieve evenementen, waaronder games waarin ze virtuele punten en exclusieve voordelen kunnen verzamelen. Aeropostale zal echter op tijd details verstrekken over de andere twee fasen.</p>
<h2 id="h2-Andere20modemerken545976"><a name="Andere modemerken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Andere modemerken</h2><p>Naast Aeropostale zijn er andere metaverse modemerken zoals Gucci, Louis Vuitton, Burberry en Balenciaga. Gucci, het Italiaanse luxemerk, lanceerde zijn NFT-gerelateerde project en sloot zich aan bij Roblox om een ruimte genaamd Gucci Garden te lanceren.</p>
<p>Louis Vuitton, het Franse modehuis, heeft samengewerkt met Beeple om een mobiel spel genaamd ‘Louis the Game’ uit te brengen, dat gebruikers een kijkje geeft in het merk. De ansichtkaarten, de avatars, andere souvenirs en het spel onthullen de geschiedenis van het merk.</p>
<p>Balenciaga, het Parijse modemerk, lanceerde zijn digitale draagbare kleding. De reeks draagbare artikelen omvat accessoires, kledingstukken en tassen. Het ontwikkelde ook een virtuele ruimte waarmee klanten de nieuwste aanbiedingen online kunnen kopen.</p>
<p>Burberry, het in Londen gevestigde luxe modehuis, heeft samengewerkt met Mythical Games om zijn Blankos Block Party-spel te lanceren. Het heeft ook samengewerkt met ELLE Digital Japan om een virtuele winkel te creëren voor zijn producten.</p>
<h2 id="h2-Hoe20kunst20kopen20op20Gateio790489"><a name="Hoe kunst kopen op Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kunst kopen op Gate.io</h2><p>Je kunt NFT’s kopen op de NFT-marktplaats van Gate.io die Magic Box heet. Er zijn honderden NFT’s waaruit je kunt kiezen. Je kunt ze kopen met behulp van het veiling- of vaste prijssysteem.</p>
<p>De eerste stap is om te klikken op de NFT die u wilt kopen, vervolgens de volledige details ervan te krijgen. Als u tevreden bent, klikt u op ‘Aankoop’ zoals weergegeven in de onderstaande afbeelding.</p>
<p>Vervolgens klik je op “Weet je zeker dat je wilt kopen”.</p>
<p>Als de aankoop succesvol is, wordt de betaling afgetrokken van uw spot-account.</p>
<h2 id="h2-Conclusie281877"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Aeropostale lanceerde zijn NFT-collectie van 30.000 unieke avatars, die deel uitmaken van zijn metaverse- en modeproject. De mode-NFT’s geven hun houders verschillende privileges, zoals VIP-promoties. De belangrijkste aspecten van de metaverse zijn meeslepend winkelen en interactieve spellen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel geeft alleen de mening van de onderzoeker weer 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 wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>