SW5kaWFzZSBjZW50cmFsZSBiYW5rIG9uZGVyem9la3QgQUkgdm9vciBkaXJlY3RlIGJldGFsaW5nZW4=

2023-08-22, 13:04

<p><img src="https://gimg2.gateimg.com/image/article/1692709194RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen305338"><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 centrale bank van India werkt aan de integratie van een op AI gebaseerde conversatiebetalingsservice met UPI.</p>
<p>India voert een pilotprogramma uit van haar digitale valuta van de centrale bank (CBDC).</p>
<p>Er is geen wettelijk verbod op cryptocurrencies in India, hoewel er geen regulering is om ze te reguleren.</p>
<h2 id="h2-Introductie349356"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De rol van kunstmatige intelligentie in het bedrijfsleven is sinds 2021 toegenomen. In het recente verleden werd AI geïntroduceerd in de crypto-sector, waar verschillende blockchain het gebruiken om hun beveiliging te verbeteren en unieke producten te bieden.</p>
<p>Als gevolg hiervan is er een nieuwe categorie crypto-activa genaamd AI-cryptovaluta, aangeboden door blockchains die kunstmatige intelligentie gebruiken. In dit artikel wordt besproken hoe de Indiase centrale bank streeft naar integratie van AI in de unified payments interface (UPI).</p>
<h2 id="h2-Reserve20Bank20of20India20gaat20AI20gebruiken20voor20UPIbetalingen734507"><a name="Reserve Bank of India gaat AI gebruiken voor UPI-betalingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reserve Bank of India gaat AI gebruiken voor UPI-betalingen</h2><p>De Reserve Bank of India heeft haar voornemen aangekondigd om kunstmatige intelligentie te gebruiken voor de uniforme betalingsinterface (UPI). Shaktikanta Das, de gouverneur van de RBI, zei dat de bank binnenkort “Conversational Payments” op UPI zal lanceren. Dat AI-aangedreven systeem zal leiden tot veilige en gemakkelijke transacties.</p>
<p>De RBI streeft ernaar nieuwe functies naar de UPI te brengen nadat ze zich realiseren dat het het digitale betalingssysteem heeft getransformeerd omdat het veilig, beveiligd en gebruiksvriendelijk is. Door nieuwe functies te introduceren, zoals conversationele betalingen, wil de RBI inspelen op de verschillende behoeften van de Indiase economie.</p>
<p>De focus van de RBI ligt op het creëren van een op AI gebaseerd systeem dat transacties initieert en voltooit via een gesprek. Het AI-gespreksbetalingsysteem zal echter alleen beschikbaar zijn op smartphones en ‘feature phone-based UPI-kanalen’.</p>
<p>De RBI zei in een rapport getiteld “Verklaring over ontwikkeling en regelgevingsbeleid: ‘Aangezien kunstmatige intelligentie (AI) steeds meer geïntegreerd raakt in de digitale economie, hebben conversatie-instructies een enorm potentieel om het gebruiksgemak en daarmee de reikwijdte van het UPI-systeem te verbeteren.</p>
<p>Neem een kijkje kunst <a href="https://www.gate.io/price/view/artificial-intelligence" target="_blank">Top kunstmatige-intelligentie crypto-munten &amp; tokens op basis van marktkapitalisatie</a></p>
<h2 id="h2-Wat20zijn20Conversational20Payment20s599450"><a name="Wat zijn Conversational Payment s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn Conversational Payment s?</h2><p>Conversationele betalingen is een systeem waarbij financiële transacties worden verwerkt met behulp van een bericht, gesprek of chat. Bij elke transactie zijn twee partijen betrokken, waarbij de ene de betalingsprovider is en de andere de chatoperator. Daarnaast gaat het om het gebruik van Chatbots, Intelligent Virtual Assistants (IVA’s) en Voicebots.</p>
<p>In dit g zullen de chatbots de gebruikers voorzien van directe betalingslinks of QR-codes, waardoor de transactiepartijen tijdens hun gesprekken naadloos betalingen kunnen uitvoeren. Het feit dat een transactie plaatsvindt binnen een geconsolideerde omgeving verhoogt de veiligheid en betrouwbaarheid van het betalingssysteem.</p>
<p>Volgens de centrale bank zal in de eerste fase de conversatie UPI-betalingsfaciliteit beschikbaar zijn in het Engels en Hindi. Na verloop van tijd zullen er echter andere talen worden toegevoegd.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-are-ai-tokens/501" target="_blank">Wat zijn AI Tokens?</a></p>
<h2 id="h2-De20UPI20en20Near20Field20Communication20NFC20technologie656930"><a name="De UPI en Near Field Communication (NFC) technologie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De UPI en Near Field Communication (NFC) technologie</h2><p>Het op AI gebaseerde transactiebetalingsysteem is afhankelijk van twee belangrijke technologieën, Near Field Communication (NFC) en UPI. Het Unified Payments Interface (UPI) is een peer-to-merchant en peer-to-peer transactiefaciliteit die bruikbaar is op mobiele telefoons.</p>
<p>Aan de andere kant maakt Near Field Communication (NFC), een technologie die twee apparaten zoals smartphones in staat stelt met elkaar te communiceren, het mogelijk dat individuen contactloze transacties uitvoeren wanneer ze zich binnen een bepaalde afstand van elkaar bevinden.</p>
<p>Volgens de RBI zal deze functie niet alleen retail digitale betalingen mogelijk maken in situaties waar de internet-/telecomverbinding zwak of niet beschikbaar is, maar ook zorgen voor snelheid, met minimale transactieafwijzingen. Instructies aan NPCI zullen binnenkort worden uitgegeven.</p>
<p>Een voordeel van het AI-aangedreven gespreksbetalingssysteem is dat het real-time betalingen mogelijk maakt waar de internet-/telecomverbinding zwak of niet beschikbaar is. Bovendien worden er zeer weinig transacties afgewezen door het systeem.</p>
<p>Nogmaals, het gebruik van het conversationele betalingssysteem kan de acceptatie van UPI verder verbeteren, terwijl QR-code betalingen toegankelijk maakt voor veel mensen in het land. Verder zullen degenen die vroeger problemen ondervonden bij het navigeren door mobiele applicaties bij het doen van digitale betalingen, het nieuwe systeem zeer gebruiksvriendelijk vinden. Dit komt omdat kunstmatige intelligentie hen zal leiden.</p>
<p>Lees ook over de <a href="https://www.gate.io/blog_detail/553/india-s-crypto-tax" target="_blank">India’s Crypto Belasting</a></p>
<h2 id="h2-Centrale20Bank20Digitale20Valuta501443"><a name="Centrale Bank Digitale Valuta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Centrale Bank Digitale Valuta</h2><p>De RBI heeft ook aangekondigd dat het bezig is met de ontwikkeling van zijn centrale bank digitale valuta, de eRupee. Al, de e-rupee bevindt zich in de testfase waar meer dan 100.000 klanten en 170.000 handelaren deelnemen aan het pilotprogramma.</p>
<p>De digitale Rupee zal een wettig betaalmiddel zijn in het land en zal tegen dezelfde waarde kunnen worden ingewisseld als zijn fysieke tegenhanger. In feite is de digitale Rupee, een digitale valuta in India, een versie van cryptocurrency die door de Indiase overheid is gecreëerd en officieel zal worden gelegaliseerd, wat betekent dat het crypto-betalingen in het land mogelijk zal maken.</p>
<h2 id="h2-Cryptoregulering20in20India304587"><a name="Crypto-regulering in India" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto-regulering in India</h2><p>Nu we dat hebben gedaan <a href="https://www.gate.io/how-to-buy/rupee-rup" target="_blank">genoemde digitale Rupee</a> Laten we als een versie van cryptocurrency bespreken de huidige cryptoregulering in het land.</p>
<p>Op dit moment zijn cryptocurrencies niet gereguleerd in India. Dit betekent dat er geen regels zijn die het gebruik van cryptocurrencies in het land reguleren. Dus, als er geschillen zijn met betrekking tot het verhandelen van cryptocurrencies of het uitvoeren van crypto betalingen, is er geen wettelijke geschillenbeslechting daarover. Daarom wordt de handel in digitale activa zoals NFT’s en cryptocurrencies op eigen risico van de belegger gedaan.</p>
<p>Lees ook: <a href="https://www.gate.io/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>Hoewel er geen officieel wettelijk verbod is op het omgaan met cryptocurrencies, blijkt uit de standpunten van de regering op basis van haar woordvoerders zoals de gouverneur van de Reserve Bank van India en de minister van Financiën dat cryptocurrencies illegaal zijn in het land. Sinds 2021 werkt de regering echter aan een cryptocurrency-wet getiteld ‘Cryptocurrency and Regulation of Official Digital Currency Bill, 2021’.</p>
<h2 id="h2-Conclusie963230"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De centrale bank van India werkt momenteel aan de introductie van een AI-gestuurd conversatiebetalingsysteem op basis van het UPI-systeem. De succesvolle implementatie ervan zal naar verwachting de adoptie van het betalingssysteem voor geünificeerde betalingen vergroten. Bovendien voert de RBI een pilotprogramma uit voor het gebruik van de digitale Rupee. Ondanks de voorgestelde <a href="https://www.gate.io/learn/articles/what-are-central-bank-digital-currencies/363" target="_blank">gebruik van de CBDC</a>, er is geen crypto-regulering in India.</p>
<h2 id="h2-Veelgestelde20vragen20over20Crypto20in20India314019"><a name="Veelgestelde vragen over Crypto in India" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Crypto in India</h2><h3 id="h3-Is20Gateio20legaal20in20India967399"><a name="Is Gate.io legaal in India?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Gate.io legaal in India?</h3><p>Gate.io is een legitieme crypto exchange die beschikbaar is in meer dan 180 landen, waaronder India. Gate.io biedt verschillende crypto-diensten aan, waaronder spot trading, futures, NFT-marktplaats en earn-producten.</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 beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat 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>