UGFzIG9wIHZvb3IgTkZULW9wbGljaHRpbmcgLSBIb2Ugb25kZXJzY2hlaWQgdGUgbWFrZW4gdHVzc2VuIGVjaHRlIGVuIHZhbHNlIE5GVD8=

2023-01-19, 08:21

<p><img src="https://gimg2.gateimg.com/blog/165042832718348369crypto101_web.jpg" alt=""></p>
<p><strong>[TL; DR]</strong><br>🔹 De totale verkoop van NFT’s in 2022 bedroeg $55,5 miljard, een stijging van 175% ten opzichte van $20,2 miljard in 2021.</p>
<p>🔹 Let op voor oplichters die NFT-kunstwerken kopiëren en ze vervolgens gaan verkopen na het slaan, waarbij ze valselijk beweren dat ze officieel verkocht zijn.</p>
<p>🔹 Er zijn 7 manieren om de waarheid over NFT’s te vertellen om u weg te houden van de NFT-zwendel.</p>
<h2 id="h2-Introductie607683"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Volgens onvolledige statistieken waren er in het hele jaar 44 2022 veiligheidsincidenten in NFT, met verliezen van meer dan $ 42,56 miljoen. In 2022 bedroeg de totale omzet van NFT $ 55,5 miljard, waarvan 46% afkomstig was van wash trading.</p>
<p>NFT is altijd een populaire trend geweest in transacties met crypto-activa. Hoe kunnen we valse NFT’s identificeren in het huidige tijdperk van fraude?</p>
<h2 id="h2-Zijn20NFToplichting20vaak20voorkomend497771"><a name="Zijn NFT-oplichting vaak voorkomend?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zijn NFT-oplichting vaak voorkomend?</h2><p>2022 is een turbulent jaar geweest voor cryptocurrencies. De bullish markt voor cryptocurrencies eindigde na verschillende belangrijke gebeurtenissen. Deze marktimpact heeft ook invloed op NFT’s. In 2022 waren de verkoop en het totale aantal gebruikers van NFT’s dalende. Desalniettemin bedroeg de totale verkoop van NFT’s in 2022 $55,5 miljard, een stijging van 175% ten opzichte van $20,2 miljard in 2021.<br><img src="https://gimg2.gateimg.com/image/article/1674115864111.png" alt=""></p>
<p>De gegevensbron van NFT-verkopen en totale gebruikers in 2022: Footprint Analytics</p>
<p>Dus zelfs in de bearmarktomgeving hebben beleggers nog steeds een sterke interesse in de NFT-markt. In 2021 waren er ongeveer 145.000 NFT-collecties, maar tegen het einde van 2022 waren de relevante gegevens aanzienlijk toegenomen. Elke dag worden er nieuwe collecties en projecten geboren in NFT, wat veel investeringsmogelijkheden creëert. Kansen en marktvraag gaan echter hand in hand, en dat geldt ook voor fraude.</p>
<p><a href="https://www.gate.io/blog_detail/544/NFTs--a-new-window-of-opportunity-for-digital-scammers--learn-How-to-Avoid-NFT-Scams" target="_blank">NFT scams zijn wijdverspreid</a> variërend van honderdduizenden dollars tot miljoenen dollars. Zo werden bijvoorbeeld onlangs Mutant Ape Yacht Club (MAYC) en de NFT-ontwikkelaar Aurelien Michel van de Mutant Ape Planet-serie gearresteerd en beschuldigd van fraude omdat ze naar verluidt 2,9 miljoen dollar hadden opgelicht.</p>
<p>In februari 2022 was OpenSea in de NFT-markt onderwerp van <a href="https://www.gate.io/ru/blog_detail/770/the-implications-of-opensea-phishing-scam?lang=en" target="_blank">om phishingfraude tegen gebruikers</a>, en NFT’s ter waarde van meer dan $2,7 miljoen werden illegaal gelekt. Fraudeurs stuurden valse e-mails vermomd als OpenSea om gebruikers te misleiden met het volgen van kwaadaardige links en hen aan te sporen om frauduleuze contracten te ondertekenen.</p>
<p>Op dit moment heeft NFT “Bored Ape Yacht Club (BAYC)”, die relatief populair is en een hoge transactieprijs heeft, ook de mogelijkheid van visfraude. De CEO van de projectontwikkelaar, Yuga Labs, verklaarde dat ze een bericht hadden ontvangen dat iemand bezig was met vissen. <a href="https://www.gate.io/blog_detail/1032/The-Official-Bored-Ape-Yacht-Club-Instagram-account-hacked-with-over--13.7-Million-worth-of-BAYC-NFTs-stolen" target="_blank">proberen aan te vallen</a> hun project.</p>
<p>Er <a href="https://www.gate.io/blog_detail/1342/What-are-the-most-common-types-of-NFT-scams" target="_blank">zijn talloze NFT-zwendel</a> van vergelijkbare grootte en de hoeveelheid is onbeperkt. Zelfs de NFT-collectie van beroemdheden is onthuld dat deze is gestolen. Zo zei bijvoorbeeld Jay Chou, een beroemde zanger, in een artikel op 1 april dat zijn nummer 3738, de Bored Ape NFT, gestolen was door phishing, met een waarde van $330.000.<br><img src="https://gimg2.gateimg.com/image/article/1674115934222.png" alt=""></p>
<p>Bored Ape Yacht Club NFTs. Bron: opensea</p>
<h2 id="h2-Wat20is20het20verschil20tussen20nietvervangbare20tokens20en20nietvervangbare20afbeeldingen894363"><a name="Wat is het verschil tussen niet-vervangbare tokens en niet-vervangbare afbeeldingen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het verschil tussen niet-vervangbare tokens en niet-vervangbare afbeeldingen?</h2><p>NFT staat voor non-fungible token. De essentie ervan ligt in het unieke vertrouwde digitale aandeel certificaat in het blockchain netwerk, dat een uniek digitaal bezit is en een belangrijke infrastructuur vormt voor het huidige populaire metaverse.</p>
<p>De kenmerken ervan omvatten uniciteit en ondeelbaarheid. Elk NFT-werk heeft een unieke ‘digitale ID-kaart’, die het nummer is dat door de maker is ingesteld. Dit maakt het ook mogelijk dat NFT-werken volledig worden geregistreerd door de blockchain in elke <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> van circulatie en handel.</p>
<p>Er zijn echter veel soorten NFT’s, waaronder afbeeldingen, schilderijen en andere kunstwerken, games, spelerskaarten, films, muziek, avatars, verzekeringen en gifs. Non-Fungible afbeelding is er slechts één van, en het is momenteel ook een populaire NFT-afbeelding.<br><img src="https://gimg2.gateimg.com/image/article/1674116062333.png" alt=""></p>
<p>MAYC. Bron: Gate.io</p>
<h2 id="h2-Belangrijke20methoden20om20de20echtheid20van20een20NFT20te20verifiren605507"><a name="Belangrijke methoden om de echtheid van een NFT te verifiëren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijke methoden om de echtheid van een NFT te verifiëren</h2><p>Hoewel NFT-kunstwerken uniek zijn, is het nog steeds noodzakelijk om aandacht te besteden aan de authenticiteit van de NFT-kunstwerken waarin u investeert bij het handelen of verzamelen. De authenticiteit van <a href="https://www.gate.io/blog_detail/902/Minting--Purchasing-and-Trading-NFT-Art" target="_blank">NFT kunstwerken</a> kan worden geverifieerd voor referentie via de volgende aspecten.</p>
<h3 id="h3-Verifieer20de20identiteit20van20de20artiest20of20verkoper600044"><a name="Verifieer de identiteit van de artiest of verkoper" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verifieer de identiteit van de artiest of verkoper</h3><p>Legale NFT-verkopers hebben een blauw authenticatiemerk naast hun gebruikersnaam op de <a href="https://www.gate.io/nft/explore" target="_blank">NFT marktplatform</a> en de kenmerken van de collectie worden duidelijk vermeld. U kunt ook de juiste kunstenaars en hun werken vinden op sociale mediakanalen of via de websites van de kunstenaars. De meest directe manier is om de kunstenaar te vragen of het kunstwerk dat u wilt kopen van hen is en of hij het juiste gebruikersprofiel heeft.<br><img src="https://gimg2.gateimg.com/image/article/1674116111444.png" alt=""></p>
<p>Bron: Gate.io</p>
<h3 id="h3-Controleer20de20grootte20en20activiteit20van20de20officile20website20en20gemeenschap303244"><a name="Controleer de grootte en activiteit van de officiële website en gemeenschap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Controleer de grootte en activiteit van de officiële website en gemeenschap</h3><p>Bezoek altijd direct geverifieerde websites voor NFT-transacties, zoals Gate NFT. Terwijl u op het marktplatform surft, kunt u de activiteit van het platform en de verkoopgegevens van NFT-gerelateerde kunstwerken observeren, de transactiegeschiedenis van kopers of verkopers en de deelname van makers bekijken. Besteed speciale aandacht aan en weersta de verleiding van de zogenaamde speciale aanbieding NFT, die een van de manieren kan zijn om investeerders te verleiden om te kopen.</p>
<h3 id="h3-Verifieer20contractadres911070"><a name="Verifieer contractadres" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verifieer contractadres</h3><p>Elke NFT-kunsthandelspagina heeft contractadresgegevens, die kunnen worden opgevraagd en u helpen de handelssituatie van de verkoper te begrijpen. Controleer of de projectmakers eerlijk en transparant zijn over hun identiteit.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674116159555.png" alt=""></p>
<p>Bron: Gate NFT</p>
<h3 id="h3-Pas20op20voor20nep20NFT20weggeefacties806585"><a name="Pas op voor nep NFT weggeefacties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pas op voor nep NFT weggeefacties</h3><p>Om investeerders aan te trekken om te handelen, zullen oplichters voordelen aanbieden: investeerders krijgen een gratis NFT door zich te registreren op de website via hun promotie-informatie. Echter, nadat de investeerder zich registreert, zal het systeem u vragen om… <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> uw portefeuille-inloggegevens om uw “giveaways” te ontvangen. Zodra fraudeurs de door investeerders ingevoerde referenties hebben, kunnen ze vrijelijk toegang krijgen tot hun accounts en activa stelen.</p>
<h3 id="h3-Google20Zoeken20naar20NFTafbeeldingen85433"><a name="Google Zoeken naar NFT-afbeeldingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Google Zoeken naar NFT-afbeeldingen</h3><p>Zoek het overeenkomstige nummer op Google voor het NFT-kunstwerk waarin je wilt investeren, of zoek direct naar afbeeldingen.</p>
<h3 id="h3-Bekijk20het20verkoopvolume20en20de20prijs20van20NFT984878"><a name="Bekijk het verkoopvolume en de prijs van NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bekijk het verkoopvolume en de prijs van NFT</h3><p>Voor <a href="https://www.gate.io/price/view/nft" target="_blank">het kopen van NFT-kunstwerken</a>, u kunt de bijbehorende prijzen controleren op het officiële handelsplatform. Als de prijs lijkt te laag te zijn in vergelijking met de prijs vermeld op de legitieme handelswebsite, koop dan voorzichtig. Dit kan een fraude zijn. Als het verkoopvolume van NFT-kunstwerken hoger is dan het normale handelsvolume, kan dit gegevensmanipulatie zijn, zoals washandel.</p>
<h3 id="h3-Omgekeerd20afbeeldingszoeken20met20behulp20van20NFT873470"><a name="Omgekeerd afbeeldingszoeken met behulp van NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Omgekeerd afbeeldingszoeken met behulp van NFT</h3><p>Als u niet zeker weet of deze NFT vervalst is, kunt u een omgekeerde beeldzoekopdracht uitvoeren, zoals Tiny Eye, om te zien of de verkoper eigendom heeft van het beeld.</p>
<h2 id="h2-Hoe20echte20NFTkunstwerken20te20kopen20en20ervoor20te20zorgen20dat20ze20niet20gestolen20zijn497945"><a name="Hoe echte NFT-kunstwerken te kopen en ervoor te zorgen dat ze niet gestolen zijn" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe echte NFT-kunstwerken te kopen en ervoor te zorgen dat ze niet gestolen zijn</h2><p>Naast de hierboven genoemde stappen om de authenticiteit van NFT te bevestigen, is er ook een belangrijke manier om een vertrouwd NFT-handelsplatform te kiezen. Naast het waarborgen van de <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroming</a> Naast de veiligheid van fondsen en de transparantie van transacties heeft het platform ook het vertrouwen van duizenden gebruikers en het bijwerken van NFT-werken om te voorkomen dat ze slachtoffer worden van nepwebsites en valse projecten.</p>
<p>Een bekende NFT-handelsmarkt is OpenSea, die ook de grootste en meest populaire markt is op het gebied van NFT op dit moment. Het aanbod van verhandelbare NFT-werken is breed en het is de plek waar de meeste gegenereerde kunstcollecties zich bevinden. Echter, makers en verkopers moeten een eenmalige vooruitbetaling doen voor de initialisatie van het account, die tussen de $20 en $250 ligt. Ook is het nodig om 2,5% van de transactieprijs aan het platform te betalen nadat de transactie is voltooid.</p>
<p>Gebruikers kunnen er ook voor kiezen om te bladeren en te handelen op de<br><strong>Gate <a href="https://www.gate.io/nft" target="_blank">NFT handelsplatform</a></strong>. Gate NFT is gemaakt op basis van de Gate.io cryptocurrency exchange, die al 9 jaar in bedrijf is. De exchange heeft een derde partij margin verstrekt voor de cryptocurrency transacties van gebruikers om de veiligheid van de fondsen van gebruikers te waarborgen. The<br><strong>Gate NFT platform</strong>, samen met kunstenaars, trending IPs en bekende makers, is een distributieplatform van de eerste categorie voor het lanceren van hoogwaardige NFT-werken op de markt. De werken omvatten alle categorieën van NFT-digitale activa zoals kunst, verzamelingen, metaverse, muziek, films, games, enz. Kunstenaars of makers verkopen NFT-werken via het Gate NFT-distributieplatform, dat de natuurlijke voordelen heeft van lage kosten, hoge opbrengsten, hoge liquiditeit en gemeenschapsaandrijving.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674116241666.png" alt=""></p>
<p>Bron: Gate NFT</p>
<p>Na het kiezen van een betrouwbaar NFT-marktplatform, moet je ook letten op andere manieren waarop fraudeurs jouw privacygegevens kunnen verkrijgen, zoals phishingfraude via berichten/e-mails met links die herinneren aan een ‘officiële adresupgrade’, evenals valse websites, NFT-risico’s verkopen via veilingen. <a href="https://www.gate.io/pt/learn/articles/what-is-a-crypto-airdrop/24" target="_blank">valse NFT-luchtdrop</a>, en het imiteren van de officiële klantenservice.</p>
<p>Fraude is overal in het NFT-veld. Investeerders moeten waakzaam zijn bij het browsen en handelen, letten op verificatie en onderzoek, en vermijden om onschuldige slachtoffers te worden.</p>
<h2 id="h2-Veelgestelde20vragen20over20NFToplichting575844"><a name="Veelgestelde vragen over NFT-oplichting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over NFT-oplichting</h2><h3 id="h3-Kunnen20NFTs20worden20vervalst962234"><a name="Kunnen NFT’s worden vervalst?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kunnen NFT’s worden vervalst?</h3><p>Over het algemeen is een NFT uniek. Elk kunstwerk is ingebed met unieke coderingsinformatie voor latere circulatie en handel. Er zullen echter nog steeds enkele oplichters zijn die kunstwerken kopiëren en ze vervolgens beginnen te verkopen nadat ze ze in een NFT hebben gemunt, waarbij ze ten onrechte beweren dat ze officieel zijn verkocht.</p>
<h3 id="h3-Hoe20weet20ik20of20de20NFT20echt20is288940"><a name="Hoe weet ik of de NFT echt is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe weet ik of de NFT echt is?</h3><p>De NFT kan worden geverifieerd via tools zoals een blockchain-browser, een authenticiteit digitaal certificaat en omgekeerd beeldzoeken. De bevestigingsmethoden worden vermeld in de bovenstaande inhoud.</p>
<h3 id="h3-Kan20iemand20NFTeigendom20vervalsen388262"><a name="Kan iemand NFT-eigendom vervalsen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan iemand NFT-eigendom vervalsen?</h3><p>Zelfs als de fraudeur de NFT kan kopiëren of vervalsen, kan het niet de metadata-eigendom kopiëren en vervalsen die verband houden met het werk. De enige coderingsinformatie die door NFT-makers voor hun kunstwerken wordt gegenereerd, wordt vastgelegd in de blockchain en gebruikers kunnen gemakkelijk hun eigendom verifiëren.</p>
<h3 id="h3-Zijn20sommige20NFTverkopen20nep489101"><a name="Zijn sommige NFT-verkopen nep?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zijn sommige NFT-verkopen nep?</h3><p>Deze mogelijkheid is te wijten aan het bestaan van wash trading in NFT-markttransacties. NFT wash trading betekent dat de koper en verkoper in de transactie dezelfde persoon zijn of twee samenspannende personen. Dit is een vorm van marktmanipulatie. Investeerders kopen en verkopen tegelijkertijd dezelfde producten om misleidende menselijke activiteiten op de markt te creëren.</p>
<h3 id="h3-Zijn20nep20NFTs20legaal971959"><a name="Zijn nep NFT’s legaal?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zijn nep NFT’s legaal?</h3><p>Normaal virtueel eigendom is wettelijke persoonlijke bezittingen beschermd door de wet. Valse NFT-producten zijn niet inbegrepen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Rena W. </strong>, Gate.io-onderzoeker<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 glen zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>