T25nZWJhbmtpZXJkZSBtZW5zZW4gd29yZGVuIGdlY29uZnJvbnRlZXJkIG1ldCBzbHVpdGluZyBhbHMgZ2V2b2xnIHZhbiByZWdlbGdldmluZ3NiZWxlbW1lcmluZ2VuIGVuIGZpbmFuY2llcmluZ3N1aXRkYWdpbmdlbg==

<p><img src="https://gimg2.gateimg.com/image/article/1686553887RDZZ.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen441992"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Unbanked heeft de operaties stopgezet vanwege het strenge regelgevende klimaat in de Verenigde Staten en de financiële uitdagingen waarmee het wordt geconfronteerd.</p>
<p>Unbanked heeft zijn klanten aangemoedigd om hun geld op te nemen, waaronder USD en cryptocurrencies</p>
<p>Het huidige onvriendelijke toezicht <a href="/price/optimism-op" target="_blank" class="blog_inner_link">op crypto</a> in de Verenigde Staten heeft veel cryptobedrijven gedwongen om te verhuizen naar andere landen.</p>
<h2 id="h2-Introductie347844"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Het jaar 2023 zal herinnerd worden als het jaar waarin veel financiële instellingen die crypto-diensten aanbieden gesloten werden en als het jaar waarin de strenge regelgevende controle van de Amerikaanse overheid op digitale activa en de cryptocurrency sector werd versterkt. In het eerste kwartaal hebben verschillende Amerikaanse banken <a href="https://www.gate.io/learn/articles/what-is-silvergate/509" target="_blank">inclusief Silvergate</a> en <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">Silicon Valley Bank gesloten</a> vanwege financieel wanbeheer en het ongunstige economische klimaat. Vandaag bespreken we andere aanstaande sluitingen van instellingen zoals Unbanked die verschillende diensten aanbieden aan de cryptosector.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2397/crashing-banks-push-crypto-towards-a-bull-market" target="_blank">Crashende banken duwen crypto richting een bullmarkt</a></p>
<h2 id="h2-Unbanked20wordt20gesloten974636"><a name="Unbanked wordt gesloten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Unbanked wordt gesloten</h2><p>Unbanked, de eigenaar van de UNBK-token en een aanbieder van verschillende financiële diensten, heeft onlangs aangekondigd dat het van plan is te sluiten vanwege een ongunstige regelgevingsomgeving en financiële uitdagingen. <a href="https://unbanked.com/unbanked-will-be-winding-down/" rel="nofollow noopener noreferrer" target="_blank">Het zei</a>,<br><strong>Vandaag hebben we de ongelukkige beslissing genomen om Unbanked af te bouwen. Toen we het bedrijf in 2018 oprichtten, wisten we dat blockchain de beste manier was om waarde over te dragen in de vorm van cryptocurrency of stablecoins.</strong>”</p>
<p>Volgens Unbanked heeft het alle mogelijke opties uitgeput om het bedrijf in stand te houden. Het zei: “<br><strong>Dit besluit om Unbanked af te bouwen is niet lichtvaardig genomen, maar we hebben alle opties uitgeput. De sluiting is niet gekomen door een gebrek aan inspanning om alle levensvatbare opties van ons team te verkennen.</strong>”</p>
<p>Over het algemeen is de regelgevende situatie voor crypto in de Verenigde Staten vijandig geweest, waardoor verschillende crypto-bedrijven gedwongen werden te sluiten. Op 9 mei kondigde Unbanked, de crypto financiële dienstverlener, zijn geplande sluiting aan.</p>
<p>Enkele van de financiële diensten die Unbanked aanbood, omvatten bankrekeningen en kaarten. Het maakte ook investeerders in staat om op een handige manier cryptocurrencies te kopen en verkopen, en ondersteunde ook de distributie van staking rewards. Sinds de oprichting in 2019 bood Unbanked financiële diensten aan in de Verenigde Staten en aan internationale entiteiten. In feite waren er 25 bedrijven in verschillende landen die gebruik maakten van zijn diensten.</p>
<h2 id="h2-Regelgevende20uitdagingen227466"><a name="Regelgevende uitdagingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regelgevende uitdagingen</h2><p>Het is belangrijk op te merken dat de regelgevende en economische uitdagingen in de Verenigde Staten veel cryptobedrijven over de hele wereld beïnvloeden, zelfs als ze geen directe zaken in dat land hebben. Dit komt doordat de belangrijke activiteiten die in de VS plaatsvinden, van invloed zijn op wereldwijde gebeurtenissen doordat andere landen in zijn voetsporen treden en ook door het besmettingseffect.</p>
<p>In feite werkt de Verenigde Staten hard om te voorkomen dat Fintech-bedrijven en financiële instellingen zoals banken cryptodiensten aanbieden of bedrijven ondersteunen die cryptocurrency-producten en -diensten leveren. Het maakt de federale overheid niet uit of deze financiële dienstverleners zich houden aan de wetgeving of niet. Het land treedt streng op tegen financiële dienstverleners die crypto-producten ondersteunen en dwingt hen om te sluiten of te verhuizen naar landen met crypto-vriendelijke regelgeving.</p>
<p>In een recente <a href="https://unbanked.com/unbanked-will-be-winding-down/" rel="nofollow noopener noreferrer" target="_blank">blogpost Unbanked zei</a>, “<br><strong>Amerikaanse toezichthouders proberen actief te voorkomen dat bedrijven (banken en fintechs) crypto-activa ondersteunen - zelfs wanneer de bedrijven proberen het op de juiste manier en volgens de regels te doen. Hun inspanningen werken en beperken uiteindelijk het vermogen van Unbanked om kapitaal op te halen en een zelfvoorzienend bedrijf te runnen.</strong>”</p>
<p>Unbanked maakte duidelijk dat het zich aan de meeste regelgevende vereisten in de Verenigde Staten hield. Echter, deze naleving droeg bij aan hoge kosten die het bedrijf beperkten.</p>
<p>Het zei: “We geloofden dat het bouwen van Unbanked aan wal in de Verenigde Staten de slimme langetermijnstrategie zou zijn. Terwijl andere cryptobedrijven snel groeiden buiten de kust door strenge regelgeving te vermijden, geloofden wij dat samenwerken met toezichthouders en het volgen van hun moeizame processen uiteindelijk Unbanked in staat zou stellen om voorop te lopen. We hebben helaas geleerd dat dit niet het g was en dat deze weg leidt tot veel verspilde tijd en buitensporige kosten.”</p>
<p>Unbanked is niet de enige instelling die met crypto-activa omgaat die negatief is beïnvloed door de regelgevingsobstakels die de sector in de Verenigde Staten treffen. BottlePay, HotBit, Beaxy, Bittrex, Teressa en TradeBlock zijn slechts enkele andere crypto-bedrijven die hun activiteiten hebben stopgezet vanwege strenge regelgevende voorwaarden.</p>
<p>Lees ook: <a href="https://www.gate.io/fr/blog_detail/384/" target="_blank">Cryptocurrency wetten in de Verenigde Staten en andere landen</a></p>
<p>Zo zei HotBit bijvoorbeeld dat het gesloten was na het onderzoek naar de meeste van zijn teamleden door de Amerikaanse regelgevende autoriteiten. Bittrex, dat faillissement heeft aangevraagd in een federale rechtbank in Delaware, verklaarde dat de regelgeving een van de redenen is voor de beslissing om de activiteiten stop te zetten. Alleen de Amerikaanse tak van het bedrijf heeft echter faillissement aangevraagd volgens hoofdstuk 11.</p>
<p>De sluiting van Bittrex volgde nadat het een Wells-bericht ontving van de Securities Exchange Commission (SEC). Deze Wellness-melding werd aan Bittrex gegeven op basis van het feit dat het opereerde als een makelaar-dealer, een clearinginstelling en een crypto-uitwisseling zonder registratie. Bovendien heeft de SEC OMG, ALGO en <a href="/price/dash-dash" target="_blank" class="blog_inner_link">DASH</a> genoteerd als crypto-effecten.</p>
<p>Helaas heeft de Securities Exchange Commission in het eerste kwartaal van 2023 verschillende handhavingsmaatregelen genomen tegen belangrijke spelers in de cryptosector, waaronder Coinbase. Aan de andere kant zet de SEC nog steeds haar zaak tegen Ripple voort. Deze voorbeelden tonen de toewijding van de SEC om de groei van de cryptocurrencysector te dwarsbomen door sommige cryptobedrijven te dwingen te sluiten.</p>
<h2 id="h2-Financile20situatie20van20mensen20zonder20bankrekening51636"><a name="Financiële situatie van mensen zonder bankrekening" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Financiële situatie van mensen zonder bankrekening</h2><p>De financiële situatie van de Unbanked heeft beperkingen toegevoegd aan de levensvatbaarheid van het bedrijf. Onlangs zei een medeoprichter van het bedrijf dat ze verwachtten dat er extra financiering zou komen om hun bedrijfsactiviteiten te ondersteunen. Desalniettemin heeft het niet de verwachte financiële injectie ontvangen. Het bedrijf gelooft dat de huidige regelgevingssituatie mogelijk heeft geleid tot het mislukken van de deal.</p>
<p>Het bedrijf legde uit: “Drie weken geleden heeft Unbanked een term sheet ondertekend voor een investering van $5 miljoen dollar tegen een waardering van $20 miljoen, waarmee we niet alleen onze activiteiten kunnen voortzetten maar ook kunnen uitbreiden. Tot op dit moment hebben we die fondsen nog niet ontvangen.”</p>
<p>Als gevolg van de huidige stand van zaken heeft Unbanked zijn klanten verzocht om hun geld op te nemen voordat het wordt gesloten. Het zei: “Alle Unbanked-klanten en degenen via onze white-label programma’s moeten zo snel mogelijk al hun geld (crypto en USD) beginnen op te nemen.”</p>
<h2 id="h2-Het20regelgevingslandschap20in20de20VS20legt20druk20op20cryptobedrijven324765"><a name="Het regelgevingslandschap in de VS legt druk op cryptobedrijven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het regelgevingslandschap in de VS legt druk op cryptobedrijven</h2><p>Sinds <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">de ineenstorting van FTX</a> de Verenigde Staten heeft een hardhandig optreden tegen veel cryptobedrijven waarvan het gelooft dat ze niet voldoen aan de crypto-regelgeving. In feite houdt het nauwlettend toezicht op het traditionele banksysteem en niet-traditionele banken.</p>
<p>Lees ook: <a href="https://www.gate.io/th/blog_detail/378/how-are-cryptocurrencies-currently-regulated-in-countries-around-the-world" target="_blank">Hoe worden cryptocurrencies momenteel gereguleerd in landen over de hele wereld?</a></p>
<p>De cryptogemeenschap beschuldigt Gary Gensler, de voorzitter van de SEC, van zijn voortdurende agressie tegen cryptocurrencies. Dit komt omdat de SEC de afgelopen maanden verschillende crypto-bedrijven heeft aangeklaagd voor hun onvermogen om wetgeving te volgen die virtuele activa, vooral cryptocurrencies, reguleert. Bijvoorbeeld in januari heeft SEC aangeklaagd. <a href="https://www.sec.gov/news/press-release/2023-7" rel="nofollow noopener noreferrer" target="_blank">Genesis Global Capital, LLC en Gemini Trust Company</a> voor de verkoop van niet-geregistreerde effecten. Het heeft ook aanklachten ingediend tegen Kraken voor dezelfde overtreding.</p>
<p>Veel crypto-insiders geloven daarom dat de actie van de SEC innovatie in de crypto-sector zal verstikken, andere bedrijven zal dwingen te sluiten en fintechbedrijven zal dwingen te verhuizen naar landen met crypto-vriendelijke wetgeving.</p>
<p>Naast de SEC zijn er andere overheidsinstanties die strijden tegen cryptocurrencies. Als voorbeeld hebben onlangs het Bureau van de Comptroller of the Currency (OCC), de Federal Reserve en de Federal Deposit Insurance Corporation (FDIC) actie ondernomen. <a href="https://www.axios.com/2023/02/23/major-banking-authorities-say-stablecoin-reserves-pose-liquidity-risk" rel="nofollow noopener noreferrer" target="_blank">waarschuwde banken voor liquiditeitsrisico’s</a> geassocieerd met stablecoins.</p>
<p>Tijdens het eerste kwartaal van 2023 heeft het New York Department of Financial Services Paxos, de uitgever van <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a>, om extra bijdrukken van de stablecoin te stoppen. Over het algemeen heeft de aanpak van cryptobedrijven in de Verenigde Staten ertoe geleid dat veel cryptobedrijven zijn verhuisd naar andere landen.</p>
<p>Brad Garlinghouse, <a href="https://www.bloomberg.com/news/articles/2023-03-02/ripple-ceo-garlinghouse-expects-a-decision-on-sec-suit-this-year#xj4y7vzkg" rel="nofollow noopener noreferrer" target="_blank">de CEO van Ripple vertelde Bloomberg</a> dat de “crypto-industrie” is begonnen met verhuizen van de VS naar andere landen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1396/the-pros-and-cons-of-crypto-and-blockchain-related-regulation" target="_blank">De voor- en nadelen van regulering van crypto- en blockchain-gerelateerde zaken</a></p>
<h2 id="h2-Conclusie615122"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Unbanked, de financiële dienstverlener, heeft aangekondigd dat het van plan is zijn operatie te sluiten vanwege de onvriendelijke crypto-omgeving in de Verenigde Staten en zijn beperkte financiële middelen. De huidige regelgevingssituatie in de VS heeft in feite veel crypto-bedrijven gedwongen om te sluiten of te verhuizen naar andere landen.</p>
<h2 id="h2-Veelgestelde20vragen20voor20nietbankieren447530"><a name="Veelgestelde vragen voor niet-bankieren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen voor niet-bankieren</h2><p><strong>Wat is Unbanked?</strong></p>
<p>Unbanked is een financiële dienstverlener die producten en diensten aanbiedt die gericht zijn op de cryptosector. Haar belangrijkste producten zijn bankkaarten en bankrekeningen, evenals faciliteiten voor de distributie van staking rewards.</p>
<p><strong>Wanneer zijn mensen niet-bancair en welke opties hebben ze voor financiële diensten? </strong></p>
<p>Unbanked verwijst naar volwassenen die geen toegang hebben tot traditionele financiële diensten zoals bankrekeningen en creditcards. Deze mensen hebben de mogelijkheid om cryptocurrencies, money orders, payday loans, non-traditionele kredietverstrekkers en cheques te gebruiken.</p>
<p><strong>Wat is het verschil tussen een bank en een financiële dienstverlener?</strong></p>
<p>Een bank is een financiële instelling die deposito’s accepteert en leningen aanbiedt aan haar klanten. Aan de andere kant richt een financiële dienstverlener zich op het beheren van de fondsen van haar klanten via verzekeringen, investeringen en andere middelen.</p>
<p>Reguleert de VS cryptocurrency?</p>
<p>De Verenigde Staten gebruiken hun bestaande financiële wetten om cryptocurrency te reguleren. De Bank Secrecy Act (BSA) is het belangrijkste financiële wetgevingsstuk dat de VS gebruiken om cryptocurrencies te reguleren.</p>
<p><strong>Wat zijn crypto-asset-serviceproviders?</strong></p>
<p>Crypto-asset-dienstverleners zijn instellingen die cryptocurrencies namens derden beheren. Hieronder vallen bedrijven die diensten aanbieden voor de conversie van cryptocurrencies naar fiatvaluta en vice versa, evenals het bieden van bewaring voor dergelijke digitale activa.</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 enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io als bron wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>