TGFidWJ1IFVsdGltZSBOb3RpemllOiBMQUJVQlUgQ29pbiBzdXBlcmEgYnJldmVtZW50ZSBpIDcwIG1pbGlvbmkgZGkgZG9sbGFyaQ==

2025-06-17, 07:24

<p><img src="https://gimg2.gateimg.com/image/labu202506171523123679498972.png" alt="">
</p><p>Il 10 giugno 2025, alla Yongle Spring Auction, un LABUBU di colore menta unico è stato venduto per 1,08 milioni di yuan, con l’identità dell’acquirente non divulgata. Un altro LABUBU marrone in edizione limitata, uno dei soli 15 realizzati, è stato venduto per un prezzo elevato di 820.000 yuan, portando la popolarità di mercato di questo “brutto-cute piccolo mostro” a un nuovo livello.</p>
<p>Solo tre giorni dopo, la filiale coreana di Pop Mart ha annunciato il 14 giugno la sospensione delle vendite offline della serie LABUBU in Corea del Sud a causa del caos su larga scala scatenato dalle vendite. I consumatori si sono messi in fila per tutta la notte, si sono verificati frequenti conflitti fisici e sono stati necessari anche agenti di polizia per mantenere l’ordine. L’azienda ha preso questa decisione per motivi di sicurezza e si è scusata pubblicamente.</p>
<h2 id="h2-LABUBU20Global20Craze20DallEffetto20Celebrit20al20Capitale20Sociale359911"><a name="LABUBU Global Craze: Dall’Effetto Celebrità al Capitale Sociale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LABUBU Global Craze: Dall’Effetto Celebrità al Capitale Sociale</h2><p>L’ascesa meteoria di LABUBU può essere descritta come un fenomeno culturale da manuale. Questo elfo della foresta nordica, creato dall’artista di Hong Kong Long Jiasheng, è nato nel libro illustrato “Il misterioso Buka” nel 2015 e ha fatto il suo debutto silenzioso nel 2018 sotto forma di un blind box da 59 yuan. Il vero punto di svolta è iniziato nel 2024:</p>
<ul>
<li>Le sponsorizzazioni delle celebrità accendono il mondo: l’idolo coreano Lisa ha acceso il mercato del sud-est asiatico postando un selfie LABUBU su Instagram; nel febbraio 2025, Rihanna è stata avvistata all’aeroporto di Los Angeles con un accessorio LABUBU rosa, guadagnandosi un “pass internazionale”; successivamente, stelle globali come David Beckham e Liu Yifei hanno condiviso foto dei loro figli, con argomenti correlati su TikTok che superano 1 miliardo di visualizzazioni.</li><li>I prezzi del mercato delle aste e dell’usato schizzano: oltre al record d’asta di 1,08 milioni di yuan, il prezzo di secondo mano di una scatola cieca standard originariamente valutata 99 yuan supera i 2300 yuan; i modelli in collaborazione sono addirittura più folli, con il modello LABUBU x Vans che schizza da 599 yuan a 27999 yuan, un premio di 47 volte.</li><li>L’emergere dell’economia dei derivati: i giovani cinesi stanno emergendo nella “tendenza alla cura dei bambini”, con i vestiti per bambini LABUBU che riscuotono grande successo su Taobao (la vendita del costume da coniglio con orecchie flosce ha superato le 3.000 unità); i “trasformatori di bambini” addebitano 300 yuan per una singola modifica, con i migliori guadagnatori che realizzano un reddito mensile a cinque cifre; ha persino dato origine all’”economia del noleggio di bambini”, con LABUBU disponibile per il noleggio giornaliero su Xianyu a 30 yuan e un deposito di 500 yuan.</li></ul>
<h2 id="h2-Previsione20dei20prezzi20tre20possibilit20nella20frenesia907353"><a name="Previsione dei prezzi: tre possibilità nella frenesia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Previsione dei prezzi: tre possibilità nella frenesia</h2><p>Con il rafforzamento delle attribuzioni finanziarie di LABUBU, il suo <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Andamento dei prezzi</a> Caratteristiche altamente differenziate:</p>
<h2 id="h2-Giocattoli20collezionabili20fisici20Premi20a20livelli20guidati20dalla20scarsit518807"><a name="Giocattoli collezionabili fisici: Premi a livelli guidati dalla scarsità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Giocattoli collezionabili fisici: Premi a livelli guidati dalla scarsità</h2><ul>
<li>Edizione standard: Prezzo originale del blind box di 99 yuan, prezzo del secondo mano dell’edizione nascosta costantemente sopra i 2000 yuan</li><li>Edizione limitata: Ad esempio, la “Serie del Giorno di San Valentino” rilasciata nell’aprile 2025, il prezzo di seconda mano è salito da 2600 yuan a 8000 yuan in due mesi.</li><li>Grado collezionabile: Le opere di grandi dimensioni di prima generazione sono entrate nel mercato delle aste a livello milionario e c’è ancora margine di apprezzamento se co-branded con marchi di lusso di alto livello come LV e Chanel in futuro.</li></ul>
<h2 id="h2-LABUBU20Coin20Speculazione20ad20alto20rischio20su20Solana990392"><a name="LABUBU Coin: Speculazione ad alto rischio su Solana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LABUBU Coin: Speculazione ad alto rischio su Solana</h2><p>Si noti che questo token non è correlato al Pop Mart ufficiale ed è una moneta Meme emessa dalla comunità, che presenta caratteristiche tipiche di forti aumenti e diminuzioni. In precedenza, LABUBU aveva superato un valore di mercato di 70 milioni di dollari, e attualmente è tornato a circa 44 milioni di dollari:</p>
<ul>
<li>Scenario ottimistico (capitalizzazione di mercato superiore a 100 milioni): Se una nuova collaborazione o un IP viene adattato in un film, insieme a quotazioni su scambi mainstream, potrebbe raggiungere una capitalizzazione di mercato di 100 milioni di dollari.</li><li>Scenario neutro: La popolarità dei giocattoli alla moda è stabile e il Token oscilla nella fascia di 0,0006-0,0009 USD.</li><li>Scenario pessimista: Se le normative colpiscono le monete Meme o l’entusiasmo svanisce, il rischio di arrivare a zero è estremamente alto.</li></ul>
<h2 id="h2-Impatto20sullindustria20e20avvertimento20razionale205868"><a name="Impatto sull’industria e avvertimento razionale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Impatto sull’industria e avvertimento razionale</h2><p>L’epidemia di LABUBU ha riscritto direttamente il panorama dell’industria:</p>
<ul>
<li>Il rapporto finanziario del 2024 di Pop Mart mostra che la serie THE MONSTERS, a cui appartiene LABUBU, ha generato un fatturato di 3,04 miliardi di yuan, con un incremento anno su anno del 726,6%, contribuendo al 23,3% del fatturato totale del gruppo.</li><li>Nel Q1 del 2025, il fatturato estero è aumentato del 475%-480% anno su anno, con il fondatore Wang Ning che punta a un fatturato totale che superi i 20 miliardi di yuan nel 2025.</li></ul>
<p>Pensieri Freddi Dietro il Frenesia: Molti analisti sottolineano che quando i giocattoli di tendenza diventano capitale sociale e strumenti di investimento, i loro prezzi si discostano dalla logica dei costi e entrano nel sistema di valutazione del capitale. L’ex collezionista Cheng Luo ammette: “Il prezzo di seconda mano di LABUBU si avvicina al suo picco,” e i collezionisti novizi dovrebbero evitare di inseguire ciecamente i prezzi elevati; devono acquisire una profonda comprensione del valore IP e valutare le proprie capacità economiche.</p>
<p>La narrativa magica di LABUBU riflette i profondi cambiamenti nella logica di consumo della Generazione Z - pagare un premio per il riconoscimento emotivo e finanziare il capitale sociale. Il futuro di questo “Moutai di plastica” dipende non solo dalla capacità di Pop Mart di sostenere la vitalità del suo IP, ma anche dalla capacità del mercato di discernere tra bolle virtuali e reali.</p>
<p>Dopo tutto, il vero valore non nasce mai dalla fine di un gioco di passare il pacchetto, sia esso la bambola tenuta in mano o i token crypto sulla catena.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui presente non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o proibire l'uso totale o parziale dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <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>