Q2lyY2xlIFJhY2VzIFRvd2FyZCBJUE8g4oCUIEthbiBVU0RDIFRldGhlcuKAmXMgVHJvb24gVWl0ZGFnZW4/

<p><img src="https://gimg2.gateimg.com/image/circle202506031527382162592302.png" alt="">
</p><p>De cryptocurrency-industrie heeft een mijlpaalmoment bereikt, aangezien Circle, de op één na grootste stablecoin-uitgever ter wereld, officieel begint aan de weg naar een notering op de New York Stock Exchange, met een dubbele spel van kapitaal en naleving die zich ontvouwt.</p>
<p>Op 28 mei 2025 diende Circle zijn nieuwste IPO-aanvraag in bij de U.S. Securities and Exchange Commission (SEC), met plannen om 24 miljoen Class A gewone aandelen uit te geven tegen een prijs van $24 tot $26 per aandeel, met als doel tot $624 miljoen aan financiering op te halen.</p>
<p>Als berekend op basis van de bovengrens van de prijsklasse, zal de volledig verwaterde waardering van Circle 6,7 miljard USD bereiken, ver boven de verwachte 5 miljard USD in april.</p>
<p>De crypto-gigant die de stablecoin USDC met een marktwaarde van $60 miljard ondersteunt, zal worden genoteerd op de New York Stock Exchange onder de aandelencode CRCL. JPMorgan, Citigroup en Goldman Sachs zijn de hoofduitgevers voor deze uitgifte.</p>
<h2 id="h2-Draaien20en20wendingen20de20IPOmarathon20van20Circle869265"><a name="Draaien en wendingen, de IPO-marathon van Circle" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Draaien en wendingen, de IPO-marathon van Circle</h2><p>De weg naar de beursnotering van Circle kan als hobbelig worden omschreven. Dit is het derde poging van het bedrijf om de publieke markt te bereiken.</p>
<p>Al in 2021 probeerde Circle openbaar te worden via een SPAC (Special Purpose Acquisition Company) fusie, met een waardering van maar liefst $9 miljard. Echter, door strengere controle door de SEC viel de deal uiteindelijk aan het einde van 2022 door de mand.</p>
<p>In 2018 toonde Circle interesse in de openbare markt, maar kreeg te maken met een crypto berenmarkt, met een waardedaling van 75%, en het plan werd in de ijskast gezet.</p>
<p>De sleutel tot het succes van deze IPO ligt in de verschuiving in de regelgevende omgeving. De regering-Trump heeft expliciet de ontwikkeling van cryptocurrencies ondersteund, met de belofte om van de Verenigde Staten een ‘wereldwijde crypto-hub’ te maken en de vooruitgang van de wetgeving rond stablecoins te versnellen.</p>
<p>De “GENIUS Act” is goedgekeurd met een stem in de Bankcommissie van de Senaat, waarbij vereist wordt dat de reserve-activa van stablecoins voor 100% gedekt zijn door contanten of contante equivalenten, waardoor de weg vrijgemaakt wordt voor conforme bedrijven zoals Circle.</p>
<h2 id="h2-De20strategische20opzet20achter20de20waardering20van206720miljard20USD377862"><a name="De strategische opzet achter de waardering van 6,7 miljard USD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De strategische opzet achter de waardering van 6,7 miljard USD</h2><p>De recent openbaar gemaakte IPO-documenten onthullen de strategische stappen van Circle: in januari 2025 voltooide het bedrijf de volledige overname van de getokeniseerde startup Hashnote voor $99,8 miljoen.</p>
<p>De transactie omvat $9,9 miljoen in contanten en ongeveer 2,9 miljoen aandelen van Circle gewone aandelen, wat de ambitie onderstreept om uit te breiden naar de getokeniseerde Amerikaanse staatsobligatiemarkt.</p>
<p>De oprichters van Circle, Jeremy Allaire en Sean Neville, behouden de controle over het bedrijf. Hun Class B-aandelen hebben vijf stemmen per aandeel, wat ervoor zorgt dat ze de richting van het bedrijf kunnen blijven sturen na de beursgang.</p>
<p>Institutionele investeerders tonen sterk vertrouwen. ARK Invest, geleid door Cathie Wood, heeft zich gecommitteerd om voor $150 miljoen aan Circle-aandelen te kopen, en wordt daarmee een van de grootste ankerinvesteringen in deze IPO.</p>
<h2 id="h2-Stablecoinoorlogen20compliancevoordelen20versus20marktomvang901291"><a name="Stablecoin-oorlogen, compliance-voordelen versus marktomvang" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stablecoin-oorlogen, compliance-voordelen versus marktomvang</h2><p>Als de uitgever van USDC neemt Circle een belangrijke positie in de stablecoinmarkt in.</p>
<ul>
<li>Marktwaarde van 60 miljard USD, de op een na grootste USD-stablecoin ter wereld.</li><li>In mei 2024 bereikte het handelsvolume 230,8 miljard USD, wat sterke liquiditeit aantoont.</li><li>Met $25 biljoen aan on-chain transacties, wordt het de kerninfrastructuur van het DeFi-ecosysteem.</li></ul>
<p>De concurrent ervan <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>(USDT) staat nog steeds op de eerste plaats met een markwaarde van 140 miljard USD, maar de nalevingsvoordelen van Circle worden steeds prominenter.</p>
<p>Met <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> De controversiële transparantiekwesties verschillen, aangezien Circle regelmatig reservebewijzen publiceert die zijn gecontroleerd door topaccountantskantoren, geldtransmissielicenties heeft verkregen in meerdere staten in de Verenigde Staten en regulatorische doorbraken heeft gerealiseerd in belangrijke markten zoals Europa en Japan.</p>
<p>Naarmate de GENIUS-wet vordert, staat <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> onder grotere regelgevende druk, terwijl Circle’s transparantiestrategie een belangrijk wapen kan worden in zijn strijd om marktaandeel.</p>
<h2 id="h2-Winstmodel20de20drukpers20van20het20digitale20tijdperk141506"><a name="Winstmodel, de “drukpers” van het digitale tijdperk?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Winstmodel, de “drukpers” van het digitale tijdperk?</h2><p>De zakelijke logica van stablecoins is behoorlijk ingenieus: nadat gebruikers hun Amerikaanse dollars hebben omgewisseld voor USDC, investeert Circle de fondsen in laag-risico activa zoals Amerikaanse staatsobligaties en geldmarktfondsen om renteverschillen te verdienen.</p>
<p>Tijdens de hoge rente cyclus van 2022 tot 2024 overschreden de Amerikaanse staatsobligatierendementen tijdelijk 5%, wat aanzienlijke winst opleverde voor uitgevers van stablecoins.</p>
<p>In 2024 behaalde Circle een omzet van $1,68 miljard, een stijging ten opzichte van $1,5 miljard in 2023. Echter, de nettowinst daalde van $268 miljoen in 2023 naar $156 miljoen.</p>
<p>In tegenstelling, Tether’s winst bereikte in 2024 zelfs een hoogtepunt van $13 miljard, waarmee het de grootste vermogensbeheerder ter wereld, BlackRock, overtrof. Dit benadrukt het belang van Circle om de schaal van USDC uit te breiden om de winstgevendheid te vergroten.</p>
<h2 id="h2-De20golf20van20crypto20IPOs20een20signaal20voor20traditioneel20kapitaal20om20binnen20te20komen858346"><a name="De golf van crypto IPO’s, een signaal voor traditioneel kapitaal om binnen te komen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>De golf van crypto IPO’s, een signaal voor traditioneel kapitaal om binnen te komen.</h2><p>De IPO van Circle is een mijlpaal voor cryptocurrencybedrijven die de traditionele kapitaalmarkten omarmen. Bitwise voorspelt dat er tegen 2025 mogelijk 5 cryptocurrencybedrijven naar de beurs zullen gaan, waaronder Kraken, Figure, Anchorage Digital en Chainalysis.</p>
<p>Dit zal de grootste cryptocurrency bedrijf IPO worden sinds Coinbase in 2021 naar de beurs ging.</p>
<p>De samenwerking tussen Coinbase en Circle biedt laatstgenoemde unieke voordelen. In 2018 lanceerden de twee bedrijven gezamenlijk USDC, waarbij Coinbase niet alleen aandelen in Circle bezit, maar ook actief de toepassing van USDC via zijn platform promoot.</p>
<p>Met de recente succesvolle IPO’s van cryptocurrencybedrijven zoals Galaxy Digital, versnelt de vraag naar traditionele kapitaalallocatie in de blockchainsector de vrijgave via het IPO-kanaal.</p>
<p>De bel in de handelszaal van de New York Stock Exchange staat op het punt te luiden voor de CRCL-code. De beursdocumenten van Circle tonen aan dat de oprichters van het bedrijf, Jeremy Allaire en Sean Neville, de controle over het bedrijf zullen behouden door Class B super-stemmingsaandelen te houden.</p>
<p>Tegelijkertijd heeft Cathie Wood’s ARK Invest beloofd om voor $150 miljoen aan aandelen te kopen, waardoor het de grootste ankerinvestor in deze uitgifte wordt.</p>
<p>Na een succesvolle notering zal Circle het grootste cryptocurrencybedrijf worden dat sinds Coinbase in 2021 de Amerikaanse hoofdmarkt betreedt. De prestaties zullen het niveau van de erkenning van traditioneel kapitaal voor het stablecoin-businessmodel testen en invloed hebben op de noteringsbeslissingen van cryptobedrijven zoals Kraken en Figure.</p>
<p>De tweede helft van de stablecoin-oorlog zal het concurrentielandschap veranderen met de herbevoorrading van munitie op de kapitaalmarkt.</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="3">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>