Qml0Y29pbiBQaXp6YSBEYXksIFByaWpzIGJyZWVrdCAxMTAuMDAwIEFtZXJpa2FhbnNlIGRvbGxhcnMsIEdhdGUgUGl6emFEcm9wIG1ldCAxMCBCVEMgYWlyZHJvcCBvbSBoZXQgZmVlc3QgdGUgdmllcmVu

<p><img src="https://gimg2.gateimg.com/image/11202505221546024336758081.png" alt="">
</p><p>Op 22 mei 2025, het 15-jarig jubileum <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Pizza Day is niet alleen een herdenking van de historische transactie in 2010 toen Laszlo Hanyecz twee pizza’s kocht met 10.000 Bitcoins, maar ook omdat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> Het doorbreken van $110.000 om een nieuw all-time high te bereiken, is het middelpunt geworden van de wereldwijde crypto-community-hysterie. De transactie, destijds ter waarde van ongeveer $4, wordt nu gewaardeerd op ongeveer $1,1 miljard en wordt lachend de ‘duurste pizza in de geschiedenis’ genoemd.</p>
<p>Op dit speciale moment is CandyDrop, het snoepairdrop-platform onder Gate, tijdelijk omgedoopt tot PizzaDrop en gelanceerd <a href="https://www.gate.com/zh/candy-drop/detail/BTC-34" target="_blank">Beperkt Tijd Carnaval Evenement</a>, nodig wereldwijde gebruikers uit om het feest te delen met een super airdrop van 10 BTC.</p>
<h2 id="h2-Bitcoinprijs20bereikt20een20nieuw20hoogtepunt20van20110000871511"><a name="Bitcoin-prijs bereikt een nieuw hoogtepunt van $110.000" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin-prijs bereikt een nieuw hoogtepunt van $110.000</h2><p>Volgens Gate-gegevens, per 22 mei 2025, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> Met een stijging van ongeveer 4% van $107.092,03 van 24 uur geleden en een stijging van 9% van $102.766,82 van een week geleden, heeft de prijs $111.689,78 bereikt. Deze prijs overtreft het hoogste punt van $109.700 op 20 januari en markeert de intrede van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> in een nieuwe fase van prijsontdekking.</p>
<p><img src="https://gimg2.gateimg.com/image/ying202505221546558745486873.png" alt="">
</p><p>Marktbeleggers zijn optimistisch, met sociale media die gevuld zijn met bullish voorspellingen over de toekomstige trend van Bitcoin. Sommige beleggers roepen zelfs op tot doelen variërend van $150.000 tot $500.000. De marktwaarde van Bitcoin heeft $2,22 biljoen bereikt, wat 66% van de totale marktwaarde van de cryptomarkt vertegenwoordigt en benadrukt zijn dominante positie.</p>
<h3 id="h3-De20drijvende20krachten20achter20de20recente20prijsstijging521007"><a name="De drijvende krachten achter de recente prijsstijging" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De drijvende krachten achter de recente prijsstijging</h3><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> Sinds het doorbreken van $100.000 aan het einde van 2024, is het blijven stijgen naar meer dan $110.000, gedreven door meerdere factoren die samen resoneren. De volgende zijn de belangrijkste redenen voor de recente stijging:</p>
<h4 id="h4-120Institutionele20beleggingsboom20en20instroom20van20ETFs995114"><a name="1. Institutionele beleggingsboom en instroom van ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Institutionele beleggingsboom en instroom van ETF’s</h4><p>In januari 2024 keurde de Amerikaanse Securities and Exchange Commission (SEC) de eerste batch spot goed <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> exchange-traded funds (ETF’s), waardoor traditionele beleggers een handig kanaal hebben voor Bitcoin-investering. Sinds goedkeuring blijft de ETF een grote hoeveelheid fondsen aantrekken, met een totale instroom van $6.9 miljard in de afgelopen drie weken, inclusief BlackRock’s iShares. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Trust (IBIT) valt op, met meer dan 400.000 munten van Bitcoin in bezit, met een nettostroom van meer dan 2,2 miljard Amerikaanse dollars. De komst van institutionele beleggers verbetert niet alleen de marktliquiditeit, maar versterkt ook de legitimiteit en aantrekkelijkheid van Bitcoin als activum.</p>
<h4 id="h4-220Bedrijven20en20walvissen20blijven20hamsteren375974"><a name="2. Bedrijven en ‘walvissen’ blijven hamsteren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Bedrijven en ‘walvissen’ blijven hamsteren</h4><p>De deelname van bedrijfsinvesteerders drijft de prijs verder op. Zo kocht MicroStrategy (nu Strategy) bijvoorbeeld op 21 januari 2025 7.390 BTC ter waarde van 1,1 miljard USD, waarmee het de grootste zakelijke Bitcoin-houder werd. De totale holdings hebben een boekwinst opgeleverd van 22,7 miljard USD. Andere bedrijven, zoals het Japanse Metaplanet, hebben zich ook aangesloten bij de hamsterrangen, wat het vertrouwen van ondernemingen weerspiegelt in de langetermijnwaarde van Bitcoin.</p>
<h4 id="h4-320Marktsentiment20en20speculatieve20gekte295631"><a name="3. Marktsentiment en speculatieve gekte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. Marktsentiment en speculatieve gekte</h4><p>De huidige marktsentiment is ‘extreem hebzuchtig’, weerspiegeld in de scherpe stijging van het openstaande interesse (OI) in de futuresmarkt. Op 20 mei bereikte het totale openstaande interesse in de Bitcoin-derivatenmarkt $72.63 miljard, een stijging van 27% ten opzichte van $57.1 miljard op 19 april. De openstaande interesse in CME-futures bereikte ook een hoogtepunt van 90 dagen, met 157.875 BTC (ongeveer $16.76 miljard). De toename van hoge hefboom-lange posities toont het sterke vertrouwen van investeerders in de opwaartse trend.</p>
<h2 id="h2-Gate20PizzaDrop20Profiteren20van20het20pizzafestival20om20het20rijkdomsfeest20te20delen136321"><a name="Gate PizzaDrop: Profiteren van het pizzafestival om het rijkdomsfeest te delen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gate PizzaDrop: Profiteren van het pizzafestival om het rijkdomsfeest te delen</h2><p>In <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> Op het snijvlak van een all-time high en Pizza Day grijpt Gate de kans om zijn CandyDrop-platform om te dopen tot PizzaDrop, met de lancering van een tijdelijk carnavalsevenement dat de gemeenschapsenthusiasme aanwakkert met een superprijs van 10 BTC. Het evenement loopt van 14:00 op 22 mei 2025 tot 23:59 op 3 juni 2025 (UTC+8). Gebruikers hoeven slechts een 1 USDT-contracttransactie te voltooien om deel te nemen aan het delen van de prijzenpot, met een maximum van 0.01 BTC per persoon.</p>
<p><img src="https://gimg2.gateimg.com/image/ying-2202505221547427212416504.png" alt="">
</p><h3 id="h3-Activiteitsregels230748"><a name="Activiteitsregels" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Activiteitsregels</h3><ul>
<li><p>Prijszwembadgrootte: 10 BTC, individueel limiet 0.01 BTC</p>
</li><li><p>Evenementtijd: 22 mei 2025, 14:00 - 3 juni 2025, 23:59 (UTC+8)</p>
</li><li><p>Deelnamemethode:</p>
<ol>
<li>Bezoek de PizzaDrop-pagina en klik op “Nu meedoen”.</li><li>Voltooi de contracthandelstaak van 1 USDT om de deelnamekwalificatie te ontgrendelen.</li><li>Volgens de voltooiing van de taken wordt ‘pizza’ (snoep) verkregen en wordt de prijzenpot proportioneel verdeeld.</li><li>Candy wordt binnen 1-3 uur na voltooiing van de taak verdeeld, en gebruikers kunnen inloggen om te controleren.</li></ol>
</li></ul>
<p>Voor meer details, klik om te lezen <a href="https://www.gate.com/zh/announcements/article/45128）" target="_blank">Aankondiging van activiteiten</a><br>**
</p><p>Dit evenement is ontworpen met een lage drempel en hoge opbrengsten, niet alleen als eerbetoon aan het Pizza Festival, maar ook om gebruikers een betaalbare kans te bieden om deel te nemen aan de Bitcoin gekte. Gate combineert de historische betekenis van Bitcoin met de huidige marktgekte via PizzaDrop, waardoor nieuwe en oude investeerders samen de potentie van de cryptowereld verkennen.</p>
<h2 id="h2-Doe20mee20aan20PizzaDrop20deel20de20legende20van20Bitcoin35493"><a name="Doe mee aan PizzaDrop, deel de legende van Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Doe mee aan PizzaDrop, deel de legende van Bitcoin</h2><p>Bitcoin heeft de $110.000 doorbroken, wat zijn overgang van een randactivum naar mainstream financiën markeert. Hoge volatiliteit blijft echter een inherent kenmerk. Vermogensadviseur Peter Hughes waarschuwde dat historische gegevens laten zien dat Bitcoin meer dan 70% daalde na het bereiken van een piek in november 2021, en investeerders alert moeten zijn op vergelijkbare risico’s. Desalniettemin zorgen institutionele instap, gunstige beleidsmaatregelen en aanbod-vraagverkrapping voor langetermijnopwaartse momentum voor Bitcoin. Marktanalyse voorspelt dat Bitcoin tegen 2025 $150.000 zou kunnen testen, maar de risico’s van een korte-termijn terugval mogen niet worden genegeerd.</p>
<p>Bitcoin Pizza Day is niet alleen een echo van de geschiedenis, maar ook een startpunt voor de toekomst. Vandaag, nu de prijs een nieuw hoogtepunt van $110.000 bereikt, nodigt Gate PizzaDrop je uit om deel te nemen aan deze wereldwijde viering met een 10 BTC-luchtdaling. Met slechts 1 USDT-contracthandel kun je ‘pizza’ ontvangen, de prijzenpot delen en deel uitmaken van de legende van Bitcoin.</p>
<p>Activiteitslink: Bezoek <a href="https://www.gate.com/zh/candy-drop/detail/BTC-34" target="_blank">Gate PizzaDrop pagina</a> Klik op ‘Nu lid worden’ om aan je reis naar versleuteling te beginnen!</p>
<p>Van een pizza tot een legendarische $1,1 miljard, het verhaal van Bitcoin gaat door. Doe mee met PizzaDrop, vier het verleden en omarm de toekomst met Gate!</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Blogteam</strong><br>  <div class="info-tips"><em>Deze inhoud vormt geen enkel aanbod, verzoek of advies. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br>  <div></div>Houd er rekening mee dat Gate mogelijk alle of een deel van zijn diensten beperkt of verbiedt in beperkte gebieden. Lees de gebruikersovereenkomst voor meer informatie, link:<a href="https://www.gate.io/zh/user-agreement。" data-index="11"></a><a href="https://www.gate.io/en/user-agreement。" data-index="12">https://www.gate.io/nl/gebruikersovereenkomst。</a><br><p></p><br></em></div></div></div>