TGFidWJ1IExhYXRzdGUgTmlldXdzOiBMQUJVQlUgQ29pbiBPdmVydHJlZnQgS29ydHN0b25kaWcgJDcwIE1pbGpvZW4=

2025-06-17, 07:24

<p><img src="https://gimg2.gateimg.com/image/labu202506171523123679498972.png" alt="">
</p><p>Op 10 juni 2025, tijdens de Yongle Spring Auction, werd een unieke mintgroene LABUBU verkocht voor 1,08 miljoen yuan, waarbij de identiteit van de koper niet bekend werd gemaakt. Een andere gelimiteerde editie van de bruine LABUBU, waarvan er slechts 15 zijn gemaakt, werd ook verkocht voor een hoge prijs van 820.000 yuan, waardoor de marktpopulariteit van dit “lelijk-schattige kleine monster” naar een nieuw hoogtepunt werd gestuwd.</p>
<p>Slechts drie dagen later kondigde de Koreaanse tak van Pop Mart op 14 juni de opschorting van offline verkopen van de LABUBU-serie in Zuid-Korea aan, vanwege de grootschalige chaos die door de verkoop werd veroorzaakt. Consumenten stonden de hele nacht in de rij, fysieke conflicten kwamen vaak voor en zelfs de politie moest ingeschakeld worden om de orde te handhaven. Het bedrijf nam deze beslissing op basis van veiligheidsoverwegingen en bood publiekelijk excuses aan.</p>
<h2 id="h2-LABUBU20Wereldwijde20Hype20Van20Celebrity20Effect20naar20Sociale20Kapitaal982459"><a name="LABUBU Wereldwijde Hype: Van Celebrity Effect naar Sociale Kapitaal" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LABUBU Wereldwijde Hype: Van Celebrity Effect naar Sociale Kapitaal</h2><p>De meteoritische opkomst van LABUBU kan worden beschreven als een voorbeeldig cultureel fenomeen. Deze Noordse boself, gecreëerd door de Hongkongse kunstenaar Long Jiasheng, werd geboren in het prentenboek “De Mysterieus Buka” in 2015 en maakte in 2018 stilletjes zijn debuut in de vorm van een blind box van 59 yuan. Het echte keerpunt begon in 2024:</p>
<ul>
<li>Celebritaire endorsements verlichten de wereld: Koreaanse idool Lisa heeft de Zuidoost-Aziatische markt aangewakkerd door een LABUBU-selfie op Instagram te posten; in februari 2025 werd Rihanna gezien op de luchthaven van Los Angeles met een roze LABUBU-accessoire, wat haar een “internationaal paspoort” opleverde; vervolgens deelden wereldsterren zoals David Beckham en Liu Yifei foto’s van hun kinderen, met gerelateerde TikTok-onderwerpen die meer dan 1 miljard weergaven overschreden.</li><li>Veiling- en tweedehandsmarktprijzen stijgen: naast het veilingrecord van 1,08 miljoen yuan, overschrijdt de tweedehandsprijs van een standaard blind box die oorspronkelijk 99 yuan kostte de 2300 yuan; de samenwerkingsmodellen zijn nog gekker, met het LABUBU x Vans-model dat van 599 yuan naar 27999 yuan stijgt, een premie van 47 keer.</li><li>De opkomst van de derivaten economie: De jonge mensen in China stijgen in de “baby-opvoeding trend”, met LABUBU babykleding die populair verkoopt op Taobao (de verkoop van de floppy-eared konijnenoutfit overschreed 3.000 stuks); “baby transformers” vragen 300 yuan voor een enkele aanpassing, met topverdieners die een vijfcijferig maandelijks inkomen verdienen; het heeft zelfs geleid tot de “baby huur economie”, met LABUBU beschikbaar voor dagelijkse verhuur op Xianyu voor 30 yuan, en een borg van 500 yuan.</li></ul>
<h2 id="h2-Prijsvoorspelling20Drie20mogelijkheden20in20de20frenzy874264"><a name="Prijsvoorspelling: Drie mogelijkheden in de frenzy" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prijsvoorspelling: Drie mogelijkheden in de frenzy</h2><p>Naarmate de financiële attributen van LABUBU sterker worden, zijn de <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Prijs trend</a> Zeer gedifferentieerde kenmerken:</p>
<h2 id="h2-Fysieke20verzamelbare20speelgoed20Schaarstegedreven20gelaagde20premies520383"><a name="Fysieke verzamelbare speelgoed: Schaarste-gedreven gelaagde premies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fysieke verzamelbare speelgoed: Schaarste-gedreven gelaagde premies</h2><ul>
<li>Standaard editie: Oorspronkelijke prijs van 99 yuan blind box, verborgen editie tweedehands prijs constant boven de 2000 yuan</li><li>Beperkte editie: Bijvoorbeeld, de “Valentijnsdag Serie” die in april 2025 werd uitgebracht, steeg de tweedehandsprijs binnen twee maanden van 2600 yuan naar 8000 yuan.</li><li>Verzamelbare graad: De eerste generatie grote werken zijn de veilingmarkt van het miljoenniveau binnengekomen, en er is nog ruimte voor waardestijging als ze in de toekomst co-branded worden met top luxe merken zoals LV en Chanel.</li></ul>
<h2 id="h2-LABUBU20Coin20Hoogrisico20speculatie20op20Solana936782"><a name="LABUBU Coin: Hoog-risico speculatie op Solana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LABUBU Coin: Hoog-risico speculatie op Solana</h2><p>Let op dat deze token niet gerelateerd is aan de officiële Pop Mart en een door de gemeenschap uitgegeven Meme-munt is, die typische kenmerken vertoont van scherpe stijgingen en dalingen. Eerder heeft LABUBU ooit een marktkapitaal van 70 miljoen dollar doorbroken en is momenteel teruggevallen naar ongeveer 44 miljoen dollar:</p>
<ul>
<li>Optimistisch scenario (marktkapitalisatie boven de 100 miljoen): Als een nieuwe samenwerking of IP wordt aangepast in een film, in combinatie met noteringen op reguliere beurzen, zou het een marktkapitalisatie van 100 miljoen dollar kunnen bereiken.</li><li>Neutraal scenario: De populariteit van trendy speelgoed is stabiel, en de Token fluctueert in het bereik van 0,0006-0,0009 USD.</li><li>Pessimistisch scenario: Als de regelgeving op Meme-munten ingrijpt of de hype vervaagt, is het risico om naar nul te gaan extreem hoog.</li></ul>
<h2 id="h2-Industrie20Impact20en20Rationele20Waarschuwing607263"><a name="Industrie Impact en Rationele Waarschuwing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Industrie Impact en Rationele Waarschuwing</h2><p>De uitbraak van LABUBU heeft het industrie-landschap rechtstreeks herschreven:</p>
<ul>
<li>De financiële rapportage van Pop Mart voor 2024 toont aan dat de THE MONSTERS-serie, waartoe LABUBU behoort, een omzet van 3,04 miljard yuan genereerde, een jaar-op-jaar stijging van 726,6%, wat 23,3% bijdroeg aan de totale omzet van de groep.</li><li>In Q1 2025 steeg de omzet uit het buitenland met 475%-480% jaar-op-jaar, met oprichter Wang Ning die streeft naar een totale omzet van meer dan 20 miljard yuan in 2025.</li></ul>
<p>Koude gedachten achter de razernij: Meerdere analisten wijzen erop dat wanneer trendy speelgoed sociaal kapitaal en investeringsinstrumenten worden, hun prijzen afwijken van de kostenlogica en het kapitaalwaarderingssysteem binnengaan. Voormalig verzamelaar Cheng Luo geeft toe: “De tweedehandsprijs van LABUBU nadert zijn piek,” en novice verzamelaars zouden moeten vermijden om blindelings hoge prijzen na te jagen; ze moeten een diepgaand begrip van de IP-waarde verkrijgen en hun economische capaciteiten beoordelen.</p>
<p>Het magische verhaal van LABUBU weerspiegelt de ingrijpende veranderingen in de consumptielogica van Generatie Z - een premie betalen voor emotionele erkenning en het financieel maken van sociaal kapitaal. De toekomst van deze “plastic Moutai” hangt niet alleen af van de vraag of Pop Mart de vitaliteit van zijn IP kan behouden, maar test ook het vermogen van de markt om te onderscheiden tussen virtuele en echte bubbels.</p>
<p>Immers, ware waarde ontstaat nooit aan het einde van een spelletje waarbij het pakketje wordt doorgegeven, of het nu de pop is die in de hand wordt gehouden of de crypto-tokens op de keten.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="2">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>