VmFsdCBoZXQgZWxrZSBzZXB0ZW1iZXI/IEFsbGVzIHdhdCBqZSBtb2V0IHdldGVuIG92ZXIgZGUgc2VwdGVtYmVybWFya3QgdHJlbmQ=

2024-09-04, 13:39

<p><img src="https://gimg2.gateimg.com/image/article/17254567681692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR75625"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Sinds 2013, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is in september voor 8 van de 11 jaar gedaald, wat een significant ‘septembereffect’ aantoont. Dit effect beperkt zich niet tot de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a>; de meeste mondiale aandelenmarkten presteerden ook zwak in september.</p>
<p>In september brengen handelaren vaak aanpassingen aan in hun beleggingsposities, realiseren ze verkoopdruk voor consumptie en neemt de voorzichtigheid toe als gevolg van meerdere belangrijke gebeurtenissen, wat leidt tot een zwakke prestatie op de financiële markt die maand.</p>
<p>Bij gebrek aan substantiële interne drijvende kracht, verzamelt de cryptomarkt langzaam nieuwe opwaartse momentum en wordt verwacht de bijna jaarlijkse stijging van het ‘Oktober-effect’ te ervaren, maar investeerders moeten nog steeds voorzichtig zijn met kortetermijnschommelingen.</p>
<h2 id="h2-Introductie189244"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Bij het ingaan van september zijn er veel meningsverschillen op de markt over de volatiliteit van de cryptomarkt. De meesten geloven dat het ‘septembereffect’ deze maand weer zal verschijnen en de maandelijkse rendementen kunnen verslechteren. Er zijn echter ook geluiden die erop wijzen dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> zal stoppen met dalen en zal herstellen tegen de achtergrond van renteverlagingen.</p>
<p>Dit artikel heeft tot doel om diepgaand te analyseren, gebaseerd op historische markttrends, de mogelijke prijskoers van Bitcoin in september en de drijvende factoren erachter.</p>
<h2 id="h2-Herhaalt20het20patroon20van20vallen20elk20jaar20in20september261154"><a name="Herhaalt het patroon van vallen elk jaar in september?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Herhaalt het patroon van vallen elk jaar in september?</h2><p>Er zijn veel gevestigde patronen en effecten op de cryptomarkt, en recentelijk is het idee van het ‘septembereffect’ populair geworden, waarbij wordt aangenomen dat elke september zal leiden tot een daling, wat de algemene pessimistische stemming ten opzichte van de huidige markt weerspiegelt.</p>
<p>Op basis van de ervaring met prijsschommelingen in de afgelopen jaren is september de meest uitdagende periode, met het grootste aantal dalingen onder alle maanden.</p>
<p>Zoals te zien is in de onderstaande afbeelding, is Bitcoin in 8 van de 11 jaar sinds september 2013 gedaald. Hoewel 2015, 2016 en 2023 stijgingen lieten zien, waren de winsten zeer beperkt, respectievelijk 2,35%, 6,04% en 3,91%.<img src="https://gimg2.gateimg.com/image/article/17254568301.jpg" alt=""><br>Bron: coinglass</p>
<p>Of je nu kijkt naar het gemiddelde of de mediaan van de maandelijkse rendementen, september is de slechtst presterende periode, wat de directe basis is voor wat mensen de ‘septembereffect’ noemen.</p>
<p><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De prijsprestatie is vergelijkbaar met die van Bitcoin, met meer dalingen dan stijgingen in juli, augustus en september en grotere volatiliteit.<br><img src="https://gimg2.gateimg.com/image/article/17254574042.jpg" alt=""><br>Bron: coinglass</p>
<p>Afgezien van het pessimistische vooruitzicht in september, hebben Bitcoin en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> traditioneel de laagste prijsprestaties in het derde kwartaal, terwijl hun rendementen in het tweede kwartaal op de eerste plaats stonden, wat wijst op significante seizoensfluctuaties.<img src="https://gimg2.gateimg.com/image/article/17254568643.jpg" alt=""><br>Bron: coinglass</p>
<p>Evenzo is de Amerikaanse aandelenmarkt, die geassocieerd wordt met schommelingen op de cryptomarkt, niet ontsnapt aan de ‘September Curse’. Volgens historische gegevens was september de slechtste maand in de afgelopen eeuw, met een negatief gemiddeld rendement van -0,78%. Specifiek heeft de Nasdaq-index, die vergelijkbare technologische aandeleneigenschappen heeft als Bitcoin, in het afgelopen decennium acht dalingen in september meegemaakt.</p>
<p>Als het observatieperspectief wordt uitgebreid naar 70 landen/regio’s over de hele wereld, domineert september ook de slechtst presterende aandelen in termen van gemiddelde en mediaan, wat kan worden beschouwd als een onbreekbare regel om elk jaar in september te dalen. <img src="https://gimg2.gateimg.com/image/article/17254568824.jpg" alt=""><br>Bron: openbare informatie</p>
<h2 id="h2-Waarom20zag20september20meer20dalingen20en20minder20winsten159425"><a name="Waarom zag september meer dalingen en minder winsten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom zag september meer dalingen en minder winsten?</h2><p>Op basis van historische gegevens is het standpunt van een prijsdaling in september geverifieerd. Daarom moeten we onderzoeken waarom deze empirische wet de cryptomarkt heeft beïnvloed.</p>
<p>In feite zorgt september er vaak voor dat handelaren hun beleggingsposities aanpassen, verkoopdruk voor consumptie realiseren en voorzichtige emoties versterken die worden veroorzaakt door meerdere belangrijke gebeurtenissen in die maand, wat leidt tot een zwakke prestatie op de financiële markt die maand.</p>
<p>-Portefeuilleherweging: Handelaren die hun posities aanpassen, kunnen de belangrijkste reden zijn. Met de afname van de handelsactiviteit in de zomer hebben Europese en Amerikaanse handelaren hun beleggingsportefeuilles opnieuw geëvalueerd en aangepast na terugkeer op de markt in september, wat heeft geleid tot een aanzienlijke toename van de marktvolatiliteit. Neerwaartse druk leidt vaak tot lage rendementen, wat ongetwijfeld de meer voorzichtige of op winst gerichte beleggingskenmerken weerspiegelt die door opnieuw instappende handelaren in die maand worden aangenomen.<br><img src="https://gimg2.gateimg.com/image/article/17254569095.jpg" alt=""><br>Bron: openbare informatie</p>
<p>-Belastingverlieswinst: Institutionele beleggers zijn geneigd om aan het einde van het kwartaal en het jaar, vooral in september, belastingplanning uit te voeren, waarbij ze verlieslijdende aandelen verkopen om kapitaalverliezen te verminderen en winstgevende aandelen verkopen om winsten vast te leggen, waardoor de verkoopdruk op de markt toeneemt.</p>
<p>-Macroeconomische gegevens en prestatieverwachtingen: september is een belangrijke periode voor bedrijven om hun verwachtingen voor het derde kwartaal en belangrijke macro-economische gegevens (zoals rapporten over loonlijsten buiten de landbouwsector, CPI, enz.) vrij te geven. Bijvoorbeeld, het recente financiële rapport van Nvidia (NVDA.US) heeft grote invloed gehad op de stijging en daling van AI-tokens. Deze gegevens hebben direct invloed op het marktvertrouwen en de kortetermijnhandelingen van handelaren, waardoor de marktvolatiliteit wordt verergerd.</p>
<p>-Persoonlijk fonds <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a>: Sommige individuele beleggers kiezen ervoor om aandelen te verkopen om geld in te zamelen voor onderwijskosten, terug-naar-school benodigdheden, of schulden die zijn opgelopen door vakantieconsumptie na de zomervakantie, wat de vraag- en aanbodbalans op de markt verder beïnvloedt.</p>
<p>Natuurlijk, naast deze macrofactoren, ervaart de cryptomarkt vaak een afkoelingsperiode van emotionele speculatie na een sterke prestatie in het tweede kwartaal, vooral in het ontbreken van duidelijke opwaartse momentum. De macro-omgeving neigt naar een conservatieve beleggingsstijl, en hoogrisicoactiva zoals Bitcoin kunnen natuurlijk worden verwaarloosd.</p>
<p>Samengevat is de slechte prestatie van de markt in september voornamelijk te wijten aan een combinatie van seizoensgebonden portefeuilleaanpassingen, macro-economische gegevens en prestatieverwachtingen. Het is echter vermeldenswaard dat marktdalingen niet elke september plaatsvinden, en we zullen nu vooruitkijken naar de complexe omgeving waarin Bitcoin zich in september zal bevinden.</p>
<h2 id="h2-Is20september20dit20jaar20anders400138"><a name="Is september dit jaar anders?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is september dit jaar anders?</h2><p>In vergelijking met de geschiedenis wordt Bitcoin geconfronteerd met een complexe impact van meerdere factoren, zoals de eerste renteverlaging van de Federal Reserve, het risico op economische recessie en de onzekerheid bij de Amerikaanse verkiezingen in september dit jaar, waardoor deze maand bijzonder cruciaal en uitdagend is voor Bitcoin.</p>
<p>Allereerst kijken we naar de verwachting van een economische recessie. De economische recessie is nog niet echt aangekomen, en het werkloosheidspercentage en de gegevens over niet-agrarische loonlijsten bevinden zich nog steeds binnen een controleerbare marge, wat de markt in zekere mate verlicht. De verklaring van de Fed leidt de markt ook om te geloven dat een economische recessie nog geen realiteit is geworden, wat helpt om de relatieve marktstabiliteit te handhaven. Nieuwe economische gegevens of beleidswijzigingen kunnen echter op elk moment deze stabiele toestand verstoren, zoals besproken in onze recente artikelen over de Sam’s Rule. Met verwijzing naar verschillende indicatoren neemt de kans toe dat de Amerikaanse economie in een vroege recessie terechtkomt.</p>
<p>Wat betreft het rentebeleid van de Federal Reserve is het een uitgemaakte zaak dat er in september een renteverlaging zal worden overeengekomen. Aangezien het ISM-rapport van augustus over de PMI voor de maakindustrie gisteren werd vrijgegeven en aantoonde dat de Amerikaanse economie blijft krimpen, is de kans op een renteverlaging van 50 basispunten gestegen van 30% naar 41%.<br><img src="https://gimg2.gateimg.com/image/article/17254570996.jpg" alt=""><br>Bron: CME Group</p>
<p>Over het algemeen kunnen financiële markten, inclusief cryptocurrencies, mogelijk profiteren van de verwachte renteverlaging van de Federal Reserve in september, aangezien de inflatie gestabiliseerd is. Omdat renteverlagingen doorgaans liquiditeit vrijgeven en de investeringsbelangstelling in risicovolle activa, inclusief cryptocurrencies, doen toenemen, kan dit tot gevolg hebben dat fondsen naar digitale activa worden geleid.</p>
<p>De manifestatie van het effect van renteverlagingen kost echter tijd, en er is vertraging in de beleidsoverdracht, dus het daadwerkelijke effect van liquiditeitsverbetering moet nog worden waargenomen.</p>
<p>Bovendien is de Amerikaanse presidentsverkiezing een belangrijk onderwerp in de huidige cryptomarkt, vooral het langverwachte televisiedebat op 10 september, wat de marktvolatiliteit kan vergroten. Vanuit het huidige perspectief kan de steun van Trump de adoptie van crypto stimuleren, terwijl de verkiezing van Harris mogelijk een strenger regelgevingsklimaat met zich meebrengt. De angstige publieke opinie speelt ook voortdurend een rol bij beleidsondersteuning, het regelgevingsklimaat, marktvertrouwen en vele andere aspecten.<img src="https://gimg2.gateimg.com/image/article/17254571187.jpg" alt=""><br>Bron: Polymarket</p>
<p>Op het moment van schrijven van dit artikel is de prijs van Bitcoin licht gestegen, maar blijft nog steeds onder het 60-daags voortschrijdend gemiddelde. De macro watch-prijs is bijna een half jaar sterk aan het schommelen en op korte termijn is de markt langzaamaan hersteld van de scherpe daling begin augustus. Zowel de long- als shortposities zullen binnenkort hun richting bepalen op het niveau van $60.000.<img src="https://gimg2.gateimg.com/image/article/17254571338.jpg" alt=""><br>Bron: Polymarket</p>
<p>Over het algemeen werd de cryptomarkt geconfronteerd met de impuls van de renteverlagingen van de Federal Reserve, externe inmenging van de economische recessie en onzekerheid in de presidentsverkiezingen van september. In afwezigheid van een substantiële interne drijvende kracht, verzamelt de cryptomarkt langzaam nieuwe opwaartse momentum en wordt verwacht dat deze het ‘oktober-effect’ van bijna jaarlijkse stijgingen zal inluiden. Investeerders moeten echter nog steeds voorzichtig zijn met kortetermijnschommelingen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<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 vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>