RGUgZWVyc3RlIHN0YWJsZWNvaW4gSVBPIGlzIGhpZXIhIENpcmNsZSBzdGFhdCBnZW5vdGVlcmQgb3AgZGUgTllTRSBlbiBoYWFsdCAkMSwxIG1pbGphcmQgb3Au

2025-06-05, 09:51

<p><img src="https://gimg2.gateimg.com/image/cir202506051750221120324714.png" alt="">
</p><p>Vandaag (5 juni 2025) logt de wereldwijde stablecoin-gigant Circle Internet Group officieel in op de New York Stock Exchange, met het aandelencode CRCL, en wordt daarmee de eerste stablecoin-uitgever ter wereld die een IPO voltooit. Het bedrijf heeft 34 miljoen aandelen uitgegeven tegen een prijs van $31 per aandeel, wat de eerder verwachte prijsrange van $27-28 overschrijdt, met een totaal opgehaald bedrag van $1,1 miljard en een waardering die stijgt naar $6,9 miljard (tot $8,1 miljard volledig verwaterd). Deze notering is niet alleen een mijlpaal voor Circle na zeven jaar inspanningen, maar markeert ook de officiële entree van stablecoins in het mainstream kapitaalmarktfase.</p>
<h2 id="h2-Oversubscribtie20van202520keer20markvertrouwen20achter20institutionele20aankopen410709"><a name="Oversubscribtie van 25 keer, markvertrouwen achter institutionele aankopen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Oversubscribtie van 25 keer, markvertrouwen achter institutionele aankopen.</h2><p>Het IPO-proces van Circle kan worden beschreven als een feest van vraag. Aanvankelijk was het de bedoeling om 24 miljoen aandelen uit te geven tegen een prijs van $24-26, maar door de hoge enthousiasme van investeerders steeg de uiteindelijke uitgifte naar 34 miljoen aandelen, met de prijs die steeg naar $31. De inschrijvingsorders overschreden het beschikbare aantal aandelen met 25 keer, met giganten zoals BlackRock (die van plan was om 10% van de aandelen te onderschrijven) en “Cathie Wood”s ARK Investment Management (van plan om $150 miljoen te onderschrijven) die de strijd aangingen. Het underwritingteam wordt geleid door JPMorgan Chase, Citigroup en Goldman Sachs, en zij ontvingen nog eens 5,1 miljoen aandelen in over-allotment rechten.</p>
<p>De markt’s <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">optimisme</a> naar CRCL voortkomt uit twee kernlogica’s:</p>
<ol>
<li>Compliance Barrières: Circle heeft meerdere vergunningen, waaronder de New York BitLicense, ondergaat regelmatige audits door de Big Four en bouwt een bescherming op te midden van verscherpte regelgeving.</li><li>Beleidsdividenden: De Amerikaanse Senaat bevordert de GENIUS Act, Hong Kong geeft de stablecoin-regelgeving uit, en het wereldwijde regelgevingskader verduidelijkt, wat de toegang van traditionele financiële instellingen versnelt.</li></ol>
<h2 id="h2-Het20Rijk20van20USDC41367"><a name="Het Rijk van USDC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het Rijk van USDC</h2><p>Als de kernactivum van Circle heeft de USD-stablecoin USDC momenteel een circulatie van 61 miljard dollar, goed voor 29% van het wereldwijde marktaandeel van stablecoins, slechts tweede na <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT (accounting for 64%). Het businessmodel is zeer gefocust:</p>
<ul>
<li>Omzetstructuur: In 2024 bedraagt de totale omzet 1,676 miljard USD, waarvan 99% komt uit de rente-inkomsten van USDC-reserves (voornamelijk geïnvesteerd in kortlopende Amerikaanse staatsobligaties en bankdeposito’s);</li><li>Inkomstendelingmechanisme: Volgens de overeenkomst met Coinbase moet Circle 50% van de resterende winst, na aftrek van de operationele kosten, delen met de andere partij, wat resulteert in distributiekosten die in 2024 maar liefst 61% van de reserve-inkomsten uitmaken.</li></ul>
<p>Financiële prestaties benadrukken de kenmerken van de sector: Nettowinst van $268 miljoen in 2023, dalend naar $156 miljoen in 2024, voornamelijk beïnvloed door de krimp van handelsdiensten, maar het behalen van winstgevendheid voor twee opeenvolgende jaren is al een benchmark in de crypto-ruimte.</p>
<h2 id="h2-Triljoen20Dollar20Markt20en20Grijze20Neushoorn20Risicos20De20Dubbele20Toekomst20van20Stablecoins795952"><a name="Triljoen Dollar Markt en Grijze Neushoorn Risico’s: De Dubbele Toekomst van Stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Triljoen Dollar Markt en Grijze Neushoorn Risico’s: De Dubbele Toekomst van Stablecoins</h2><p>De notering van Circle komt op een moment van explosieve groei voor de stablecoin-industrie: de wereldwijde marktkapitalisatie heeft de 250 miljard USD overschreden en kan binnen vijf jaar 3 biljoen USD bereiken. Het groeimomentum is duidelijk:</p>
<ul>
<li>Vraag naar crypto-infrastructuur: Als een ruilmiddel en een waardeopslag zijn stablecoins de kerninfrastructuur van DeFi en grensoverschrijdende betalingen;</li><li>Traditionele financiële infiltratie: Instellingen zoals PayPal (PYUSD) en Fidelity betreden de markt en bevorderen de tokenisatie van RWA (real-world assets) en de diepe integratie van stablecoins.</li></ul>
<p>Maar de schaduw van risico kan ook niet worden genegeerd:</p>
<ul>
<li>Rentegevoeligheid: Volgens het prospectus kan een renteverlaging van 1% door de Federal Reserve resulteren in een daling van $441 miljoen in de omzet van Circle;</li><li>Bankrunrisico: Tijdens de crisis van de Silicon Valley Bank in 2023 had Circle te maken met een tijdelijke depegging van USDC omdat $3,3 miljard aan reserves vastzat. Economen waarschuwen dat als stablecoins zich ontwikkelen tot “schaduwbanken”, grootschalige terugbetalingen een verkoop van Amerikaanse staatsobligaties kunnen uitlokken, wat de financiële stabiliteit bedreigt.</li></ul>
<p>Wanneer de bel rinkelt in de NYSE-handelszaal voor CRCL, merkte een trader op: “Dit is niet alleen een overwinning voor Circle, maar ook een keerpunt voor de integratie van cryptocurrency in het traditionele financiële systeem.”</p>
<p>Aangezien de USDC-reserves $53 miljard overschrijden (beheerd door BlackRock), en RWA de implementatie versnelt in scenario’s zoals groene energie en grensoverschrijdende afwikkeling, kan de notering van Circle een nieuw tijdperk van mondiale allocatie van on-chain activa inluiden—mits het de “dubbele ankers” van regelgeving en mark vertrouwen kan overwinnen.</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 enige 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="3">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>