Z2F0ZUxpdmUgQU1BIFJlY2FwLVNuYXBtdXNlLmlv

2024-04-26, 05:33

<p><img src="https://gimg2.gateimg.com/image/article/1714109534SMXBLOG.jpeg" alt=""></p>
<h2 id="h2-V120Vertel20ons20alstublieft20iets20over20uw20project20Hoe20is20het20idee20van20Snapmuseio20ontstaan20en20waar20gaat20het20platform20over151292"><a name="V1: Vertel ons alstublieft iets over uw project. Hoe is het idee van Snapmuse.io ontstaan en waar gaat het platform over?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Vertel ons alstublieft iets over uw project. Hoe is het idee van Snapmuse.io ontstaan en waar gaat het platform over?</h2><p>In zeer eenvoudige bewoordingen is Snapmuse.io een platform voor gemeenschapsfinanciering. Het is gebouwd op RWA-tokenisatie en betrokkenheid-om-te-verdienen dynamiek en het is specifiek ontworpen voor de entertainmentindustrie.</p>
<p>We laten projecten &amp; socialemediamakers financiering krijgen via hun gemeenschap door hun kanalen te tokeniseren &amp; hun leden te belonen met voordelen &amp; voordelen.</p>
<p>Maar om uit te leggen hoe dit idee is ontstaan, moet ik een stap terug doen en u wat achtergrondinformatie geven. We komen uit een muzikale achtergrond. We hebben een ander bedrijf dat rechtenvrije muziek maakt voor makers van sociale media. Zoals u weet, kunt u de Justin Timberlakes en Drake’s niet in uw video’s gebruiken vanwege auteursrechtelijke kwesties. En ons andere bedrijf biedt muziek aan professionele makers zodat ze hun inhoud kunnen monetariseren.</p>
<p>Samenwerken met makers heeft ons doen inzien dat er een nijpende behoefte is aan financiering in de sector. Makers van sociale media hebben geen toegang tot financiering omdat banken ‘social media-ster’ niet accepteren als beroepstitel. Zelfs Mr. Beast, de maker die miljoenen verdient met alleen al zijn YouTube-video’s, had financiering nodig voor zijn video’s. De bestaande financieringsoplossingen voor makers zijn niet maker-vriendelijk. Ze vereisen ofwel dat je meer inhoud creëert wanneer je al onder constante creatieve druk staat, OF je moet je inhoud verkopen zoals Mr. Beast moest doen. En dat betekent dat je in feite je meest succesvolle werk verkoopt. Dit is niet oké.</p>
<p>Vanaf onze CEO, Moris, waren we allemaal op verschillende niveaus betrokken bij <a href="/web3" target="_blank" class="blog_inner_link">web3</a> en zagen we het potentieel van de toepassing ervan in deze industrie. Dat is zo ongeveer wanneer we op het idee kwamen om web3 te gebruiken om dit probleem op te lossen.</p>
<p>Hoe Snapmuse.io werkt is vrij eenvoudig. Creators of projecten komen naar Snapmuse.io met een project dat ze willen financieren. Wij helpen hen bij het maken van hun NFT-drops.</p>
<p>Deze drops zijn op 2 manieren speciaal:<br>1) Makers kunnen een deel van hun kanaalopbrengsten opnemen voor houders om als korting op SMX-rewards te claimen. Dus het is niet alleen financiering voor projecteigenaren, het is ook een manier om de betrokken leden van de community te belonen. Dit is iets waar we veel nadruk op leggen. Als je een NFT van een maker hebt en je bent bereid bij te dragen aan het succes van het project door betrokkenheid te tonen, dan kun je potentieel het proces verbeteren.</p>
<p>2) In tegenstelling tot andere NFT-voordelen die er zijn, hebben NFT’s op Snapmuse.io een vervaldatum. Wat betekent dat?<br>De voordelen en voordelen van NFT’s die op Snapmuse.io worden verkocht, hebben een vervaldatum. Op deze manier zitten makers niet vast in een eeuwige cyclus waarin ze meer voordelen moeten bedenken, die ze niet kunnen, wat de gemeenschap ongelukkig maakt en het project doodt. Hier weten fans wat ze kopen en makers weten wat ze verkopen. Dit gaat over het verenigen van fans en makers om dromen te realiseren.</p>
<h2 id="h2-Q220Hoe20werkt20snapmuseio20Heeft20u20tot20nu20toe20enige20projecten20gefinancierd753522"><a name="Q2: Hoe werkt snapmuse.io? Heeft u tot nu toe enige projecten gefinancierd?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Hoe werkt snapmuse.io? Heeft u tot nu toe enige projecten gefinancierd?</h2><p>Ik heb min of meer uitgelegd hoe het platform werkt, maar laat me praten over de drops die we hebben gemaakt en ik weet zeker dat het voor iedereen duidelijker zal zijn. We hebben 2 grote grote drops gemaakt.</p>
<p>Mariana Avila en Sofia Castro. Elk had 40 miljoen volgers op sociale media. Houd er rekening mee dat elk project of elke artiest zijn eigen specifieke voordelen en beloningen mag kiezen.</p>
<p>Mariana lanceerde haar solocarrière en een parfumlijn, dus ze organiseerde een drop om haar eerste onderneming te financieren. Ze bood haar fans gratis NFT’s, social media volgers en een zoom meet and greet aan.</p>
<p>Sofia Castro is een TikToker die bekend staat om haar zang. Ze wilde de volgende stap zetten in haar carrière en haar eerste concert organiseren. En dat is de reden waarom ze een drop organiseerde op Snapmuse.io. Ze maakte het zo dat haar NFT’s concertkaartjes waren als je kon komen, als dat niet het g was, kon je ze gebruiken om de token gated livestream te bekijken, enkele grote verzamelaars mochten haar backstage ontmoeten en haar warming-up bekijken… Dit was een drop van 3 maanden, wat betekent dat er gedurende 3 maanden gemeenschapsactiviteiten waren en fans beloningen konden winnen door gemeenschapsspellen te spelen, inclusief USDT-beloningen. Omdat het hele idee is om de meest betrokken fans te belonen.</p>
<h2 id="h2-Q320Snapmuseio20is20een20RWAproject20Hoe20gebruikt20u20RWA20als20onderdeel20van20een20financieringsoplossing639363"><a name="Q3: Snapmuse.io is een RWA-project. Hoe gebruikt u RWA als onderdeel van een financieringsoplossing?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Snapmuse.io is een RWA-project. Hoe gebruikt u RWA als onderdeel van een financieringsoplossing?</h2><p>Onze infrastructuur stelt ons in staat om social media-creators de mogelijkheid te geven om een deel van hun inkomsten uit social media-advertenties op te nemen in hun NFT-collectie als beloning. We hebben de infrastructuur en het juridische model op zijn plaats om namens hen hun zeggen..YT-inkomsten te innen en het % dat ze toewijzen aan fans te distribueren, terwijl we de rest aan de makers geven. Het doel hier is om fans te belonen die echt bijdragen aan het succes van het project.</p>
<p>RWA voor ons is een instrument / een manier om makers en fans samen te brengen over een gemeenschappelijk doel en hen te helpen samen te werken terwijl ze een geweldige tijd hebben. Dat is de schoonheid van ons platform.</p>
<h2 id="h2-Q420Hoe20vergelijkt20u20zich20met20andere20projecten20in20het20makersecosysteem20zoals20xcad20mirroror20royal197344"><a name="Q4: Hoe vergelijkt u zich met andere projecten in het makersecosysteem? zoals xcad, mirroror, royal?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Hoe vergelijkt u zich met andere projecten in het makersecosysteem? zoals xcad, mirroror, royal?</h2><p>Zeer goede vraag. Er zijn andere projecten die proberen financieringsoplossingen voor te stellen. Zowel in web2 als web3.</p>
<p>In web2 hebben we jellysmack of spotter. Beiden kopen inhoud, wat betekent dat de makers hun beste werk gebruiken. Dit is niet oké voor ons. Wij geloven dat de inhoud aan de maker moet toebehoren.</p>
<p>Je hebt ook zoiets als patreon, maar daar zijn makers en projecten verplicht om nog meer inhoud te maken voor betalende klanten, terwijl het al erg moeilijk is om hun reguliere stroom van inhoud te maken. We willen dat makers blijven doen wat ze doen en we stellen ze in staat financiering te krijgen door hun kanalen en tijd te tokeniseren.</p>
<p>In web3 heb je platforms zoals Royal en Opulus, die zich beperken tot muziek. Als wat ze beweren klopt, verliezen artiesten ook een percentage van hun inkomsten voor onbepaalde tijd. En beide platforms hebben geen notie van gemeenschap.</p>
<p>Xcad is een relatief vergelijkbaar project. Het is ongetwijfeld een gaaf project, maar het is geen RWA-project en het gaat niet over gemeenschap. Het zal xcad-gebruikers uit Turkije bijvoorbeeld aansporen om naar een Spaanse maker te kijken. Het is overduidelijk dat dit alleen maar mensen zijn die kijken om de beloning te krijgen. Geen gemeenschap. Wij belonen de gemeenschap en creëren gemeenschappen die samenwerken met makers om dromen te verwezenlijken.</p>
<h2 id="h2-Q520Wat20is20de20langetermijnvisie20Hoe20zal20het20project20evolueren20en20verbeteren20voor20duurzaam20succes591874"><a name="Q5: Wat is de langetermijnvisie? Hoe zal het project evolueren en verbeteren voor duurzaam succes?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Wat is de langetermijnvisie? Hoe zal het project evolueren en verbeteren voor duurzaam succes?</h2><p>We zijn nog maar net begonnen. We hebben toegang tot een zeer groot netwerk van makers en projecten in de entertainmentindustrie. Hun financieringsbehoeften zijn reëel en wij hebben de middelen en knowhow om oplossingen te ontwikkelen.</p>
<p>Duurzaamheid is een echt probleem. En daarvan bewust zijn, zijn we al begonnen met uitbreiden naar nieuwe genres zoals gaming en ook naar nieuwe geografieën.</p>
<p>We zijn ook bezig met het ontwikkelen van meer functies. We zijn van plan uit te breiden om sporten op te nemen. Denk aan voetbal en hoe toegewijd de fan-gemeenschappen zijn. Dit is een groep die we echt kunnen mobiliseren en voetbalteams hebben altijd financiering nodig. Dus dit is iets waar we naar kijken.</p>
<p>Een deel van ons team werkt ook aan een act2earn product dat gemeenschappen en merken zal verbinden. Ik wil niet te veel onthullen omdat dit verder op onze routekaart staat, maar eigenlijk willen we de kracht van de gemeenschap mobiliseren voor merken.</p>
<p>En via Act2Earn willen we dat de community verdient voor de aandacht die ze aan merken geven. Denk aan hoe vaak je wordt blootgesteld aan advertenties. We willen dat jij, de gewone gebruiker, iets terug kunt krijgen voor het betrokken zijn bij het merk of voor het maken van inhoud voor hen. In de kern is het idee om het publiek deel te laten uitmaken van de creatieve economie.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> GateLive</strong>, Gate.io-team<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>