RGV1dHNjaGUgQmFuazogUmV0YWlsYmVsZWdnZXJzIHZvb3JzcGVsbGVuIGRhdCBCaXRjb2luIHRlZ2VuIGhldCBlaW5kZSB2YW4gMjAyNCBvbmRlciBkZSAkMjAuMDAwIHphbCBkYWxlbg==

2024-02-08, 04:52

<p><img src="https://gimg2.gateimg.com/image/article/1707367393RDZZ1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen88033"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Pessimistisch <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> analisten voorspellen dat de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> zal dalen tot onder de $20.000.</p>
<p>Optimistische crypto-analisten voorspellen dat de prijs van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> tegen het einde van het jaar rond de $100.000 zal schommelen.</p>
<p>De recent gelanceerde spot bitcoin ETF’s en de BTC halvering in 2024 zouden de bitcoin prijs moeten opdrijven.</p>
<h2 id="h2-Introductie218101"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Bitcoin heeft de afgelopen vijf jaar te maken gehad met wisselende prijsvolatiliteit. Als voorbeeld, in 2021 presteerde bitcoin opmerkelijk en bereikte zijn all-time high van $69,000. Daarentegen daalde de prijs in 2022 als gevolg van de langste crypto-winter ooit.</p>
<p>Voor het grootste deel van 2023 bleef de bitcoinprijs relatief laag. De waarde begon vanaf juli toe te nemen. Aan het einde van het jaar schommelde de prijs rond de $40.000.</p>
<p>De bullish momentum zette zich voort in januari 2024 tot BTC op de 11e een jaarlijkse hoogtepunt bereikte van $49.000 als gevolg daarvan <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf-and-why-does-everyone-from-blackrock-to-grayscale-want-one/1702" target="_blank">van de lancering van de spot bitcoin ETF’s</a>. Helaas daalde de bitcoin prijs opnieuw tegen het einde van de maand tot het werd verhandeld rond $39.000.</p>
<p>Het heeft echter iets hersteld omdat het op dit moment handelt rond de $42.992. Het doel van dit artikel is om de potentiële prijsontwikkeling van bitcoin voor 2024 te ueren. We zullen de bevindingen van het Deutsche-onderzoek gebruiken om… <a href="https://www.gate.io/price-prediction/bitcoin-btc" target="_blank">voorspel de prijsvoorspelling van BTC voor het jaar</a>.</p>
<h2 id="h2-Met20minder20dan20een20maand20na20de20lancering20van20de20Spot20Bitcoin20ETF20kan20de20prijs20van20BTC20verder20dalen876042"><a name="Met minder dan een maand na de lancering van de Spot Bitcoin ETF kan de prijs van BTC verder dalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Met minder dan een maand na de lancering van de Spot Bitcoin ETF kan de prijs van BTC verder dalen</h2><p>Een recent onderzoek van Deutsche Bank heeft geconcludeerd dat de bitcoinprijs tegen het einde van 2024 onder de $20.000 kan dalen. Ongeveer 15% van de 2.000 mensen die aan het onderzoek deelnamen, uitgevoerd tussen 15 en 19 januari, voorspelde dat de prijs van bitcoin zou schommelen tussen $40.000 en $75.000 tegen het einde van het jaar.</p>
<p>Opmerkelijk is dat ruim een derde van de deelnemers, die op het moment van het onderzoek in de VS, het VK en de Eurozone woonden, voorspelden dat de BTC-prijsdaling $20.000 zou bereiken tegen januari 2025. In een verrassende bevinding gelooft ongeveer 42% van de onderzoekdeelnemers dat bitcoin op een dag zal verdwijnen.</p>
<p>In tegenstelling tot 39% van de ondervraagde bevolking denkt dat bitcoin nog vele jaren zal blijven bestaan. Afgezien van deze onderzoeksresultaten hebben Marion Laboure en Cassidy Ainsworth-Grace, analisten bij Deutsche Bank, gezegd. <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf-and-why-does-everyone-from-blackrock-to-grayscale-want-one/1702" target="_blank">dat de goedkeuring van spot bitcoin ETF’s door de Amerikaanse SEC zal bijdragen aan de adoptie van BTC door instellingen</a>. De volgende grafiek toont een samenvatting van de prijsbevindingen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707367925Deutse.png" alt=""><br>De Bitcoin-prijsvoorspelling van Deutsche Bank Survey - <a href="https://static.news.bitcoin.com/wp-content/uploads/2024/01/deutsche-bank-survey-bitcoin.jpg" rel="nofollow noopener noreferrer" target="_blank">Deutsche Bank</a></p>
<p>Zoals u opmerkt, heeft de meerderheid van de enquête deelnemers voorspeld dat bitcoin tegen het einde van het jaar onder de $20.000 zal dalen.</p>
<p>Vooral de resultaten kunnen veel investeerders ontmoedigen om bitcoin te kopen gedurende het jaar. Aan de andere kant kunnen sommige individuen ervoor kiezen om bitcoin te verkopen wanneer de prijs nog steeds hoog is. Echter, of <a href="https://www.gate.io/blog_detail/264/how-to-buy-bitcoin-on-gate.io-buy-btc" target="_blank">investeerders kopen bitcoin tijdens 2024</a> hangt af van hun beleggingsoriëntatie en de heersende BTC-marktprijs.</p>
<p>Naast de onderzoeksresultaten zijn er andere analisten die denken dat de bitcoinprijs tegen het einde van het jaar zal dalen tot ongeveer $20.000. Als voorbeeld zei Chris Burniske, voormalig crypto-lead bij Cathie Wood’s Ark Invest, onlangs dat crypto-investeerders <a href="https://www.gate.io/how-to-buy/bitcoin-btc" target="_blank">kan bitcoin kopen</a> tegen een prijs van tussen de $30.000 en $36.000, tegen het einde van het jaar.</p>
<p>Echter, <a href="https://twitter.com/cburniske/status/1750623508307284171" rel="nofollow noopener noreferrer" target="_blank">hij voegde eraan toe</a> dat hij “niet verbaasd zou zijn als we de midden tot hoge jaren 20 testen voordat alles is gezegd en gedaan, en we een daadwerkelijke stap kunnen zetten in de richting van eerdere ATH’s. De weg om daar te komen zal volatiel zijn - verwacht nep-outs en zal maanden duren om uit te spelen.</p>
<h2 id="h2-Negatief20sentiment20ten20opzichte20van20crypto20gekoppeld20aan20FTXdaling20USTcollaps20en20Amerikaanse20regelgevingsdruk962188"><a name="Negatief sentiment ten opzichte van crypto gekoppeld aan FTX-daling, UST-collaps en Amerikaanse regelgevingsdruk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Negatief sentiment ten opzichte van crypto gekoppeld aan FTX-daling, UST-collaps en Amerikaanse regelgevingsdruk</h2><p>Het sentiment weerspiegeld in het Deutsche Bank Survey-rapport zou kunnen zijn voortgekomen uit eerdere crypto-evenementen en ontwikkelingen zoals de instorting van de FTX-beurs, het <a href="https://www.gate.io/es/blog_detail/2026" target="_blank">implosie van TerraUSD</a> en de bestaande cryptoreguleringsomgeving in de Verenigde Staten. Bijvoorbeeld, aan het begin van 2023 hebben verschillende Amerikaanse regelgevende instanties rechtszaken aangespannen <a href="https://www.gate.io/learn/articles/the-wild-west-of-the-crypto-world/670" target="_blank">tegen crypto-uitwisselingen zoals Binance en Coinbase</a>.</p>
<p>Ook hebben de diepgewortelde effecten van de crypto-winter die begon in 2022 en aanhield tot 2023 invloed gehad op het sentiment van de respondenten ten opzichte van bitcoin en andere cryptocurrencies. Sterker nog, sommige deelnemers geloven nog steeds dat de crypto-winter nog steeds aan de gang is en niet snel zal eindigen.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/a-comprehensive-analysis-of-key-information-on-btc-spot-etfs/1576" target="_blank">Een uitgebreide analyse van belangrijke informatie over BTC Spot ETF’s</a></p>
<p>Desalniettemin heeft het rapport benadrukt dat sommige deelnemers aan het onderzoek weinig begrip hebben van cryptocurrency. Sterker nog, de publicatie stelde dat ongeveer twee derde van de deelnemers weinig kennis had over cryptocurrencies. Dit zou hun perceptie van crypto-activa kunnen hebben beïnvloed.</p>
<h2 id="h2-Bitcoin20Prijsvoorspelling20voor20202462572"><a name="Bitcoin Prijsvoorspelling voor 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin Prijsvoorspelling voor 2024</h2><p>We hebben al enkele bitcoin prijsvoorspellingen besproken op basis van de bevindingen van de Deutsche Bank Survey en Chris Burniske. Ondanks de voorspelling dat de bitcoin prijs zal dalen in 2024, voorspellen andere analisten dat deze scherp zal stijgen vanwege het naderende bitcoin halveringsevenement in 2024 en de waarschijnlijke toename van institutionele adoptie na het <a href="https://www.gate.io/blog_detail/3434/bitcoin-etf-approval-potential-catalyst-for-historic-crypto-bull-run" target="_blank">spot BTC ETF-goedkeuringen in de Verenigde Staten</a>.</p>
<p>Verschillende analisten, waaronder de wereldwijde bank Standard Chartered, zeggen dat de prijs van bitcoin tegen het einde van het jaar $100.000 kan bereiken. Geoff Kendrick, hoofd FX-onderzoek bij Standard Chartered, heeft twee belangrijke redenen gegeven voor de voorspelling.</p>
<p>Ten eerste noemde Kendrick de goedkeuring van spot bitcoin ETF’s door de SEC als de belangrijkste drijfveer voor de stijging van de bitcoin prijs dit jaar. Dit komt omdat sommige grote financiële instellingen hun geld in bitcoin investeringen kunnen steken, wat de vraag naar BTC verhoogt.</p>
<p>Zoals per <a href="https://www.coindesk.com/markets/2023/11/28/bitcoin-remains-on-track-for-100k-by-year-end-2024-standard-chartered/" rel="nofollow noopener noreferrer" target="_blank">In de publicatie van CoinDesk zei Kendrick</a>, “Zaken verlopen zoals verwacht, volgens Standard Chartered Bank, waarbij het zijn voorspelling van april herhaalt dat bitcoin tegen het einde van 2024 $100.000 zou bereiken.”</p>
<p>Opnieuw zei Kendrick dat de aanstaande bitcoin-halvering de prijs van BTC naar $100.000 zal duwen. Zoals gebruikelijk investeren veel mensen vóór en na de bitcoin-halvering in bitcoin, wat de vraag ernaar vergroot en uiteindelijk de waarde ervan verhoogt.</p>
<p>De Daily Mail citeerde <a href="https://www.dailymail.co.uk/yourmoney/article-12823947/bitcoin-crash-rally-analysts-experts-100k-20k.html" rel="nofollow noopener noreferrer" target="_blank">Kendrick zoals gezegd</a>“We verwachten nu meer prijsstijgingen voordat de halvering plaatsvindt dan we eerder deden, met name door de eerder dan verwachte introductie van Amerikaanse spot-ETF’s. Dit suggereert het risico dat het niveau van USD 100.000 kan worden bereikt vóór eind 2024.”</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/blog_detail/3728/what-does-bitcoin-etf-introduction-mean-for-investors" target="_blank">Wat betekent de introductie van Bitcoin ETF voor investeerders</a></p>
<h2 id="h2-Conclusie417997"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Een rapport van Deutsche Bank concludeert dat de prijs van bitcoin kan dalen tot onder $20.000 tegen januari 2025. Desalniettemin voorspellen sommige optimistische analisten zoals Geoff Kendrick, hoofd van FX-onderzoek bij Standard Chartered, dat de BTC-prijs tegen het einde van het jaar $100.000 kan bereiken. Zowel de recente goedkeuring van spot bitcoin ETF’s door de SEC als de komende halvering kunnen de waarde van bitcoin doen stijgen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Mashell C. </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 is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen er juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>