QU5aIHN0b3B0IGNvbnRhbnRlIG9wbmFtZXMgYWxzIHJlYWN0aWUgb3AgcHVibGlla2UgZHJ1aw==

2023-04-12, 07:27

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""><br>ANZ Australia, Commonwealth Bank en NAB hebben plannen om het aantal bankkantoren in het land te beperken.</p>
<p>CBA en ANZ hebben aangegeven dat ze de rationalisatie van de bankdiensten hebben opgeschort totdat het onderzoek van de senaatscommissie is afgerond.</p>
<p>De sluiting van enkele genoemde bankfilialen zal nadelig zijn voor klanten uit de landelijke gemeenschappen en ook voor ouderen.</p>
<p>Een senaatscommissie voert een onderzoek uit naar het effect van banksluitingen op de economie en plattelandsgemeenschappen.</p>
<p>Trefwoorden: ANZ Australië, ANZ AU, grootste banken in Australië, contant opnemen, banken van Australië, Banken in Australië</p>
<h2 id="h2-Introductie978322"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De ontwikkelingen die plaatsvinden in Australië laten veranderingen zien die zich voordoen in de banksector, waar veel banken zijn gestopt met het verwerken van contant geld in sommige filialen. Als gevolg hiervan geloven sommige analisten dat de samenleving langzaam op weg is naar een cashloze maatschappij die waarschijnlijk digitaal geld zal omarmen. In dit artikel richten we ons op de redenen waarom verschillende grote banken sommige filialen sluiten en de impact ervan op de samenleving.</p>
<h2 id="h2-ANZ20stopt20met20het20verwerken20van20contant20geld20bij20sommige20filialen467725"><a name="ANZ stopt met het verwerken van contant geld bij sommige filialen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ANZ stopt met het verwerken van contant geld bij sommige filialen</h2><p>Er is publieke verontwaardiging ontstaan in Australië toen ANZ AU, een van de grootste banken in het land, zijn plan onthulde om het verwerken van contant geld in sommige van zijn filialen in het hele land stop te zetten. De belangrijkste reden hiervoor is een afname van het volume aan contante transacties in deze filialen.</p>
<p>ANZ heeft deze ontwikkeling bevestigd aan NCA NewsWire toen het zei dat het enkele bankdiensten zal beperken in sommige van zijn filialen. Specifiek zullen sommige filialen klanten niet toestaan om fysiek geld op te nemen of te storten. Deze filialen zullen echter wel personeelsleden hebben die klanten kunnen helpen om geld op te nemen of te storten met behulp van slimme geldautomaten en muntstortmachines.<br><img src="https://gimg2.gateimg.com/image/article/168128419601.png" alt=""><br>ANZ - Globalcapital</p>
<p>Een woordvoerder van ANZ zei: ‘Bij deze vestigingen kunnen contante en chequestortingen en contante opnames blijven worden gedaan met behulp van onze Slimme geldautomaat en muntstortingsmachines en we hebben personeel paraat om klanten te helpen die ze misschien voor de eerste keer gebruiken.’</p>
<p>De Reserve Bank of Australia (RBA) bevestigt dat het gebruik van contant geld in het land afneemt. Uit een van haar enquêtes bleek dat het gebruik van contant geld bij winkelbetalingen is afgenomen van 69% in 2007 tot 27% in 2019.</p>
<p>Gerelateerd artikel: <a href="https://www.gate.io/zh/blog_detail/378/how-are-cryptocurrencies-currently-regulated-in-countries-around-the-world?lang=en" target="_blank">Hoe worden cryptocurrencies op dit moment gereguleerd in landen over de hele wereld?</a></p>
<p>De enquête zei,<br><strong>“Kaarten worden steeds vaker gebruikt voor transacties met een lage waarde, wat de adoptie van contactloze ‘tik en ga’ functionaliteit bij de verkooppunt weerspiegelt. Hoewel het aandeel van betalingen met contant geld bleef dalen, werd contant geld nog steeds gebruikt voor meer dan een kwart van de consumentenbetalingen.”</strong></p>
<p>Ook gegevens van de Australian Prudential Regulation Authority wijzen op een scherpe daling van het aantal bankfilialen dat contant geld aan klanten verstrekt. Er werd gesteld dat het aantal filialen dat contant geld afhandelt, is gedaald van 4.323 tot 4.014 per 30 juni 2022.</p>
<p>Tegenwoordig maken klanten het grootste deel van hun betalingen via directe online overschrijvingen, mobiele betalingen en Tap-and-go-kaarten. Een woordvoerder van ANZ zei: ‘Onze klanten veranderen de manier waarop ze bankieren, met meer dan 50 procent minder transacties in de filialen van ANZ in de afgelopen vier jaar. De meerderheid geeft de voorkeur aan online en mobiele bankmethoden.’</p>
<h2 id="h2-Reactie20van20de20samenleving20op20het20plan20van20ANZ554600"><a name="Reactie van de samenleving op het plan van ANZ" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reactie van de samenleving op het plan van ANZ</h2><p>Veel klanten en commentatoren waren geschokt door de ontwikkeling en riepen de relevante autoriteiten op om in te grijpen ten behoeve van kwetsbare leden van de gemeenschap, zoals ouderen.</p>
<p>Als voorbeeld zei Steve Worthington, een professor aan de Swinburne University of Technology, dat een dergelijke actie uitsluitend is. Hij legde aan 7NEWS uit: “Ouderen, nieuwe migranten, mensen met een handicap hebben wel degelijk persoonlijke hulp nodig, er bestaat hier een gevaar om bepaalde segmenten van onze maatschappij uit te sluiten.”</p>
<p>De plattelands Australiërrs behoren tot de mensen die sterk getroffen worden door deze stap. Dit komt doordat velen van hen enkele bergen moeten passeren en lange afstanden moeten afleggen om naar de dichtstbijzijnde bankkantoren te gaan. Als gevolg hiervan hebben veel mensen en organisaties bij deze banken gesmeekt om aan de plattelandsmensen en hun gemeenschappen te denken.</p>
<p>Een commentator zei: “De Black Spur is erg winderig en steil, er zijn veel wilde dieren die het oversteken, er zijn bussen, vrachtwagens met boomstammen en veel toeristen … het te gebruiken. De weg is vaak gehuld in mist, bedekt met ijs.” Hij is van mening dat de banken mensen zonder gedoe toegang moeten geven tot hun contant geld bij de dichtstbijzijnde filialen.</p>
<p>Jim Seymour, een voormalige inwoner van Tenterfield in het noorden van NSW, zei: “Alsjeblieft, ik smeek je, laat deze zaak niet onder het tapijt geveegd worden, voor het welzijn van de toekomst van dit land.”</p>
<p>Een andere klant zei: ‘Elke bank die dit pad volgt, zal klanten verliezen en uiteindelijk failliet gaan … het is al erg genoeg dat ze vestigingen sluiten.’</p>
<p>Ondertussen is de senaat een onderzoek aan het doen naar de sluiting van plattelands- en regionale bankfilialen door ANZ en andere banken van Australië. Een senaatscommissie is in februari met het onderzoek begonnen en dit zal eindigen in december 2023. Deze commissie heeft als doel om de impact van de sluiting van bankfilialen en de effecten van het stopzetten van persoonlijke bankdiensten op de economie en het welzijn van de klanten te onderzoeken.</p>
<p>Recente aankondiging: <a href="https://www.gate.io/vi/blog_detail/708/gate.io-vip-sharing-campaign-vitalik-on-the-cover-of-time-magazine-opensea-may-have-supported-sol-payments-russia-accepts-bitcoin-as-export-payment-method?lang=en" target="_blank">ANZ wordt de eerste Australische bank die een stablecoin slaat</a></p>
<h2 id="h2-Plannen20van20andere20grote20banken20Westpac20NAB20en20Commonwealth20Bank133436"><a name="Plannen van andere grote banken (Westpac, NAB en Commonwealth Bank)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Plannen van andere grote banken (Westpac, NAB en Commonwealth Bank)</h2><p>De sluiting van sommige bankkantoren beperkt zich niet alleen tot ANZ, aangezien andere banken in Australië hebben beloofd hetzelfde te doen. De Commonwealth Bank was ook van plan om zijn filiaal in Junee te sluiten. Het heeft echter al het plan om filialen te sluiten in de wacht gezet in afwachting van de uitkomst van het onderzoek van de Senaatscommissie naar de sluiting van regionale banken.<br><img src="https://gimg2.gateimg.com/image/article/168128432702.png" alt=""><br>Commonwealth Bank - ABCnet</p>
<p>Een woordvoerder van CBA zei: “Na bestudering van een verzoek van de Senaatscommissie zal CBA geen regionale filialen sluiten terwijl het onderzoek in 2023 aan de gang is. Als extra teken van goede wil zal CBA de sluiting van twee filialen [waaronder Junee], die al zijn aangekondigd, uitstellen terwijl het onderzoek in 2023 aan de gang is.”</p>
<p>Hoewel Westpac, een van de andere grote banken in Australië, eerder zijn voornemen aankondigde om enkele filialen in Queensland, Victoria, NSW en Zuid-Australië te sluiten, heeft het aan NCA NewsWire laten weten momenteel geen plannen te hebben om een van deze filialen te sluiten. Zijn <a href="https://regionriverina.com.au/westpac-and-anz-to-push-ahead-with-riverina-bank-closures/" rel="nofollow noopener noreferrer" target="_blank">woordvoerder zei</a>,<br><strong>“Onze klanten kunnen vijf dagen per week gebruik maken van contante diensten over de toonbank bij alle filialen van de Westpac Group en bij meer dan 3500 Australië Post verkooppunten in het hele land via onze samenwerking met Bank Post.”</strong></p>
<p>De National Australia Bank (NAB) heeft aangekondigd dat het van plan is om enkele van zijn bankfilialen in 2022 te sluiten. De betreffende filialen bevinden zich in Narrandera, Corrimal Lavington, Maroubra, Figtree en Cronulla. Onlangs heeft NAB aangegeven dat het zal doorgaan met de geplande sluitingen.</p>
<p><a href="https://aboutregional.com.au/westpac-and-anz-to-push-ahead-with-riverina-bank-closures/" rel="nofollow noopener noreferrer" target="_blank">Krissie Jones, NAB retail utive, zei</a>, “Tijdens de besprekingen van het Comité in 2023 zullen we ons filiaalhervormingsproces voortzetten, waarbij sluitingen, consolidaties en nieuwe investeringen zullen plaatsvinden om aan de behoeften van onze klanten te voldoen.”</p>
<h2 id="h2-Digitaal20geld20of20banken2020wie20zal20winnen708782"><a name="Digitaal geld of banken - wie zal winnen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digitaal geld of banken - wie zal winnen</h2><p>Er is een stijging in het gebruik van digitaal geld over de hele wereld. In eenvoudige bewoordingen is digitaal geld elke vorm van betaling die op internet plaatsvindt. Digitaal geld heeft geen fysieke tegenhanger zoals bankbiljetten en munten. Voorbeelden van digitale valuta zijn cryptocurrencies en centrale bank digitale valuta (CBDC).</p>
<h2 id="h2-Digitale20valuta20heeft20zijn20eigen20voor20en20nadelen190903"><a name="Digitale valuta heeft zijn eigen voor- en nadelen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digitale valuta heeft zijn eigen voor- en nadelen.</h2><p>Een van de belangrijkste voordelen van digitaal geld is de snelle transacties. Iemand kan binnen enkele minuten geld overmaken naar een andere persoon in een ander land. Dit is anders dan banken die mogelijk meerdere dagen nodig hebben om het geld op de beoogde bestemming te krijgen.</p>
<p>Met digitaal geld hoef je geen fysieke portefeuilles te hebben om je geld op te slaan. Men moet het geld online beheren met behulp van zijn/haar digitale rekeningen.</p>
<p>Digitale valuta heeft geen tussenpersonen nodig die helpen bij het verwerken van transacties. Individuen houden eenvoudigweg hun fondsen aan in accounts en gebruiken het zoals ze willen.</p>
<p>Echter heeft digitaal geld zijn nadelen. Het grootste probleem van digitaal geld is dat van hacken. Hackers kunnen gemakkelijk geld stelen uit wallets. Er is geen mogelijkheid om fysiek geld te hacken. Het is belangrijk op te merken dat de beste moderne samenleving zowel digitaal als fysiek geld nodig zou hebben.</p>
<h2 id="h2-Conclusie650065"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De grote banken in Australië, namelijk ANZ, NAB en CBA, zijn van plan om hun bankdiensten te rationaliseren. In sommige glen zijn ze van plan om de filialen volledig te sluiten, terwijl anderen van plan zijn om fysieke contante opnames en stortingen stop te zetten. Momenteel hebben ANZ en CBA hun rationalisatieprocessen stopgezet in afwachting van de uitkomst van het onderzoek door de senaatscommissie.</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 opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat 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>