WmFsIEJpdGNvaW4gaW5zdG9ydGVuPyBCVEMgMjAyNSBQcmlqc3Zvb3JzcGVsbGluZw==

2025-06-23, 08:11

<p><img src="https://gimg2.gateimg.com/image/crash202506231609384281442239.png" alt="">
</p><p>De maand juni 2025 binnenkomen, de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> de markt trekt de zenuwen van wereldwijde investeerders aan te midden van gewelddadige schommelingen. Deze maand <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> Op een bepaald moment daalde het met meer dan 7%, en de Fear &amp; Greed-index kelderde van 49 naar 43, wat paniek in de markt verspreidde. Momenteel fluctueert BTC rond de $100.000, terwijl <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> is onder de $2.200 gezakt, wat de altcoin-markt naar beneden trekt. Geconfronteerd met intense gevechten tussen stieren en beren, zijn investeerders benieuwd: zal <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> zijn grote dump voortzetten, of zal het kracht verzamelen om nieuwe hoogtepunten te bereiken?</p>
<h2 id="h2-Negatief20Signaal20Marktwaarschuwingen20Onder20Meerdere20Risicos733700"><a name="Negatief Signaal: Marktwaarschuwingen Onder Meerdere Risico’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Negatief Signaal: Marktwaarschuwingen Onder Meerdere Risico’s</h2><p>De huidige markt staat onder druk van drie aspecten, die aanzienlijke bearish factoren vormen:</p>
<ol>
<li>Technische indicatoren verslechteren: BTC en de COIN50-index zijn beide onder het 200-daags voortschrijdend gemiddelde gevallen, en de doorbraak van deze belangrijke trendlijn duidt meestal op een langdurige zwakte. Nog verontrustender is dat, ondanks dat de prijzen in juni een lokaal hoogtepunt bereikten, de RSI-indicator een bearish divergentie heeft laten zien, en de koopmomentum aanzienlijk is verzwakt - dit signaal was te zien voordat de grote dump in 2022 plaatsvond.</li><li>Hefboomzeepbel en macrodruk: de markthefbomverhouding is dicht bij het piekniveau van de bullmarkt van 2021, met recente lange posities van meer dan $250 miljoen die zijn geliquideerd te midden van ernstige volatiliteit. In combinatie met de onzekerheid over de renteverlagingen van de Federal Reserve en geopolitieke conflicten, staan risicovolle activa onder aanzienlijke druk.</li><li>Regulatoire en verkoopdruk risico’s: Hoewel de verkiezing van Trump de markt tijdelijk een boost gaf, viel het tempo van de beleidsimplementatie tegen de verwachtingen in, wat het vertrouwen van investeerders verzwakte. Het Amerikaanse Ministerie van Justitie is van plan 70.000 in beslag genomen BTC (ongeveer $6,5 miljard) te verkopen, wat paniek op de markt kan veroorzaken als dit wordt uitgevoerd.</li></ol>
<h2 id="h2-Bullish20Momentum20Ondersteuning20van20Institutionele20Instap20en20Cyclische20Patronen707252"><a name="Bullish Momentum: Ondersteuning van Institutionele Instap en Cyclische Patronen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bullish Momentum: Ondersteuning van Institutionele Instap en Cyclische Patronen</h2><p>Optimistische factoren kunnen niet worden genegeerd en kunnen zelfs de markt in de tweede helft van het jaar domineren:</p>
<ul>
<li>Institutioneel kapitaal blijft <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flow</a> in: BlackRock heeft zijn aandelen zes opeenvolgende dagen in juni verhoogd, met een aankoop van 1,4 miljard USD in Bitcoin, waardoor de totale waarde van zijn crypto-holdings meer dan 70 miljard USD bedraagt. Bovendien bedraagt het huidige totale beheerd vermogen van spot Bitcoin ETF’s 111,858 miljard USD, wat goed is voor 5,89% van de totale marktkapitalisatie van BTC, en biedt het een solide basis voor de markt.</li><li>Historische cycli wijzen op hogere doelen: Op basis van AVIV-verhoudingen en machtwettenmodellen liggen de huidige indicatoren ver onder de historische piekniveaus, wat suggereert dat de top van deze cyclus 330.000 USD zou kunnen bereiken. Geen van de 30 bull-bear-indicatoren van het onafhankelijke onderzoeksinstituut CoinGlass heeft een signaal afgegeven dat de piek is bereikt, wat de beoordeling voor een voortdurende opwaartse beweging ondersteunt.</li><li>Beleid en technologische innovatie-empowerment: Texas heeft een wet aangenomen ter bescherming van Bitcoin-reserves, waarmee de lange termijn financiële positie is vastgesteld; Solana’s eerste Layer 2-netwerk Solaxy heeft in slechts 36 uur meer dan $ 56 miljoen opgehaald, en upgrades zoals het Hooks-mechanisme van <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> V4 zal ook de on-chain efficiëntie verbeteren.</li></ul>
<h2 id="h2-202520Prijsvoorspelling20Consensus20Te20midden20van20Divergentie738366"><a name="2025 Prijsvoorspelling: Consensus Te midden van Divergentie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2025 Prijsvoorspelling: Consensus Te midden van Divergentie</h2><p>Analisten tonen een aanzienlijke divergentie in hun voorspellingen voor de jaarpijlen, maar er is een algemene consensus over een “eerst onderdrukken en dan stijgen” traject:</p>
<ul>
<li>Voorzichtige faction: CryptoCapo waarschuwt voor een mogelijke terugval naar $60.000 - $65.000 (sleutelondersteuningszone van 2021);</li><li>Neutraal: Changelly verwacht dat het bereik tussen 79.458 – 126.840 USD zal liggen, met een piek in augustus of nu.</li><li>Optimisten: Het BitcoinWisdom-model voorspelt $175.035 – $218.794, terwijl CryptoQuant optimistisch is over het bereiken van $135.000 in augustus op basis van on-chain gegevens.</li></ul>
<h2 id="h2-Belangrijke20Variabelen20Beslissende20Factoren20in20Richting93328"><a name="Belangrijke Variabelen: Beslissende Factoren in Richting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijke Variabelen: Beslissende Factoren in Richting</h2><p>Drie belangrijke factoren zullen de markttrend in de tweede helft van het jaar domineren:</p>
<ol>
<li>Macroeconomisch Beleid: Beslissingen van de Federal Reserve over de rente en effectiviteit van inflatiecontrole;</li><li>Regulatory progress: De snelheid van de Amerikaanse cryptocurrency wetgeving en de implementatie van beloofde beleidsmaatregelen door Trump;</li><li>Technologische doorbraak: Layer 2 schaling (zoals <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> L2), kunnen AI-agenten en DePIN de praktische waarde op de blockchain vergroten.</li></ol>
<p>Extreme risico’s vereisen ook waakzaamheid: ChatGPT-simulaties tonen aan dat als er een regionale nucleaire oorlog uitbreekt, BTC met 60%-80% kan dalen - ondanks de kans op dit scenario slechts 18% is.</p>
<h2 id="h2-Conclusie20Strategische20Indeling20is20Beter20dan20Korte20Termijn20Speculatie612484"><a name="Conclusie: Strategische Indeling is Beter dan Korte Termijn Speculatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie: Strategische Indeling is Beter dan Korte Termijn Speculatie</h2><p>Gezien verschillende signalen wordt verwacht dat Bitcoin zijn bodemvorming zal voltooien tussen het einde van Q2 en het begin van Q3 in 2025, met mogelijk een herstelkanaal in de tweede helft van het jaar. Korte termijn volatiliteit kan aanhouden, en $93.000 is een belangrijk steunniveau; het doorbreken van dit niveau kan de correctie verdiepen. Echter, gesteund door de instroom van fondsen in spot ETF’s, de vraag naar institutionele allocatie, en het halveringscycluspatroon, wordt onder $100.000 beschouwd als een lange termijn waardebereik.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u enige investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van (een deel van) de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="7">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>