TCdJbmRvbmVzaWEgZmlzc2EgbG8gc2d1YXJkbyBzdWxsYSByZWdvbGFtZW50YXppb25lIGNvbXBsZXRhIGRlbGxlIGNyaXB0b3ZhbHV0ZTogVW5vIHNndWFyZG8gYXBwcm9mb25kaXRvIGFsbCdhcHByb2NjaW8gZGVsIHNhbmRib3ggcmVnb2xhbWVudGFyZQ==

2024-04-10, 01:53

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR415470"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>L’Indonesia si appresta a introdurre nuove regolamentazioni criptovalutarie volte a promuovere l’innovazione e la sicurezza dei consumatori.</p>
<p>Tutte le nuove società di criptovalute in Indonesia dovranno partecipare al programma Regulatory Sandbox.</p>
<p>Nel 2025 l’Autorità dei servizi finanziari dell’Indonesia (OJK) assumerà la regolamentazione delle criptovalute dall’Agenzia di regolamentazione del commercio di futures di materie prime.</p>
<h2 id="h2-Introduzione976748"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Molti paesi che mirano a creare ambienti abilitanti per le criptovalute si concentrano sull’istituzione di legislazioni pertinenti che proteggano sia i consumatori che l’industria. Inoltre, la regolamentazione aiuta a ridurre gli attriti tra le imprese criptovalutarie e le autorità di regolamentazione.</p>
<p>Quest’analisi esplora lo sviluppo normativo in Indonesia e come il settore delle criptovalute trarrà vantaggio dal suo programma sandbox. Discuteremo anche la legislazione cripto esistente nel paese.</p>
<h2 id="h2-LIndonesia20prevede20di20attuare20una20rigorosa20regolamentazione20delle20criptovalute20nel202025829652"><a name="L’Indonesia prevede di attuare una rigorosa regolamentazione delle criptovalute nel 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’Indonesia prevede di attuare una rigorosa regolamentazione delle criptovalute nel 2025</h2><p>L’Indonesia ha adottato una posizione molto proattiva nei confronti delle criptovalute attraverso le sue nuove normative che sono in linea con gli sviluppi globali. Il paese si è impegnato a adottare un approccio bilanciato che promuove la protezione dei consumatori di criptovalute in Indonesia e l’innovazione nel settore digitale.</p>
<p>Fondamentalmente, il paese sta raffinando <a href="https://www.gate.io/learn/articles/crypto-regulation-in-2024/1966" target="_blank">le sue regolamentazioni criptovalutarie esistenti</a> creare un mercato crittografico sicuro, protetto e prospero. Promette di introdurre leggi sulla criptovaluta più rigorose di prima, che creeranno un ambiente più favorevole per la crescita delle valute digitali.</p>
<p>L’Autorità per i Servizi Finanziari (OJK), che è il regolatore dei servizi finanziari indonesiano, ha recentemente introdotto una nuova legislazione criptata che entrerà in vigore nel 2025. La regolamentazione criptata dell’Indonesia guiderà le istituzioni finanziarie come banche e compagnie di assicurazioni che potrebbero aver bisogno di avventurarsi nel settore digitale.</p>
<p>Parte delle normative comprende il programma di sandbox regolamentare focalizzato sulla protezione dei consumatori. L’autorità dei servizi finanziari dell’Indonesia ha dichiarato che le nuove normative obbligheranno tutte le istituzioni finanziarie a sottoporsi al programma di valutazione dei prodotti crittografici in Indonesia, chiamato anche <a href="/price/the-sandbox-sand" rel="nofollow noopener noreferrer" target="_blank">The Sandbox</a> programma.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/breaking-eu-passed-new-crypto-regulation/2393" target="_blank">Notizia di ultima ora: l’UE ha approvato una nuova regolamentazione sulle criptovalute</a></p>
<p>Attraverso questo programma, l’autorità di regolamentazione valuterà i diversi modelli di business cripto in Indonesia. Solo le aziende che rispettano le sue linee guida saranno autorizzate a operare nel paese.</p>
<p>Secondo Hasan Fawzi, Responsabile Esecutivo dell’Innovazione Tecnologica del Settore Finanziario, della Supervisione degli Asset Finanziari Digitali e degli Asset Cripto, l’obiettivo principale del programma Sandbox e della legge cripto in generale è proteggere i consumatori attraverso la prevenzione delle frodi cripto.</p>
<p>Come riportato da una pubblicazione di BeInCrypto, <a href="https://beincrypto.com/indonesia-strict-crypto-regulation-2025/" rel="nofollow noopener noreferrer" target="_blank">Fawzi ha detto</a>«Questo incarna il nostro spirito presso l’OJK, soprattutto nella protezione dei consumatori e nell’educazione. Ci aspettiamo che tutti i nostri meccanismi di regolamentazione impattino direttamente nella prevenzione degli investimenti fraudolenti.»</p>
<h2 id="h2-Regolamentazione20attuale20delle20criptovalute20in20Indonesia856908"><a name="Regolamentazione attuale delle criptovalute in Indonesia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione attuale delle criptovalute in Indonesia</h2><p>Dal momento che la nuova regolamentazione delle criptovalute entrerà in vigore nel gennaio 2025, il paese sta utilizzando le leggi attuali per regolare le attività legate alle criptovalute. Ad esempio, il paese utilizza il Regolamento Bappebti n. 8⁄2021che contiene linee guida per il trading fisico di cripto-attività. Questo insieme di regolamenti fornisce indicazioni chiare su come i trader di cripto dovrebbero operare.</p>
<p>Il paese ha anche il Regolamento Bappebti n. 4 del 2023 che stabilisce i requisiti per il trading di criptoasset in Indonesia. Ad esempio, stabilisce condizioni per la conservazione e il trading di asset digitali.</p>
<p>Un’altra normativa cripto presente attualmente in Indonesia è la Legge Omnibus Finanziaria (Legge n. 4 del 2023). Le disposizioni di questa legge regolamentano l’intero settore finanziario anche se ha alcune implicazioni per il settore delle criptovalute.</p>
<h2 id="h2-Il20ruolo20di20OJK20in20questa20nuova20normativa20criptata20dellIndonesia508575"><a name="Il ruolo di OJK in questa nuova normativa criptata dell’Indonesia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il ruolo di OJK in questa nuova normativa criptata dell’Indonesia</h2><p>Le nuove normative sulla criptovaluta in Indonesia, che entreranno in vigore nel 2025, coincideranno con il cambio dell’autorità di regolamentazione delle criptovalute nel paese. L’Autorità dei servizi finanziari dell’Indonesia (OJK) diventerà la nuova autorità dei servizi finanziari dell’Indonesia, prendendo il posto dell’Agenzia di regolamentazione del trading di futures di commodity (Bappebti), operante sotto la supervisione del Ministero del Commercio.</p>
<p>La ragione di questo cambiamento è creare un approccio regolatorio più integrato e completo che governi gli asset crittografici rispetto a prima. Una delle cose fondamentali che ci si aspetta che faccia l’OJK è classificare le criptovalute come titoli che avranno forti implicazioni fiscali. La riclassificazione dei criptoasset come titoli comporterà una riduzione delle tasse.</p>
<p>Il programma Sandbox sarà al centro del quadro normativo crittografico in Indonesia. In relazione a questa nuova sviluppo, <a href="https://beincrypto.com/indonesia-strict-crypto-regulation-2025/" rel="nofollow noopener noreferrer" target="_blank">Fawzi ha detto</a>“Ciò si allinea con il nostro spirito presso OJK, in particolare nella protezione e nell’educazione dei consumatori. Ci aspettiamo che i nostri meccanismi regolatori abbiano un impatto diretto nella prevenzione degli investimenti fraudolenti.”</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/378/how-are-cryptocurrencies-currently-regulated-in-countries-around-the-world" target="_blank">Come sono attualmente regolamentate le criptovalute in diversi paesi</a></p>
<h2 id="h2-Programma20Sandbox20Regolamentare202025900616"><a name="Programma Sandbox Regolamentare 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Programma Sandbox Regolamentare 2025</h2><p>Come accennato in precedenza, il <a href="https://www.gate.io/bitwiki/detail/467/regulatory-sandbox" target="_blank">Programma Crypto Sandbox Regolamentare</a> sarà al centro della nuova regolamentazione delle criptovalute in Indonesia. L’obiettivo principale del programma Sandbox è quello di migliorare la prevenzione delle frodi criptovalutarie e promuovere l’innovazione tecnologica finanziaria in Indonesia.</p>
<p>Articolo correlato: <a href="https://www.gate.io/learn/articles/what-is-the-sandbox-how-to-join-the-metaverse/1599" target="_blank">Cos’è The Sandbox &amp; Come Unirsi al Metaverso</a></p>
<p>Ad esempio, l’Autorità per i Servizi Finanziari dell’Indonesia (OJK) ha spiegato che le istituzioni finanziarie locali che saranno disposte a offrire nuovi prodotti e servizi dovrebbero partecipare al programma Sandbox. In parole semplici, le aree di prova regolamentate sono strumenti per testare e sperimentare nuovi prodotti o servizi innovativi prima che vengano lanciati sul mercato.</p>
<p>Approfondendo ulteriormente le Sandboxes, Fawzi ha detto: “Penso che questo sia il nostro spirito all’OJK, specialmente nella protezione dei consumatori e nell’istruzione. Speriamo davvero che tutti i nostri meccanismi di regolamentazione siano presenti e abbiano un impatto diretto sulla prevenzione degli investimenti fraudolenti.”</p>
<p>Notizie correlate: <a href="https://www.gate.io/post/CQQDFjYMQkpAQgghGxAdA19cWxgEDhkO0O0O/status/4996025" target="_blank">La regolamentazione dei criptovalori russi potrebbe dover attendere fino al 2025</a></p>
<p>Una volta che le diverse istituzioni finanziarie aderiscono al programma sandbox, diventerà facile per la supervisione degli asset crittografici in Indonesia. In altre parole, l’OJK supervisionerà tutte le aziende e progetti criptografici registrati.</p>
<p>Il programma Sandbox consentirà all’innovazione del settore finanziario in Indonesia di familiarizzare con le operazioni dell’OJK e con il modo in cui le normative del paese si applicano al settore delle criptovalute. È importante notare anche che le imprese criptografiche che non partecipano al programma Sandbox saranno classificate come imprese non autorizzate.</p>
<p>Fawzi ha sottolineato: ‘In sostanza, se un fornitore di servizi finanziari basati su IT non è registrato come partecipante nel nostro ambiente di prova, o successivamente, dopo aver stabilito determinati cluster, che siano o meno autorizzati dall’OJK, verrà considerato equivalente ad altre entità non autorizzate’.</p>
<h2 id="h2-Benefici20e20svantaggi20della20regolamentazione20delle20criptovalute211828"><a name="Benefici e svantaggi della regolamentazione delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Benefici e svantaggi della regolamentazione delle criptovalute</h2><p>Non vi è alcun dubbio che le normative sulla criptovaluta siano essenziali per la protezione dei consumatori di criptovalute in Indonesia, così come per la promozione dell’innovazione nel settore. Nel caso dell’Indonesia, molti investitori arriveranno nel paese, il che potrebbe trasformarlo in un polo per le criptovalute.</p>
<p>Lo svantaggio principale è che le imprese cripto non registrate probabilmente incontreranno ostacoli legali nelle loro operazioni. Ad esempio, alcune di esse saranno costrette a pagare multe salate o a chiudere. Tuttavia, per la promozione dell’innovazione nel settore cripto, le istituzioni finanziarie dovrebbero attenersi alle normative indonesiane.</p>
<p>Importante sapere: <a href="https://www.gate.io/blog_detail/716/the-main-countries-that-actually-banned-crypto" target="_blank">I principali paesi che hanno effettivamente vietato le criptovalute</a></p>
<h2 id="h2-Conclusione642823"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>L’Indonesia introdurrà una rigorosa regolamentazione delle criptovalute che entrerà in vigore nel gennaio 2025 e sarà supervisionata dall’Autorità per i servizi finanziari (OJK). Entro quel momento l’Agenzia di regolamentazione del commercio di futures di commodities (Bappebti) non regolerà più e superviserà le attività legate alle criptovalute nel paese. La legge richiederà a tutte le aziende di criptovalute di partecipare al Programma Sandbox Regolamentativo.</p>
<h2 id="h2-Domande20frequenti20sulle20normative20criptate20in20Indonesia31826"><a name="Domande frequenti sulle normative criptate in Indonesia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulle normative criptate in Indonesia</h2><h3 id="h3-Chi20regola20le20criptovalute20in20Indonesia872320"><a name="Chi regola le criptovalute in Indonesia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi regola le criptovalute in Indonesia?</h3><p>Attualmente, l’Autorità dei Servizi Finanziari dell’Indonesia regola e supervisiona le attività legate alle criptovalute in Indonesia. Tuttavia, a partire da gennaio 2025, l’Autorità dei Servizi Finanziari dell’Indonesia (OJK) assumerà la regolamentazione delle criptovalute nel paese.</p>
<h3 id="h3-LIndonesia2020un20paese20cryptofriendly975108"><a name="L’Indonesia è un paese crypto-friendly?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’Indonesia è un paese crypto-friendly?</h3><p>L’Indonesia è un paese amico delle criptovalute che utilizza regolamentazioni pertinenti per proteggere i consumatori e sostenere l’innovazione. Tuttavia, le aziende cripto dovrebbero registrarsi presso l’autorità per iniziare a operare nel paese.</p>
<h3 id="h3-Le20criptovalute20sono20tassate20in20Indonesia378161"><a name="Le criptovalute sono tassate in Indonesia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le criptovalute sono tassate in Indonesia?</h3><p>In Indonesia vi è una doppia tassazione delle criptovalute che comprende un’imposta sul reddito dello 0,1% e un’imposta sul valore aggiunto (IVA) dello 0,11%. Tuttavia, il paese ha pianificato di ridurre le tasse sulle criptovalute nel 2025.</p>
<h3 id="h3-La20criptovaluta2020legale20a20Bali214736"><a name="La criptovaluta è legale a Bali?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La criptovaluta è legale a Bali?</h3><p>È legale scambiare criptovalute a Bali, in Indonesia, anche se non è legale effettuare pagamenti con esse. Pertanto, le persone che utilizzano le criptovalute come mezzo di pagamento possono essere imprigionate o pesantemente multate.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il riposting dell'articolo a condizione che Gate.io sia citato. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>