TCdGQ0EgZGVsIFJlZ25vIFVuaXRvIHBlcnNlZ3VlIGdsaSBpbmZsdWVuY2VyIGRpIE1lbWUgQ29pbiBzdWxsZSByaWNoaWVzdGUgZGkgY29uZm9ybWl0w6A=

2024-04-09, 06:51

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR57921"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Gli influencer delle criptovalute dovrebbero promuovere i prodotti criptati nel rispetto delle disposizioni legali del governo del Regno Unito.</p>
<p>I finfluencer che violano le disposizioni legali del Regno Unito in materia di promozione di prodotti finanziari possono passare fino a 2 anni in prigione.</p>
<p>Gli influencer finanziari non britannici che intendono pubblicizzare prodotti finanziari ai residenti nel Regno Unito dovrebbero utilizzare materiale approvato da un agente FCA.</p>
<h2 id="h2-Introduzione478240"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Sin dalla loro introduzione <a href="https://www.gate.io/blog_detail/1143/memecoins-what-are-they" target="_blank">memecoins</a> sono stati molto popolari tra gli investitori di criptovalute e hanno attirato molti investimenti criptati. Anche se molti investitori hanno tratto beneficio dalla loro elevata volatilità, altri hanno subito pesanti perdite.</p>
<p>Il fatto che <a href="https://www.gate.io/blog_detail/452/what-are-memecoins-and-can-they-make-you-rich" target="_blank">le monete meme hanno il supporto di persone influenti</a> Come le celebrità li ha resi una classe di attività crittografica primaria. Tuttavia, i rischi che comportano hanno costretto diversi governi a intervenire per proteggere i propri cittadini.</p>
<p>Questo post discuterà della legge recentemente promulgata nel Regno Unito che mira a proteggere i consumatori dalle promozioni finanziarie improprie. Esamineremo anche linee guida specifiche che potrebbero <a href="https://www.gate.io/learn/articles/10-crypto-influencers-you-should-be-following/2349" target="_blank">aiutare le imprese FinTech e gli influencer cripto a conformarsi</a> con le nuove regolamentazioni.</p>
<p>Leggi anche: <a href="https://www.gate.io/price/view/meme-token" target="_blank">Top Meme Crypto Coins &amp; Tokens per Capitalizzazione di Mercato</a></p>
<h2 id="h2-Avvertimento20dellFCA20agli20Influencer20sui20Social20Media135321"><a name="Avvertimento dell’FCA agli Influencer sui Social Media" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Avvertimento dell’FCA agli Influencer sui Social Media</h2><p>L’Autorità di condotta finanziaria del Regno Unito (FCA) ha posto il settore delle criptovalute sotto la sua giurisdizione per quanto riguarda le promozioni finanziarie. Anche le regole di promozione finanziaria sui social media nel Regno Unito si applicheranno al settore delle criptovalute. Di conseguenza, gli influencer finanziari (Finfluencers) e le aziende di criptovalute dovrebbero attenersi a queste regole.</p>
<p>A causa degli ultimi sviluppi normativi nel Regno Unito sui social media, la FCA monitorerà le attività degli influencer criptovalutari per garantire che rispettino la legalità degli annunci finanziari nel Regno Unito.</p>
<p>Le nuove linee guida per la promozione dei prodotti finanziari sono state introdotte per regolamentare le pubblicità cripto che le aziende e gli influencer fanno su diverse piattaforme mediatiche, tra cui Telegram, Tiktok, Facebook e X.com.</p>
<p>L’avvertimento dell’FCA agli influencer delle meme coin è il risultato dell’aumento dei consigli online ingannevoli e delle pubblicità sfrenate di meme criptate popolari da parte di celebrità e altre persone influenti. È alla luce di tale sviluppo che l’FCA chiede la protezione dei consumatori nelle pubblicità finanziarie che contengono informazioni corrette e non ingannevoli.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/master-memecoins-with-5-must-have-crypto-tools/2138" target="_blank">Padroneggia le Memecoins con 5 strumenti cripto indispensabili</a></p>
<p>Fondamentalmente, l’autorità di regolamentazione è preoccupata per l’aumento della scarsa qualità delle promozioni finanziarie che potrebbero danneggiare i consumatori che vengono indotti a prendere decisioni di investimento errate. Nella maggior parte dei casi, gli influencer finanziari utilizzano la promozione sui social media per mirare a un pubblico più giovane e ad altre persone che sono vulnerabili agli investimenti ad alto rischio.</p>
<p>Secondo la FCA, una promozione finanziaria è una comunicazione che contiene un incentivo o un invito ad acquisire o disporre di asset o convertire diritti in un investimento controllato. La comunicazione può assumere la forma di presentazioni tramite seminari, webinar, pagine web o email.</p>
<p>A proposito di questo <a href="https://www.fca.org.uk/publication/finalised-guidance/fg24-1.pdf" rel="nofollow noopener noreferrer" target="_blank">La Financial Conduct Authority ha detto</a>, “Ai sensi della sezione 21 (s21) del Financial Services and Markets Act 2000 (FSMA), una persona non deve, nel corso dell’attività, comunicare un invito o un incentivo a impegnarsi in un’attività di investimento. Questo è noto come restrizione della promozione finanziaria”.</p>
<p>Tuttavia, le restrizioni alla promozione finanziaria non si applicheranno sotto <a href="https://www.fca.org.uk/publication/finalised-guidance/fg24-1.pdf" rel="nofollow noopener noreferrer" target="_blank">le seguenti condizioni</a>.</p>
<ol>
<li>La promozione è comunicata da una persona autorizzata</li><li>Il contenuto della promozione è approvato da una persona autorizzata appropriata o</li><li>Un’esenzione nella Financial Services and Markets Act 2000.</li></ol>
<p>La FCA mira a garantire la conformità degli annunci finanziari nel Regno Unito a causa dei pericoli delle promozioni non controllate. Per complicare ulteriormente le cose, gli influencer e le aziende utilizzano vari annunci sui social media per raggiungere molte persone. Ad esempio, utilizzano streaming di giochi, meme e reels per influenzare molti individui ignari a prendere decisioni di investimento non giustificate.</p>
<p>Detto ciò, il messaggio principale della FCA è che gli influencer dei social media nel diritto britannico, che utilizzino video a breve termine, meme o streaming di giochi, dovrebbero seguire gli standard pubblicitari del Regno Unito.</p>
<p>Come da una dichiarazione in un <a href="https://fintech.global/2024/03/28/fca-cracks-down-on-misleading-financial-ads-on-social-media/" rel="nofollow noopener noreferrer" target="_blank">Pubblicazione globale di Fintech</a>, Lucy Castledine, direttore degli investimenti dei consumatori presso la FCA, ha affermato: “Ogni marketing per i prodotti finanziari deve essere equo, chiaro e non fuorviante in modo che i consumatori possano investire, risparmiare o prendere in prestito con fiducia.”</p>
<p>Ha aggiunto: “Le promozioni non riguardano solo i like, ma anche la legge. Prenderemo provvedimenti contro coloro che pubblicizzano illegalmente prodotti finanziari.”</p>
<p>Pertanto, per essere legalmente sicuri, i finfluencer dovrebbero utilizzare solo promozioni finanziarie autorizzate dalla FCA. Come per <a href="https://www.fca.org.uk/publication/finalised-guidance/fg24-1.pdf" rel="nofollow noopener noreferrer" target="_blank">le linee guida della FCA</a>: “Una promozione finanziaria illegale è una comunicazione effettuata in violazione dell’articolo 21. Ad esempio, un influencer (non autorizzato) che comunica una promozione finanziaria senza l’approvazione di un’autorità autorizzata appropriata e in cui non si applica alcuna esenzione FPO.”</p>
<p>Questo avviso si applica anche ai finfluencers non britannici che mirano ai cittadini del Regno Unito. In questo contesto, la linea guida afferma: “La restrizione della promozione finanziaria ha una vasta applicazione territoriale. Si applica anche se una comunicazione proviene dall’esterno del Regno Unito se è in grado di avere un effetto nel Regno Unito.”</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/588/female-crypto-influencers-in-the-world" target="_blank">Influenzatrici femminili nel mondo delle criptovalute</a></p>
<h2 id="h2-Implicazioni20legali20per20gli20influencer20non20conformi450709"><a name="Implicazioni legali per gli influencer non conformi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicazioni legali per gli influencer non conformi</h2><p>L’FCA ha chiarito che promuovere prodotti finanziari senza l’approvazione di un’agenzia autorizzata dalla FCA è un atto criminoso il cui castigo include una condanna a una pena detentiva. Secondo le linee guida sulla promozione finanziaria, solo le persone autorizzate possono pubblicizzare prodotti finanziari.</p>
<p>Le monete meme che pubblicizzano rischi legali nel Regno Unito includono condanne detentive o sanzioni finanziarie senza limite superiore. Di fatto, il tempo massimo di prigione per gli influencer di monete meme è di 2 anni. Tuttavia, non c’è un limite superiore alla sanzione finanziaria. In merito a questo <a href="https://www.fca.org.uk/publication/finalised-guidance/fg24-1.pdf" rel="nofollow noopener noreferrer" target="_blank">FCA ha chiarito</a>: “La violazione dell’articolo s21 è un reato penale punibile con fino a 2 anni di reclusione, l’applicazione di una multa illimitata, o entrambi.”</p>
<p>Notizia importante: <a href="https://www.gate.io/article/26485/gate-influencers-be-a-trade-analyst-promoter-for-gate.io" target="_blank">Gate Influencers - Sii un analista commerciale e promotore per Gate.io</a></p>
<h2 id="h2-Ruolo20dei20social20media20nelle20promozioni20finanziarie757576"><a name="Ruolo dei social media nelle promozioni finanziarie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ruolo dei social media nelle promozioni finanziarie</h2><p>Molte istituzioni finanziarie utilizzano i canali dei social media per diffondere le loro promozioni al fine di raggiungere molte persone. In particolare, le società crypto mirano agli utenti dei social media perché la maggior parte di loro è rappresentata dalla generazione più giovane interessata agli asset digitali e agli investimenti ad alto rendimento.</p>
<p>Pertanto, le promozioni sui social media attraggono maggiormente i giovani e i nuovi investitori. Inoltre, le società utilizzano i finfluencer che spesso hanno un gran numero di follower che li ascoltano. Poiché le criptovalute sono senza confini, ha molto senso utilizzare le piattaforme dei social media che attraggono persone da tutto il mondo.</p>
<p>Fondamentalmente, i social media sono un componente critico di come le persone interagiscono a livello globale. Inoltre, individui e organizzazioni che mirano a ottenere determinate informazioni utilizzano piattaforme di social media e si connettono con persone con interessi simili.</p>
<p>Inoltre, i progetti cripto possono creare comunità su piattaforme di social media come Discord, Facebook e Telegram, rendendo facile pubblicizzare i loro prodotti e raggiungere una vasta popolazione.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/1938/earn-crypto-income-with-gate.io-s-influencer-program" target="_blank">Guadagna reddito Crypto con il programma Influencer di Gate.io</a></p>
<h2 id="h2-LImpegno20dellFCA20per20Proteggere20i20Consumatori838707"><a name="L’Impegno dell’FCA per Proteggere i Consumatori" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’Impegno dell’FCA per Proteggere i Consumatori</h2><p>È chiaro che l’obiettivo principale della FCA è proteggere i consumatori dall’attrazione degli investimenti ad alto rischio, in particolare criptovalute e altri asset digitali. Il regolatore ha capito che ci sono molti finfluencer che forniscono agli investitori informazioni fuorvianti.</p>
<p>In una dichiarazione citata da <a href="https://www.telegraph.co.uk/money/investing/tiktok-finfluencers-prison-threat-dodgy-advice/" rel="nofollow noopener noreferrer" target="_blank">Telegrafo, Susannah Streeter</a> Il capo del denaro e dei mercati di Hargreaves Lansdown ha detto: “I regolatori sono chiaramente horrorizzati dai danni che le celebrità superstar possono fare ai bilanci bancari dei consumatori vulnerabili, che sono influenzati da quasi ogni mossa che fanno.”</p>
<p>“Le illusioni di arricchimento rapido possono diffondersi troppo rapidamente sui social media, con la speculazione amplificata dai repost di milioni di follower.”</p>
<p>Pertanto, per mostrare la sua intenzione di proteggere i consumatori, FCA <a href="https://www.fca.org.uk/publication/finalised-guidance/fg24-1.pdf" rel="nofollow noopener noreferrer" target="_blank">disse</a> I consumatori dovrebbero essere più informati e consapevoli dei rischi legati all’acquisto di prodotti e servizi finanziari, aiutandoli a prendere decisioni migliori che siano in linea con le loro esigenze e il loro profilo di rischio. I consumatori informati sono meno inclini a subire perdite impreviste e perdita di fiducia nei servizi finanziari.</p>
<p>L’FCA ha aggiunto che il suo obiettivo è ridurre “il numero di consumatori che investono in HRIs e che hanno una bassa tolleranza al rischio o una o più caratteristiche di vulnerabilità entro il 2025.” La rimozione degli annunci fuorvianti dell’FCA nel 2023 è stata un chiaro segnale del suo impegno a proteggere i consumatori. Al momento attuale, il regolatore continuerà con la sua azione repressiva sugli annunci finanziari fuorvianti.</p>
<p>Articolo correlato: <a href="https://www.gate.io/learn/articles/the-legal-and-market-dynamics-of-meme-coins/2238" target="_blank">La dinamica legale e di mercato delle Meme Coins</a></p>
<h2 id="h2-Linee20guida20per20la20conformit331103"><a name="Linee guida per la conformità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Linee guida per la conformità</h2><p>Il modo migliore per le società finanziarie e i finfluencer per evitare conseguenze legali è attuare le linee guida della strategia di mercato finanziario della FCA. Sia le società che i finfluencer dovrebbero utilizzare materiale promozionale, inclusi contenuti di marketing di meme coin, che siano stati approvati dai rappresentanti nominati dalla FCA. Tuttavia, il primo passo è per le società e i finfluencer registrarsi presso la FCA in modo che l’ente regolatore possa valutare e approvare il loro contenuto promozionale.</p>
<p>I promoter dovrebbero sempre includere avvertenze sui rischi nei loro contenuti. Questo si applica a tutti i tipi di contenuti multimediali come presentazioni dal vivo, streaming, video e articoli. Per i video e lo streaming, le avvertenze dovrebbero essere visibili durante le presentazioni.</p>
<p>Le aziende dovrebbero assicurarsi che i finfluencers con cui collaborano utilizzino solo contenuti autorizzati dalla FCA e che non includano informazioni fuorvianti. Potrebbe essere consigliabile che le aziende registrino tutti i contenuti promozionali che utilizzano e che i finfluencers li firmino prima di distribuire gli annunci pubblicitari.</p>
<p>Infine, le aziende e i finfluencer dovrebbero evitare un’eccessiva mira utilizzando gli annunci pubblicitari. In altre parole, dovrebbero astenersi dal bombardare i consumatori con annunci e altro materiale promozionale. La FCA ritiene che tali attività possano sfruttare i pregiudizi comportamentali tra i consumatori vulnerabili.</p>
<h2 id="h2-Conclusione394132"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La Financial Conduct Authority (FCA) del Regno Unito ha avvertito sia le aziende che i finfluencer di non utilizzare materiale promozionale non autorizzato che mira ai suoi cittadini. Pertanto, queste parti dovrebbero attenersi ai requisiti dell’ente regolatore del Regno Unito per evitare cause legali e le conseguenti ripercussioni legali come l’imprigionamento e pesanti sanzioni finanziarie. Questa legge si applicherà anche alle aziende non basate nel Regno Unito e agli influencer finanziari.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di 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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>