V2F0IGlzIENSQ0w/IENSQ0wgUHJpanN2b29yc3BlbGxpbmcgdm9vciBkZSBUb2Vrb21zdA==

2025-07-02, 08:16

<p><img src="https://gimg2.gateimg.com/image/crcl202507021615064514777480.jpg" alt="">
</p><p>CRCL is de stockcode van Circle, de op een na grootste uitgever van de USD-stablecoin USDC, op de New York Stock Exchange. Als een belangrijk onderdeel van de crypto financiële infrastructuur beheert Circle een grote reserve aan activa door USDC uit te geven, dat is gekoppeld aan de Amerikaanse dollar in een 1:1 verhouding (met een huidige marktkapitalisatie van ongeveer $60 miljard), en investeert de fondsen in veilige activa zoals kortlopende Amerikaanse staatsobligaties om rente-inkomsten te genereren als zijn kerninkomstenbron. Zijn marktaandeel bedraagt 29% van de wereldwijde stablecoin-markt, slechts tweede na <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT, en door strikte compliance-audits en transparante reserve-openbaringen, is de voorkeursweg geworden voor traditionele instellingen zoals JPMorgan om de crypto-wereld binnen te treden. Op 5 juni 2025 werd het de eerste stablecoin-onderneming die op de New York Stock Exchange werd genoteerd, gezien door de kapitaalmarkt als een mijlpaal in de mainstreaming van crypto-financiering.</p>
<h2 id="h2-Gekke20IPOdebuut20Drie20handelsstoppen20en20kapitaalgekte526967"><a name="Gekke IPO-debuut: Drie handelsstoppen en kapitaalgekte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gekke IPO-debuut: Drie handelsstoppen en kapitaalgekte</h2><p>De beursgang van Circle kan worden omschreven als “fenomenaal”. De uitgifteprijs was vastgesteld op $31, waarmee $1,054 miljard werd opgehaald, maar deze steeg met 122% naar $69 op het moment van opening, met een intraday hoogtepunt van $103,75 (een stijging van 235%), wat leidde tot drie handelsstops vanwege extreme volatiliteit. Uiteindelijk sloot het op de eerste dag op $83,23, een stijging van 168,5%, met een marktkapitalisatie die steeg naar $18,4 miljard (ongeveer 130 miljard RMB).</p>
<p>De volgende dag steeg de prijs van CRCL verder naar $107,7, met een marktkapitalisatie van meer dan $21,6 miljard. Achter de explosieve groei schuilt de frantic kapitaalrush: de emissie was 25 keer overtekend, met BlackRock die een belang van 10% veiligstelde en ARK Invest voor $150 miljoen aan aandelen kocht. De vraag dwong Circle om de emissiegrootte en prijs drie keer te verhogen, waarbij het oorspronkelijke plan van 24 miljoen aandelen tegen $24-26 werd uitgebreid naar 34 miljoen aandelen tegen $31.</p>
<h2 id="h2-Prijsvoorspelling20Rationele20Terugtrekkingen20en20Ondersteuning20Te20Midden20van20Hoge20Volatiliteit193663"><a name="Prijsvoorspelling: Rationele Terugtrekkingen en Ondersteuning Te Midden van Hoge Volatiliteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prijsvoorspelling: Rationele Terugtrekkingen en Ondersteuning Te Midden van Hoge Volatiliteit</h2><p>Na de notering zette CRCL aanvankelijk zijn opwaartse trend voort en bereikte eind juni een piek van $298,99 (een stijging van 860% ten opzichte van de IPO-prijs). Echter, een gebrek aan winstondersteuning op korte termijn leidde tot een scherpe terugval door waarderingsbubbels. Op 1 juli viel de aandelenprijs terug naar ongeveer $181,29, met een daling van meer dan 15% op één dag. Analisten suggereren dat het mogelijk een technische aanpassingsfase ingaat op korte termijn, met verwachte fluctuaties in het bereik van $150-200. De langetermijntrend zal afhangen van twee belangrijke factoren:</p>
<ol>
<li>Renteafhankelijkheid: Momenteel komt 99% van de inkomsten uit reserverente, en als de Federal Reserve de rente verlaagt, zal dit direct de winstmarges verkleinen.</li><li>Winstverificatie: In 2024 bedraagt de nettowinst van het bedrijf $156 miljoen, maar het moet de niet-rente-inkomsten (zoals betalingsvergoedingen en API-diensten) uitbreiden om de hoge waardering te ondersteunen. Beleggers moeten letten op de verificatie van de winstgevendheid in de winstverslagen voor de komende 1-2 kwartalen.</li></ol>
<h2 id="h2-Toekomstige20Uitdagingen20en20Kansen20Compliance20Dividenden20en20Ecologische20Doorbraken873566"><a name="Toekomstige Uitdagingen en Kansen: Compliance Dividenden en Ecologische Doorbraken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstige Uitdagingen en Kansen: Compliance Dividenden en Ecologische Doorbraken</h2><p>Ondanks een brede vooruitzicht, staat Circle nog steeds voor meerdere testen:</p>
<ul>
<li>Toenemende concurrentie: PayPal’s PYUSD, de marktaandeeluitbreiding van <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> en stablecoins die mogelijk door traditionele banken worden uitgegeven, zullen de marktruimte voor USDC onder druk zetten;</li><li>Kostendruk: In 2024 zal het betalen van $900 miljoen aan omzetdeling aan partner Coinbase, dat meer dan de helft van de omzet vertegenwoordigt, de werkelijke winsten verzwakken;</li><li>Systeemrisico: Het incident met Silicon Valley Bank leidde ooit tot de de-pegging van USDC, wat de kwetsbaarheden in de bewaring van reserve-activa blootlegde.</li></ul>
<p>Echter, de beleidswind kan de sleutel zijn tot het doorbreken van de impasse. De goedkeuring van de Amerikaanse “GENIUS Act” verwijdert obstakels voor conforme stablecoins, en Circle verwacht dit te benutten om zijn marktaandeel van 29% naar 40% te verhogen. Tegelijkertijd verkent het scenario’s zoals grensoverschrijdende betalingen en tokenisatie van staatsobligaties, waardoor USDC van een handelsinstrument naar een brug voor financiële infrastructuur wordt gepromoot.</p>
<p>Op het moment dat de CRCL-code op het NYSE-handelsplatform sprong van $31 naar $103, stortte de eeuwenoude barrière tussen traditionele financiën en de crypto-wereld in. De stijgende aandelenprijs is niet alleen een stem van kapitaal voor USDC, maar ook een goedkeuring van het transparante stablecoin-model. En de ware strijd van Circle,</p>
<p>Zachtjes ontvouwend vanuit de weerklank van de beursbel — hoe te zorgen dat de groene code met een marktwaarde van 18 miljard blijft schitteren temidden van de renteverlagingen en de omsingeling door giganten. De integratie van crypto-financiering en de reguliere kapitaalmarkten heeft de eerste stap gezet vanuit de brug van stablecoins.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, verzoek 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 gedeelte 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>