R2F0ZS5pbyBBTUEgbWV0IFByaW1hbC1Nb3ZlMkVhcm4gKyBGYW4gVG9rZW5zICsgSW5uZXIgQ2lyY2xlcw==

<p><img src="https://gimg2.gateimg.com/image/article/1674898428FmmCI_gX0AAbiIP.jpeg" alt=""><br><strong>Tijd: 17 januari 2023, 13:00 uur (UTC)</strong><br><strong>Gate.io organiseerde een AMA (Ask-Me-Anything) sessie met de Co-Founder van Primal, Ben, in de Twitter Space.</strong><br><strong>Officiële website: <a href="http://www.getprimal.com/" rel="nofollow noopener noreferrer" target="_blank">http://www.getprimal.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/enterprimal" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/enterprimal</a></strong><br><strong>Volg Primal op Telegram en Twitter</strong></p>
<p><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/167489852611.png" alt=""><br><strong>Ben — Medeoprichter van Primal</strong></p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio339788"><a name="Vraag &amp; Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag &amp; Antwoord van Gate.io</h2><h3 id="h3-Q120Kun20je20een20overzicht20geven20van20PRIMAL427847"><a name="Q1: Kun je een overzicht geven van PRIMAL?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je een overzicht geven van PRIMAL?</h3><p><strong>Ben</strong> PRIMAL is het eerste atleet fan-tokenproject met geïntegreerde Move2Earn dat gebruikers beloont voor het sporten, fans verbindt met beroemde atleten en atleten van alle niveaus ondersteunt op hun reis. PRIMAL combineert 2 enorm succesvolle concepten: STEP App-style sporten + Chiliz-style fan tokens. Ontworpen voor massale adoptie: fans verbinden met beroemde atleten, trainen en verdienen aan alle soorten fitnessactiviteiten, ruil je favoriete atleten fan tokens. PRIMAL heeft 3 belangrijke pijlers, allemaal aangedreven door $PRIMAL: Inner Circle, PRIMAL’s Inner Circle verbindt fans en atleten als nooit tevoren via zijn branchedefiniërende app. Denk aan Patreon ontmoet masterclass gevoed door de blockchain. Fan Tokens, huidige projecten verbinden fans met instellingen. PRIMAL streeft ernaar om te decentraliseren van grote bedrijven en fans rechtstreeks te verbinden met hun favoriete atleten. Move 2 Earn.<br><img src="https://gimg2.gateimg.com/image/article/167489871512.png" alt=""><br>Train op jouw manier, wanneer je maar wilt. In tegenstelling tot andere M2E-projecten die zich alleen richten op hardlopen en je straffen, lanceert PRIMAL een app die alle soorten fitnessactiviteiten beloont door verbinding te maken met biometrische gegevens.</p>
<h3 id="h3-Q220Kun20je20de20nut20van20de20PRIMALtoken20bespreken599178"><a name="Q2: Kun je de nut van de $PRIMAL-token bespreken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kun je de nut van de $PRIMAL-token bespreken?</h3><p><strong>Ben</strong>: $PRIMAL is onze belangrijkste governance &amp; Utility-token. $PRIMAL voedt ons hele ecosysteem.<br>Fan Tokens - Gebruikers zullen $PRIMAL gebruiken om fan tokens te kopen van elke atleet in het PRIMAL-ecosysteem, wat aanzienlijke koopdruk op het token toevoegt<br>Inner Circles - Gebruikers zullen $PRIMAL betalen aan atleten om toegang te krijgen tot hun inner circles, trainingskampen, exclusieve inhoud en forums.<br>App - NFT-marktplaats, aankoop van digitale &amp; fysieke goederen van merken &amp; atleten<br>Het inzetten van $PRIMAL biedt ook veel voordelen, zoals korting op NFT-handelskosten, limited edition NFT’s en meer.<br>PRIMAL heeft ook verbrandingsmechanismen die u op onze website kunt bekijken- <a href="https://www.getprimal.com/economy" rel="nofollow noopener noreferrer" target="_blank">https://www.getprimal.com/economy</a>.</p>
<h3 id="h3-Q320Wat20maakt20u20anders20dan20de20concurrentie831758"><a name="Q3: Wat maakt u anders dan de concurrentie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Wat maakt u anders dan de concurrentie?</h3><p><strong>Ben</strong>: Andere Move2Earn-projecten laten je alleen lopen of rennen en straffen je zelfs. De PRIMAL-app synchroniseert met uw fitnesstrackers – dit zijn meer dan 150.000.000 potentiële gebruikers samen.<br>Samenwerkingen met biometrische apparaten stellen PRIMAL in staat om belangrijke gezondheidsgegevens te benutten, de activiteit in de echte wereld te meten en verbrande calorieën om te zetten in verdiend geld. Dit betekent dat de functionaliteit oefening-agnostisch is, waardoor alle activiteiten kunnen worden geteld, wat enorme mogelijkheden biedt voor het onboarden van gebruikers.<br>Dit omvat de integratie van Apple Health, Whoop, Oura Ring en Fitbit, waardoor bestaande gebruikers die deze fitnessapparaten hebben, bruikbaar worden.<br>Hierdoor kun je trainen HOE je wilt, wanneer je wilt. Mensen hebben verschillende niveaus van fitheid en daar zijn we ons van bewust.<br>Er is ook geen ander project dat zowel fan als atleet met elkaar verbindt, waardoor ze kunnen leren, trainen en verdienen terwijl ze dat doen.</p>
<h3 id="h3-Q420Wat20heb20je20tot20nu20toe20bereikt106077"><a name="Q4: Wat heb je tot nu toe bereikt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Wat heb je tot nu toe bereikt?</h3><p><strong>Ben</strong>: PRIMAL heeft sinds de lancering aanzienlijke sprongen gemaakt en heeft zich door de bearmarkt geworsteld en zichzelf verstevigd in de sport- en web3-ruimte, terwijl andere projecten inactief waren.<br><img src="https://gimg2.gateimg.com/image/article/167489864313.png" alt=""><br>Tot op heden heeft PRIMAL:</p>
<ul>
<li>$PRIMAL gelanceerd op 4 grote CEX en Pancake-swap</li><li>Top 5 meest verhandelde token op alle beurzen waarop we genoteerd staan</li><li>$PRIMAL werd 4e qua volume in Pancakes Wap enkele dagen na notering - alleen BNB, BUSD en USDT hadden een hoger volume</li><li>App heeft nu 960.000+ downloads, met 160.000 dagelijks actieve gebruikers - groeit met 100% MoM</li><li>1e NFT-verkoop, waarbij voor $500.000 aan NFT’s werd verkocht, de grootste NFT-verkoop van dit jaar</li><li>Meerdere partnerschappen met FIAT-toevoerwegen</li><li>Fan-token-gekko gelanceerd, een site waar gebruikers dagelijks volume, marktkapitalisatie en prijs van alle atleet-fantokens kunnen controleren. We hadden 35k weergaven op dag 1 + een gemiddelde kijktijd van 3 min<br>Groei-campagne - alle ogen zijn op ons gericht, het enige project dat levert en fundamenten bouwt voor de volgende bull run</li><li>Eerste fan-token met Andreas Pereira, een Premier League-voetballer samen met 15 andere ambassadeurs</li><li>Onze Fan Token Offering-site is deze week gelanceerd - <a href="https://fto.getprimal.com/" rel="nofollow noopener noreferrer" target="_blank">https://fto.getprimal.com/</a></li></ul>
<h3 id="h3-Q520Wat20heeft20de20toekomst20in20petto20voor20PRIMAL529076"><a name="Q5: Wat heeft de toekomst in petto voor $PRIMAL?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Wat heeft de toekomst in petto voor $PRIMAL?</h3><p><strong>Ben</strong> 2023 is het jaar van PRIMAL.<br>We hebben zoveel in petto voor het eerste deel van het jaar.</p>
<ul>
<li>Onze Fan Token DEX gaat deze week live, waar gebruikers fan tokens kunnen verhandelen van Binance en andere platforms</li><li>Samenwerking met een top 100 project binnenkort</li><li>Onze eerste fan token wordt zeer binnenkort gelanceerd</li><li>Onze Mainnet lanceert op 10 februari met M2E-functionaliteit &amp; andere app-functies</li><li>Onze eerste Inner Circles met topsporters gaan live op de PRIMAL app</li><li>Meer partnerschappen &amp; meer atleten worden binnenkort bekendgemaakt</li><li>Meer beurzen worden binnenkort bekendgemaakt</li><li>We vieren PRIMAL tijdens onze PRIMAL takeover week in Zuid-Korea in Q1/2 van dit jaar, waar beroemdheden aanwezig zullen zijn samen met onze atleten.</li></ul>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle gevallen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>