Q2lyY2xlIHZlcnRyb3V3dCBvcCAkMSBtaWxqYXJkIGFhbiBsaXF1aWRlIG1pZGRlbGVuIHRlIG1pZGRlbiB2YW4gZWVuIGFhbmJvZHRla29ydCBlbiBoZXZpZ2UgY29uY3VycmVudGll

<p><img src="https://gimg2.gateimg.com/image/article/1692707523RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen606292"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>De marktaandeel en kapitalisatie van USDC zijn sinds het begin van 2023 afgenomen.</p>
<p>PYUSD zal waarschijnlijk de grootste concurrentie vormen voor USDC zodra het op de markt komt.</p>
<p>De CEO van Circle heeft beloofd om het potentieel van USDC te herstellen door samenwerkingen en marktgroei.</p>
<h2 id="h2-Introductie825941"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Bedrijven die te maken hebben met stevige concurrentie, moeten stimulerende strategieën creëren om levensvatbaarheid te behouden en hun activiteiten uit te breiden. Er is geen twijfel dat de cryptosector vol zit met concurrentie als gevolg van het ontbreken van regelgeving. In dit artikel onderzoeken we maatregelen die Circle, een Amerikaanse stablecoin-uitgever, neemt om om te gaan met de toename van de concurrentie in de sector.</p>
<p>Circle reserveert $1 miljard om met marktdreigingen om te gaan<br>De stablecoin-uitgever, Circle, heeft een kasreserve van $1 miljard gereserveerd om eventuele mogelijke marktdreigingen aan te pakken te midden van de afnemende omloop van zijn stablecoin USDC. Circle, bekend om zijn stablecoin USDC, wordt geconfronteerd met toenemende concurrentie van de crypto-technologie-industrie en traditionele financiële spelers.</p>
<p>PayPal, dat onlangs zijn stablecoin PYUSD lanceerde, heeft voor veel concurrentie gezorgd voor Circle. We weten al dat Circle’s USDC, de op één na grootste stablecoin qua marktkapitalisatie, concurreert met andere sterke stablecoins zoals <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a> (BUSD), <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USD (USDT), DAI, <a href="/price/trueusd-tusd" rel="nofollow noopener noreferrer" target="_blank">TrueUSD</a>, <a href="/price/frax-frax" target="_blank" class="blog_inner_link">FRAX</a> en <a href="/price/usdd-usdd" rel="nofollow noopener noreferrer" target="_blank">USDD</a>, onder andere. In de volgende tabel staan de belangrijkste stablecoins.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692708971Circle 1.png" alt=""><br>Top 6 stabiele munten - <a href="https://www.coingecko.com/en/categories/stablecoins" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Zoals de tabel aangeeft, staat USDC met een marktkapitalisatie van $25.991.517.319 op de tweede plaats onder de stablecoins. Desondanks is de markt van Circle de afgelopen zeven maanden gekrompen.</p>
<p>Jeremy Allaire, Circle CEO, bevestigde tijdens een interview met Bloomberg dat er sterke concurrentie is in de sector. Hij zei: “Ik verwacht dat je veel, niet alleen internetbetalingenbedrijven, maar ook allerlei soorten financiële dienstverleners en anderen meer betrokken zult zien worden. Het is geweldig om deze nieuwe concurrentie te hebben. Ik denk wel dat het meer en meer bedrijven naar het veld zal drijven.”</p>
<p>In feite zal Circle Fintech bedrijf de $1 miljard aan contante reserves gebruiken om zich te beschermen tegen negatieve ontwikkelingen in de sector. Momenteel richt het bedrijf zich op het uitbreiden van zijn inkomstenstroom en het bevorderen van een grotere adoptie van USDC. Het genereert grotendeels zijn inkomsten uit de rente die wordt verdiend op de beleggingen die USDC ondersteunen, waaronder kortlopende schatkistpapier en dollardeposito’s.</p>
<p>Volgens Allaire zullen veel andere bedrijven hun stablecoins introduceren naar het voorbeeld van PayPal, wat waarschijnlijk de concurrentie zal vergroten en het marktaandeel van Circle zal verminderen. Hij merkte echter ook op dat veel stablecoins in de toekomst zullen instorten nadat verschillende regelgevers cryptoreguleringen introduceren.</p>
<p>Lees ook: <a href="https://www.gate.io/de/hot_news/detail/88/what-you-need-to-know-when-buying-bitcoin-with-paypal" target="_blank">Wat u moet weten bij het kopen van Bitcoin met PayPal</a></p>
<h2 id="h2-USDCmarkt20daalt550951"><a name="USDC-markt daalt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>USDC-markt daalt</h2><p>Hoewel Circle winst heeft geboekt in de eerste helft van dit jaar, voornamelijk door renteopbrengsten, is het marktaandeel van USDC de afgelopen maanden afgenomen. Bijvoorbeeld, het marktaandeel daalde van $45 miljard aan het begin van 2023 tot $26 miljard in juli. Er zijn verschillende redenen die hebben bijgedragen aan de afname van het marktaandeel van USDC.</p>
<p>Het is belangrijk op te merken dat de omloop van USDC sinds juni 2022 met meer dan 53% is afgenomen, toen het een marktkapitalisatie van $56 miljard had. Helaas is ook het marktaandeel gedaald tot 21%. Dit betekent dat er een afname is geweest in het aantal individuen en instellingen dat USDC-betalingen promoot.</p>
<p>Volgens Circle’s CEO, Allaire, was de belangrijkste oorzaak van de daling van de omloop van USDC de terugtrekking van Binance uit de munt ten gunste van zijn eigen stablecoin, <a href="/price/binance-usd-busd" target="_blank" class="blog_inner_link">Binance USD</a> (BUSD), momenteel gerangschikt als de op drie na beste stablecoin op basis van marktkapitalisatie.</p>
<p>Ten tweede was de USDC-stablecoin <a href="https://www.gate.io/blog_detail/2303/svb-crash-caused-the-butterfly-effect-in-the-crypto-market-what-should-investors-do" target="_blank">beïnvloed door het faillissement van Silicon Valley Bank</a> tijdens het eerste kwartaal van het jaar. In feite zat de $3,3 miljard USDC-reserves van Circle vast bij Silicon Valley Bank, een van de crypto-vriendelijke banken die door de Amerikaanse regelgevers werd gesloten, wat resulteerde in het depegen van USDC.</p>
<p>Na de Amerikaanse bankencrisis en het loskoppelen van USDC is de marktkapitalisatie bijna gehalveerd. Dit komt doordat veel investeerders het vertrouwen erin hebben verloren vanwege de loskoppeling.<br>Bovendien heeft het optreden van de Verenigde Staten tegen crypto-activiteiten een negatieve invloed gehad op de marktprestaties van USDC.</p>
<h2 id="h2-CEO20van20Circle20nog20steeds20optimistisch20over20USDC20en20andere20Stablecoins55908"><a name="CEO van Circle nog steeds optimistisch over USDC en andere Stablecoins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CEO van Circle nog steeds optimistisch over USDC en andere Stablecoins</h2><p>Volgens de CEO van Circle is er nog steeds veel hoop voor stablecoins ondanks de toename van de concurrentie. Op dit moment streeft Circle ernaar om nieuwe inkomstenbronnen te verkennen en het wereldwijde gebruik van USDC te vergroten om de daling van het marktaandeel tegen te gaan. Om haar wereldwijde expansie te bevorderen, werkt Circle aan het smeden van verschillende partnerschappen en het vergroten van de transparantie door middel van tijdige marktrapporten.</p>
<p>Op dezelfde manier streeft het bedrijf ernaar zich aan te passen aan de veranderende regelgeving. Daarom richt het zich op het verbeteren van zijn normen om zich gunstig te positioneren voor wereldwijde groei. Ondanks zijn negatieve financiële prestaties in de afgelopen zeven maanden, heeft Circle geprofiteerd. <a href="https://www.gate.io/blog_detail/1804/key-lessons-from-the-collapse-of-ftx-and-the-implosion-of-ftt" target="_blank">van de ineenstorting van FTX</a> en <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD dat destijds de groei van zijn marktaandeel bevorderde.</p>
<h2 id="h2-PayPals20PYUSD20concurreert20met20Circles20USDC387114"><a name="PayPals PYUSD concurreert met Circle’s USDC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>PayPals PYUSD concurreert met Circle’s USDC</h2><p>Eerder zeiden we dat de daling van USDC te wijten is aan een toename van concurrentie, onder andere factoren. Inderdaad, er is een toename geweest van het aantal stablecoins op de markt. Afgezien van <a href="https://www.gate.io/blog_detail/3034/daily-news-paypal-launched-a-us-dollar-stablecoin-pyusd-monetary-authority-of-singapore-supports-innovation-in-web3-industry-btc-volatility-dropped-to-historical-lows" target="_blank">PayPal’s PYUSD</a>, <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> De algoritmische GHO en Binance-ondersteunde First Digital USD (FDUSD) zijn onlangs op de markt gekomen.</p>
<p>Desalniettemin verwacht Circle de zwaarste concurrentie van PYUSD te krijgen. PayPal benadrukt dat zijn stablecoin volledig gedekt zal worden door stortingen in Amerikaanse dollars. Bovendien kunnen mensen het kopen en verkopen via de applicatie.</p>
<p>Verder zullen individuen PYUSD gebruiken om peer-to-peer betalingen te doen. Ze kunnen de munt overmaken naar en van andere geschikte digitale portefeuilles. Nog interessanter is dat PYUSD alle valuta zal ondersteunen die PayPal heeft. Dit betekent dat PYUSD-gebruikers de munt kunnen omzetten naar een van deze nationale valuta.</p>
<p>Dan Schulman, de president en CEO van PayPal, noemde de belangrijkste reden voor de lancering van zijn eigen stablecoin. Hij zei: “De verschuiving naar digitale valuta vereist een stabiel instrument dat zowel digitaal inheems is als gemakkelijk verbonden is met fiatvaluta zoals de Amerikaanse dollar.”</p>
<p>Paxos, een in New York gevestigd bedrijf dat gereguleerde blockchain-infrastructuur biedt aan verschillende crypto-projecten, is de uitgever van PYUSD die bestaat. <a href="https://www.gate.io/learn/articles/what-is-ethereum/42" target="_blank">op de Ethereum-blockchain</a> PayPal heeft al in 2022 zijn New York BitLicense verkregen, waarmee klanten cryptocurrencies kunnen kopen en verkopen.</p>
<p>De beslissing van PayPal om zijn eigen stablecoin te ontwikkelen is niet verrassend, aangezien de bedrijfsvoering het kopen, verkopen en overdragen van cryptocurrencies zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, ETH, <a href="https://www.gate.io/price/litecoin-ltc" target="_blank">Litecoin</a> en <a href="https://www.gate.io/price/bitcoin-cash-bch" target="_blank">Bitcoin Cash</a>.</p>
<h2 id="h2-Conclusie54721"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Circle heeft $1 miljard aan reservegeld gereserveerd om de USDC stablecoin te beschermen tegen negatieve marktontwikkelingen. De belangrijkste bedreiging waarmee de USDC wordt geconfronteerd, is de concurrentie van andere stablecoins, waaronder <a href="https://www.gate.io/price/tether-usdt" target="_blank">Tether USDT</a>, <a href="https://www.gate.io/price/binance-usd-busd" target="_blank">BUSD</a>, PYUSD en <a href="https://www.gate.io/price/dai-dai" target="_blank">DAI</a>. Echter neemt Circle maatregelen om met dergelijke concurrentie om te gaan.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-is-dai/178" target="_blank">Wat is Dai? Alles wat u moet weten over DAI</a></p>
<h2 id="h2-Veelgestelde20vragen20over20USDC155085"><a name="Veelgestelde vragen over USDC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over USDC</h2><h3 id="h3-Is20Circle20een20crypto20bedrijf495624"><a name="Is Circle een crypto bedrijf?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Circle een crypto bedrijf?</h3><p>Circle is een Fintech en crypto bedrijf dat het bezit en beheert <a href="https://www.gate.io/price/usd-coin-usdc" target="_blank">USDC (Verenigde Staten)</a> stablecoin. Het biedt ook zijn blockchain-infrastructuur aan crypto-projecten die gebruik willen maken van openbare blockchains en stablecoins voor online betalingen.</p>
<h3 id="h3-Is20Circle20een20stablecoin682407"><a name="Is Circle een stablecoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Circle een stablecoin?</h3><p>Circle is een fintech bedrijf met een levensvatbare blockchain-infrastructuur die andere crypto-projecten kunnen gebruiken. Het bezit USDC, een stablecoin gekoppeld aan de Amerikaanse dollar. Daarom is Circle geen stablecoin.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>