Skip to main content
Back

Criteria for Stock Exchange Database

The SSE maintains a database of sustainability activities for all stock exchanges that are either members of the SSE initiative and/or members of the World Federation of Exchanges. This database is the most comprehensive database of stock exchanges worldwide and contains data on all main stock exchanges. The information in this database is intended to inform investors and other stakeholders on the work stock exchanges are undertaking to advance sustainability in their respective markets.

The information provided in this database is based on publicly available information prepared by the SSE Secretariat with input from stock exchanges in most instances. Sources and explanatory notes on sustainability information have been included in individual Stock Exchange Fact Sheets. The criteria for each category can be found below.

While every effort is made to keep the information in this database up to date, please be aware that certain factors change frequently and therefore may not be exact, such as the number of listed companies or market cap.

Field

Criteria Considered

CountryCountry of primary residence or registration
Has signed the SSE Commitment Letter?To be considered an SSE Partner Exchange, the CEO or Chairperson of the exchange must sign an SSE commitment letter. Contact the SSE for more information if your exchange would like to join.
Has annual sustainability report?For a yes, stock exchanges must report, either in a stand alone report or integrated into their financial report, on their environmental and social impact and corporate governance.
ESG reporting required as a listing rule?For a yes, all three factors have been considered (environmental, social and governance) within the listing rules for some or all listed companies. This requirement may come from the regulatory authority or the exchange, depending on the market.
Offers written guidance on ESG reporting?For a yes, all three factors have been considered (environmental, social and governance). The SSE has developed a model guidance that all exchanges can use to develop their own guidance to issuers. For more details, click here.
Offers ESG related training?For a yes, training must have taken place in the previous 12 months, and must be interactive. The topic of the training must be on some area of sustainability.
Market covered by sustainability-related index?Sustainability-related indices may include environmental or social  indices, or ESG indices. This could include specific themes, such as low carbon indices, or general sustainability indices. The index must be specific to the market the exchange operates in (a region or world index is not included).
Has sustainability bond listing segment?For a yes, the exchange has developed the rules and regulations allowing for sustainability bonds to be listed, and provides a separate segment for listing making the bonds easy to find and identify.
Has an SME listing platform?For a yes, the exchange offers a listing platform specifically for Small-and-Medium sized enterprises.
Additional InformationAdditional Information captures exchanges’: sustainability section of websites,  sustainability products not captured under indices; information on future sustainability commitments and other information on the exchange
Organizational model of stock exchangeWhether the exchange is listed or not, and when it was demutualized
Regulatory bodiesThe regulatory authority that sets listing requirements and capital market regulation for the exchange's market
Regulatory model

The extent to which exchanges have regulatory authority in their market. This may include:

  • Limited exchange SRO
  • Strong exchange SRO
  • Independent member SRO
  • Government (Statutory)
  • Non-SRO
About the stock exchangeThe location of the headquarters of the exchange, and any additional details about the stock exchange.
[{"id":51,"Country":"Argentina","cc":"AR","Name0":"Bolsas y Mercados Argentinos (BYMA) and Bolsa de Comercio de Buenos Aires (BCBA)","Link":"/stock-exchange/argentina","Name":"<a href=\"https://www.byma.com.ar\">Bolsas y Mercados Argentinos (BYMA) and Bolsa de Comercio de Buenos Aires (BCBA)</a>","nlc":80,"dmc":1212,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/argentina-byma.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.byma.com.ar/wp-content/uploads/2023/04/BYMA-Reporte-de-Sustentabilidad-2021.pdf\">Yes</a>\n<ul><li style=\"list-style-type:none;\"><ul><li>BYMA launched its first sustainability report in 2019 with GRI standards</li></ul></li></ul><p>Previous sustainability reports:</p><ul><li><a href=\"https://www.byma.com.ar/wp-content/uploads/dlm_uploads/2019/10/BYMA-Sustainability-Report-2018.pdf\">2018</a></li><li><a href=\"https://www.byma.com.ar/wp-content/uploads/dlm_uploads/2019/09/BYMA-Reporte-de-Sustentabilidad-2019.pdf\">2019</a></li><li><a href=\"https://www.byma.com.ar/wp-content/uploads/dlm_uploads/2019/10/BYMA-Reporte-de-Sustentabilidad-2020.pdf\">2020</a></li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes\n<ul><li>BYMA has included in its Listing Rules, following the National Securities Commission approval, sections that require issuers of shares and/or marketable securities to issue a Sustainability Report, to submit it together with the issuer´s annual accounting documentation. See <a class=\"waffle-rich-text-link\" href=\"https://www.byma.com.ar/wp-content/uploads/dlm_uploads/2019/10/BYMA-Sustainability-Report-2018.pdf\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:''docs-Calibri'';font-style:normal;text-decoration-skip-ink:none;\" data-sheets-formula-bar-text-link=\"https://www.byma.com.ar/wp-content/uploads/dlm_uploads/2019/10/BYMA-Sustainability-Report-2018.pdf\">BYMA Sustainability Report 2018 p.29</a>, and <a class=\"waffle-rich-text-link\" href=\"https://www.byma.com.ar/wp-content/uploads/dlm_uploads/2019/08/BYMA-Reglamento-de-Listado-2020-02-04.pdf\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:''docs-Calibri'';font-style:normal;text-decoration-skip-ink:none;\" data-sheets-formula-bar-text-link=\"https://www.byma.com.ar/wp-content/uploads/dlm_uploads/2019/08/BYMA-Reglamento-de-Listado-2020-02-04.pdf\">Rules to List on BYMA (pg. 31)</a></li></ul>","hwg":"No","hwgt":"No","oert":"Yes","oertt":"Yes\n<ul><li>Alongside the&#160;<a href=\"https://www.byma.com.ar/en/noticias/ring-the-bell-for-gender-equality-2019/\"> 2019 Ring the Bell for Gender Equality</a>&#160;event in March, BYMA held a seminar on board equality revealing data on Argentinian board composition.</li><li><a href=\"https://www.byma.com.ar/noticias/byma-lanza-el-primer-indice-de-sustentabilidad-del-mercado-argentino/\">December 2018</a>: Seminar on green and sustainable investment products at the occasion of the launch of the Sustainability Index</li><li><a href=\"https://www.byma.com.ar/noticias/indice-de-sustentabilidad-byma/\">11/06/2018</a>: Sustainability Index seminar at BYMA</li><li><a href=\"/home-slider/mexico-and-argentina-join-forces-to-grow-green-finance-spanish-version-of-the-sse-action-plan-launched/\">18/17/2018</a>: Advancing Sustainable Finance event at BCBA</li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes\n<ul><li>On December 2018, BYMA together with the IDB launched the Sustainability Index. For more information:&#160;<a href=\"https://www.byma.com.ar/en/issuers/sustainability-index-eng/\">https://www.byma.com.ar/en/issuers/sustainability-index-eng/</a></li><li>BYMA also launched a Corporate Governance Panel, which is a trading board where stocks issued by companies who voluntarily adhere to Corporate Governance practices are traded, provided said practices are additional to the standard regulatory requirements set forth by the Argentine legislation in force. For more information:&#160;<a href=\"https://www.byma.com.ar/en/issuers/corporate-governance-panel/\">https://www.byma.com.ar/en/issuers/corporate-governance-panel/</a></li></ul><p></p>","hsbls":"Yes","hsblst":"Yes\n<ul><li>BYMA has developed Issuance and&#160;<a href=\"https://www.byma.com.ar/download/11123/\">Listing Rules</a>&#160;and&#160;<a href=\"https://www.byma.com.ar/download/11126/\">Guidelines</a>&#160;on Social, Green and Sustainability (SGS) Bonds, and&#160;<a href=\"https://www.byma.com.ar/download/12435/\">Listing Rules on Social, Green and Sustainability (SGS) Trust Securities and/or Shares of Closed-End Mutual Funds</a>&#160;(FCCI for its Spanish acronym). These Guidelines and Rules have been approved by the National Securities Commission.</li><li><a href=\"https://www.byma.com.ar/en/social-green-and-sustainability-bonds/\">Social, Green and Sustainability Bonds</a></li></ul><p></p>","HSMElp":"No","HSMElpt":"No","wom":"Yes","womt":"Yes\nCivil entities and commercial companies must respect the same number of women and men in the composition of their administrative and supervisory bodies, <a href=\"https://www.argentina.gob.ar/noticias/paridad-de-genero-en-las-entidades-civiles-y-sociedades-comerciales\" target=\"_blank\" rel=\"noopener\">according to the General Resolution 34/2020. If the total number of directors is an odd number, women shall hold at least one-third of the positions. </a>","Additional_information":"<ul><li>In 2008, Buenos Aires City Council passes&#160;<a href=\"https://www.codigor.com.ar/brsa.htm\">Law 2594</a> requiring all local and international companies in the city with over 300 employees to generate annual sustainability reports. At minimum, companies are required to produce their reports in accordance with the Ethos Reporting Initiative’s G3 indicators and the Accountability 1000 standard.</li><li>BCBA information on&#160;<a href=\"https://www.bcba.sba.com.ar/institucional/otros-mercados/\">sustainable development</a>&#160;and the&#160;<a href=\"https://www.bcba.sba.com.ar/institucional/otros-mercados/carbono/\">Carbon Market</a></li><li>The regulator requires listed companies to include in their Annual Reports, a Corporate Governance Code with the explanation of the level of compliance with set principles. Also, they should report their environmental or sustainability policy, including the main indicators of the issuer’s performance in the matter, or, if they do not have such policies or indicators, provide an explanation of why they consider that they are not relevant to their business. Companies, cooperatives, and associations that qualify as Small and Medium-sized companies are excluded.</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>BYMA: Listed company for profit; demutualized in 2012 by means of Law 26,831.</li><li>BCBA: Association not for profit; demutualized in 2012.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cnv.gov.ar/sitioweb/\">Comisión Nacional de Valores (National Securities Commission)</a></li></ul><p></p>","Regulatory_model":"<ul><li>BYMA (Bolsas y Mercados Argentinos) is a private company registered under CNV as a Stock Exchange and a Clearing House. It is also a listed company and its shares are listed on BYMA. As it is under the jurisdiction of the CNV, all activities are subject to CNV direct oversight. BYMA acts as a Central Counterparty (CCP) in guaranteed transactions. BYMA is responsible for monitoring and overseeing market participants acting as members registered in BYMA. BYMA also is responsible and in charge of listing procedures that private companies must fulfil after having CNV public offering authorization. BYMA provides CNV daily information of market operations and all other issues and documents required. BYMA collaborates with the regulator for the local capital market development.</li><li>As controlling shareholder of BYMA, Bolsas de Comercios de Buenos Aires (BCBA) acts as designated entity fulfilling proficient duties regarding certain activities pursuant to Act 26,831, under CNV regulation. The BCBA authorizes, suspends and cancels listing and securities trading by proxy pursuant to its rules and regulations, and issues the daily and weekly trading bulletins. Its functions include the creation of a Court of Arbitration, which the BCBA has originated in 1963.</li></ul><p>","About_the_stock_exchange":"Location: Buenos Aires, Argentina.<ul><li>BYMA is the main exchange in Argentina, and is a spinoff of the exchange activities formerly conducted by Mercado de Valores de Buenos Aires S.A. (MERVAL). Major changes have been introduced to its core business, incorporating 99.96% of the capital stake of Caja de Valores S.A. (CVSA) the only Central Depositary in Argentina. Listed companies in BYMA are the same ones as the ones listed at MERVAL only that new companies have been incorporated as they have seen the opportunity of benefiting with the enhanced exchange that BYMA represents.</li><li>BCBA is a controlling shareholder of Argentina's main stock exchange BYMA, and was founded in 1854. Its by-laws set forth among its main purposes to provide its associates with the environment for the realization of all kinds of lawful business and mercantile operations; and to promote the passing of adequate legislation related to commerce, production, finance and the economy at large.</li><li>Owned 100% by Bolsa de Comercio de Buenos Aires</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"Yes","Notes":"BCBA assists companies active in CDM-based projects, through education programs, corporate carbon trading simulations and building relationships between project developers and international investors.","Source_lnk":"https://dialogochino.net/en/climate-energy/60208-carbon-market-argentina-cop27-growth-concerns/"},{"id":52,"Country":"Armenia","cc":"AM","Name0":"Armenia Securities Exchange","Link":"/stock-exchange/amx","Name":"<a href=\"https://amx.am/\">Armenia Securities Exchange</a>","nlc":11,"dmc":2169,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/armenia-amx.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"For Profit<p>","Regulatory_bodies":"<a href=\"https://www.cba.am/\">Central Bank of Armenia</a><p></p>","Regulatory_model":"Non-SRO<p>","About_the_stock_exchange":"AMX | Armenia Securities Exchange<p><p>Armenia Securities Exchange is Armenia's only stock exchange that also runs the Central Depository of Armenia, helping investors raise capital for 19 years. We offer market professionals an automated electronic platform for exchange trading in securities. The company also provides securities listing, initial public offering and market data services. CDA offers a wide array of services including registry keeping, clearing and settlement, asset and registry servicing as well as funded pension administration.</p><p>Our Mission</p><p>Be the leading securities exchange of choice across asset classes in the region for both local and international investors seeking multi-regional exposure, backed by international standards and innovation.</p><p>Details</p><p>Address: 26/1 Vazgen Sargsyan str., 5th floor, Erebuni Plaza Business Centre, Yerevan 0010, Armenia</p><p>Phone: +374 60 69 55 55</p><p>E-mail: <a href=\"mailto:info@amx.am\">info@amx.am</a></p><p>Website: amx.am</p>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":53,"Country":"Australia","cc":"AU","Name0":"Australian Securities Exchange (ASX)","Link":"/stock-exchange/asx","Name":"<a href=\"https://www.asx.com.au/\">Australian Securities Exchange (ASX)</a>","nlc":2147,"dmc":2537664,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/australia-asx.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www2.asx.com.au/content/dam/asx/about/media-releases/2022/41-22-august-asx-2022-annual-report.pdf\">Yes</a><br><p>The sustainability report is included in the annual report since 2020</p><ul><li><a href=\"https://www2.asx.com.au/content/dam/asx/annual-reports/asx-annual-report-2020.pdf\">2020 Annual report</a></li><li><a href=\"https://www2.asx.com.au/content/dam/asx/about/media-releases/2021/25-19-aug-asx-limited-2021-appendix-4e-and-annual-report.pdf\">2021 Annual report</a></li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<ul><li>From 1 January 2025, many large Australian businesses and financial institutions will need to prepare annual sustainability reports containing mandatory climate-related financial disclosures, following the passage of a major bill through Parliament.</li><li><p style=\"color:rgb(28, 48, 101);margin:0px 0px 15px;font-size:medium;line-height:22px;font-family:Inter, sans-serif;text-align:start;background-color:rgb(255, 255, 255);\">The mandatory climate reporting requirements will be phased in over the next three years across three groups of reporting entities, with the first reporting cohort required to prepare annual sustainability reports for the financial year commencing on or after 1 January 2025. The second and third reporting cohorts are required to prepare annual sustainability reports for the financial years commencing on or after 1 July 2026 and 1 July 2027 respectively.&#160;</p></li><li>Read more here;&#160;<a href=\"https://asic.gov.au/regulatory-resources/sustainability-reporting/\">https://asic.gov.au/regulatory-resources/sustainability-reporting/</a><p style=\"margin:0px 0px 15px;line-height:22px;text-align:start;background-color:rgb(255, 255, 255);\"></p></li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>The commentary to Recommendation 7.4 of the ASX Corporate Governance Council’s Principles and Recommendations refers companies to existing guidance such as:<ul><li><a href=\"https://www.asx.com.au/documents/asx-compliance/acsi-fsc-esg-reporting-guide-final-2015.pdf\">2015 ESG Report Guide for Australian Companies</a>&#160;issued by the Financial Services Council and the Australian Council of Superannuation Investors</li><li><a href=\"https://www.unglobalcompact.org/what-is-gc/mission/principles\">UN Global Compact ten principles</a></li><li><a href=\"https://mneguidelines.oecd.org/guidelines/\">OECD’s Guidelines for Multinational Enterprises</a></li></ul></li></ul><ul><li>ASX also refers companies to the various publications of the:<ul><li><a href=\"https://www.globalreporting.org/Pages/default.aspx\">Global Reporting Initiative</a>,</li><li><a href=\"https://www.cdsb.net/\">Climate Disclosure Standards Board</a></li><li><a href=\"https://www.integratedreporting.org/\">International Integrated Reporting Council</a>.</li></ul></li></ul><p></p>","oert":"Yes","oertt":"Yes<br><p>In 2022, ASX provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/australia-tcfd-101-workshop-training-2/\">source</a>)</p><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.asx.com.au/asx/share-price-research/company/NSX\">NSX</a>, since 2005</li></ul><p></p>","wom":"No","womt":"No","Additional_information":"<ul><li>ASX lists a range of responsible investing and ethically managed ETFs and managed funds.</li><li>ASX publishes an environment, social and governance section in its<a href=\"https://www.asx.com.au/documents/investor-relations/asx-annual-report-2016.pdf\">&#160;Annual Report 2016</a>&#160;(pages 14 to 16).</li><li>ASX also has a&#160;<a href=\"https://www.asx.com.au/about/corporate-social-responsibility.htm\">corporate social responsibility</a>&#160;section on its website.</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Listed, shareholder-owned for-profit public company; demutualized and self-listed in 1998.</li><li>Vertically integrated exchange offering trading in both equity and derivatives markets as well as the clearing and settlement for these markets.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://asic.gov.au/\">Australian Securities and Investments Commission&#160;</a>(ASIC)</li><li><a href=\"https://www.rba.gov.au/\">Reserve Bank of Australia</a>&#160;(RBA)</li></ul><p></p>","Regulatory_model":"<ul><li>ASIC supervises the real-time trading across all domestically licensed equities and futures markets. It is also responsible for the supervision of operators of financial markets and clearing and settlement facility (CS facilities) providers like ASX. ASIC also supervises ASX’s compliance as a listed public company on its own market.</li><li>RBA has formal responsibility for ensuring that CS facilities conduct their affairs in a way that is consistent with financial system stability.</li><li>ASX Compliance, a wholly owned subsidiary of ASX Limited, is responsible for monitoring and enforcing compliance by listed entities with the ASX Listing Rules.</li><li>The ASX Corporate Governance Council publishes principles and recommendations that set the standards of corporate governance for Australia’s listed entities.</li></ul><p>","About_the_stock_exchange":"<p>Location: Sydney, Australia</p><ul><li>The ASX Group’s origins as a national exchange go back to 1987. The Australian Stock Exchange Limited was formed in 1987 after the Australian Parliament drafted legislation that enabled the amalgamation of six independent state-based stock exchanges. Each of those exchanges brought with it a history of share trading dating back to the 19th century. In 2006 The Australian Stock Exchange merged with the Sydney Futures Exchange and originally operated under the name Australian Securities Exchange. Later, however, ASX launched a new group structure to better position it in the contemporary financial market environment. From 1 August 2010, the Australian Securities Exchange has been known as the ASX Group.&#160;<a href=\"https://www.asx.com.au/about/history.htm\">Source</a></li><li>ASX is a multi-asset class, vertically integrated exchange group whose activities span equity, derivative and OTC markets. It offers primary and secondary market services, including the raising, allocation and hedging of capital flows, trading, central counterparty risk transfer, and securities settlement. See&#160;<a href=\"https://www2.asx.com.au/about\">ASX</a>&#160;for more details.</li><li>Ownership: Shareholders of more than 10% shares includes HSBC Custody Nominees (Australia), BNP Paribas Nominees Pty Ltd. and JP Morgan Nominees Australia Ltd.</li></ul>","am":true,"os":true,"nz":false,"VCM":"Yes","CCM":"No","Notes":"ASX lists an ETF tracking ICE Carbon Futures Index and is also exploring more carbon derivative products.","Source_lnk":"https://www2.asx.com.au/markets/trade-our-cash-market/asx-investment-products-directory/etps  https://www.afr.com/companies/financial-services/australia-s-first-carbon-credits-etf-set-to-hit-asx-20220523-p5anr4"},{"id":54,"Country":"Australia","cc":"AU","Name0":"Sydney Stock Exchange","Link":"/stock-exchange/ssx","Name":"<a href=\"https://www.ssx.sydney/\">Sydney Stock Exchange</a>","nlc":6,"dmc":0,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/10/Australia-Sydney-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p>In 2021, the Sydney Stock Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/australia-tcfd-101-workshop-training/\">source</a>)</p><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"","Regulatory_bodies":"<ul><li><a href=\"https://asic.gov.au/\">Australian Securities and Investment Commission</a></li></ul><p>","Regulatory_model":"","About_the_stock_exchange":"<p>Location: Sydney, Australia</p><ul><li>Sydney Stock Exchange (SSX) is a securities exchange in Australia with a market licence granted by the Australian Securities & Investments Commission (ASIC). SSX provides opportunities for growth oriented companies to raise the capital they need for expansion from a diversified range of domestic and international investors, especially from the Asia-Pacific region.</li><li>SSX operates its official list of securities as a Main Board, but it has the flexibility that a Second Board provides as well. SSX will provide and develop specialised markets in a number of sectors, including Mining, Oil & Gas, Real Estate (REITs), Hi-tech, Agribusiness, Servicing and growth companies.As a securities exchange, SSX provides ‘listing’ facilities to companies and securities issuers as well as ‘trading' facilities for stock brokers, traders and investors to buy and sell shares/securities.</li><li>The securities that can be traded on SSX include: shares issued by companies, units issued by trusts and other pooled investment products as well as fixed interest instruments, such as bonds.&#160;<a href=\"https://www.ssx.sydney/en/about-us/about-ssx/\">(Source)</a></li></ul>","am":false,"os":false,"nz":false,"VCM":"UD","CCM":"No","Notes":"SSX is part of a consortium that has been shortlisted by the Australian Government’s Clean Energy Regulator (CER) to participate in the next phase for the delivery of the Australian Carbon Exchange.","Source_lnk":"https://www.ssx.sydney/en/find-us/news/432-InSite-MarketNews-sydney-stock-exchange-shortlisted-by-the-australian-governments-clean-energy-reg/ https://www.spglobal.com/commodityinsights/en/market-insights/latest-news/energy-transition/050223-rising-carbon-credit-demand-in-australia-fuels-launch-of-new-trading-platforms"},{"id":56,"Country":"Austria","cc":"AT","Name0":"Wiener Börse","Link":"/stock-exchange/wiener-borse","Name":"<a href=\"https://www.wienerborse.at/en/\">Wiener Börse (Vienna Stock Exchange)</a>","nlc":85,"dmc":174788,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2020/01/Austria-Vienna-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No<br>","ESGrr":"Yes","ESGrrt":"Yes<br>The European directive on non-financial information reporting (NFRD) has been implemented into the Austrian legal environment. The Nachhaltigkeits- und Diversitätsverbesserungsgesetz (<a href=\"https://www.ris.bka.gv.at/Dokumente/BgblAuth/BGBLA_2017_I_20/BGBLA_2017_I_20.pdf\">NaDiVeG</a>) makes CRS reporting mandatory as part of annual reporting.<p></p><p>Also, listed companies have to abide by the Corporate Governance Code and include a declaration of commitment. <a href=\"https://www.wienerborse.at/uploads/u/cms/files/issuers/ipo/market-segments-of-the-vienna-stock-exchange.pdf\">Source</a></p><p></p>","hwg":"Yes","hwgt":"Yes<br>See: <a href=\"https://www.wienerborse.at/en/listing/shares/investor-relations-services/\">Sustainability reporting - Guidance for issuers (2023)</a><p>","oert":"Yes","oertt":"Yes<br>See: <a href=\"https://www.wienerborse.at/wissen/bildung-beruf/seminare-lehrgaenge/seminare/ethisch-und-nachhaltig-investieren/\">Sustainable Investments</a><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.wienerborse.at/en/indices/index-values/overview/?ISIN=AT0000496906&ID_NOTATION=21919814\">VÖNIX</a> Made up of exchange-listed companies that are leaders with respect to social and ecological performance.</li><li><a href=\"https://www.wienerborse.at/en/indices/index-values/overview/?ISIN=AT0000A0CFV1&ID_NOTATION=26860089\">CECE SRI</a> &#160;Capitalisation-weighted price index that comprises companies traded on the stock exchange in the regions of Central, Eastern and Southeast Europe and are leaders in social and ecological performance.</li></ul><p>","hsbls":"Yes","hsblst":"Yes<br>Green- and social bonds platform launched in 2018 see: <a href=\"https://www.wienerborse.at/en/issuers/bond-admission-listing/green-and-social-bonds/\">https://www.wienerborse.at/en/issuers/bond-admission-listing/green-and-social-bonds/</a><p>","HSMElp":"Yes","HSMElpt":"Yes<br>See <a href=\"https://www.wienerborse.at/en/issuers/going-public-ipo/directmarketplus/\">Direct Market + and Direct Market</a><p>","wom":"Yes","womt":"Yes<br>Pursuant to<a href=\"https://www.ris.bka.gv.at/NormDokument.wxe?Abfrage=Bundesnormen&Gesetzesnummer=10002070&Artikel=&Paragraf=86&Anlage=&Uebergangsrecht=#:~:text=%287%29%20In%20b%C3%B6rsenotierten%20Gesellschaften%20sowie%2csechs%20Mitgliedern%20%28Kapitalvertretern%29%20und%20die\" target=\"_blank\" rel=\"noopener\"> § 86 (7) Aktiengesetz (AktG)</a>, listed companies and companies with more than 1,000 employees permanently employed, at least 30% of the Supervisory Board shall consist of women and at least 30% of the Supervisory Board shall consist of men, provided that the Supervisory Board consists of at least six (shareholder-appointed) members and at least 20% of the company’s workforce consists of female or male employees, respectively.","Additional_information":"<ul><li>Sustainability section of website: <a href=\"https://www.wienerborse.at/en/about-us/sustainability-and-social-responsibility/\">https://www.wienerborse.at/en/about-us/sustainability-and-social-responsibility/</a></li></ul><p>","Organizational_model_of_stock_exchange":"Private company for profit, demutualized in 1999<p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fma.gv.at/en/\">Financial Market Authority</a></li><li><a href=\"https://www.esma.europa.eu/\">European Securities and Markets Authority</a></li></ul><p>","Regulatory_model":"Government (Statutory) Model - &#160;the securities exchange is regulated by the Financial Market Authority (FMA). The FMA's main responsibilities in regulating the Wiener Borse, is to supervise the legality of the stock exchange organisation and the decisions made by the bodies of the exchange operating company as well as the proper conduct of stock exchange trading. Listing requirements are set according to the Austrian Stock Exchange Act.<p>","About_the_stock_exchange":"<p></p>As the main infrastructure provider in the region, Wiener Börse AG is the gate to global financial markets. It operates the stock exchanges in Vienna and Prague. With state-of-the-art technology and customer-oriented services, the Vienna Stock Exchange, as a private, profit-oriented company, makes a significant contribution to an internationally competitive capital market. Its mission is to achieve greater growth than comparable stock exchanges. Creating trust and transparency has been its fundamental duty since 1771.<p><p>Listed companies benefit from maximum liquidity and visibility. Wiener Börse offers issuers efficient, cost-effective listing services for equity and debt instruments in line with international standards. Investors profit from fast and inexpensive trading by the market leader as well as a wide variety of products. Wiener Börse distributes stock market data and calculates the most important indices for a dozen markets in the region. Because of its unique know-how, the national exchanges in Budapest, Ljubljana and Zagreb trust the IT services of the Vienna Stock Exchange. Additionally, the group holds stakes in energy exchanges and clearing houses. <a href=\"https://www.wienerborse.at/en/about-us/vienna-stock-exchange/\">Source</a></p><p>Ownership (Any owner with more than 4% of the exchange):<br>UniCredit Bank Austria AG: 13.36%<br>Erste Group Bank AG: 11.30%<br>VIENNA INSURANCE GROUP AG Wiener Versicherung Gruppe: 8.50%<br>Raiffeisen Bank International AG: 6.97%<br>Oesterreichische Kontrollbank AG: 6.60%<br>UNIQA Insurance Group AG: 6.60%<br>EVN AG: 4,65%<br>Others:&#160; 42,02%<br><a href=\"https://www.wienerborse.at/en/about-us/organization/shareholders/\">Source</a>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Country is covered in EU ETS. Has National emissions certificate trading system (NEHG 2022) for fossil fuels not already covered by the EU ETS","Source_lnk":"https://icapcarbonaction.com/en/ets/austrian-national-emissions-trading-system"},{"id":57,"Country":"Azerbaijan","cc":"AZ","Name0":"Baku Stock Exchange","Link":"/stock-exchange/bfb","Name":"<a href=\"https://bfb.az/eng/\">Baku Stock Exchange</a>","nlc":28,"dmc":1556.69,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/bse-partner-exchange-commitment-letter.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p>In 2022, the Baku Stock Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/azerbaijan-tcfd-101-workshop-training/\">source</a>)</p><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No<br><ul><li>However, BSE has <a href=\"https://bfb.az/eng/listing-advisory-program/\">Listing Advisory Program (LAP)</a> that focuses on companies that are interested in issuing securities. Through this program, BSE assists companies to develop their corporate governance, financial reporting system and provide staff training on securities market free of charge. In addition, different companies from audit, law, IT, consulting sectors are the partners of LAP and they provide their services to issuers at discounted prices.</li></ul><p></p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<p>Unlisted and For Profit</p><p>","Regulatory_bodies":"<p><a href=\"https://www.cbar.az/home?language=en\">Central Bank of the Republic of Azerbaijan</a></p><p></p>","Regulatory_model":"<p>Limited exchange SRO</p><p>","About_the_stock_exchange":"<p>Founded in 1997 as a closed stock company, Baku Stock Exchange (BSE) was aimed to establish and develop the market infrastructure that would provide the trading securities and efficient execution of trading transactions. BSE has 20 shareholders and its headquarter is situated in Baku. The first trading operation at the stock exchange was carried out on September 1, 2000, and today BSE organizes trading of the stocks, bonds and repo transactions. Now 18 companies are listed in two listing segments – premium and standard – that total market capitalization is about 1.44 bln USD.</p>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":58,"Country":"Bahrain","cc":"BH","Name0":"Bahrain Bourse (BHB)","Link":"/stock-exchange/bhb","Name":"<a href=\"https://www.bahrainbourse.com/\">Bahrain Bourse (BHB)</a>","nlc":43,"dmc":30200,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Bahrain-BahrainBourse.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://bahrainbourse.com/resources/files/Sustainability/BHB_SustainabilityReport_2021_EN.pdf\">Yes</a><br><ul><li><a href=\"https://bahrainbourse.com/resources/files/Sustainability/sustainability%20report_2020_en.pdf\">Bahrain Bourse Sustainability Report 2020</a></li><li><a href=\"https://www.bahrainbourse.com/resources/files/Sustainability/Sustainability%20Report%20EN.pdf\">Bahrain Bourse Sustainability Report 2019</a></li></ul><p></p>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li><p>In June 2020, Bahrain Bourse launched its voluntary environmental, social and governance (ESG) reporting guideline for listed companies and other stakeholders. The Guidance was updated in December 2022.</p><ul><li><a href=\"https://www.bahrainbourse.com/resources/files/Sustainability/ESG_Guide_2%20Jan%202023.pdf\">ESG Reporting Guide</a></li></ul></li></ul><p></p>","oert":"Yes","oertt":"Yes<br><p>The Bahrain Bourse provides ESG related training on an ad-hoc basis/based on requirements:</p><ul><li><a href=\"https://bahrainbourse.com/bahrain-bourse-holds-workshop-on-sustainability-and-ir-digital-solutions\">Workshop on Sustainability and IR Digital Solutions&#160;</a></li><li>In 2022, the Bahrain Bourse provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/bahrain-tcfd-101-workshop-training/\">source</a>)</li></ul><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.bahraininvestmentmarket.com/\">Bahrain Investment Market</a></li></ul><p></p>","wom":"No","womt":"No<br>Current High Level Control module requires listed companies to disclose on female representations on Board. The rule also ‘encourages’ female representation, but not mandatory at this stage.","Additional_information":"<p><a href=\"https://bahrainbourse.com/sustainability\">https://bahrainbourse.com/sustainability</a>&#160;</p><p>More information is available under the “Sustainability’ tab in the Header of the Main page. </p><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Bahrain Bourse (BHB) was established as a shareholding company according to Law No. 60 for the year 2010 to replace Bahrain Stock Exchange (BSE) that was established in 1987.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cbb.gov.bh/about-cbb/\">Central Bank of Bahrain</a></li></ul><p></p>","Regulatory_model":"<ul><li>Self Regulated Organization (SRO)</li></ul><p>","About_the_stock_exchange":"<ul><li>Bahrain Bourse Company B S C C is a self-regulated multi-asset marketplace. Bahrain Bourse aims to offer to its investors, issuers, and intermediaries a comprehensive suite of exchange-related facilities including offering listing, trading, settlement, and depositary services for various financial instruments.&#160;</li></ul>","am":true,"os":false,"nz":true,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":59,"Country":"Bangladesh","cc":"BD","Name0":"Chittagong Stock Exchange (CSE)","Link":"/stock-exchange/cse_bangladesh","Name":"<a href=\"https://cse.com.bd/\">Chittagong Stock Exchange (CSE)</a>","nlc":628,"dmc":73379.97,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/bangladesh-chittagong-stock-exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br><p>However, CSE has prepared a Draft Guidance on ESG reporting which is now under review; and the <a href=\"https://www.cse.com.bd/upload_bsec/Corporate_Governance_Code_10_06_2018.pdf\">Corporate Governance Code</a>&#160;has been issued in 2018 with mandatory effectiveness from the beginning of 2019.</p><p></p>","oert":"Yes","oertt":"Yes<br><p>In 2021, the Chittagong Stock Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/bangladesh-tcfd-101-workshop-training/\">source</a>)</p><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.cse.com.bd/sme/listedcompanies\">Listed Companies SME</a></li></ul><p></p>","wom":"No","womt":"No","Additional_information":"<ul><li style=\"font-weight:400;\" aria-level=\"1\">Listed Companies have to report on the Corporate Governance Code (CGC) of the Bangladesh Securities and Exchange Commission in their Annual Reports.</li><li style=\"font-weight:400;\" aria-level=\"1\">Environmental issues are reported to The Department of Environment, Ministry of Environment, Forest and Climate Change.</li><li style=\"font-weight:400;\" aria-level=\"1\">Bank Companies have to report on Corporate Social Responsibilities (CSR) in their Annual Reports under Bangladesh Bank (Central Bank) guidelines.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Incorporated as a limited company in 1995.</li><li>Demutualized in 2013.</li><li>Registered as a Public Limited Company after demutualization under Companies Act, 1994. The Board, headed by elected Chairman from the Independent Directors, consist of 13 members comprising 7 Independent Directors, 5 Shareholder Directors including 1 Strategic Investor and the Managing Director.</li></ul><p>","Regulatory_bodies":"<p><a href=\"https://sec.gov.bd/\">Bangladesh Securities and Exchange Commission (BSEC)</a></p><p>&#160;</p><p></p>","Regulatory_model":"<ul><li>Limited Exchange SRO</li><li>CSE activities are regulated by its own Memorandum & Articles of Association, regulations and by laws along with the rules, order and notifications of the Bangladesh Securities and Exchange Commission (BSEC)&#160;<a href=\"https://www.cse.com.bd/about/regulatory_structure\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.cse.com.bd/about/regulatory_structure&source=gmail&ust=1562000357058000&usg=AFQjCNF866ciPChpgLapR5FTZLiKdkWO0g\">(Source).&#160;</a></li></ul><p></p>","About_the_stock_exchange":"<p>Location: Chittagong, Bangladesh</p><ul><li>Chittagong Stock Exchange is one of the highly automated and sophisticated bourses of Bangladesh. CSE commenced its operation in 1995 and in 2013 it was converted into a demutualized Exchange. We are a fast progressing frontier market in South Asia with a transformational business plan to accommodate new products and services. CSE Next Generation Trading System (NGTS) supports multi asset class and multi-channel trading facilities.</li><li>CSE is an affiliated member of the World Federation of Exchanges (WFE), the founding member of the South Asian Federation of Exchanges (SAFE) and a member of the OIC Member States’ Stock Exchanges Forum, through which it maintains wide exposure to international and regional exchanges.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"OTC carbon credit trading seems active in banking sector","Source_lnk":"https://www.tbsnews.net/bangladesh/environment/bangladesh-earns-17m-carbon-credits-just-tip-iceberg-613410"},{"id":60,"Country":"Bangladesh","cc":"BD","Name0":"Dhaka Stock Exchange","Link":"/stock-exchange/dse_bangladesh","Name":"<a href=\"https://www.dsebd.org/\">Dhaka Stock Exchange</a>","nlc":348,"dmc":57006.73,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/bangladesh-dhaka-stock-exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br><ul><li>Compliance with Corporate Governance guidelines is a&#160;<a href=\"https://www.dsebd.org/criteria_for_listing.php\">requirement</a>&#160;for listing.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.dsebd.org/pdf/DSE%20GRI%20Guidance%20Document%20Final.pdf\">Guidance on Sustainability Reporting for Listed Companies in Bangladesh</a><ul><li>The Guidance was developed using the GRI Standard</li></ul></li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li><a href=\"https://www.dsebd.org/pdf/20-05-2018.pdf\">20 May 2018 and 26 July 2018</a>: Workshop on Corporate Transparency & Sustainability Reporting for listed companies.</li><li><a href=\"https://www.dsebd.org/pdf/01aug18.pdf\">26 July 2018:</a> Workshop on Corporate Transparency & Sustainability Reporting- Policies & Practice for listed companies and capital market regulators.</li></ul><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Public Limited Company, demutualized in 2013.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://sec.gov.bd/\">Bangladesh Securities and Exchange Commission&#160;(BSEC)</a></li></ul><p></p>","Regulatory_model":"<ul><li>The Dhaka Stock Exchange (DSE) is registered as a Public Limited Company and its activities are regulated by its Articles of Association, rules & regulations and by-laws along with the rules, order and notifications of the Bangladesh Securities and Exchange Commission (BSEC).&#160;&#160;<a href=\"https://www.dsebd.org/ilf.php\">(Source).</a></li></ul><p></p>","About_the_stock_exchange":"<ul><li>Originally incorporated in 1954. Headquarters in Dhaka, Bangladesh. More on company&#160;<a href=\"https://www.dsebd.org/ilf.php\">here</a>.</li><li>Public Company Limited by Share. Not listed company (Presently 266 shareholders).</li></ul>","am":true,"os":true,"nz":false,"VCM":"No","CCM":"No","Notes":"OTC carbon credit trading seems active in banking sector","Source_lnk":"https://www.tbsnews.net/bangladesh/environment/bangladesh-earns-17m-carbon-credits-just-tip-iceberg-613411"},{"id":61,"Country":"Barbados","cc":"BB","Name0":"The Barbados Stock Exchange Inc. (BSE)","Link":"/stock-exchange/barbados-bse","Name":"<a href=\"https://bse.com.bb/\">The Barbados Stock Exchange Inc. (BSE)</a>","nlc":16,"dmc":2387,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2022/03/Barbados-BSE.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No<br><ul><li>However, BSE has crafted the formulation of such a segment in the Rules for the BSE’s International Securities Market (“ISM”). It must be firstly approved by the board and ultimately by the regulator.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>The BSE has an SME platform called the Innovation & Growth Market (“IGM”). In partnership with Barbados’ Ministry of Energy and Business Development to secure funding for an incubator program for SMEs.</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Unlisted for Profit</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"http://www.fsc.gov.bb/index.php/en/\">Financial Services Commission of Barbados</a></li></ul><p>","Regulatory_model":"<ul><li>Limited exchange SRO</li></ul><p>","About_the_stock_exchange":"<ul><li>The Barbados Stock Exchange, commonly known as the BSE and formerly the Securities Exchange of Barbados, was re-incorporated on August 2, 2001, in accordance with the Securities Act 2001-13, which also enabled the establishment of the Barbados Securities Commission which on April 1st, 2011 was subsumed by the Financial Services Commission (FSC). The FSC is responsible for the regulation of the Insurance sub-sector, Co-operative and Non-Banking Financial sectors and the entire Barbados Capital Market, including Self-Regulatory Organizations and public companies whether listed or not. The Barbados Stock Exchange and its wholly owned subsidiary, the Barbados Central Securities Depository (BCSDI) are designated as Self-Regulatory Organizations (SROs) under the Securities Act and are regulated by the Financial Services Commission.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":62,"Country":"Belarus","cc":"BY","Name0":"Belarusian Currency and Stock Exchange","Link":"/stock-exchange/bcse","Name":"<a href=\"https://www.bcse.by/\" title=\"Belarusian Currency and Stock Exchange\">Belarusian Currency and Stock Exchange</a>","nlc":12,"dmc":6760,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Belarusia-BCSR.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br><ul><li>On 1 November 2017, BCSE&#160;updated its Listing Rules, which included the<br>introduction of a questionnaire for issuers of securities on the social and<br>environmental aspects of the organization's activities and corporate governance<br>issues into the Appendix 6 of the Listing Rules.</li></ul>","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"BCSE and the Ministry of Natural Resources signed a cooperation agreement on green financing https://bcse.by/press-center/news/n200820251/2025-08-20T11:15:26 <br><br>On 22.05.2025 BCSE hold a seminar on ESG topic &#160; https://www.bcse.by/presentations/prs220520251 <br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"<p style=\"margin:0cm 0cm 8pt;line-height:107%;font-size:11pt;font-family:Calibri, sans-serif;margin-bottom:0cm;line-height:normal;\"><a href=\"https://bcse.by/press-center/news/n091220221/2022-12-09T09:53:21\" title=\"In December 2022, the Ministry of Finance of the Republic of Belarus successfully placed the first \"green\" bonds listed on BCSE.\">In December 2022, the Ministry of Finance of the Republic of Belarus successfully\nplaced the first \"green\" bonds listed on BCSE.</a> </p>","HSMElp":"Yes","HSMElpt":"<a href=\"https://bcse.by/for_issuers/listing\">https://bcse.by/for_issuers/listing</a>","wom":"No","womt":"55% stuff are women, 41% heads are women. <br>","Additional_information":"<ul><li>BCSE Report<br><a href=\"https://bcse.by/about_bcse/reporting/bcse_reporting\">https://bcse.by/about_bcse/reporting/bcse_reporting</a></li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Not Listed / Not For Profit</li></ul><p></p>","Regulatory_bodies":"<p style=\"margin:0cm 0cm 8pt;line-height:107%;font-size:11pt;font-family:Calibri, sans-serif;margin-bottom:0cm;line-height:normal;\"><ul><li>The Ministry Finance of the Republic of\nBelarus (for Securities market) <a href=\"https://www.minfin.gov.by/en/\">https://www.minfin.gov.by/en/</a></li><li>The National Bank of the Republic of\nBelarus (for Currency market) <a href=\"https://www.nbrb.by/engl\">https://www.nbrb.by/engl</a></li></ul></p><p></p>","Regulatory_model":"<ul><li><p style=\"margin:0cm 0cm 8pt;line-height:107%;font-size:11pt;font-family:Calibri, sans-serif;margin-bottom:0cm;line-height:normal;\">Limited\nexchange SRO</p></li></ul><p></p>","About_the_stock_exchange":"Belarusian Currency and Stock Exchange (BCSE) is located in Minsk, Belarus. BCSE is the trading platform serving the four main segments of the organized financial market of the Republic of Belarus (currency, securities, money and derivatives market). BCSE carries out the following activities: organization of trading, clearing activities, activities on electronic document management system (EDMS) and information services. In addition, BCSE performs the function of supporting indicative quotations on assets traded outside the trading floor, and acts as a central registrar of information about OTC securities transactions. The main purpose of the BCSE is to promote the formation of fully organized financial market that meets its members’ needs, providing the government with effective market mechanisms for monetary and fiscal policy implementation, for performing supervisory and regulatory functions.","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":63,"Country":"Belgium","cc":"BE","Name0":"Euronext Brussels","Link":"/stock-exchange/euronext-brussels","Name":"<a href=\"https://www.euronext.com/en/markets/brussels\">Euronext Brussels</a>","nlc":206,"dmc":363957.57,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/belgium-euronext-brussels.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"/sites/sseinitiative/files/documents/eur_2022_urd_mel-2.pdf\">Yes</a><br><ul><li>There is a chapter in the annual report dedicated to sustainability activities, find all reports <a href=\"https://www.euronext.com/en/investor-relations/financial-information/financial-reports\">here</a>.</li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>The <a href=\"https://www.europarl.europa.eu/RegData/etudes/BRIE/2021/654213/EPRS_BRI%282021%29654213_EN.pdf\">European directive on non-financial information reporting</a> (NFRD) has been implemented into the Belgian legal environment.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"/sites/sseinitiative/files/documents/euronext-esg-guide-2022.pdf\">ESG Reporting Guide – Target 1.5°C</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br>Through the Euronext Academy, see more details&#160;<a href=\"https://www.corporateservices.euronext.com/academy?s=ESG\">here</a>.<p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li>See the list of ESG indices on the Euronext website <a href=\"https://live.euronext.com/en/products/indices/esg-indices\">here</a>.</li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.euronext.com/en/list-products/bonds/green-bonds\">Euronext ESG Bonds</a> is a community of ESG bond issuers where green, sustainability, social, blue and sustainability-linked bonds listed on all Euronext locations are consolidated onto one highly visible area. Details of the securities <a href=\"https://live.euronext.com/en/products/fixed-income/esg-bonds\">here</a>.</li><li>As of January 2021, Euronext is home to 420&#160;ESG bonds from&#160;150&#160;issuers across the globe including sovereigns, development banks, municipals, government-backed entities, financial institutions, corporates, pure play issuers.</li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>Euronext Growth,&#160;Euronext Access,&#160;Euronext Access+. More information <a href=\"https://www.euronext.com/en/raise-capital/sme\">here</a>.</li></ul><p></p>","wom":"No","womt":"No","Additional_information":"Euronext supports climate friendly innovations by financing Cleantech SME’s benefitting from major Euronext initiatives:<p><ul><li>TechShare: 27 Cleantech have followed the program on how to leverage capital markets</li><li>Tech40 Index: 10% of this increasingly important index is made up of Cleantech SME’s</li><li>Morningstar: the program fully covers the scope of Cleantech SME issuers (55)</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2000</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.nbb.be/en\">Belgian National Bank (BNB)</a></li><li><a href=\"https://www.fsma.be/en\">Belgian Financial Services and Markets Authority (FSMA)</a></li><li><a href=\"https://finance.belgium.be/en\">Belgian Ministry of Finance</a></li><li><a href=\"https://www.esma.europa.eu/\">European Union (ESMA)</a></li></ul><p></p>","Regulatory_model":"Government (Statutory) Model<p><ul><li>The Markets in Financial Instruments Directive (MiFID)&#160;classifies Euronext’s European cash markets as a regulated market. As such, the real-time monitoring performed by Euronext’s cash market operations and technical support is formally enforced, and trading rules and procedures are approved by five regulators. This regulatory and organizational system gives Euronext the power to efficiently manage crisis situations and extraordinary circumstances. Some of the markets organized by Euronext are exchange regulated, which means they are subject to a body of rules laid down by the market operator, Euronext. They are not regulated markets as defined by&#160;The Markets in Financial Instruments Directive (MiFID). These structured, exchange regulated markets offer simplified access to financial markets and streamlined listing requirements for companies from every sector of the economy, while ensuring compliance with rules on investor disclosure and the control of financial information.<a href=\"https://www.euronext.com/en/equities/market-regulation\">&#160;(Source)</a></li></ul><p></p>","About_the_stock_exchange":"Location of the listed holding: Brussels, Belgium<ul><li>Euronext Brussels is governed by the Belgian Law of 21 November 2017 on the market infrastructures for financial instruments and transposing Directive 2014/65/EU. Accordingly to the Law, Euronext Brussels is responsible for matters such as the organisation of the markets and the admission, suspension and exclusion of members and has been appointed by law as the “competent authority” for listing matters within the meaning of EU Directive 2001/34/EC dated 28 May 2001. Euronext Brussels is subject to the supervision of the Financial Services and Markets Authority (FSMA), an independent public authority which strives to ensure the honest and equitable treatment of financial consumers and the integrity of the financial markets. Euronext is the leading pan-European exchange in the Eurozone, spanning Belgium, France, Ireland, Norway, the Netherlands, Portugal, the UK and Ireland.&#160;Created in 2000, it unites markets which date back to the start of the 17th century. It is the primary exchange in the Euro zone with nearly 1,500 listed issuers worth more than €4.5 trillion in market capitalization as of end May 2019, an unmatched blue chip franchise consisting of 20+ issuers in the Morningstar® Eurozone 50 Index℠ and a strong diverse domestic and international client base</li></ul><p>100% ownership by Euronext NV</p>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":64,"Country":"United Kingdom","cc":"GB","Name0":"The Bermuda Stock Exchange (BSX)","Link":"/stock-exchange/bsx","Name":"<a href=\"https://www.bsx.com/\">The Bermuda Stock Exchange (BSX)</a>","nlc":1154,"dmc":2870,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2021/05/bermudabsx.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br><ul><li>To be released</li></ul><p>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Unlisted/For-Profit – Private Company</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.bma.bm/\">Regulatory bodies Bermuda Monetary Authority </a></li></ul><p>","Regulatory_model":"<ul><li>Strong exchange SRO</li></ul><p>","About_the_stock_exchange":"Established in 1971, the Bermuda Stock Exchange (BSX) is today the world’s preeminent fully-electronic, offshore securities exchange, offering a variety of domestic and international listing options.<p><p>A full member of the World Federation of Exchanges, and affiliate member of the International Organization of Securities Commissions the BSX is globally recognised and renowned and respected for its commercially sensible listing requirements.</p><p>With over 700 listings to date the Exchange is a leading market for the listing of investment funds, debt and insurance related securities, as well as those of small to medium enterprise companies.</p><p>The Exchange’s significant growth over the past several years is due in large part to its innovative and commercial approach. For instance, the BSX is able to offer listed issuers speed to market, with many listings taking as little as two weeks to complete.</p><p>Another example of the BSX’s pioneering approach is the Mezzanine Listing facility, which provides development stage companies with a unique opportunity to list, and subsequently raise capital on an internationally recognized exchange at a much earlier stage than a traditional IPO.</p><p>Furthermore, the BSX’s electronic trading, settlement and depository platform, licensed by NASDAQ OMX, is specifically designed to support the secondary market trading and settlement of sophisticated listed securities. The platform, based on a central limit order book model, is fully automated and allows for the trading of both equity and fixed income securities in a modern and secure environment.</p><p>All listed securities are supported through Bloomberg (BSX <GO>) and the BSX web site www.bsx.com carries details on all listed securities, providing important information supporting transparency and disclosure, with a view to encouraging liquidity and inspiring investor confidence.</p><p>When considering the Exchange, location should also not be overlooked. Bermuda, positioned one hour ahead of New York and four hours behind London, has earned a reputation as a world-class centre for commerce, with both a sound regulatory and legal environment (English Common Law), stable government and unsurpassed access to intellectual capital.</p><p>Working closely with Government, the Bermuda Monetary Authority (BMA) and the newly formed Bermuda Business Development Agency (BBDA) the BSX ensures that Bermuda’s stellar reputation is constantly enhanced through collaboration, innovation and growth.</p>","am":false,"os":false,"nz":false,"VCM":"","CCM":"","Notes":"","Source_lnk":""},{"id":65,"Country":"Bhutan","cc":"BT","Name0":"Royal Securities Exchange of Bhutan","Link":"/stock-exchange/rseb","Name":"<a href=\"https://rsebl.org.bt/\">Royal Securities Exchange of Bhutan</a>","nlc":19,"dmc":678,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2021/07/Bhutan-Royal-Securities-Exchange-.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"Not for Profit<p>","Regulatory_bodies":"","Regulatory_model":"Strong Exchange SRO<p>","About_the_stock_exchange":"The Royal Securities Exchange of Bhutan (RSEB) was established in August, 1993 and officially opened for trading on 11th October 1993. It was established as a non-profit making and quasi-public organization under the aegis of the Royal Monetary Authority (RMA). The objectives of the company are to encourage wider spread of share ownership in the enterprises, mobilize savings, provide platform to raise equity capital for new ventures and to provide liquidity to the existing shareholders. Developed under the Technical Assistance of the Asian Development Bank, RSEB was incorporated under the Companies Act of the Kingdom of Bhutan, 2016 and is regulated by the Financial Services Act 2011.","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Bhutan signed an agreement with Singapore on trading carbon credits between both the countries.","Source_lnk":"https://carbonherald.com/singapore-and-bhutan-agree-to-collaborate-on-carbon-credits/"},{"id":66,"Country":"Bosnia and Herzegovina","cc":"BA","Name0":"Banja Luka Stock Exchange (BLSE)","Link":"/stock-exchange/blse","Name":"<a href=\"https://www.blberza.com/Pages/Default.aspx\">Banja Luka Stock Exchange (BLSE)</a>","nlc":516,"dmc":4530,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/bosnia-banja-luka-stock-exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p class=\"p1\">In 2022, the Banja Luka Stock Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/banja-luka-and-belgrade-stock-exchanges-tcfd-101-workshop-training/\">source</a>)</p><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://www.blberza.com/Pages/DocView.aspx?page=scorecard\">The Scorecard and Corporate Governance Codes</a></li><li><a href=\"https://www.blberza.com/Pages/docview.aspx?page=sp74\">Issuers Reporting System</a></li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Joint-stock company (Private company)</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.secrs.gov.ba/en/\">The Republic of Srpska Securities Commission</a></li></ul><p></p>","Regulatory_model":"<ul><li>Under the Law the Commission is delegated the authorities and powers to:<ul><li>Pass regulations on the Republika Srpska securities market operation; Prescribe the conditions, issuing method and trading of securities distributed through the public offer</li><li>Issue licenses and permits for the establishment of investment funds and investment fund management companies and other authorized participants in the securities market as well as supervise their operations</li><li>Monitor compliance with rules for ordinary trading and fair competition in securities trade</li><li>Organize, undertake and supervise measures for ensuring the efficient functioning of the securities market and the protection of investors' interests</li><li>Prescribe elements of mandatory disclosure to investors and the public on the operations of issuers and other securities market participants and supervise the application thereto</li><li>Suspend the issuance and trade of particular securities and undertake other activities in the case of manipulation during trade, or when it estimates that certain activities are endangering interests of investors and the public, or they are not in accordance with the Law or other regulations</li><li>Monitor and assess the situation and securities market trends</li><li>Implement the previous activities if provisions and regulations of the Law have been violated, pronounce fines for violations and undertake other measures for which the Commission is authorized;</li><li>Provide information on the activities of the securities market and disseminate such information</li><li>Cooperate with cognate international organizations.</li></ul></li></ul><p>","About_the_stock_exchange":"<p>Location: Banja Luka, RS, BiH.</p><ul><li><a href=\"https://www.blberza.com/Pages/docview.aspx?page=sp2\">About BLSE</a></li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Bosnia and Herzegovina plans to introduce CO2 emissions pricing and trading system by the beginning of 2026","Source_lnk":"https://seenews.com/news/bosnia-plans-to-introduce-carbon-pricing-trading-system-by-2026-foreign-min-official-778093"},{"id":67,"Country":"Botswana","cc":"BW","Name0":"Botswana Stock Exchange","Link":"/stock-exchange/bse","Name":"<a href=\"https://www.bse.co.bw\">Botswana Stock Exchange</a>","nlc":30,"dmc":3114.5,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/botswana-bse-2.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.bse.co.bw/core/uploads/2024/08/BSE-Sustainability-Disclosure-Guidance-1.pdf\" title=\"Guidance for listed companies on reporting ESG information to investors\">Guidance for listed companies on reporting ESG information to investors</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>In 2022, <a href=\"http://bse.co.bw/wp-content/uploads/2022/01/SADC-Green-Bond-Study-Workshop-Report.pdf\">BSE in partnership with CoSSE (Committee of SADC Stock Exchanges) held a virtual workshop on Green Finance</a></li><li>24 June 2019 <a href=\"/home-slider/botswana-stock-exchange-hosts-responsible-investing-and-esg-workshop/\">BSE hosted a responsible investing and ESG workshop</a>.</li></ul><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.bse.co.bw/objectives-benefits/\">Tshipidi SME Board</a>, since 2017</li></ul>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>BSE is a statutory body created by an Act of Parliament of 1994. It is governed by the BSE Act pending the commencement of the Securities Act which will replace the BSE Act. Pursuant to the commencement of the BSE Transition Act in December 2015, the BSE has commenced the process of demutualization.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.nbfira.org.bw/\">Non-Bank Financial Institutions Regulatory Authority (NBFIRA)</a>.</li><li><a href=\"https://www.bankofbotswana.bw/\">Bank of Botswana.</a></li><li><a href=\"https://www.cipa.co.bw/home\">Companies & Intellectual Property Authority (CIPA)</a>.</li></ul><p></p>","Regulatory_model":"<ul><li>BSE is regulated by NBFIRA. Although the BSE promulgates&#160;the Listing Requirements and the Members Rules, NBFIRA gives approval of the Rules and Regulations.</li></ul><p>","About_the_stock_exchange":"Location: Gaborone, Botswana<ul><li>The Botswana Stock Exchange is Botswana’s national stock exchange. It has the responsibility of operating and regulating the equities and fixed interest securities market. Formally established in 1989, the BSE continues to be pivotal to Botswana’s financial system, and in particular the capital market, as an avenue on which the government, quasi- government and the private sector can raise debt and equity capital. The BSE plays host to the most preeminent companies doing business in Botswana. These companies represent a spectrum of industries and commerce, from Banking and financial services to Wholesaling and Retailing, Tourism and Information Technology.</li><li>To date, the BSE is one of Africa’s best performing stock exchanges, averaging a 24% aggregate return in the past decade. This has allowed the BSE to be the third largest stock exchange in terms of market capitalization in Southern Africa.</li></ul>","am":true,"os":false,"nz":true,"VCM":"No","CCM":"No","Notes":"May be approached as part of ACMI work","Source_lnk":""},{"id":68,"Country":"Brazil","cc":"BR","Name0":"B3","Link":"/stock-exchange/b3","Name":"<a href=\"https://www.b3.com.br/en_us/\">B3</a>","nlc":463,"dmc":935583,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/brazil-bmfbovespa.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://ri.b3.com.br/pt-br/informacoes-financeiras/relatorio-anual/\">Yes</a><br>","ESGrr":"No","ESGrrt":"No<br><ul><li>There are no listing rules related to ESG reporting at B3. However, there’s a specific item incorporated in the Reference Form by the Regulator, CVM (Securities and Exchange Comission of Brazil) – Item 7.8 “Social and Environmental Policies and Transparency” of CVM Instruction 480.</li><li>B3 encourages transparency and recommends that listed companies report their ESG practices and explain if they have published Annual Report that integrates sustainability indicators through item 7.8 of the Reference Form.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.b3.com.br/data/files/1A/D7/91/AF/132F561060F89E56AC094EA8/Guia-para-empresas-listadas.pdf\">Sustainability Guidance for Companies </a>(second edition 2016; first edition 2011).</li><li><a href=\"http://www.bmf.com.br/portal/pages/newsletter/bmfbovespa/Folheto_ESG_B3_Bi.pdf\">Sustainability Guidance and Business Opportunities in the Intermediation Industry</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>B3 offers ESG training, workshops, events, and opportunities to exchange of experiences among listed companies and investors to foster this agenda in the Brazilian Capital Market. The initiative is lead by the Client’s Relationship Department in partnership with the Sustainability Area.</li><li>Integration of ESG issues to education through the <a href=\"https://edu.b3.com.br/\">B3 Education</a>, a platform in which the Company acts as curator of knowledge already developed by the market, organizing content produced by partners, clients and academy, together with authored content, in the form of knowledge trails. Launched in 2020, it had 71 courses at the end of the year of 2021, more than 400 contents and 178,000 registered users, in addition to 1,7 million of registered accesses.</li><li><p class=\"p1\">In 2022, B3 provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/brazil-tcfd-101-workshop-training/\">source</a>)</p></li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"http://www.b3.com.br/en_us/market-data-and-indices/indices/sustainability-indices/corporate-sustainability-index-ise.htm\">Corporate Sustainability Index (ISE B3)</a></li><li><a href=\"http://www.b3.com.br/en_us/market-data-and-indices/indices/sustainability-indices/carbon-efficient-index-ico2.htm\">Carbon Efficient Index (ICO2 B3)</a></li><li><a href=\"https://www.b3.com.br/pt_br/market-data-e-indices/indices/indices-de-governanca/\">Family of Corporate Governance Indices</a></li><li><a href=\"https://www.spglobal.com/spdji/pt/indices/esg/sp-b3-brazil-esg-index/#overview\">S&P/B3 Brazil ESG Index</a></li><li><a href=\"https://www.b3.com.br/en_us/market-data-and-indices/indices/sustainability-indices/gptw-index-igptw-b3.htm\">GPTW/B3 Index (IGPTW B3)</a></li><li><a href=\"https://www.b3.com.br/main.jsp?lumPageId=8A488A2C50B9E6BF0150BA21E75849DF&lumA=1&lumII=8A80CB81633FBF0B016340B213195725&locale=en_US&doui_processActionId=setLocaleProcessAction\">Inclusion and Diversity Index (I&D Index) – To be launched until 2024</a></li><li>Besides the indices, there’s a couple of sustainability-related Exchange Traded Funds (ETFs) listed at B3, such as&#160;<a href=\"https://www.itnow.com.br/isus11/\">ETF ISE B3 (ISUS11)</a>,&#160;<a href=\"https://www.blackrock.com/br/products/251711/ishares-ndice-carbono-eficiente-ico2-brasil-fundo-de-ndice-fund\">ETF ICO2 B3 (ECOO11)</a>, <a href=\"https://www.itnow.com.br/gove11/\">ETF IGCT B3 (GOVE11)</a> and <a href=\"https://www.btgpactual.com/asset-management/etf-esg/sobre-esg-e-etf\">ETF S&P/B3 Brazil ESG (ESGB11)</a></li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.b3.com.br/en_us/b3/sustainability/esg-products-and-services/green-bonds/\">Green, Social and Sustainability Bonds (ESG Thematic Bonds)</a></li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.b3.com.br/en_us/products-and-services/solutions-for-issuers/listing-segments/bovespa-mais/\">BOVESPA MAIS</a>, since 2005</li></ul>","wom":"No","womt":"No","Additional_information":"<p>B3´s ambition is to connect sustainability with the business, leveraging the company´s strategic objectives, and promoting a resilient business environment aligned with the best ESG practices. For B3, sustainability is an essential market practice, which generates long-term value for its stakeholders. As an organization that is at the center of the financial and capital markets, B3 has the role of inducing the best ESG (Environmental, Social and Governance) practices among its stakeholders, offering products and services that support the clients in the transition to a resilient, low-carbon economy and, at the same time, conduct its own activities through responsible internal management. To reinforce this commitment, B3´s Sustainability Strategy, approved by Executive Board, is based on 3 pillars:</p><li>To be a company aligned with the sustainability best practices</li><li>Induce ESG best practices in the Brazilian market</li><li>Strengthen the product portfolio and develop new ESG market fronts</li><p>Considering the importance of the ESG agenda, B3 has the&#160;<a href=\"https://api.mziq.com/mzfilemanager/v2/d/5fd7b7d8-54a1-472d-8426-eb896ad8a3c4/fcfb5bf8-d0e2-c9b0-60fe-b6a18c03da09?origin=1\">Social and Environmental Responsibility Policy</a>, approved by the Board of Directors, which is &#160;aligned with the company’s strategic principles and aims to formalize and guide actions on the subject. Regarding governance structure, the company has a Sustainability Committee, responsible for strategic guidance on B3’s sustainability issues and approval of the planning and macro initiatives related to sustainability. It is composed by the CEO, Chief Financial, Corporate and Investors Relations Officer, Chief Client and Products Officer, Managing Director of People, Marketing, Communication and Sustainability and two members from the Board of Directors. Believing in the value of partnership, B3 acts as an associate, member and/or signatory of several institutions and commitments with an ESG focus. Thus, the company seeks to monitor trends and possible regulations that may impact operations and stakeholders, and subsidies for the creation of new products and services. B3 was the first stock exchange in the world to become a signatory to the UN Global Compact, in 2005, and the first stock exchange in an emerging country to commit to the Principles for Responsible Investment (PRI), in 2010. In 2012, the company became a signatory founder of the Sustainable Stock Exchanges initiative (SSE) within the UN and, since 2014, is a member of the Sustainability Working Group of the World Federation of Exchanges (WFE). In the climate agenda, B3 is a member of the Advisory Board of the CDP Latin America. B3 also seeks to engage companies in sustainability issues and, at the same time, prepare them for this new business context, in which ESG factors are as important as economic-financial ones. As an example of the promotion of this agenda, B3 has the Corporate Sustainability Index (ISE B3), which, since 2005, aims to create an investment environment compatible with the demands for sustainable development of contemporary society and encourage ethical responsibility of corporations, among other initiatives. B3´s activities have a low environmental impact due to their nature. However, considering the company´s commitment to be aligned with the best sustainability practices and encourage other companies to do the same, B3 monitors its environmental impacts and implement management, mitigation and transparency initiatives, among which it can be highlighted the preparation of the&#160;<a href=\"http://www.b3.com.br/en_us/b3/sustainability/at-b3/transparency/\">greenhouse gas emissions inventory</a>&#160;since 2009; being Carbon Neutral for 9 years, through the neutralization of greenhouse gas emissions; Reporting to the&#160;<a href=\"http://www.b3.com.br/en_us/b3/sustainability/at-b3/transparency/\">CDP Climate Change questionnaire</a>&#160;since 2009; and the implementation of internal selective waste collection, eco-efficiency, and incentive to conscientious consumption programs. As a responsible company, B3 strive to attract and retain talent, promote quality of life, and develop its employees. In addition, the company encourages diversity, inclusion, gender equality and volunteering agendas. B3 is also committed to inducing social practices in its value chain and promoting private social investment through B3 Social, a non-profit association, founded in 2007, responsible for integrating and coordinating the private social investment projects. In 2021, the company contributed with approximately R$48 million to 160 civil society projects on several topics, including youth training projects, fighting the impacts of the pandemic on food, health and income fronts, and projects supported through incentive laws on the fronts of health, sport and culture. In 2021, B3 became the first stock exchange in the world to issue a Sustainability Linked Bond (SLB) in the amount of US$700 million and is now financially committed to meeting sustainability-related goals. Among the commitments foreseen in the SLB are, by 2024, the creation of a diversity index for the Brazilian market and, by 2026, increase to 35% the percentage of women in leadership positions within the Exchange. Since 2010, base year 2009, B3 has been releasing the Annual Report drawn up based on the guidelines of the Global Reporting Initiative (GRI) and, since 2020, it also started to consider indicators of the Sustainability Accounting Standards Board (SASB) and some elements of the International Integrated Reporting Council (IIRC). The Annual Report, which is audited by a third party, and which covers the most relevant UN Sustainable Development Goals (SDGs) for the company´s business, aims to disclose, in a transparent manner, economic, environmental, social, and corporate governance information related to the strategy, business and performance of B3.</p><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2007</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.bcb.gov.br/en\">Central Bank</a></li><li><a href=\"https://www.cvm.gov.br/\">CVM (Securities and Exchange Commission of Brazil)</a></li></ul><p></p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model</p><ul><li>B3’s organization and operations are subject to direct oversight from the CVM. B3 is a market operator and operator of clearing houses that, in such capacity, acts as a self-regulatory and market surveillance organization, responsible for monitoring and overseeing market participants and the transactions carried out on its markets. The self-regulatory and market surveillance arm is B3 Market Surveillance (BSM), which maintains close relationships with the regulators, in particular the Central Bank of Brazil and the CVM. It is also responsible for keeping the CVM abreast of market developments and providing the market regulator with periodic reports of its market surveillance operations. Activities involving clearing and settlement services, which are provided through B3´s four clearing facilities, are subject to the regulatory and oversight authority of both the CVM and the Central Bank.</li></ul><p>","About_the_stock_exchange":"<p>Location: São Paulo, Brazil.</p><ul><li>B3 provides market infrastructure, with products and services that connect, enable and develop the capital and financial markets. The company operates as a stock, commodities and futures exchange, has a private securities clearinghouse, and is also a fixed income and equities depository.</li><li>B3 activities, therefore, encompass securities trading, post-trading, clearing, settlement, depository and registration, being managed by a structured and strict combination of standards and rules. The company also has robust risk management and governance, which guarantees solidity, agility and credibility to the services it provides to customers, including banks, brokerage houses, companies, asset managers, high frequency traders, individual investors and pension funds, among others.</li><li>B3 is a publicly-held company with more than 98% of its shares traded in its own exchange environment’s Novo Mercado listing segment, in which companies commit to Corporate Governance best practices.</li><li>B3 is headquartered in São Paulo, with offices in Rio de Janeiro (RJ) and Alphaville (SP). Overseas, the exchange has offices in London (UK), Shanghai (China) and Chicago (United States) dedicated to assisting customers with activities in these markets and disclosing products and services to potential investors. B3 also has stakes in stock exchanges in Chile, Colombia and Peru.</li></ul>","am":true,"os":false,"nz":false,"VCM":"UD","CCM":"Yes","Notes":"Offers an electronic interface platform for the trading of Brazilian carbon credits (CBIOs). Decarbonization Credits (CBIOs) are instruments adopted by the Brazilian National Biofuels Policy (RenovaBio) as a tool to reach annual decarbonization targets for the Brazilian fuel sector. B3 provides the registration environment for CBIO issuance, trading and retirement requests. Voluntary use of the market is not yet mainstream but expected to grow.","Source_lnk":"https://www.levysalomao.com.br/publications/lsbraziloutlook/brazilian-carbon-market-and-market-infrastructure https://www.b3.com.br/en_us/solutions/platforms/trading-interface/trader/introduction.htm https://www.spglobal.com/commodityinsights/en/market-insights/latest-news/oil/061220-brazilian-carbon-credit-first-trade-at-near-10cbio"},{"id":69,"Country":"Bulgaria","cc":"BG","Name0":"Bulgarian Stock Exchange","Link":"/stock-exchange/bse-sofia","Name":"<a href=\"https://bse-sofia.bg/en/\">Bulgarian Stock Exchange</a>","nlc":385,"dmc":16886.84,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/bulgaria-bulgarian-stock-exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p class=\"p1\">In 2022, the Bulgarian Stock Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/bulgaria-tcfd-101-workshop-training/\">source</a>)</p><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><p>BSE has adopted Refinitiv’s Environment, Social and Governance (ESG) metrics to power its sustainability index launched at the end of 2022.</p><p>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.bse-sofia.bg/en/growth-market-beam\">SME Growth Market&#160;beam&#160;</a>is a special market organised by the Bulgarian Stock Exchange (BSE) which enables the financing of small and medium companies in Bulgaria.</li></ul><p></p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<p>Listed</p><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fsc.bg/en/\">Financial Supervision Commission</a></li></ul><p></p>","Regulatory_model":"<ul><li>BSE considers its regulatory model to be of a “Limited Exchange SRO” (“Limited exchange self-regulatory organization”). Although its activities as market operator (as well as those of the listed companies and trading members) are supervised by the Bulgarian Financial Supervision Commission, BSE as the market operator for the Regulated Market, has the authority to regulate the organization and carry out the specific activities of its markets in terms of financial instruments available for trading, as well as specific rules applicable to listed companies and trading members. BSE also monitors activities of its trading members and listed companies, within the specific framework that is in line with applicable regulation.</li></ul><p>","About_the_stock_exchange":"<p>Bulgarian Stock Exchange is a public company that was officially licensed by the State Securities and Exchange Commission to operate as a stock exchange on October 9, 1997 and is currently the only functioning stock exchange in Bulgaria. Bulgarian Stock Exchange is licensed to operate as a benchmark administrator of financial instruments and financial contracts or to measure the performance of investment funds following the requirements of Regulation (EU) 2016/1011. In this way, BSE is a part of the European family of benchmark administrators, among which are the stock exchanges in Austria, Germany, Greece, Ireland, Slovenia, Hungary and Croatia as well as the groups of NASDAQ and Euronext. Founded in 1995 by the merger of several regional exchanges Bulgarian Stock Exchange AD is the driving force that contributes to the further development of the Bulgarian capital market. BSE’s core business includes operation of a cash market (equity market, bond market and other financial instruments), operation and maintenance of information systems for trading in securities, establishment and maintenance of a clearing system guaranteeing the obligations assumed under securities transactions executed on the Exchange. BSE’s mission is to facilitate the development of an organized capital market which guarantees its members and their clients’ equal access to market information and equal conditions for participation in exchange trading. Corporate social responsibility is part of the Bulgarian Stock Exchange’s business model. The Exchange has adopted a corporate social responsibility policy that covers the company and its employees and contributes to the sustainable development of Bulgaria.</p><ul><li><a href=\"https://www.bse-sofia.bg/en/sustainability\">BSE – Sustainability</a></li></ul>","am":true,"os":true,"nz":false,"VCM":"No","CCM":"No","Notes":"Country is covered in EU ETS - No relevant information","Source_lnk":""},{"id":70,"Country":"Canada","cc":"CA","Name0":"NEO Exchange","Link":"/stock-exchange/neo","Name":"<a href=\"https://www.aequitasneo.com/en/home\">NEO Exchange</a>","nlc":3264,"dmc":1270000,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2020/01/Canada-Aequitas-NEO-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"Yes","mcbsrit":"Yes<br>Fidelity Sustainable World ETF (<a href=\"https://finance.yahoo.com/news/fidelity-launches-first-esg-etf-133000084.html\">NEO:FCSW</a>)<p>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"For Profit<p>","Regulatory_bodies":"<a href=\"https://www.securities-administrators.ca/\">Canadian Securities Administrators&#160;(CSA)</a><p>","Regulatory_model":"","About_the_stock_exchange":"<ul><li>The NEO Goal is to create a new national stock exchange in Canada that re-focuses on the original purpose of an exchange, the bringing together of investors looking to build wealth with companies looking to raise money for growth, so that new wealth and jobs can be created. To achieve this goal, they are passionately dedicated to three key things:</li><li><li><a href=\"https://aequitasneoexchange.com/en/trading\">Increasing investor confidence</a></li><li><a href=\"https://aequitasneoexchange.com/en/listings\">Supporting public company success</a></li><li><a href=\"https://aequitasneoexchange.com/en/trading/designated-market-makers/\">Re-engaging the dealer community</a></li></li><li>NEO is driven by two key concepts: competition and innovation.&#160;<a href=\"https://www.aequitasneo.com/en/about/neo-overview\">Read more here.</a></li></ul>","am":false,"os":false,"nz":false,"VCM":"Yes","CCM":"No","Notes":"The exchange lists a number of companies that are focused on the creation, management and financing of carbon credit projects.","Source_lnk":"https://www.businesswire.com/news/home/20230117005386/en/NEO-Exchange-Expands-Coverage-in-Carbon-Credits-Market-With-Public-Listing-of-DevvStream https://cassels.com/rep_work/base-carbon-completes-reverse-takeover-listing-on-the-neo-exchange-and-strategic-investment-in-hardwick-climate-business-limited/"},{"id":71,"Country":"Canada","cc":"CA","Name0":"TMX Group Inc.","Link":"/stock-exchange/tmx","Name":"<a href=\"https://www.tmx.com/\">TMX Group Inc. (Toronto Stock Exchange)</a>","nlc":3504,"dmc":3264137.36,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Canada-TMX.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.tmx.com/investor-relations/corporate-information/environmental-social-and-governance\">Yes</a><br><ul><li>TMX Group introduced the TMX Group Environmental, Social and Governance Report in May/2020</li></ul><p></p>","ESGrr":"No","ESGrrt":"No<br><ul><li>However, if any environmental or social information is deemed ‘material’, it must be immediately disclosed by a news release as required by the Exchanges’ Timely Disclosure Policies. In addition, securities rules require issuers to disclose all material information including material environmental and social issues. <a href=\"https://tmx.complinet.com/en/display/display_viewall.html?rbid=2072&element_id=110&print=1\">(Source).</a></li><li>Canadian Environmental Protection Act (1999) requires companies to provide information on specific pollutant emissions for inclusion in the National Pollutant Release Inventory. The act was expanded five years later to include the GHG Emissions Reporting Program, which requires Canadian Large Emitters to report GHG emissions.&#160; Banks and other financial institutions with equity of CDN$1 billion or more are also required (Ban Act, 1991) to publish an annual statement describing their contributions to the Canadian economy and society.&#160;<a href=\"https://hausercenter.org/iri/wp-content/uploads/2011/08/CSR-Disclosure-Updates-4-18-14.pdf\">(Source).</a></li><li>The Canadian Securities Administrators requires mining companies to report on reasonably available information on environmental, permitting, and social or community factors as it relates to mineral exploration, development, and production activities on a mineral property that is material to the issuer. TSX includes a reference to this in its listing standards for mineral exploration and development stage mining companies.&#160;<a href=\"https://www.osc.gov.on.ca/en/SecuritiesLaw_ni_20110624_43-101_mineral-projects.htm\">(Source,</a>&#160;<a href=\"https://tmx.complinet.com/en/display/display_viewall.html?rbid=2072&element_id=28&record_id=28&filtered_tag\">Source).</a></li></ul><p></p>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.tsx.com/resource/en/2388\">A Primer for Environmental & Social Disclosure</a>, 2020 (First edition in March 2014)</li><li><a href=\"https://www.tsx.com/company-services/learning-academy/esg-101?id=503\">TMX entered&#160;into a strategic alliance with IHS Markit</a> to endorse their <a href=\"https://ihsmarkit.com/products/esg-reporting-repository.html\">ESG Reporting Repository (the “Repository”</a>). The Repository facilitates the disclosure of issuer ESG information into a variety of frameworks and standards, such as SASB and TCFD, and has extensive distribution channels to disseminate the information to global investors and stakeholders.</li><li>Related information:<ul><li>In 2010, the Canadian Securities Administrators issued CSA Staff Notice 51-333 Environmental Reporting Guidance to help issuers understand reporting requirements for environmental issues. It identifies where requirements exist, explores the concept of materiality and provides specific disclosure examples. While the notice did not specifically address social information, it has been noted that social issues are included since the Annual Information Form and Management's Discussion and Analysis cover all material issues. (<a href=\"https://www.osc.gov.on.ca/documents/en/Securities-Category5/csa_20101027_51-333_environmental-reporting.pdf\">Source)</a></li></ul></li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>Inside the <a href=\"https://www.tsx.com/tsx-company-services/learning-academy\">Learning Academy</a> platform, TMX offers training and content related to ESG.</li><li>The webpage <a href=\"https://www.tsx.com/tsx-company-services/learning-academy/esg-101?lang=en\">ESG 101</a> shows training designed to offer support for navigating ESG reporting, ratings, and data collection.</li><li><p class=\"p1\">In 2022, TMX provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/canada-tcfd-101-workshop-training/\">source</a>)</p></li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.tsx.com/news?id=148&year=2014&month=6\">S&P/TSX 60 ESG</a></li><li><a href=\"https://us.spindices.com/indices/equity/sp-tsx-60-fossil-fuel-free-carbon-efficient-index\">S&P/TSX 60 Fossil Fuel Free Carbon Efficient Index</a></li><li><a href=\"https://us.spindices.com/indices/equity/sp-tsx-60-fossil-fuel-free-index\">S&P/TSX 60 Fossil Fuel Free Index</a></li><li><a href=\"https://us.spindices.com/indices/equity/sp-tsx-renewable-energy-and-clean-technology-index\">S&P/TSX Renewable Energy and Clean Technology Index</a></li><li><a href=\"https://www.robecosam.com/csa/indices/sp-esg-index-family.html\">S&P Canada LargeMidCap ESG</a></li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>The <a href=\"https://www.tsx.com/sustainable-bonds/en.php\">TSX Sustainable Bonds</a> initiative enables investors to access information and transact sustainable bonds with the same ease and transparency that with listed equities. Regulatory approval was received in November 2020, and Sustainable Bonds is available for trading on TSX since March 1, 2021.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.tsx.com/trading/tsx-venture-exchange\">TSX Venture Exchange</a>, since 1999</li></ul><p>","wom":"No","womt":"No<br><ul><li>Several provinces have a “comply or explain” rule regarding women's consideration for top management positions in listed companies with self-determined quotas. In 2017 the province of Ontario set a goal of 30% women on board to be reached within three or five years by listed companies. More details <a href=\"/wp-content/uploads/2021/03/UN-SSE-Gender-Equality-Policy-Brief.pdf\">here</a>.</li></ul>","Additional_information":"<ul><li>TMX Group has strategically targeted growth- oriented Clean Technology and Renewable Energy companies seeking a market to access North American and global capital. As of March 2018, TSX and TSX Venture Exchange were home to 90 of these companies with a total market cap of over C$40 billion. Source: TSX/TSXV Market Intelligence Group. <a href=\"https://www.tmx.com/newsroom?id=643\">(Source).</a></li><li>TMX Group is a member of the following organizations:<ul><li>UN Sustainable Stock Exchange</li><li>World Federation of Exchanges Sustainability Working Group</li><li>Responsible Investment Association of Canada</li></ul></li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2000</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.osc.gov.on.ca/\">Ontario Securities Commission</a>&#160;- Ontario</li><li><a href=\"https://www.iiroc.ca/Pages/default.aspx\">Investment Industry Regulatory Organization of Canada (IIROC)</a>&#160;- Ontario</li><li><a href=\"https://lautorite.qc.ca/en/general-public/\">Autorité des marchés financiers</a>&#160;- Quebec</li></ul><p>","Regulatory_model":"<p>Independent Member Self-Regulatory Organization (SRO) Model</p><ul><li>The two major exchanges that the TMX Group operates are the TSX and the Montreal Exchange. Under Ontario securities rules, the Ontario Securities Commission gives oversight to all financial markets in the province. The TSX has self-regulatory abilities but delegates market surveillance and enforcement to the Investment Industry Regulatory Organization of Canada (IIROC); an independent organization. The TSX only has listing regulatory authority as a result of the delegated powers. This would warrant a ‘Independent Member SRO Model' classification. The Montreal Exchange operates in Quebec, which is regulated by the Autorité des Marchés Financiers (AMF), an independent but government owned organization. The AMF assists the Montreal Exchange in developing rules and regulations and gives general oversight to the markets but the majority of the regulatory authority lies with the Montreal Exchange itself, making it a Strong Exchange SRO Model.</li></ul><p>","About_the_stock_exchange":"<p>Location: Toronto, Canada</p><ul><li>TMX Group's businesses operate cash and derivative markets for multiple asset classes including equities, fixed income and energy. They also provide clearing facilities, data products and other services to the international financial community. <a href=\"https://www.tmx.com/en/about_tsx/\">(Source).</a></li></ul>","am":true,"os":false,"nz":false,"VCM":"Yes","CCM":"No","Notes":"The energy trading solutions provider Trayport which provides the primary trading network, back-office and data platform for The Voluntary Climate Marketplace (TVCM), is a wholly-owned subsidiary of TMX Group Limited.","Source_lnk":"https://www.thevcm.com/ https://www.esgtoday.com/tmxs-trayport-incubex-launch-carbon-marketplace/"},{"id":72,"Country":"Chile","cc":"CL","Name0":"Bolsa de Santiago (nuam)","Link":"/stock-exchange/bolsa-santiago","Name":"<a href=\"https://www.bolsadesantiago.com/\">Bolsa de Santiago</a>","nlc":295,"dmc":179335,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/chile-bolsa-de-comercio-de-santiago.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://cibe.bolsadesantiago.com/Documentos/Noticias/Avisos%20Generales/Memoria%20Bolsa%202022.pdf\">Yes</a><br><p>The sustainability report is integrated into the annual report.</p><ul><li><a href=\"https://cibe.bolsadesantiago.com/Documentos/Noticias/Avisos%20Generales/Memoria%20Bolsa%202021.pdf\">2021</a></li><li><a href=\"https://cibe.bolsadesantiago.com/Documentos/Noticias/Avisos%20Generales/memoria%20bolsa%202020.pdf\">2020</a></li><li><a href=\"https://cibe.bolsadesantiago.com/Documentos/Noticias/Avisos%20Generales/Memoria%20bolsa%202019.pdf\">2019</a></li><li><a href=\"https://cibe.bolsadesantiago.com/Documentos/Noticias/Avisos%20Generales/Memoria%20Anual%202018.pdf\">2018</a></li><li><a href=\"https://cibe.bolsadesantiago.com/Documentos/Noticias/Avisos%20Generales/Memoria%20BCS%202017.pdf\">2017</a></li></ul><p></p>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li>Guide on Sustainability Disclosure 2021 in Spanish (<a href=\"https://servicioscms.bolsadesantiago.com/Corporativo/Documentos/Relacionado/Guia%20de%20Reporte%20de%20Sostenibilidad%20Chile_GRI%20y%20Bolsa%20de%20Santiago.pdf\">Guía De Reporte Y Divulgación De Sostenibilidad Para Emisores En Chile – 2021</a>)</li><li>Provides guidance for issuers on the Design and Construction of Sustainability. Guide in <a href=\"https://servicioscms.bolsadesantiago.com/noticias/SiteAssets/Paginas/Forms/EditForm/Gui%CC%81a%20Sostenibilidad%20de%20Emisores%20Bolsa%20de%20Santiago.pdf\">Spanish</a> and <a href=\"/sites/sseinitiative/files/documents/2017-design-and-construction-of-sustainability-reports-santiago-exchange.pdf\">English</a>.</li><li><a href=\"https://servicioscms.bolsadesantiago.com/Corporativo/Documentos/Relacionado/4%20-%20Gu%C3%ADa%20de%20Inversi%C3%B3n%20Responsable%20-%20Bolsa%20de%20Santiago%20%282017%29.pdf\">Guide on Responsible Investment</a> (2017)</li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>Offered a training workshop in April 2018 on green bonds. <a href=\"http://clgchile.cl/uncategorized/06-04-2018/programa-seminario-bonos-verdes-en-chile-el-futuro-ya-esta-aqui\">(Source)</a>.</li><li>Provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC in 2022. (<a href=\"/sse-event/chile-tcfd-101-workshop-training/\">source</a>)</li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.spglobal.com/spdji/en/indices/esg/dow-jones-sustainability-chile-index/#overview\">Dow Jones Sustainability Chile Index</a></li><li><a href=\"https://www.bolsadesantiago.com/sostenibilidad_indices\">List of sustainability indices</a></li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.bolsadesantiago.com/bonos_verdes\">Green and Social Bond Segment</a> Launched&#160;10-04-2018.</li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.bolsadesantiago.com/mercado_venture\">Santiago SE, Venture</a> (SSEV), since 2015</li></ul>","wom":"No","womt":"No","Additional_information":"<ul><li>Offers guidance on sustainable and responsible investment on website <a href=\"https://www.bolsadesantiago.com/sostenibilidad_guiayrecomendaciones\">here</a>.</li><li>On 18 July, at the Santiago Exchange in Chile, the leadership teams of the Santiago Exchange and the Luxembourg Stock Exchange (LuxSE) signed a Memorandum of Understanding (MoU) to facilitate cooperation in the field of cross listing and trading of financial securities in the two markets. The agreement defines green and social bonds as an area of priority, reflecting the efforts made by both exchanges to bring sustainable finance centre stage. News Release found <a href=\"https://www.bourse.lu/pr-luxse-mou-santiago-exchange-30072019\">here</a>.</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cmfchile.cl/portal/principal/605/w3-channel.html\">Comisión para el Mercado Financiero (CMF)</a>.</li></ul><p></p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model</p><ul><li>Reviewing the CMF “Response to Survey on Implementation of IOSCO Objectives and Principles of Securities Regulation” document reveals that the CMF carries out and enforces most regulations in Chile. CMF is the main regulatory authority for tasks such as listing securities and derivatives contracts, the authorization of funds and its fund managers Licensing and the issuance of securities. Therefore, the Santiago Exchange regulates its own operational activities but the CMF acts as the main authority for higher-level activity in Chile.</li></ul><p>","About_the_stock_exchange":"<p>Location: Santiago, Chile</p><ul><li>The first attempts to establish a stock exchange in Chile were made in 1840 with little success. In 1884, there were already 160 corporations and this forced the creation of a specialized stock market where to direct all transactions with securities. The Santiago Stock Exchange was founded on November 27th, 1893, as a major step to infuse energy and vitality into the national economy.</li><li>​Santiago Exchange has several markets, which currently trade over USD 2 billion a day in equities, fixed income securities, money market instruments, investment fund shares and foreign securities. During the last decade, the exchange has expanded and evolved into a global point of interest for investors and a strategic partner for regional stock markets.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Chile is considering implementation of compliance carbon marketCurrently has a mechanism of carbon tax with offsets included","Source_lnk":"https://blogs.law.columbia.edu/climatechange/2022/06/22/chile-adopts-new-climate-change-framework-law-a-paradigm-shift/ https://www.whitecase.com/publications/insight/latin-america-focus-fall-2022-growth-carbon-markets https://www.giz.de/en/worldwide/42204.html"},{"id":73,"Country":"China","cc":"CN","Name0":"Hong Kong Exchanges and Clearing Limited","Link":"/stock-exchange/hkex","Name":"<a href=\"https://www.hkexgroup.com/?sc_lang=en\">Hong Kong Exchanges and Clearing Limited (HKEX)</a>","nlc":2602,"dmc":4567683,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/China-HKEX.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li>Information about HKEX’s efforts in promoting sustainable development of the marketplace is available in its annual&#160;<a href=\"https://www.hkexgroup.com/Corporate-Social-Responsibility/CSR-Reporting?sc_lang=en\">Corporate Social Responsibility reports</a>&#160;and the&#160;<a href=\"https://www.hkexgroup.com/Corporate-Social-Responsibility?sc_lang=en\">Corporate Social Responsibility section of the HKEX Group website.</a></li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><p>Issuers must publish their ESG reports on an annual basis and regarding the same period covered in their annual reports. Reporting requirements can be found in the related Main Board Listing Rules (<a href=\"https://en-rules.hkex.com.hk/node/2654\">here</a>) and the ESG Reporting Guide (the “Guide”), Appendix 27 to the Main Board Listing Rules&#160;(<a href=\"https://en-rules.hkex.com.hk/rulebook/1391\">here</a>).</p><p></p><p>With effect on 1 July 2020, the ESG Reporting Guide comprises two levels of disclosure obligations: (a) mandatory disclosure requirements; and (b) “comply or explain” provisions. Issuers must disclose the information required under the “Mandatory Disclosure Requirements”; and if the issuer does not report on any of the “comply or explain” provisions, it must provide considered reasons in its ESG report. The amendments had an emphasis in the board’s leadership role and accountability in ESG and the governance structure for ESG matters. HKEX also introduced climate change disclosure requirements and incorporated elements of the recommendations of the Task Force on Climate-Related Financial Disclosures (TCFD) into our Rules. In April 2022, the Exchange published a consultation on the enhancement of climate-related disclosures under its ESG framework. It proposes to mandate all issuers to make climate-related disclosures in their ESG reports, and introduce new climate-related disclosures aligned with the IFRS S2 Climate-related Disclosures exposure draft (as supplemented and modified by deliberations of the International Sustainability Standards Board (ISSB) up to April 2023). The consultation paper on the enhancement of climate-related disclosures under the ESG framework can be found (<a href=\"https://www.hkex.com.hk/-/media/HKEX-Market/News/Market-Consultations/2016-Present/April-2023-Climate-related-Disclosures/Consultation-Paper/cp202304.pdf\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.hkex.com.hk/-/media/HKEX-Market/News/Market-Consultations/2016-Present/April-2023-Climate-related-Disclosures/Consultation-Paper/cp202304.pdf&source=gmail&ust=1690441175868000&usg=AOvVaw1dh7FUSz8PfgyWTBraaJG2\">here</a>).</p><p>Disclosure requirements on corporate governance issues are contained in the Corporate Governance Code, Appendix 14 to the Listing Rules&#160;(<a href=\"https://en-rules.hkex.com.hk/node/3828\">here</a>). With effect on 1 January 2022, the Corporate Governance Code was revised to further enhance corporate governance standards among listed issuers in Hong Kong, specifically in the areas of corporate culture, director independence and diversity. The Corporate Governance Code mandates that IPO applicants must have at least one female director on board and existing listed issuers must appoint at least one female director on their boards by the end of 2024.&#160;</p><p>Issuers are required to publish ESG reports (covering financial year commencing on or after 1 January 2022) at the same time as publication of annual reports. Consultation paper and conclusions on the amendments can be found&#160;<a href=\"https://www.hkex.com.hk/News/Market-Consultations/2016-to-Present/April-2021-Review-of-CG-Code-and-LR?sc_lang=en\">here</a>.</p>","hwg":"Yes","hwgt":"Yes<br>Written guidance on ESG Report includes:<p><ul><li style=\"font-weight:400;\" aria-level=\"1\"><a href=\"https://www.hkex.com.hk/Listing/Sustainability/ESG-Academy/Rules-and-Regulations?sc_lang=en\">ESG Reporting Guide and FAQs</a></li><li style=\"font-weight:400;\" aria-level=\"1\"><a href=\"https://www.hkex.com.hk/Listing/Sustainability/ESG-Academy/Publications-and-Training?sc_lang=en\">Publications and Training under the HKEX ESG Academy</a></li><li style=\"font-weight:400;\" aria-level=\"1\"><a href=\"https://www.hkex.com.hk/Listing/Sustainability/ESG-Academy/ESG-in-Practice?sc_lang=en\">ESG in Practice the HKEX ESG Academy</a></li></ul><p>","oert":"Yes","oertt":"Yes<br>All resources can be found on the&#160;<a href=\"https://www.hkex.com.hk/Listing/Sustainability/ESG-Academy?sc_lang=en\">HKEX ESG Academy</a>, a centralised ESG educational platform launched in November 2021 to guide issuers and the broader business community in their sustainability journeys. The ESG Academy comprises several sections which houses all training and guidance materials published by the Exchange.&#160;In April 2022, the Exchange launched a new page headed “<a href=\"https://www.hkex.com.hk/Listing/Sustainability/ESG-Academy/ESG-in-Practice?sc_lang=en\">ESG in Practice</a>” under the ESG Academy, which highlights the Exchange’s latest ESG regulatory developments, and provides examples of exemplary ESG practices amongst its issuers.&#160;<p><p>The Exchange launched&#160;<a href=\"https://www.hkex.com.hk/Listing/Rules-and-Guidance/Other-Resources/Listed-Issuers/Director-Training-Programme?sc_lang=en\">e-training</a>&#160;courses, for directors to help them develop and refresh their knowledge and skills so as to ensure that their contribution to the board remains informed and relevant.&#160;In May 2021, the&#160;<a href=\"https://www.hkex.com.hk/Listing/Sustainability/ESG-Academy/Publications-and-Training?sc_lang=en\">ESG Academy Webinar Series</a>&#160;was launched to deepen ESG understanding and knowledge among listed issuers and the wider business community, and facilitate the integration of ESG considerations into their decision making processes. <a href=\"https://www.hkex.com.hk/Listing/Rules-and-Guidance/Other-Resources/Listed-Issuers/Director-Training-Programme-2017?sc_lang=en\">The Director Training Programme 2017/2018</a>&#160;also covers the topic of ESG reporting.</p><p>HKEX representatives also gave presentations at events organised by various non-governmental organisations and professional organisations&#160;to identify the latest trends and share practical advice in relation to ESG reporting.</p><p>In 2022, HKEX provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/hong-kong-tcfd-101-workshop-training/\">source</a>)<p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li style=\"font-weight:400;\" aria-level=\"1\"><a href=\"https://www.hsi.com.hk/static/uploads/contents/en/news/pressRelease/20180810T000000.pdf\">Hang Seng Corporate Sustainability Index</a></li><li style=\"font-weight:400;\" aria-level=\"1\"><a href=\"https://www.hsi.com.hk/eng/indexes/all-indexes/hsiesg\">Hang Seng ESG Index</a></li></ul><p>","hsbls":"Yes","hsblst":"Yes<br>At the heart of STAGE is an&#160;<a href=\"https://www.hkex.com.hk/Join-Our-Market/Sustainable-Finance/HKEX-STAGE/Product-Repository?sc_lang=en\">online product repository</a>, which provides access and transparency on sustainable finance products, including sustainability, green, and transition instruments from issuers across a variety of sectors. STAGE is also an online source of sustainable and green finance educational resources, promoting knowledge sharing and stakeholder engagement.<p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.hkgem.com/root/e_default.aspx\">GEM</a>, since 1999</li></ul><p>","wom":"Yes","womt":"Yes<br>Source:&#160;<a href=\"/wp-content/uploads/2022/05/HKEX-Disclaimer-for-the-Consolidated-Main-Board-Listing-Rules.pdf\" target=\"_blank\" rel=\"noopener\">HKEX Listing Rules</a>","Additional_information":"HKEX has been rated highly and awarded by both local and overseas rating agencies or professional institutions, in recognition of its achievement in corporate governance and CSR. More details are available on the&#160;<a href=\"https://www.hkexgroup.com/About-HKEX/About-HKEX/Awards-and-recognition?sc_lang=en\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.hkexgroup.com/About-HKEX/About-HKEX/Awards-and-recognition?sc_lang%3Den&source=gmail&ust=1690441175869000&usg=AOvVaw0JhNRbQtEH_TGE4PPoHdcj\">HKEX Group website</a>.<p><p>As part of the Exchange’s ongoing initiative to raise the overall standard of ESG performance and disclosures among issuers, the Exchange has conducted&#160;<a href=\"https://www.hkex.com.hk/Listing/Sustainability/ESG-Academy/Latest-News/Market-Consultation?sc_lang=en\">market consultations</a> on proposed changes to the ESG reporting requirements under the Listing Rules.&#160;In addition, the Exchange conducts periodic review of issuers’ ESG disclosures and publishes its findings&#160;both on the&#160;<a href=\"https://www.hkex.com.hk/Listing/Sustainability/ESG-Academy/Publications-and-Training?sc_lang=en\">ESG Academy</a>&#160;and the&#160;<a href=\"https://www.hkex.com.hk/Listing/Rules-and-Guidance/Other-Resources/Listed-Issuers/Exchange-Review-of-Issuer-Annual-Disclosure/Review-of-Implementation-of-ESG-Reporting-Guide?sc_lang=en\">HKEX Market website</a>.<p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2000.</li></ul><p>","Regulatory_bodies":"<a href=\"https://www.sfc.hk/en/\">&#160;&#160; Securities and Futures Commission</a><p></p><p></p>","Regulatory_model":"HKEX is a recognised exchange controller under the Securities and Futures Ordinance (Chapter 571 of the Laws of Hong Kong). The Exchange is responsible under statute for ensuring, so far as reasonably practicable, that the Hong Kong markets are fair, orderly and informed (the Exchange’s statutory duty). The Securities and Futures Commission performs a lead role in market regulation and certain areas of listing regulation and a complementary role through the exercise of its statutory powers by providing investigation and enforcement in cases involving corporate misconduct. Details of the regulatory framework of Hong Kong’s securities market are available on the&#160;<a href=\"https://www.hkex.com.hk/Services/Rules-and-Forms-and-Fees/Regulatory-Framework/Introduction?sc_lang=en\">HKEX Market website.</a><p>","About_the_stock_exchange":"<p></p>Location: Hong Kong<p><p>Hong Kong Exchanges and Clearing Limited (HKEX) is a publicly-traded company (HKEX Stock Code:388) and one of the world’s leading global exchange groups, offering a range of equity, derivative, commodity, fixed income and other financial markets, products and services, including the London Metals Exchange.</p><p>As a superconnector and gateway between East and West, HKEX facilitates the two-way flow of capital, ideas and dialogue between China and the rest of world, through its pioneering Connect schemes, increasingly diversified product ecosystem and its deep, liquid and international markets.</p><p>HKEX is a purpose-led organisation which, across its business and through the work of HKEX Foundation, seeks to connect, promote and progress its markets and the communities it supports for the prosperity of all.</p><p>More information about HKEX and its subsidiaries is available on the&#160;<a href=\"https://www.hkexgroup.com/About-HKEX/Company-Information/About-HKEX?sc_lang=en\">HKEX Group website</a></p>","am":true,"os":true,"nz":true,"VCM":"Yes","CCM":"No","Notes":"Hong Kong Exchanges & Clearing (HKEX) launched their International Carbon Market Council in July 2022, as a forum for collaboration with leading local corporates and financial institutions on new climate projects, technologies and businesses relating to emissions reduction. The HKEX Core Climate platform offers an international carbon marketplace to source, hold, trade, settle and retire voluntary carbon credits verified against international standards. HKEX has also signed a Memorandum of Understanding (MOU) with the China Emissions Exchange (CEEX) to jointly explore the development of a regional voluntary carbon emission reduction programme. An MOU with the Guangzhou Futures Exchange (GFEX) will explore the feasibility of cooperation on product development in both onshore and offshore markets.","Source_lnk":"https://www.nasdaq.com/articles/hong-kong-exchange-carries-out-first-carbon-credit-trades Core Climate launch --> https://www.hkex.com.hk/News/News-Release/2022/221028news?sc_lang=en GFEX MOU --> https://www.hkex.com.hk/News/News-Release/2021/210827news?sc_lang=en CEEX MOU --> https://www.hkex.com.hk/News/News-Release/2022/220324news?sc_lang=en International Carbon Market Place --> https://www.hkex.com.hk/Join-Our-Market/Sustainable-Finance/Core-Climate/ICMC?sc_lang=en"},{"id":74,"Country":"China","cc":"CN","Name0":"Shanghai Stock Exchange","Link":"/stock-exchange/sse","Name":"<a href=\"http://english.sse.com.cn/\">Shanghai Stock Exchange</a>","nlc":2184,"dmc":7095094.06,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/China-Shanghai-Stock-Exchange.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li><a href=\"http://english.sse.com.cn/news/newsrelease/a/20230425/b4870f1189eb9b4ac8a639dab9142ac6.pdf\">2022</a></li><li><a href=\"http://www.sse.com.cn/aboutus/socialresponsibility/download/c/5702535.pdf\">2021</a></li><li><a href=\"http://www.sse.com.cn/services/greensecurities/report/c/5705112.pdf\">2020</a></li><li><a href=\"http://www.sse.com.cn/aboutus/socialresponsibility/download/c/5122392.pdf\">2019</a></li><li><a href=\"http://www.sse.com.cn/aboutus/socialresponsibility/download/c/4766349.pdf\">2018</a></li><li><a href=\"http://www.sse.com.cn/aboutus/socialresponsibility/download/c/4509994.pdf\">2017</a></li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes","hwg":"Yes","hwgt":"Yes<br><a class=\"waffle-rich-text-link\" href=\"http://www.sse.com.cn/lawandrules/sserules/main/listing/stock/c/c_20190228_4727830.shtml\" target=\"_blank\" rel=\"noopener\">Guidelines for Environmental Information Disclosure of Listed Companies in Shanghai Stock Exchange</a> (in Chinese)","oert":"No","oertt":"No<br>","mcbsri":"Yes","mcbsrit":"Yes<br>List of green indices <a href=\"https://www.deepl.com/translator#zh/en/%E7%BB%BF%E8%89%B2%E6%8C%87%E6%95%B0%0a\">here</a>.<p>","hsbls":"Yes","hsblst":"Yes<br>Source: <a href=\"http://english.sse.com.cn/markets/bonds/overview/\">SSE Green Bonds</a><p><p>&#160;</p><p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li>SSE <a href=\"https://hk.lexiscn.com/latest_message.php?id=189868\">announced</a> the Circular on Launching Pilot Program for Green Corporate Bonds in March, 2016.</li><li>SSE is the Observer of Green Bond Principles (GBP) and is nominated <a href=\"https://www.climatebonds.net/2017/03/green-bond-pioneer-awards-2017-leadership-green-finance-glittering-event-london%E2%80%99s-guildhall\">Green Finance Pioneer</a> by Climate Bonds Initiative.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Association not for profit.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"http://www.csrc.gov.cn/csrc_en/c102023/common_zcnr.shtml\">China Securities Regulatory Committee&#160;(CSRC)</a>.</li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>The Shanghai Stock Exchange is able to set basic rules and regulations such as accepting new listings and market surveillance, but the China Securities Regulatory Committee holds the majority of regulatory abilities in China. Any new regulatory abilities the exchange wants to undertake must be approved by the China Securities Regulatory Committee.</li></ul><p>","About_the_stock_exchange":"Location: Shanghai, China.<p><ul><li>The Shanghai Stock Exchange (SSE) was founded on Nov. 26th, 1990 and commenced operations on Dec. 19th of the same year. It is a membership institution directly governed by the China Securities Regulatory Commission (CSRC). The SSE bases its development on the principle of “legislation, supervision, self-regulation and standardization” to create a transparent, open, safe and efficient marketplace. The SSE endeavors to realize a variety of functions: providing marketplace and facilities for securities trading; formulating business rules; accepting and arranging listings; organizing and monitoring securities trading; regulating members and listed companies; managing and disseminating market information. <a href=\"http://english.sse.com.cn/aboutsse/overview/\">(Source)</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"UD","Notes":"The Shanghai Environment and Energy Exchange which operates the trading platform for China’s Emissions Trading Scheme is collaborating with the Shanghai Stock Exchange to develop a price benchmark index.","Source_lnk":"https://www.yicaiglobal.com/news/china-national-carbon-market-starts-to-develop-carbon-price-index"},{"id":75,"Country":"China","cc":"CN","Name0":"Shenzhen Stock Exchange","Link":"/stock-exchange/szse","Name":"<a href=\"https://www.szse.cn/English/index.html\">Shenzhen Stock Exchange</a>","nlc":2578,"dmc":6219831.22,"SSEPE":"Yes","SSEPEt":"<a href=\"https://sseinitiative.org/sites/sseinitiative/files/documents/china-shenzhen-stock-exchange.pdf\" title=\"Yes\">Yes</a>","asr":"No","asrt":"No","ESGrr":"Yes","ESGrrt":"Yes","hwg":"Yes","hwgt":"Yes<br><ul><li><a class=\"ellipsis art-list-link\" title=\"Shenzhen Stock Exchange Social Responsibility Instructions to Listed Companies\" href=\"https://www.szse.cn/English/rules/siteRule/t20070604_559475.html\">Shenzhen Stock Exchange Social Responsibility Instructions to Listed Companies</a></li><li>In September 2006, Shenzhen Stock Exchange (SZSE) issued the “Guidelines for Corporate Social Responsibility of Shenzhen Stock Exchange Listed Companies”. From 2009 to 2010, the three boards of SZSE successively issued the “Guidelines for the Standardised Operation of Listed Companies”, which contained two separate chapters of “Corporate Governance” and “Social Responsibility”. In 2015, SZSE further revised the “Guidelines for the Standardised Operation of Listed Companies” and issued the Memorandum of Information Disclosure for Periodic Reports. Listed companies which are included in component of the Shenzhen 100 Index shall disclose social responsibility reports in accordance with the revised guidelines.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>SZSE has been offering training courses and seminars to senior management, independent directors of listed and Pre-IPO stage companies on ESG-related topics since September 2007, covering topics of socially responsible investing, compilation of corporate social responsibility report etc.</li><li>In 2022, SZSE provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/china-tcfd-101-workshop-training/\">source</a>)</li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.cnindex.com.cn/zstx/szxl/ztzs/201206/t20120618_5679.htm\">SZSE Environmental Protection Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/szxl/dzzs/201704/t20170427_8968.htm\">SZSE Energy Conservation Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/dzzs/201206/t20120614_6023.htm\">CNI TEDA EP Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/dzzs/201206/t20120614_6020.htm\">CNI Low-carbon 50 Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/cctv50/201406/t20140605_6051.htm\">CCTV 50 Ecology Industry Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/zqzsxl/lszqzstx/201703/t20170320_8914.htm\">CUFE-CNI High Grade Green Bond Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/zqzsxl/lszqzstx/201703/t20170320_8917.htm\">CUFE-CNI High Grade Unlabeled Green Bond Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/zqzsxl/lszqzstx/201703/t20170320_8920.htm\">CUFE-CNI High Grade Labeled Green Bond Total Return Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/ztzs/201405/t20140515_5934.htm\">CNI New Energy Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/ztzs/201409/t20140923_5930.htm\">CNI New Energy Vehicles Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/kjzsxl/201712/t20171218_10069.htm\">CUFE-CNI SZ-HK Connect Green Selection Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/kjzsxl/201803/t20180313_10175.htm\">CNI SZ-HK Connect Energy Conservation Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/kjzsxl/201803/t20180313_10176.htm\">CNI SZ-HK Connect Alternative Energy Cars Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/szxl/ztzs/201206/t20120618_5684.htm\">SZSE Corporate Social Responsibility Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/szxl/ztzs/201208/t20120822_5670.htm\">SZSE SME Corporate Social Responsibility Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/cctv50/201306/t20130625_6052.htm\">CCTV 50 Corporate Social Responsibility Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/dzzs/201206/t20120614_6018.htm\">CNI-CBN-AEGON-Industrial Corporate Social Responsibility Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/szxl/ztzs/201206/t20120618_5689.htm\">SZSE Corporate Governance Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/szxl/ztzs/201208/t20120822_5671.htm\">SZSE SME Corporate Governance Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/jcxl/ztzs/201206/t20120614_5950.htm\">CNI Corporate Governance Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/cctv50/201306/t20130625_6053.htm\">CCTV 50 Corporate Governance Index</a></li><li><a href=\"https://www.cnindex.com.cn/zstx/cctv50/201306/t20130625_6057.htm\">CCTV 50 Index</a></li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>SZSE assigns designated labels for ESG-related bond products. For example, the green bonds will be specially labelled as “G” in the bond code - <a href=\"https://bond.szse.cn/\" target=\"_blank\">https://bond.szse.cn/</a></li></ul>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.szse.cn/English/products/equity/ChiNext/index.html\">ChiNext</a>, since 2009.</li></ul>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Member-based stock exchange</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.csrc.gov.cn/pub/csrc_en/\">China Securities Regulatory Commission (CSRC)</a>.</li></ul><p>","Regulatory_model":"<ul><li>A self-regulatory legal entity under the direct administration of the CSRC.</li></ul><p>","About_the_stock_exchange":"<p>Location: Shenzhen, China.</p><ul><li>Shenzhen Stock Exchange (SZSE), established on 1st December, 1990, is a self-regulated legal entity under the supervision of China Securities Regulatory Commission (CSRC). It also organizes, supervises securities trading and performs duties prescribed by laws, regulations, rules and policies. Its main functions include providing the venue and facilities for securities trading, formulating operational rules, receiving listing applications and arranging securities listing, organizing and supervising securities trading, supervising members; regulating listed companies, managing and disseminating market information and other functions as approved by the CSRC. <a href=\"https://www.szse.cn/English/about/overview/index.html\">(Source)</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Has various dedicated exchanges that enable trading of carbon credits but unclear on the integration with the Shenzen Stock Exchange","Source_lnk":"https://www.eex.com/en/markets/environmental-markets/china-carbon"},{"id":76,"Country":"Colombia","cc":"CO","Name0":"Bolsa de Valores de Colombia (nuam)","Link":"/stock-exchange/bvc","Name":"<a href=\"https://en.bvc.com.co/nueva/\">Bolsa de Valores de Colombia (Colombian Securities Exchange)</a>","nlc":65,"dmc":90541.48,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/colombia-bvc.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.bvc.com.co/pps/tibco/portalbvc/Home/Accionistas/Informaci%C3%B3n+Financiera/Informes+de+Gesti%C3%B3n\">Yes</a><br><p>&#160;</p><p></p>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://bvcsostenible.bvc.com.co/contenido/45\">Guide for the elaboration of ESG reports for Issuers in Colombia</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br><p>In 2021, Bolsa de Valores de Colombia provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/colombia-tcfd-101-workshop-training/\">source</a>)</p><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://en.bvc.com.co/pps/tibco/portalbvc/Home/Empresas/IR/Indice_COLIR?action=dummy\">IR Recognition Index (COLIR)</a></li><li><a href=\"https://www.spglobal.com/spdji/en/indices/equity/dow-jones-sustainability-mila-pacific-alliance-index/#overview\">Dow Jones Sustainability MILA Pacific Alliance Index</a></li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://bvcsostenible.bvc.com.co/instrumentos?lang=en\">Green, Social, Sustainable and Orange Bonds</a></li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://a2censo.com/\">A2scenso</a></li></ul><p></p>","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://bvcsostenible.bvc.com.co/home?lang=en\">Sustainability Section (bvc sostenible)</a></li><li><a href=\"https://www.bvc.com.co/pps/tibco/portalbvc/Home/Accionistas/Informaci%C3%B3n+Financiera/Informes+de+Gesti%C3%B3n\">Sustainability Section On 2019 Management Report</a></li><li><a href=\"https://en.bvc.com.co/pps/tibco/portalbvc/Home/AcercaBVC/Sostenibilidad/Inversor?action=dummy\">Sustainability Impact Investment Fund: Inversor</a></li><li><a href=\"https://www.unglobalcompact.org/what-is-gc/participants/14975-Bolsa-de-Valores-de-Colombia\">Bolsa de Valores de Colombia is a member of the United Nations Global Compact</a></li><li><a href=\"https://www.bvc.com.co/pps/tibco/portalbvc/Home/AcercaBVC/Responsabilidad_Social/Nuestra_Estrategia?com.tibco.ps.pagesvc.action=updateRenderState&rp.currentDocumentID=-36fd85d1_1475dba7d5d_-753f0a0a600b&rp.revisionNumber=1&rp.attachmentPropertyName=Attachment&com.tibco.ps.pagesvc.targetPage=1f9a1c33_132040fa022_-78750a0a600b&com.tibco.ps.pagesvc.mode=resource&rp.redirectPage=1f9a1c33_132040fa022_-787e0a0a600b\">Inversión Responsable y Sostenible: Visión General, Prácticas Actuales y Tendencias</a></li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2007.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.minhacienda.gov.co\">Ministry of Finance and Public Credit.</a></li><li><a href=\"https://en.superfinanciera.gov.co/jsp/index.jsf\">Superintendent of Finance.</a></li><li><a href=\"https://www.amvcolombia.org.co/\">Colombian Capital Market Self Regulator (AMV)</a>.</li></ul><p></p>","Regulatory_model":"Independent Member Self-Regulatory Organization Model<p><ul><li>The Ministry of Finance and Public Credit is an entity of the Colombian Federal Government that issues regulations and laws regarding the stock exchange. The Superintendent of Financial Institutions sets out instructions in order for exchanges to remain compliant with the aforementioned laws and regulations. The Exchange of Colombia is self-regulatory and manages its own operations; its supervisory tasks are handled by a separate organization it created in 2006 which is known as the “Autorregulador del Mercado de Valores”.</li></ul>&#160;<p><p>","About_the_stock_exchange":"<ul><li>Bolsa de Valores de Colombia (bvc) is the Leading operator of the Colombian capital market infrastructure with presence&#160;in the entire value chain. bvc provides solutions and services of Pre-trading (issuer services and issuances), Trading&#160;(access, electronic and OTC), Post-trading (clearing, settlement, custody and securities administration), Information&#160;(market data and price vendor) and Technology (systems implementation of core banking, capital markets and digital solutions) in the markets of equities, fixed income, derivatives and FX in a direct fashion or through its subsidiaries and investments. (Source: BVC).</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Ministry of Environment and Sustainable Development runs a Voluntary Carbon Market. Has carbon tax with offsets included and the assumption is that the VCM facilitates trading of such offsets","Source_lnk":"https://www-minambiente-gov-co.translate.goog/mercados-de-carbono/contexto-mercados-de-carbono/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=sc https://www.whitecase.com/publications/insight/latin-america-focus-fall-2022-growth-carbon-markets"},{"id":77,"Country":"Costa Rica","cc":"CR","Name0":"Bolsa Nacional de Valores","Link":"/stock-exchange/bolsacr","Name":"<a href=\"https://www.bolsacr.com\">Bolsa Nacional de Valores</a>","nlc":10,"dmc":2037.34,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/costa-rica-bnv.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li><a href=\"https://www.bolsacr.com/bolsa-valores-cr/memorias-anuales/reporte-de-sostenibilidad-2017?ano=2017&seccion=1875\">2017 Sustainability Report</a> (in Spanish).</li><li><a href=\"https://www.bolsacr.com/sites/default/files/29/p_memoria_de_sostenibilidad_2018_bnv.pdf\">2018 Sustainability Review</a> (in Spanish).</li></ul><p></p>","ESGrr":"No","ESGrrt":"No<br><ul><li>There is mandatory corporate governance regulation for the securities market, issued by The Securities Regulator (SUGEVAL). Regulation in Spanish <a href=\"https://www.sugeval.fi.cr/normativa/Lists/Reglamentos%20vigentes%20y%20en%20consulta/DispDetalle.aspx?List=f7496750-b231-4ea2-8f77-9c6c13d216d4&ID=38\">here</a>.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.bolsacr.com/empresas/guia-para-reporte-de-sostenibilidad\">Guía voluntaria para la creación de reportes de sostenibilidad</a> (in Spanish).</li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>May 2019, “<a href=\"/home-slider/exchange-in-focus-costa-rica-holds-first-responsible-investment-workshop/\">Responsible Investment Workshop</a>” in collaboration with UNEP-FI.</li><li><a href=\"/home-slider/national-stock-exchange-of-costa-rica-celebrates-its-first-green-economy-summit-signs-green-economy-principles/\">September 2018 Green Economy Summit</a>.</li><li>April 2018 Seminar to promote the use of green bonds with <a href=\"https://www.unepfi.org/events/regions-events/latin-america-caribbean-events/promotion-of-green-bonds-in-costa-rica/\">UNEP-FI.</a></li><li>Free <a href=\"https://www.bolsacr.com/sites/default/files/capacitaciones/BonosVerdes/app.html\">online course</a> on Green Bonds (in Spanish).</li><li>September 2022, provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/central-america-tcfd-101-workshop-training/\">source</a>)</li></ul><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No<br><ul><li>There is a specific section on the website that shows: general information, on-line training, benefits for issuers, the standard for the emission and so on. Green bonds section <a href=\"https://bolsacr.com/empresas/bonos-verdes-bnv\">here.</a></li><li>The National Stock Exchange of Costa Rica defined a standard for the green bonds emission, based on the Green Bond Principles (GBP-ICMA) in order to provide transparency and confidence to the investors. Through this new instrument, the Exchange promotes the financing of green projects in Costa Rica through the stock market. Find standards for emission <a href=\"https://bolsacr.com/sites/default/files/239/estandar_bonos_verdes_bnv.pdf\">here</a>, video about green bonds <a href=\"https://www.youtube.com/watch?v=04yQvyzUKjc&feature=youtu.be\">here</a>, green bond section <a href=\"https://bolsacr.com/empresas/bonos-verdes-bnv\">here</a>.</li><li>The exchange plans to launch a green bond listing segment in 2019.</li></ul><p></p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li>The BNV promotes projects that generate economic, social and environmental value, such as:<ul><li>Providing textbooks, school supplies and computer labs to schools, as well as facilitating improvements in classroom infrastructure.</li><li>Supporting new entrepreneurs as a jury and sponsor of the Seedstars Costa Rica edition, an event that awards innovative small entrepreneurs with potential projects.</li></ul></li><li><a href=\"https://bolsacr.com/capacitacionesenlinea\">BNV Aprenda</a> is a form of self-taught training online which allows users to learn about the Costa Rican stock market.</li><li><a href=\"https://www.mapacr.com/\">MAPA, the Mercado Alternativo para Acciones,</a> is an initiative that promotes raising capital for small- and medium-sized enterprises (SMEs). Through MAPA, BNV helps SMEs in adopting governance best practice and becoming more professional.</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Private company owned by the brokerage companies (mutualized), and it is not a listed company.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.sugeval.fi.cr/Paginas/Inicio.aspx\">Superintendencia General de Valores (SUGEVAL).</a></li></ul><p></p>","Regulatory_model":"<ul><li>Government (Statutory).</li><li>In Costa Rica exists the Consejo Nacional de Supervisión del Sistema Financiero (CONASSIF) which is the superior regulator entity in Costa Rica, its purpose is to provide uniformity and integration to the activities of regulation and supervision of the Costa Rican Financial System. CONASSIF executes its work on the Superintendencia General de Entidades Financieras (SUGEF), the Superintendencia General de Seguros (SUGESE), the Superintendencia de Pensiones (SUPEN) and the Superintendencia General de Valores (SUGEVAL).</li><li>Meanwhile, the SUGEVAL is the entity in charge of supervising the whole securities market, the National Stock Exchange is supervised by it. Moreover, in Costa Rica exist a regulation (Securities Market Regulatory Law N°7732) that has as a main purpose the regulation of: the securities markets, the individuals and legal entities that directly or indirectly participate in this market. Furthermore, the National Stock Exchange must regulate the operation of the market and autorized the Brokers and Brokerages.</li></ul><p>","About_the_stock_exchange":"<p>Location: San José, Costa Rica</p><ul><li>Founded: 29 September 1976.</li><li>The National Stock Exchange of Costa Rica is a private organization owned by brokerages in accordance with the Securities Market Regulatory Law. The main purpose of the exchange is to facilitate transactions with securities, as well as the authorization, inspection and regulation of brokers.&#160;In addition, the exchange provides the technological platform that facilitates the trade of securities, and provides a meeting point between investors and issuers that requires financing of public and private projects.</li><li>The exchange is the only platform for the secondary market, based on national regulation.</li><li>The BNV contributes to the formation of prices of traded securities and provides a strong regulated structure that gives transparency and confidence to the various market participants.</li><li>The BNV is the biggest and oldest exchange in the Central America region.</li></ul>","am":true,"os":true,"nz":false,"VCM":"Yes","CCM":"No","Notes":"A domestic voluntary carbon market exists to support national commitments to achieve carbon neutrality. Carbon credits established by a national standard, Costa Rican Compensation Units (“UCCs”), are issued and traded at the national stock exchange or through bilateral agreements.","Source_lnk":"https://climateactiontracker.org/countries/costa-rica/policies-action/"},{"id":78,"Country":"Côte D'Ivoire","cc":"CI","Name0":"BRVM (Regional Securities Exchange)","Link":"/stock-exchange/brvm","Name":"<a href=\"https://www.brvm.org/\">Bourse Régionale des Valeurs Mobilières</a>","nlc":46,"dmc":10501.16,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/cote-divoire-brvm-regional-exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br><ul><li>However, received an offer from BeDeveloppment to produce ESG guidance.</li></ul><p>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br><ul><li>However, BRVM is in the beginning phase of creating a BRVM SSE Index.</li></ul><p>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Demutualised</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.crepmf.org/Wwwcrepmf/?AspxAutoDetectCookieSupport=1\">Conseil Régional de l’Epargne Publique et des Marchés Financiers (CREPMF)</a></li></ul><p></p>","Regulatory_model":"<ul><li>Non self regulatory exchange</li></ul><p>","About_the_stock_exchange":"<ul><li>The Bourse Regionale des Valeurs Mobilieres (BRVM) was founded in 1998 and operates on the CFA Franc. It is a regional stock exchange serving the following West African Economic and Monetary Union (WAEMU) countries: Cote d’Ivoire, Mali, Senegal, Togo, Burkina Faso et Niger. BRVM ranks first among the top-performing African stock markets in terms of increases in its index of all listed securities (BRVM Composite), finishing 2015 with a 17.77 % increase of its composite index. Stocks and Bonds are traded on BRVM.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"In their early phase of exploring and understanding carbon markets","Source_lnk":"https://www.un-redd.org/post/cote-divoire-explores-carbon-markets-potential-source-finance-climate-goals"},{"id":79,"Country":"Croatia","cc":"HR","Name0":"Zagreb Stock Exchange","Link":"/stock-exchange/zse","Name":"<a href=\"https://zse.hr/en\">Zagreb Stock Exchange</a>","nlc":91,"dmc":21679,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2021/03/Zagreb-Stock-Exchange_Commitmentletter.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://eho.zse.hr/en/issuer-announcements/view/48132\">Yes</a><br><ul><li>Zagreb Stock Exchange is publishing the Report on Environmental and Social Matters since 2017</li></ul>","ESGrr":"Yes","ESGrrt":"Yes<br>The Croatian Financial Services Supervisory Agency, at the Board meeting held on 17 March 2021, adopted the following: <a href=\"https://www.hanfa.hr/media/5669/guidelines-for-the-preparation-and-disclosure-of-esg-relevant-issuer-information_24-3-2021.pdf\">Guidelines for the Preparation and Disclosure of ESG Relevant Issuer Information&#160;</a><p></p><ul><li>The Regulation is oriented towards environmentally sustainable objectives exclusively and prescribes direct obligations, with the following being applicable to issuers: - obligation to disclose information for issuers of corporate bonds that are made available as environmentally sustainable and - disclosure obligation for all entities subject to non-financial reporting requirements under the NFRD (Articles 21a and 24a of the Accounting Act) as regards how and to what extent their activities are related with economic activities qualifying as environmentally sustainable. .</li></ul><p></p>","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><ul><li>With the help of EBRD (European Bank for Reconstruction and Development), in 2010 Zagreb Stock Exchange established the <a href=\"https://www.akademijazse.hr/\">Zagreb Stock Exchange Academy</a>, a department for education in the field of capital markets. Today the Academy is the largest provider of education in financial markets in Croatia.</li><li>Among others, Academy offers seminar Socially Responsible Investing giving participants the insight in ESG concept.</li><li>Courses offered in 2021: <a href=\"https://www.akademijazse.hr/event/odgovorno-investiranje-2/\">Responsible investing, </a><a class=\"waffle-rich-text-link\" href=\"https://www.akademijazse.hr/event/esg-i-odrzivost-uvod-u-radionicu-o-nefinancijskom-izvjestavanju/\" data-sheets-formula-bar-text-link=\"https://www.akademijazse.hr/event/esg-i-odrzivost-uvod-u-radionicu-o-nefinancijskom-izvjestavanju/\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:'docs-Calibri';font-style:normal;text-decoration-skip-ink:none;\">ESG and sustainability - an introduction to the workshop on non-financial reporting</a></li><li>In 2022, the Zagreb Stock Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/croatia-tcfd-101-workshop-training/\">source</a>)</li><li>Courses offered in 2023: <a class=\"waffle-rich-text-link\" href=\"https://www.akademijazse.hr/event/esg-radionica-2/\" data-sheets-formula-bar-text-link=\"https://www.akademijazse.hr/event/esg-radionica-2/\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:''docs-Calibri'';font-style:normal;text-decoration-skip-ink:none;\">ESG Workshop (04.07.23)</a> , <a class=\"waffle-rich-text-link\" href=\"https://www.akademijazse.hr/event/shaareholders-stakeholders-and-esg-module-c/\" data-sheets-formula-bar-text-link=\"https://www.akademijazse.hr/event/shaareholders-stakeholders-and-esg-module-c/\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:''docs-Calibri'';font-style:normal;text-decoration-skip-ink:none;\">Shareholders, Stakeholders and ESG – module C (12.10.23)</a> , <a class=\"waffle-rich-text-link\" href=\"https://www.akademijazse.hr/event/esg-radionica/\" data-sheets-formula-bar-text-link=\"https://www.akademijazse.hr/event/esg-radionica/\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:''docs-Calibri'';font-style:normal;text-decoration-skip-ink:none;\">ESG Workshop (26.05.23)</a></li></ul><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://progress.market/home\">Progress Market</a> is multilateral trading facility in Croatia and Slovenia, managed by the Zagreb Stock Exchange, Inc, intended for small and medium enterprises.</li><li><a href=\"https://listed-sme.com/en-GB\">Listed SME research Hub</a></li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"Public listed company; demutalized in 2016.<p>","Regulatory_bodies":"<ul><li><a href=\"https://www.hanfa.hr/en/\">Croatian Financial Services Supervisory Agency (CFSSA)</a></li></ul><p>","Regulatory_model":"Limited exchange SRO (“Limited exchange self-regulatory organization”) The Zagreb Stock Exchange is regulated by the Capital Market Act and the Stock Exchange Rules and supervised by Croatian Financial Services Supervisory Agency (CFSSA).<p>","About_the_stock_exchange":"Registered office: Ivana Lučića 2a/22, Zagreb, Croatia. Zagreb Stock Exchange manages the Regulated Market and Multilateral Trading Facility Progress Market, which is also registered as a SME Growth Market. Zagreb Stock Exchange has been approved as APA (Approved Publication Arrangement) by the Croatian Financial Services Supervisory and is also accredited by the Global Legal Entity Identifier Foundation (GLEIF) for issuing LEI’s. More info <a href=\"https://zse.hr/en/company-details/703\">here</a>.","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Country is covered in EU ETS - No relevant information","Source_lnk":""},{"id":80,"Country":"Cyprus","cc":"CY","Name0":"Cyprus Stock Exchange (CSE)","Link":"/stock-exchange/cse_cyprus","Name":"<a href=\"https://www.cse.com.cy/en-GB/home/\">Cyprus Stock Exchange (CSE)</a>","nlc":108,"dmc":5651.98,"SSEPE":"No","SSEPEt":"No","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.cse.com.cy/en-GB/non-regulated-market/\">Emerging Companies Market (Cyprus)</a>, since 2000.</li></ul>","wom":"No","womt":"No","Additional_information":"<ul><li>The Cyprus Stock Exchange has been appointed by the Republic of Cyprus as the Auctioneer for the Emissions Allowances. Trading of emissions allowances through auctions is part of an EU plan to reduce GHG emissions.<a href=\"https://www.cse.com.cy/Files/CSE_Services/Ripoi_05112012_en/\"> (Source)</a>.</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Governmental not for profit.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cysec.gov.cy/en-GB/home/\">Cyprus Securities and Exchange Commission.</a></li><li><a href=\"https://www.centralbank.cy/\">Central Bank of Cyprus</a>.</li></ul><p></p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization Model<p><ul><li>The Cyprus Securities and Exchange Commission holds most of the regulatory power in Cyprus as it regulates and monitors the Cyprus Stock Exchange. The organization also has the ability to enforce laws and regulations through various means.</li></ul><p>","About_the_stock_exchange":"Location: Nicosia, Cyprus<ul><li>The Cyprus Stock Exchange was established as a legal entity in the form of a public corporate body under the Cyprus Securities and Stock Exchange Laws and Regulations which were passed by the House of Representatives in 1993 and 1995, respectively. The first trading session on the Cyprus Stock Exchange was held on March 29, 1996. <a href=\"https://www.cse.com.cy/en-GB/profile/\">(Source)</a>.</li></ul>Location: Dar es Salaam, Tanzania.<p><ul><li>Founded in 1996, became operational in 1998.</li><li>DSE is a Public Company Limited by Shares. The Government owns 15% and the Public owns 85%.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Country is covered in EU ETS - No relevant information","Source_lnk":""},{"id":81,"Country":"Czechia","cc":"CZ","Name0":"Prague Stock Exchange","Link":"/stock-exchange/prague","Name":"<a href=\"https://www.pse.cz/en\">Prague Stock Exchange</a>","nlc":54,"dmc":37670.44,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2020/01/Austria-Vienna-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><p>In March 2023, Prague Stock Exchange launched its first <a href=\"https://www.pse.cz/userfiles/related_documents/cs/ESG-Guidelines.pdf\">ESG guidelines</a> for Czech companies, developed with the technical assistance of the European Bank for Reconstruction and Development (EBRD) and technical cooperation support from the TaiwanBusiness – EBRD Technical Cooperation Fund. (<a href=\"https://www.pse.cz/en/news/prague-stock-exchange-launches-sustainability-reporting-guidelines\">source</a>)</p><p>","oert":"Yes","oertt":"Yes<br><p>In 2022, the Prague Stock Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/czech-republic-tcfd-101-workshop-training/\">source</a>)</p><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>START Market is a MTF market for Czech & innovative SME’s<ul><li>START is a market for small innovative companies worth more than CZK25 million that want to raise new capital or whose owners want to withdraw partially or completely from the current business to capitalize their existing activities. The advantage of START over other similar markets in Europe is minimal costs for the issuer. The price of new capital is therefore competitive compared to any other form of funding or exit. (<a href=\"https://www.pse.cz/en/trading/markets/start-market\">Source</a>)</li></ul></li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"","Regulatory_bodies":"","Regulatory_model":"","About_the_stock_exchange":"<p>Prague Stock Exchange (PSE) is the largest and oldest organizer of the securities market in the Czech Republic. The PSE offers several markets suitable for different types of companies – from the elite Prime Market for large companies to START Market for smaller and innovative Czech companies. PSE and its subsidiaries form the PX Group. In addition to the Exchange, the most important member in the Group is Central Securities Depository Prague (CSD Prague) which has a dominant position in the area of settlement of securities trades on the Czech capital market. PSE is a member of the Federation of European Securities Exchanges (FESE), and the US Securities and Exchange Commission (US SEC) included PSE on its list of exchanges safe for investors by granting it the status of “Designated Offshore Securities Market”. (<a href=\"https://www.pse.cz/en/about-us\">Source</a>)</p>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":82,"Country":"Denmark","cc":"DK","Name0":"Nasdaq Copenhagen","Link":"/stock-exchange/nasdaq-copenhagen","Name":"<a href=\"https://www.nasdaqomxnordic.com/news/marketnotices/copenhagen\">Nasdaq Copenhagen</a>","nlc":125,"dmc":789509,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Denmark-Nasdaq-Copenhagen.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li>Guidance was released in March 2017 across Nasdaq's Nordic and Baltic Exchanges.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>Nasdaq Nordic and Baltic exchanges run a pilot program on ESG reporting.</li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://business.nasdaq.com/discover/corporate-responsibility-and-sustainability/index.html\">Nasdaq offers 70 sustainability-related indexes</a> (not all actively traded), including:<ul><li>OMX GES Ethical indexes:</li><li>OMX GES Ethical Nordic Index</li><li>OMX GES Ethical Norway Index</li><li>OMX GES Ethical Sweden Index</li><li>OMX GES Ethical Denmark Index</li><li>OMX GES Ethical Finland Index</li><li>OMX GES OMXS30 Ethical Index</li></ul></li><li>OMX GES Sustainability Nordic and OMX GES Sustainability Sweden:<ul><li>OMX GES Sustainability Nordic Index</li><li>OMX GES Sustainability Sweden Index</li><li>OMX GES Sustainability Sweden Ethical Index</li></ul></li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.nasdaq.com/solutions/listing-of-sustainable-bonds\">Nasdaq Nordic Sustainable Bonds</a></li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.nasdaqomxnordic.com/shares/listed-companies/first-north\">Nasdaq First North</a>, 2006.</li></ul>","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://business.nasdaq.com/Docs/Nasdaq%20UNGC%20COP%202014%20RevFinal.pdf\">Nasdaq Progress Report 2014, United Nations Global Compact.</a></li><li>Nasdaq speaks, moderates, sponsors, or otherwise exhibits at key industry events related to sustainability. <a href=\"https://business.nasdaq.com/discover/corporate-responsibility-and-sustainability/index.html\">(Source).</a></li><li>Nasdaq and CERES’ Investor Network on Climate Risk (INCR) is working with other partners to create an investor-centric sustainability reporting proposal for public companies and stock exchanges. <a href=\"https://www.ceres.org/news-center/press-releases\">(Source).</a></li><li>Nasdaq had a three-part article series in 2013, called Doing Well by Doing Good. <a href=\"https://business.nasdaq.com/marketinsite#%21?tag=Corporate%20Responsibility\">(Source).</a></li><li>Nasdaq is a member of the United Nations Global Compact and Chair of the WFE Sustainability Working Group. <a href=\"https://www.unglobalcompact.org/what-is-gc/participants/18220-The-NASDAQ-OMX-Group-Inc-\">(Source)</a>.</li><li>Board Member, US Global Compact US Network; Advisory Board Member, SASB.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in:<ul><li>NASDAQ - 2000</li><li>OMX - 1993.</li></ul></li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.finanstilsynet.dk/en.aspx\">Danish Financial Supervisory Authority.</a></li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>Regulatory practices in regards to this exchange vary slightly from country to country. However, the exchanges operated by Nasdaq in each country appear to have basic regulatory oversight. However, the ultimate regulatory authority for each market lies with the regulatory bodies listed.</li></ul><p>","About_the_stock_exchange":"HQ Location: New York, New York.<p><ul><li>Nasdaq (Nasdaq: NDAQ) is a leading global provider of trading, clearing, exchange technology, listing, information and public company services. Through its diverse portfolio of solutions, Nasdaq enables customers to plan, optimize and execute their business vision with confidence, using proven technologies that provide transparency and insight for navigating today's global capital markets. As the creator of the world's first electronic stock market, its technology powers more than 90 marketplaces in 50 countries, and 1 in 10 of the world's securities transactions. Nasdaq is home to approximately 3,900 total listings with a market value of approximately $13 trillion. To learn more, click <a href=\"https://business.nasdaq.com\">here</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":83,"Country":"Dominican Republic","cc":"DO","Name0":"Bolsa y Mercados de Valores de la República Dominicana","Link":"/stock-exchange/bvrd","Name":"<a href=\"https://bvrd.com.do/\">Bolsa y Mercados de Valores de la República Dominicana</a>","nlc":36,"dmc":"","SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/bolsa-y-mercados-de-valores-de-la-republica-dominicana-partner-exchange-model-commitment-letter-2.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p>In 2022, Bolsa y Mercados de Valores de la República Dominicana provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/central-america-tcfd-101-workshop-training/\">source</a>)</p><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://bvrd.com.do/wp-content/uploads/2019/07/BVRD-Guia-de-Bonos-Verdes-1.pdf\">Guía de Bonos Verdes</a></li><li><a href=\"https://bvrd.com.do/wp-content/uploads/2019/07/BVRD-Segmento-de-Finanzas-Verdes.pdf\">Segmento de Finanzas Verdes para la República Dominicana</a></li></ul><p></p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<p>For Profit</p><p>","Regulatory_bodies":"<p><a href=\"https://simv.gob.do/\">Superintendencia del Mercado de Valores de la República Dominicana (SIMV)</a></p><p></p>","Regulatory_model":"<p>Strong exchange SRO</p><p>","About_the_stock_exchange":"Founded in Santo Domingo in 1988 by Decree No. 544-88 as Santo Domingo Stock Exchange, Inc. Subsequently, Law 19-00 has a legal basis and a regulatory framework for this institution. The Exchange, in order to comply with the provisions of said Law, made the name change to the Bolsa de Valores de la República Dominicana SA. On October 10, 2003, the Securities Superintendency granted the BVRD the authorization to operate and register with the Securities and Products Market Registry, after having complied with the requirements established in the Securities Market Law No.19-00 . BVRD is in charge of implementing and managing the operations of the stock market, and its main purpose is to facilitate the negotiation of securities, through the provision of infrastructure, services, technological means, norms and appropriate procedures to carry out transactions or operations of the market. It is currently one of the largest exchanges in the Caribbean region, offering listing, execution, market surveillance n and reporting services for sovereign and corporate fixed income operations and open and closed investment funds. La Bolsa y Mercados de Valores de la República Dominicana, S.A. (BVRD) is the only stock exchange that operates in the Dominican Republic, offering services of listing and primary and secondary operations of public and private securities, and the registry of extra-stock transactions.","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":84,"Country":"Ecuador","cc":"EC","Name0":"Bolsa de Valores Guayaquil (BVG)","Link":"/stock-exchange/bvg","Name":"<a href=\"https://www.bolsadevaloresguayaquil.com/\">Bolsa de Valores Guayaquil (BVG)</a>","nlc":408,"dmc":9118,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/sustainable-stock-exchanges-1-1.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p>In 2022, BVG provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/central-america-tcfd-101-workshop-training/\">source</a>)</p><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Listed/ For Profit</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.supercias.gob.ec/portalscvs/index.htm\">Superintendencia de Compañías, Valores y Seguros (Superintendencia de Compañías)</a></li></ul><p></p>","Regulatory_model":"<ul><li>Strong exchange SRO</li></ul><p>","About_the_stock_exchange":"<p>Bolsa de Valores de Guayaquil (BVG): It's a corporation authorized and controlled by the Superintendent of Companies, Values and Insurances, whose sole social objective is to provide the required services and mechanisms for the negotiation of values between capital bidders and buyers in the short and long term, of fixed and variable rent, mainly shares and debt.&#160;</p>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Ecuador has been working on a regulation for offset mechanism/services","Source_lnk":"https://www.wrm.org.uy/bulletin-articles/environmental-services-in-the-ecuadorian-constitution-a-way-to-strengthen-the-monopolization-of-territories https://www.argusmedia.com/en/news/2355156-latin-america-pushes-carbon-pricing"},{"id":85,"Country":"Ecuador","cc":"EC","Name0":"Quito Stock Exchange","Link":"/stock-exchange/bolsaquito","Name":"<a href=\"https://www.bolsadequito.com/index.php\">Quito Stock Exchange (Bolsa de Valores de Quito)</a>","nlc":57,"dmc":10023,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Ecuador-Quito-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br><ul><li>However, the exchange is working on an incentive of to promote sustainability in its market.</li></ul><p></p>","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p>In 2022, Bolsa de Valores de Quito provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/central-america-tcfd-101-workshop-training/\">source</a>)</p><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No<br><ul><li>The exchange has provided a guidance document for green and sustainability bonds - found&#160;<a href=\"https://www.bolsadequito.com/index.php/blog-2/471-primera-guia-de-bonos-verdes-y-sociales-para-ecuador\">here</a>.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>Called locally “Registro Especial Bursatil”, more information <a href=\"https://www.seps.gob.ec/interna-npe?12702\">here</a> and <a href=\"https://www.bolsadequito.com/index.php/blog-2/308-oportunidades-de-inversion-y-financiamiento-para-las-cooperativas-de-ahorro-y-credito-en-el-mercado-de-valores-ecuatoriano\">here</a>.</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li style=\"text-align:left;\">BVC and the Global Compact - Click&#160;<a href=\"https://www.bolsadequito.com/index.php/blog-2/313-la-bvq-comprometida-con-los-cuatro-pilares-del-pacto-global\">here</a>&#160;for more information.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed. The Quito Stock Exchange was demutualized on 10th August 2016.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.supercias.gob.ec/portalscvs/\">Superintendencia de Companias, Valores y Seguros</a> / <a href=\"https://www.sri.gob.ec/web/guest/home\">Servicios de Rentas Internas.</a></li></ul><p>","Regulatory_model":"<ul><li>The Junta de Política y Regulación de Mercado issues the legislation in relation to the stock market. The Quito Exchange supervises and regulates the activities of the intermediaries (brokers and investment banks) and the information requirements of issuers.</li></ul><p>","About_the_stock_exchange":"<ul><li>The Quito Exchange was established in 1969. It currently has 100 shareholders, of whom some 30 are market intermediaries and 70 are individuals. In 2016 USD 6,600 million was traded of which 99% was fixed income. QSE is a member of the Federacion Iberoamericana de Bolsas (FIAB) and BOLSEN (the Exchanges of Central America and the Caribbean). QSE has an independent Board of Directors. The main office of the Exchange is in Quito and it operates nationwide in Ecuador.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Ecuador has been working on a regulation for offset mechanism/services","Source_lnk":"https://www.wrm.org.uy/bulletin-articles/environmental-services-in-the-ecuadorian-constitution-a-way-to-strengthen-the-monopolization-of-territories https://www.argusmedia.com/en/news/2355156-latin-america-pushes-carbon-pricing"},{"id":86,"Country":"Egypt","cc":"EG","Name0":"Egyptian Exchange","Link":"/stock-exchange/egx","Name":"<a href=\"https://www.egx.com.eg/en/homepage.aspx\">Egyptian Exchange</a>","nlc":242,"dmc":35111,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/egypt-egyptian-exchangeegxpdf.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.egx.com.eg/getdoc/17bea476-d682-440e-8ce4-dc99e1b44f5a/Sustainability-2021.aspx\">Yes</a><br>In 2016 EGX, in collaboration with its Sustainability Advisory Committee (SAC) introduced the first annual sustainability report in accordance with the Global Reporting Initiative (GRI) G4 Standards (<a href=\"https://www.egx.com.eg/en/Sustainability-Reports.aspx\">source</a>).<p><p><a href=\"https://www.egx.com.eg/getdoc/17bea476-d682-440e-8ce4-dc99e1b44f5a/Sustainability-2021.aspx\">The latest Sustainability report is from 2021 in Arabic</a><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>In 2021, FRA issued resolutions requiring companies listed on the Egyptian Stock Exchange to submit environmental, social, and governance disclosure reports related to sustainability (ESG standards) <a href=\"/all-news/egyptian-fra-issued-mandatory-esg-and-climate-disclosure/\">source</a></li><li>Also, companies whose issued capital or net ownership rights are not less than 500 million Egyptian pounds and that are listed on the Egyptian Stock Exchange are required to complete disclosures related to the financial effects of climate change in accordance with TCFD&#160;<a href=\"/all-news/egyptian-fra-issued-mandatory-esg-and-climate-disclosure/\">source</a></li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>Published&#160;<a href=\"https://www.egx.com.eg/getdoc/98b4f610-5544-4f93-a36e-636d3baf8f45/EGX-Model-Guidance-on-ESG_en-11-10-2016.aspx\">Model Guidance for Reporting on ESG Performance & SDGs</a>&#160;in 2016.</li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li><a href=\"https://www.arab-exchanges.org/News/Trainings%2c-Seminars-and-Workshops/Old-Press-Releases/%D8%A8%D8%AD%D8%B6%D9%88%D8%B1-20-%D9%85%D8%B3%D9%8A%D9%88%D9%84-%D8%B9%D9%86-%D8%A7%D8%AF%D8%A7%D8%B1%D8%A7%D8%AA-%D9%85%D8%AE%D8%AA%D9%84%D9%81%D8%A9-%D8%A7%D9%84%D8%A8%D9%88%D8%B1%D8%B5%D8%A9-%D8%AA%D9%86%D8%AA%D9%87%D9%8A-%D9%85%D9%86-%D8%AA.aspx\">19 Sept 2018</a>: the Egyptian Exchange (EGX) provided a training session for Federation of European and Asian Stock Exchanges (FEAS) members at EGX Smart Village premises on the importance of sustainability in stock markets, and how stock markets can raise the awareness of stakeholders about sustainability, and the importance of ESG reporting.</li><li>June 2022: EGX provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/egypt-tcfd-101-workshop-training/\">source</a>)</li><li>In 2022, EGX Sustainability Foundation and DCarbon Company, the regional representative of Global Reporting Initiative (GRI), agreed on a comprehensive training program for listed companies, on ESG & TCFD reporting, in accordance with international best practices in this regard. (<a href=\"https://www.egx.com.eg/en/NewsDetails.aspx?NewsID=220388\">source</a>)</li><li>In 2023, CFA Society Egypt launched the Certificate in ESG Investing, under the patronage of the Financial Regulatory Authority and the Egyptian Exchange (<a href=\"https://www.zawya.com/en/press-release/companies-news/cfa-society-egypt-launches-the-certificate-in-esg-investing-rim8pblx\">source</a>)</li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.egx.com.eg/en/overviews-p-egx.aspx?nav=7\">SP/EGX ESG Index</a> (launched March 2010). More details <a href=\"https://www.egx.com.eg/en/NewsDetails.aspx?NewsID=211357%20\">here</a>.</li></ul><p></p>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://egx.com.eg/en/NILEX.aspx\">NILEX</a>, since 2007.</li></ul>","wom":"Yes","womt":"Yes<br><ul><li>In 2021, the Egyptian FRA imposes&#160;that the EGX-listed and regulated companies should raise the percentage of women representation on their boards to 25% or have at least two females as members of the board. More info <a href=\"http://sapegyptlaw.com/fra-raises-the-percentage-of-women-on-the-boards-of-directors-of-listed-companies-in-egyptian-exchange-egx-companies.html\" target=\"_blank\" rel=\"noopener\">here</a>.</li></ul>","Additional_information":"<ul><li>EGX launched the <a href=\"https://egx.com.eg/en/EGX-Sustainability-Foundation.aspx#:~:text=Realizing%20the%20importance%20of%20its%2cof%20all%20market%20participants%20in\">EGX Sustainability Foundation in 2017</a>.</li><li>https://www.egx.com.eg/en/EGX-And-Sustainability.aspx</li><li>https://www.egx.com.eg/en/EGX-Sustainability-Affiliations.aspx</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Governmental not for profit.</li></ul><p>","Regulatory_bodies":"<ul><li>Egyptian Financial Supervisory Authority.</li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>The Egyptian Exchange has a basic level of regulatory authority when it comes to listing and market surveillance. However, the Egyptian Financial Supervisory Authority is the overall regulator for the stock exchange.</li></ul><p>","About_the_stock_exchange":"Location: Cairo, Egyp<ul><li>The Egyptian Exchange is one of the oldest stock markets established in the Middle East. The Egyptian Exchange traces its origins to 1883 when the Alexandria Stock Exchange was established, followed by the Cairo Stock Exchange in 1903. <a href=\"https://www.egx.com.eg/en/History.aspx\">(Source)</a>.</li></ul>","am":true,"os":true,"nz":false,"VCM":"Yes","CCM":"No","Notes":"AFRICARBONx is a regulated voluntary carbon market established by the Egyptian Exchange that allows companies & entities to offset their residual emissions through buying & retiring high-quality carbon credits through a regulated auction operated by the Egyptian Exchange and regulated by The Financial Regulatory Authority.","Source_lnk":"https://www.africarbonex.com/"},{"id":87,"Country":"El Salvador","cc":"SV","Name0":"Bolsa de Valores El Salvador","Link":"/stock-exchange/bolsa-de-valores-el-salvador","Name":"<a href=\"https://www.bolsadevalores.com.sv/\">Bolsa de Valores El Salvador</a>","nlc":83,"dmc":4694,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/el-salvador-bolsa-de-valores-el-salvador-bves.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p>In 2021, a <a href=\"https://www.youtube.com/watch?v=TJeUXFvv4JI\">workshop on Green, Social, and Sustainable Bonds issuance</a> was held.</p><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No<br><p>Bolsa de Valores de El Salvador launched in June 2021 a <a href=\"https://www.bolsadevalores.com.sv/index.php/mercados/instrumentos-bursatiles/valores-de-renta-fija/bonos-verdes-sociales-y-sostenibles\">Guidance for the issuance of Green, Social and Sustainable Bonds</a> for the Salvadorian market. This work was supported by Bid Invest. In addition, sustainable bonds structuring is included in the <a href=\"https://www.bolsadevalores.com.sv/index.php/marco-legal/instructivos\">Issuance Guidance</a>.</p><p></p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<p>Its shares are listed on the stock exchange. The registration of the share issue on the Bolsa de Valores El Salvador was in 1993.</p><p>","Regulatory_bodies":"<p>Superintendencia del Sistema Financiero</p><p>Banco Central de Reserva</p><p>","Regulatory_model":"<p>Self-Regulatory Organisation (SRO)</p><p>The Stock Exchange of El Salvador is part of the securities market regulated by the Securities Market Law. <br>This Law regulates the public offering of securities, transactions, the respective markets and the participants of the Stock Exchange System, in order to promote the efficient development of these markets and to watch over the interests of the investing public.<br>According to Art. 29, the Stock Exchange is attributed the following regulatory, supervisory, disciplinary and administrative functions:</p><ul><li>To regulate stock exchange operations through regulations, rules and instructions to which brokerage firms are subject in order to have a “transparent, equitable, competitive, orderly and informed market”.</li><li>Oversee that the operations carried out within the Exchange are carried out in accordance with the regulations and instructions issued by the Exchange, and those issued by the Superintendency.</li><li>Apply disciplinary measures to Brokerage Firms, their Agents and other personnel, in accordance with the provisions of the regulations to ensure the proper conduct of Trading Sessions and the Market.</li><li>Collect and disseminate information on issuers and registered securities.</li></ul><p>","About_the_stock_exchange":"<p>Location: San Salvador. El Salvador. Edificio Bolsa de Valores</p><p>It began operations on 27 April 1992.<br>Main functions of the Stock Exchange: </p><ul><li>Promotes a capital market, encouraging the participation of a greater number of issuing companies, as well as investors to encourage stock market transactions.</li><li>It holds daily trading sessions, providing the necessary technological infrastructure and facilitating communication between stockbrokers (representatives of brokerage firms), issuers and investors.</li><li>It facilitates the efficient channelling of domestic national savings towards the investment needs of issuing entities (public or private) that require additional financial resources.</li><li>It offers investors the conditions of legality and security in transactions carried out through the Stock Exchange, based on the Securities Market Law and other regulations.</li><li>It adopts appropriate measures to foster confidence in the system, allowing greater participation of investors (large and small), and broadening the range of investment opportunities.</li><li>It also constantly monitors compliance with the rules to maintain the integrity and transparency of the market, enforcing its rights under the laws, regulations and other rules.</li><li>It keeps a record of the actual trading and prices of securities, and makes available to the public all information on what is happening in the stock market.</li><li>The timely dissemination of information is one of the main commitments of the Salvadoran Stock Exchange, using all available channels to provide adequate and timely information for investment decisions. The Exchange's website brings together all relevant information on trading and market participants. It also developed the first stock market application in El Salvador: Bolsa Móvil.</li><li>A relevant aspect is that the El Salvador Stock Exchange was the forerunner in the creation of the first integrated market in the region. Working together with the Panama Stock Exchange, they reached the legal and operational agreements that allowed them in 2017 to materialise the first cross-border trades using the innovative Remote Trader model. This market has proven to be a success and an example in Latin America. In 2023, Nicaragua joined this initiative and is working to finalise the details that will allow it to enter the dynamics of this common market in the short term.</li></ul>","am":false,"os":false,"nz":false,"VCM":"","CCM":"","Notes":"","Source_lnk":""},{"id":88,"Country":"Estonia","cc":"EE","Name0":"Nasdaq Tallinn","Link":"/stock-exchange/nasdaq-tallinn","Name":"<a href=\"https://nasdaqbaltic.com/about-us/nasdaq-tallinn/\">Nasdaq Tallinn</a>","nlc":31,"dmc":5727,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Estonia-Nasdaq-Tallinn.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li>Released in March 2017 across Nasdaq's Nordic and Baltic Exchanges.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>Nasdaq Nordic and Baltic exchanges run a <a href=\"https://www.globenewswire.com/news-release/2017/08/29/1101564/0/en/Nasdaq-Nordic-and-Baltic-Exchanges-Announce-Pilot-Program-for-ESG-Reporting.html\">pilot program on ESG reporting</a>.</li></ul><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><ul><li>Riga/Tallinn/Vilnius, Nasdaq Baltic Market, June 18, 2018&#160;–&#160;<a href=\"https://globenewswire.com/news-release/2018/06/18/1525578/0/en/Nasdaq-Highlights-Sustainable-Bond-Issues-in-the-Baltics.html\">Nasdaq</a>.</li></ul><p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li>Sustainability Section on&#160;<a href=\"https://www.nasdaqomx.com/aboutus/sustainability\">Website.</a></li><li>The Nasdaq speaks, moderates, sponsors, or otherwise exhibits at key industry events related to sustainability. <a href=\"https://www.nasdaqomx.com/aboutus/sustainability/sustainabilityevents\">(Source)</a>.</li><li>Nasdaq is a member of the United Nations Global Compact and Chair of the WFE Sustainability Working Group.&#160;<a href=\"https://www.unglobalcompact.org/participant/18220-The-NASDAQ-OMX-Group-Inc-\">(Source).</a></li><li>Board Member, US Global Compact US Network; Advisory Board Member, SASB.</li></ul><p>","Organizational_model_of_stock_exchange":"Listed company for profit; demutualized in:<p><ul><li>NASDAQ - 2000</li><li>OMX - 1993</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fi.ee/index.php?id=12264&year=2004\">Estonian Financial Supervisory Authority</a>.</li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>Regulatory practices in regards to this exchange vary slightly from country to country. However, the exchanges operated by Nasdaq in each country appear to have basic regulatory oversight. However, the ultimate regulatory authority for each market lies with the regulatory bodies listed.</li></ul><p>","About_the_stock_exchange":"HQ Location: New York, New York<p><ul><li>Nasdaq (Nasdaq: NDAQ) is a leading global provider of trading, clearing, exchange technology, listing, information and public company services. Through its diverse portfolio of solutions, Nasdaq enables customers to plan, optimize and execute their business vision with confidence, using proven technologies that provide transparency and insight for navigating today's global capital markets. As the creator of the world's first electronic stock market, its technology powers more than 90 marketplaces in 50 countries, and 1 in 10 of the world's securities transactions. Nasdaq is home to approximately 3,900 total listings with a market value of approximately $13 trillion. To learn more, click <a href=\"https://business.nasdaq.com\">here</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":89,"Country":"Finland","cc":"FI","Name0":"Nasdaq Helsinki","Link":"/stock-exchange/nasdaq-helsinki","Name":"<a href=\"https://www.nasdaqomxnordic.com\">Nasdaq Helsinki</a>","nlc":135,"dmc":359912,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Finland-Nasdaq-Helsinki.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li>Released in March 2017 across Nasdaq's Nordic and Baltic Exchanges.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>Nasdaq Nordic and Baltic exchanges run <a href=\"https://www.globenewswire.com/news-release/2017/08/29/1101564/0/en/Nasdaq-Nordic-and-Baltic-Exchanges-Announce-Pilot-Program-for-ESG-Reporting.html\">a pilot program on ESG reporting.</a></li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.nasdaqomx.com/aboutus/sustainability/greenindexes\">Nasdaq offers 70 sustainability-related indexes</a> (not all actively traded), including:<ul><li>OMX GES Ethical indexes:</li><li>OMX GES Ethical Nordic Index</li><li>OMX GES Ethical Norway Index</li><li>OMX GES Ethical Sweden Index</li><li>OMX GES Ethical Denmark Index</li><li>OMX GES Ethical Finland Index</li><li>OMX GES OMXS30 Ethical Index</li><li>OMX GES Sustainability Nordic and OMX GES.</li></ul></li><li>Sustainability Sweden:<ul><li>OMX GES Sustainability Nordic Index</li><li>OMX GES Sustainability Sweden Index</li><li>OMX GES Sustainability Sweden Ethical Index</li></ul></li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>Nasdaq Stockholm and Nasdaq Helsinki launched <a href=\"https://www.nasdaq.com/solutions/listing-of-sustainable-bonds\">a sustainable bond list</a> in 2015 on the main market and another, the First North Sustainable Bond List, on the First North market in the beginning of 2018.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.nasdaq.com/solutions/nasdaq-first-north-premier-growth-market\">Nasdaq First North,</a> since 2006.</li></ul>","wom":"No","womt":"No","Additional_information":"<ul><li>Sustainability Section on <a href=\"https://www.nasdaqomx.com/aboutus/sustainability\">Website.</a></li><li>The Nasdaq speaks, moderates, sponsors, or otherwise exhibits at key industry events related to sustainability. <a href=\"https://www.nasdaqomx.com/aboutus/sustainability/sustainabilityevents\">(Source).</a></li><li>Nasdaq and CERES’ Investor Network on Climate Risk (INCR) is working with other partners to create an investor-centric sustainability reporting proposal for public companies and stock exchanges. <a href=\"https://www.ceres.org/press/press-releases/world2019s-largest-investors-launch-effort-to-engage-global-stock-exchanges-on-sustainability-reporting-standard-for-companies\">(Source)</a>.</li><li>Nasdaq is a member of the United Nations Global Compact and Chair of the WFE Sustainability Working Group. <a href=\"https://www.unglobalcompact.org/participant/18220-The-NASDAQ-OMX-Group-Inc-\">(Source)</a></li><li>Board Member, US Global Compact US Network; Advisory Board Member, SASB.</li></ul><p>","Organizational_model_of_stock_exchange":"Listed company for profit; demutualized in:<p><ul><li>NASDAQ - 2000</li><li>OMX - 1993.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fin-fsa.fi/en/pages/default.aspx\">Finnish Financial Supervisory Authority</a>.</li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>Regulatory practices in regards to this exchange vary slightly from country to country. However, the exchanges operated by NASDAQ OMX in each country appear to have basic regulatory oversight. However, the ultimate regulatory authority for each market lies with the regulatory bodies listed.</li></ul><p>","About_the_stock_exchange":"HQ Location: New York, New York.<p><ul><li>Nasdaq (Nasdaq: NDAQ) is a leading global provider of trading, clearing, exchange technology, listing, information and public company services. Through its diverse portfolio of solutions, Nasdaq enables customers to plan, optimize and execute their business vision with confidence, using proven technologies that provide transparency and insight for navigating today's global capital markets. As the creator of the world's first electronic stock market, its technology powers more than 90 marketplaces in 50 countries, and 1 in 10 of the world's securities transactions. Nasdaq is home to approximately 3,900 total listings with a market value of approximately $13 trillion. To learn more, click <a href=\"https://business.nasdaq.com\">here</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Finnish Government has published guidelines and good practices for voluntary carbon markets and a project for understanding carbon offsetting in the next 1.5 years, but doesn't seem like the exchange is facilitating the VCM trading","Source_lnk":"https://ym.fi/en/voluntary-carbon-offsetting"},{"id":90,"Country":"France","cc":"FR","Name0":"Euronext Paris","Link":"/stock-exchange/euronext-paris","Name":"<a href=\"https://www.euronext.com/en/markets/paris\">Euronext Paris</a>","nlc":795,"dmc":4580000,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/france-euronext-paris.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li>There is a chapter in the annual report dedicated to sustainability activities, find all reports <a href=\"https://www.euronext.com/en/investor-relations/financial-information/financial-reports\">here</a>.</li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>The European directive on non-financial information reporting (NFRD) has been implemented into the French legal environment (<a href=\"https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=celex:32014L0095\">source</a>).</li><li>Moreover,<ul><li>The <a href=\"https://www.diplomatie.gouv.fr/IMG/pdf/Mandatory_reporting_built_on_consensus_in_France.pdf\">Grenelle II Act of 2010</a> makes CSR reporting mandatory as part of annual reporting for all large companies doing business in France.</li><li>Euronext Paris supports and implements ESMA’s and National Competent Authorities stringent rules with regards to governance among its community of listed companies.</li></ul></li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"/sites/sseinitiative/files/documents/euronext-esg-guide-2022.pdf\">ESG Reporting Guide – Target 1.5°C</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br>Through the Euronext Academy, see more details <a href=\"https://www.corporateservices.euronext.com/academy?s=ESG\">here</a>.<p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li>See the list of indices on the Euronext website <a href=\"https://live.euronext.com/products-indices/index-rules\">here</a>. ESG/ISR indices fall under the tab “theme indices”. This list is automatically updated.</li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.euronext.com/en/list-products/bonds/green-bonds\">Euronext ESG Bonds</a> is a community of ESG bond issuers where green, sustainability, social, blue and sustainability-linked bonds listed on all Euronext locations are consolidated onto one highly visible area. Details of the securities <a href=\"https://live.euronext.com/en/products/fixed-income/esg-bonds\">here</a>.</li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>Euronext Growth,&#160;Euronext Access,&#160;Euronext Access+. More information <a href=\"https://www.euronext.com/en/raise-capital/sme\">here</a>.</li></ul><p><p></p>","wom":"Yes","womt":"Yes<br><ul><li>There is a 40% mandatory minimum rule for women on boards.<br>Source: Assemblée Nationale. (2011). Dossiers. <a href=\"https://www.assemblee-nationale.fr/13/dossiers/egalite_prof_hommes_femmes.asp\">Société : représentation des femmes dans les conseils d’administration et de surveillance.</a> Details of the rule: In cases where the total board members are less than 9, there should not be more than a 2 seat difference between one gender.</li></ul>","Additional_information":"Euronext supports climate friendly innovations by financing Cleantech SME’s benefitting from major Euronext initiatives:<p><ul><li>TechShare: 27 Cleantech have followed the program on how to leverage capital markets.</li><li>Tech40 Index: 10% of this increasingly important index is made up of Cleantech SME’s.</li><li>Morningstar: the program fully covers the scope of Cleantech SME issuers (55).</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2000.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://acpr.banque-france.fr/en/acpr.html\">ACPR</a>.</li><li><a href=\"https://www.economie.gouv.fr/\">The Ministry of Economics and Finance.</a></li><li><a href=\"https://www.amf-france.org/en_US/\">Autorité des Marchés Financiers (AMF).</a></li><li><a href=\"https://www.esma.europa.eu/\">European Union (ESMA)</a>.</li></ul><p></p>","Regulatory_model":"Government (Statutory) Model<p><ul><li>The Markets in Financial Instruments Directive (MiFID) classifies Euronext’s European cash markets as a regulated market. As such, the real-time monitoring performed by Euronext’s cash market operations and technical support is formally enforced, and our trading rules and procedures are approved by our four regulators. This regulatory and organizational system gives Euronext the power to efficiently manage crisis situations and extraordinary circumstances. Some of the markets organized by Euronext are exchange regulated, which means they are subject to a body of rules laid down by the market operator, Euronext. They are not regulated markets as defined by the Markets in Financial Instruments Directive (MiFID). These structured, exchange regulated markets offer simplified access to financial markets and streamlined listing requirements for companies from every sector of the economy, while ensuring compliance with rules on investor disclosure and the control of financial information.&#160;<a href=\"https://www.euronext.com/en/equities/market-regulation\"> (Source)</a>.</li></ul><p></p>","About_the_stock_exchange":"Location of the listed holding:<ul><li>Paris, France As a market operator, Euronext Paris, which is the market of reference for the Euronext shares, manages the Euronext regulated markets in France. In accordance with Article L.421-10 of the French Monetary and Financial Code, Euronext Paris adopts rules for each of these markets to ensure fair and orderly trading and efficient order execution. The requirements for market access and admission of financial instruments to trading are also covered by these rules, which are approved by the Autorité des Marchés Financiers (“AMF”) and published on the market operator’s website. Euronext Paris markets are subject to the provisions of Article L.421-4 et seq. of the French Monetary and Financial Code, which authorises the French Minister of Economy to confer and revoke regulated market status upon proposal of the&#160;AMF, which has to consult with the Autorité de Contrôle Prudentiel et de Résolution (“ACPR”). Euronext is the leading pan-European exchange in the Eurozone, spanning Belgium, France, Ireland, Norway, the Netherlands, Portugal, the UK and Ireland. Created in 2000, it unites markets which date back to the start of the 17th century. It is the primary exchange in the Euro zone with nearly 1,500 listed issuers worth more than €4.5 trillion in market capitalization as of end May 2019, an unmatched blue chip franchise consisting of 20+ issuers in the Morningstar® Eurozone 50 Index℠ and a strong diverse domestic and international client base.</li></ul>","am":true,"os":true,"nz":true,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":91,"Country":"Germany","cc":"DE","Name0":"Deutsche Börse","Link":"/stock-exchange/deutsche-borse","Name":"<a href=\"https://deutsche-boerse.com/dbg-en/\">Deutsche Börse (German Exchange)</a>","nlc":447,"dmc":2503045.83,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/germany-deutsche-boerse.pdf\">Yes</a>","asr":"Yes","asrt":"Yes","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li>Guidance – <a href=\"https://deutsche-boerse.com/dbg/dispatch/en/binary/gdb_content_pool/imported_files/public_files/10_downloads/33_going_being_public/10_products/Communicating_sustainibility.pdf\">Communicating Sustainability, 7 recommendations for issuers</a> (2013).</li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>Training will be offered through an <a href=\"https://www.deutsche-boerse-cash-market.com/dbcm-en/primary-market/events/stocks-and-standards/Sustainable-Corporate-Reporting--Understanding-the-importance-of-ESG-information-/2955776\">ESG workshop</a> in June 2018.</li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://deutsche-boerse.com/dbg-en/sustainability/build-trust/sustainable-products-and-services\">STOXX Low Carbon Index Family</a></li><li>ÖkoDAX</li><li>DAXglobal Alternative Energy</li><li>DAXglobal Sarasin Sustainability Germany</li><li>STOXX ESG Leaders Index family</li><li>STOXX Sustainability Index family</li><li>Photovoltaik Global 30</li><li>Credit Suisse Global Alternative Energy</li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://deutsche-boerse.com/dbg-en/media-relations/press-releases/New-Green-Bond-segment-on-the-Frankfurt-Stock-Exchange/3533484\">Via the Frankfurt Stock Exchange.</a></li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.venture-network.com/dbvn-de/\">Deutsche Börse Venture Network</a>, since 2015.</li></ul>","wom":"Yes","womt":"Yes<br><ul><li>There is a 30% mandatory minimum rule for women on boards.<br>Source: Deloitte. (2019). <a href=\"https://www2.deloitte.com/content/dam/Deloitte/global/Documents/Risk/gx-risk-women-in-the-boardroom-sixth-edition.pdf\" target=\"_blank\" rel=\"noopener\">Data driven change: Women in the boardroom a global perspective.</a> Detail of the rule: the quota applies to non executives board seats</li><li><a href=\"https://www.bundestag.de/dokumente/textarchiv/2021/kw08-de-frauen-fuehrungspositionen-821764\" target=\"_blank\" rel=\"noopener\">Gesetzes zur gleichberechtigten Teilhabe von Frauen</a></li><li><a href=\"https://www.dcgk.de/files/dcgk/usercontent/en/download/code/191216_German_Corporate_Governance_Code.pdf\" target=\"_blank\" rel=\"noopener\">German Corporate Governance Code 2019</a> recommends following the gender quota in the composition of the supervisory board (p.7)</li>","Additional_information":"<ul><li>Launched <a href=\"https://deutsche-boerse.com/dbg-en/media/deutsche-boerse-spotlights/spotlight/Sustainable-finance-143942\">the Hub for Sustainable Finance along with the German Council for Sustainable Development in late 2017.</a></li><li>Launched <a href=\"https://www.deutsche-boerse.com/dbg-en/sustainability/our-responsibility/accelerating-sustainable-finance\">Accelerating Sustainable Finance Initiative in May 2017</a> along with major stakeholders from the Frankfurt/Main financial centre. Participants signed the Frankfurt Declaration, a letter of intent about the creation of sustainable infrastructures in the financial sector.</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2000.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.esma.europa.eu/\">European Securities and Markets Authority.</a></li><li><a href=\"https://www.bafin.de/EN/Homepage/homepage_node.html\">Federal Financial Supervisory Authority.</a></li><li><a href=\"https://www.deutsche-boerse-cash-market.com/dbcm-en/about-us/organisation-of-the-fwb/market-surveillance-in-germany\">Trading Surveillance Office</a>.</li></ul><p></p>","Regulatory_model":"Government<p><ul><li>Deutsche Börse AG is regulated by various bodies. The Trading Surveillance Office is an independent supervisory body that supervises and monitors the market. However, a great deal of authority falls upon the government. Both the Exchange Supervisory Authority and the Federal Financial Supervisory Authority are governmental regulatory bodies that monitor for proper conduct and cases of insider trading, fraud, price manipulation and violations of the Exchange Act.</li></ul><p>","About_the_stock_exchange":"Location: Frankfurt, Germany<ul><li>As one of the world’s leading exchange organizations, Deutsche Börse Group provides investors, financial institutions and companies access to global capital markets. Our business covers the entire process chain from securities and derivatives trading, clearing, settlement and custody, through to market data and the development and operation of electronic trading systems.Our reliable systems and our integrity as a neutral provider form the basis of our business philosophy. We operate to the most exacting standards to create products and services to meet the needs of international financial markets. As a listed company we work to create value for our customers and our shareholders. <a href=\"https://deutsche-boerse.com/dbg-en/meta/disclaimer\">(Source)</a>.</li></ul>","am":true,"os":false,"nz":true,"VCM":"Yes","CCM":"No","Notes":"Deutsche Börse owns the European Energy Exchange (EEX) and has bought a stake in ACX (previously AirCarbon Exchange). It has also entered into an MOU with Guangzhou Futures Exchange (GFEX) in 2022 to facilitate carbon markets across China and Europe.","Source_lnk":"https://www.eex.com/en/markets/environmental-markets/voluntary-carbon-markets https://www.deutsche-boerse.com/dbg-en/our-company/contact/locations/location-leipzig https://www.prnewswire.com/news-releases/deutsche-borse-invests-in-and-partners-with-the-aircarbon-exchange-301507649.html https://deutsche-boerse.com/dbg-en/media/press-releases/Deutsche-B-rse-and-Guangzhou-Futures-Exchange-launch-cooperation-on-carbon-markets-2913040"},{"id":92,"Country":"Ghana","cc":"GH","Name0":"Ghana Stock Exchange","Link":"/stock-exchange/ghana-stock-exchange","Name":"<a href=\"https://gse.com.gh/\">Ghana Stock Exchange</a>","nlc":37,"dmc":3055.5,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/gse-sustainable-stock-exchanges-questionnaire.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br><ul><li>Some of GSE listed companies have ESG reports but it is not as a mandatory requirement. More information and additional notes in the GSE's Listing Rules. GSE encourages issuers to report on ESG topics.</li></ul>","hwg":"Yes","hwgt":"Yes<br><p>Reporting requirements are in the <a href=\"https://gse.com.gh/wp-content/uploads/2022/11/GSE-ESG-DISCLOSURES-GUIDANCE-MANUAL-1-1.pdf\">GSE ESG Disclosure Guidance Manual</a></p><p></p>","oert":"Yes","oertt":"Yes<br><p>Capacity building programmes are organized in collaboration with GRI and IFC. (<a href=\"https://www.globalreporting.org/about-gri/gri-in-africa/\">source</a>)</p><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://gaxsme.com/\">Ghana Alternative Market (GAX)</a> is the market segment of the GSE dedicated to SMEs. It was established in 2013 and counts with six companies listed on it.&#160;This market was created with incentives to assist SMEs as well as start up businesses to raise capital to expansion and growth.</li></ul><p></p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Not for Profit</li></ul><p>","Regulatory_bodies":"<ul><li class=\"LC20lb MBeuO DKV0Md\"><a href=\"https://sec.gov.gh/\">Securities and Exchange Commission Ghana</a></li></ul><p></p>","Regulatory_model":"<ul><li>Strong exchange SRO</li></ul><p>","About_the_stock_exchange":"<p>Established thirty-one years ago, the Ghana Stock Exchange has played a significant role in the country’s economic growth. It was established with the mission to be a relevant, significant, efficient, and effective tool for capital mobilization and wealth creation. Just as other markets in Africa, the stock market has emerged as a major provider of investment capital inflow in Ghana. It operates three namely, the equity market which is the main Market, the Ghana Fixed Income Market (GFIM) which is the Bonds Market and the Ghana Alternative Market (GAX) which is the Market for Small and Medium businesses. For more information visit <a href=\"http://www.gse.com.gh\">www.gse.com.gh</a></p>","am":true,"os":true,"nz":false,"VCM":"No","CCM":"No","Notes":"Ghana has established a Carbon Market Office and Carbon Registry to support carbon markets. Not sure whether GSE allows carbon credits trading. The country also has a national framework on carbon market.","Source_lnk":"https://cmo.epa.gov.gh/wp-content/uploads/2022/12/Ghana-Carbon-Market-Framework-For-Public-Release_15122022.pdf https://gcr.epa.gov.gh/about-us/# https://cmo.epa.gov.gh/index.php/about-cmo/#"},{"id":93,"Country":"Greece","cc":"GR","Name0":"Athens Exchange Group","Link":"/stock-exchange/athex","Name":"<p style=\"margin:0cm;font-size:12pt;font-family:Aptos, sans-serif;\"><a href=\"https://www.athexgroup.gr/en\">Athens Exchange Group</a></p>","nlc":135,"dmc":168329,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/greece-athens-stock-exchange-athex-2.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br>The sustainability report is included in the annual report. See all reports&#160;<a href=\"https://www.athexgroup.gr/en/more-options/esg\" style=\"font-family:Aptos, sans-serif;font-size:12pt;\">here.</a>","ESGrr":"Yes","ESGrrt":"Yes<p>Corporate Sustainability Reporting Directive sets the requirements for the disclosure of non-financial and diversity sustainability information by large companies.</p>","hwg":"Yes","hwgt":"Yes<br><ul><li><p style=\"margin:0cm;font-size:12pt;font-family:Aptos, sans-serif;\"><a href=\"https://www.athexgroup.gr/en/more-options/esg/reporting-guide\">ATHEX Reporting\nGuide</a></p></li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>Offers ESG&#160;<a href=\"https://www.athexgroup.gr/en/more-options/esg\" style=\"font-family:Aptos, sans-serif;font-size:12pt;\">executive training courses</a>.</li><li>Organizes events to raise awareness of the ecosystem.</li><li>Participates in annual CSR conferences.</li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><p style=\"margin:0cm;font-size:12pt;font-family:Aptos, sans-serif;\"><a href=\"https://www.athexgroup.gr/en/more-options/esg/index\">ATHEX ESG Index</a></p></li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><p style=\"margin:0cm;font-size:12pt;font-family:Aptos, sans-serif;\"><a href=\"https://www.athexgroup.gr/en/more-options/esg/greenet\">ATHEX BONDS GREENet</a></p></li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><p style=\"margin:0cm;font-size:12pt;font-family:Aptos, sans-serif;\"><a href=\"https://www.athexgroup.gr/en/raise-capital/listing-options/products/equity\">ATHEX\nAlternative Market (EN.A), since 2008.</a></p></li></ul>","wom":"Yes","womt":"Yes<br>Greece adopted a quota of 25% in 2020. <a href=\"https://www.europarl.europa.eu/RegData/etudes/STUD/2021/700556/IPOL_STU%282021%29700556_EN.pdf\" target=\"_blank\" rel=\"noopener\">Source</a><p>See also the <a href=\"https://www.equalitylaw.eu/downloads/5251-greece-gender-quota-of-a-minimum-of-25-for-administrative-councils-of-listed-companies-100-kb\" target=\"_blank\" rel=\"noopener\">European network of legal experts in gender equality and non-discrimination flash report.</a></p>","Additional_information":"<ul><li>ESG corner on their&#160;<a href=\"https://www.athexgroup.gr/en/more-options/esg/greenet\" style=\"font-family:Aptos, sans-serif;font-size:12pt;\">website</a>.<br></li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Private company for profit; demutualized in 1999.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.hcmc.gr/en_US/web/portal/home\">Hellenic Capital Market Commission</a>.</li></ul><p></p>","Regulatory_model":"Government (Statutory)<p><ul><li>The Hellenic Capital Market Commission is the primary regulator for the capital markets of Greece. The commission not only oversees the capital markets but also ensures compliance by companies listed on the Athens Stock Exchange with capital market laws. Due to the regulatory power of the Hellenic Capital Market Commission, the Athens Stock Exchange has limited self-regulatory power.</li></ul><p>","About_the_stock_exchange":"Location: The ATHENS STOCK EXCHANGE (ATHEX) is located in Athens, 110 Athinon Ave. GR10442 Athens – GREECE.&#160;https://www.athexgroup.gr/en<p></p><p>The Athens Exchange Group provides support to the Greek Capital Market and participates&#160;in the Energy Market since 2019.&#160;The Group offers financing tools and solutions to companies, expands investor choice by providing a secure, stable and investor-friendly environment in full alignment with international practices and the European regulatory framework. HELLENIC EXCHANGES-ATHENS STOCK EXCHANGE (ATHEX) is the parent company of the Group.&#160;The parent company and its 100% subsidiaries ATHEXClear and ATHEXCSD operate the organized equities and derivatives markets, the alternative market, perform clearing, settlement of trades and registration services, provide integrated IT solutions in the Greek capital market, and promote the development of the capital market concept in Greece.</p>","am":true,"os":false,"nz":false,"VCM":"UD","CCM":"No","Notes":"ACX (AirCarbon Exchange) and the Athens Stock Exchange (ATHEX) have established a partnership to explore the development of a Voluntary Carbon Market in Greece.","Source_lnk":"https://acx.net/media-release/acx-partners-athens-stock-exchange/"},{"id":94,"Country":"Guatemala","cc":"GT","Name0":"Bolsa de Valores Nacional, S.A. (BVNSA)","Link":"/stock-exchange/bvnsa","Name":"<a href=\"http://www.bvnsa.com.gt/\">Bolsa de Valores Nacional S.A. (BVNSA)</a>","nlc":17,"dmc":16016,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/guatemala-bnv.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p>In 2022, BVNSA provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/central-america-tcfd-101-workshop-training/\">source</a>)</p><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<p>Private company owned by brokerage companies (mutualized), and independent shareholders. BNV is not a listed company.</p><p>","Regulatory_bodies":"<p><a href=\"https://www.rmvm.gob.gt/\">Registro del Mercado de Valores y Mercancías</a> (RMVM)</p><p></p>","Regulatory_model":"<p>Bolsa de Valores Nacional, S.A. (BVN) is a private company registered as a Stock Exchange, which is a parent company to Central de Valores Nacional, S.A. (CVN), its CSD. BVN and CVN fall under the registral jurisdiction of the RMVM, a dependency of the Government’s Ministry of Economy in charge of the control of legality of all participants in the country’s Capital Market as well as registering their existence and overseeing their transparency. &#160;BVN is a SRO, thus providing its own requirements for its members and issuers. All rules and regulations regarding public offerings must be submitted to the RMVM and published in the Official Diary. BVN provides daily information regarding transactions and offerings.</p><p>","About_the_stock_exchange":"<p>BVN is currently the only stock exchange in Guatemala. Founded in 1986, it started operating in 1987 and as of October 2021 it has 17 stock brokerage firms as members. Its CSD functioned for many years as an internal department of the Exchange but became an independent corporation in 2011. BVN was a member of BOLCEN (Central American and the Caribbean Exchange Association) and is currently a founding member of AMERCA (Association of Capital Markets of the Americas), an alliance constituted by 10 Latin American Exchanges, whose objective is the construction of a regional market. CVN is a member of ACSDA and has subscribed agreements with other regional CSDs in order to provide its customers with a broader range of trading and settlement. In 2021 BVN was invited to the SSE’s “Ring the Bell for Gender Equality”.</p>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":95,"Country":"United Kingdom","cc":"GB","Name0":"The International Stock Exchange (TISE)","Link":"/stock-exchange/tise","Name":"<a href=\"https://www.tisegroup.com/\">The International Stock Exchange (TISE)</a>","nlc":2481,"dmc":1025979,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2021/06/210616-TISE-UNSSE-Partner-Exchange-Commitment-Letter.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://tisegroup.com/company-profile/corporate-social-responsibility/\" title=\"Yes\">Yes</a><br><ul><li>The TISE Group publishes a statement of compliance with the Quoted Companies Alliance (QCA) Code of Corporate Governance and produces a standalone Corporate Sustainability Statement.</li></ul><p></p>","ESGrr":"No","ESGrrt":"No<p></p>","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br><ul><li>According to the stock exchange information, TISE proactively engages with regulators and industry associations to promote and support the development of environmental, social and sustainable finance products and initiatives. TISE also adds that their employees regularly contribute articles to industry publications and participate in panel discussions, both locally and internationally, discussing a variety of topics connected with the financing of a sustainable future.</li></ul><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><ul><li>TISE Sustainable is available to all TISE-listed issuers – including both bond and equity issuers and investment vehicles – who demonstrate (both at admission and on an ongoing basis) their qualifying credentials through an independent assessment of compliance with at least one internationally recognized sustainable finance standard. Further information <a href=\"https://www.tisegroup.com/market/segments/sustainable\">here</a></li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>The TISE equity market for trading companies is aimed at SMEs</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li>More information about the Group’s governance and sustainability credentials <a href=\"https://www.tisegroup.com/about/investor-relations/\">here</a></li><li>More information about TISE Sustainable market segment <a href=\"https://www.tisegroup.com/market/segments/green\">here</a> and <a href=\"/sites/sseinitiative/files/documents/tise.pdf\">here</a>.</li></ul><p>&#160;</p><p>","Organizational_model_of_stock_exchange":"Private company. The International Stock Exchange Group Limited, is a wholly owned subsidiary of Miami International Holdings, Inc. &#160;Further information <a href=\"https://tisegroup.com/regulation/\" title=\"here\">here</a><br><p></p>","Regulatory_bodies":"<a href=\"https://www.gfsc.gg/commission/regulated-entities/2240067\">Guernsey Financial Services Commission (GFSC)</a><p>","Regulatory_model":"Strong exchange SRO.<p><p>The International Stock Exchange Authority Limited (a wholly-owned subsidiary of The International Stock Exchange Group Limited) is licensed to operate an investment exchange by the Guernsey Financial Services Commission (GFSC). The GFSC is only permitted to oversee the operation of TISE itself and is not responsible for regulating the conduct of TISE’s members or acting as Market Authority. Therefore, The International Stock Exchange Authority Limited is required to establish, supervise and enforce its own Listing Rules and Membership Rules to regulate the conduct of TISE’s members and issuers.</p><p>","About_the_stock_exchange":"Built on a culture of responsiveness and innovation, The International Stock Exchange (TISE) provides financial markets and securities services to public and private companies.<br><br>TISE is best known as one of Europe’s major professional bond markets. Its Qualified Investor Bond Market (QIBM) is the leading market in Europe for listing high yield bonds and private equity debt and has a growing reputation for listing securitisation transactions. TISE also has a pool of investment funds and a significant share of the market for listed UK Real Estate Investment Trusts (REITs), as well as hosting a comprehensive sustainable finance segment, TISE Sustainable.<p>TISE has a unique offering for the private markets. TISE Private Markets provides unlisted companies with a dedicated marketplace through which they can access an integrated set of tailored electronic solutions, including trading, settlement and registry management.</p>A wholly owned subsidiary of Miami International Holdings, Inc., TISE is headquartered in Guernsey and operates across Dublin, Guernsey, the Isle of Man, Jersey and London. TISE has over 4,500 securities on its Official List with a total market value of more than £750 billion.<br><br>TISE is committed to being part of the sustainable capital markets ecosystem, both in terms of how we conduct and manage our business and through our role as a facilitator of global capital flows. Our dedicated market segment, TISE Sustainable, connects international investors with global issuers who are promoting environment, social or sustainable activities.<br><br>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"The London Stock Exchange Voluntary Carbon Market enables funds and operating companies to raise capital for projects that are expected to generate carbon credits. The Voluntary Carbon Market designation will be applied to funds or operating companies that are admitted to Main Market or AIM and which invest in climate change mitigation projects that are expected to yield carbon credits.","Source_lnk":"https://tisegroup.com/sustainable/"},{"id":96,"Country":"Honduras","cc":"HN","Name0":"Bolsa Centroamericana de Valores S.A.","Link":"/stock-exchange/bcv","Name":"<a href=\"https://www.bcv.hn/\">Bolsa Centroamericana de Valores S.A.</a>","nlc":15,"dmc":2082,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/honduras-bcv.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p>In 2022, Bolsa Centroamericana de Valores provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/central-america-tcfd-101-workshop-training/\">source</a>)</p><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<p>Listed, For Profit</p><p>","Regulatory_bodies":"<p><a href=\"https://www.cnbs.gob.hn/\">Comisión Nacional de Bancos y Seguros</a></p><p></p>","Regulatory_model":"<p>Government (Statutory)</p><p>","About_the_stock_exchange":"<p>La Bolsa Centroamericana de Valores S.A., (BCV) is a private commercial institution that provides the place, the physical and electronic facilities and the optimal conditions for the negotiation of securities to be carried out.</p>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":97,"Country":"Hungary","cc":"HU","Name0":"Budapest Stock Exchange","Link":"/stock-exchange/bse_hungary","Name":"<a href=\"https://www.bse.hu\">Budapest Stock Exchange</a>","nlc":50,"dmc":34287.57,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/hungary-budapest-stock-exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li>At the end of March 2021, the BSE published its first <a href=\"/sites/sseinitiative/files/documents/esg-reporting-guide_final_eng.pdf\">ESG Reporting Guide for Issuers</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br>BSE offers ESG training in cooperation with Budapest Institute of Banking (owned by the stock exchange). More details <a href=\"https://www.bib-edu.hu/\">here</a>.<p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.bse.hu/Issuers/services-for-medium-sized-companies/xtend/What-opportunities-and-tools-does-a-listing-on-the-Xtend-market-offer-businesses\">BSE Xtend market</a></li><li><a href=\"https://www.bse.hu/site/Angol/Contents/Issuers/services-for-medium-sized-companies/bse-xbond/bse-xbond\">BSE Xbond</a></li></ul><p></p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Non-listed, for profit. 81,35% owned by the MNB (the Central Bank of Hungary).</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.mnb.hu/en/\">MNB as the Central Bank of Hungary</a>.</li></ul><p></p>","Regulatory_model":"<ul><li>Government (Statutory) Model. Supervisory functions are separated and independent from ownership functions within the Central Bank.</li></ul><p>","About_the_stock_exchange":"Location: Budapest, Hungary<ul><li>The Budapest Stock Exchange Ltd. (BSE) creates a platform for Hungarian companies to grow and prosper. Our mission includes providing small and medium sized firms with expertise and financial support needed to join the stock exchange, as well as improving the financial culture in our society. BSE has a considerable history: it was originally established in 1864 and re-established after the fall of communism in 1990. Today we are following our 2016-2020 strategy to become more attractive for investors and companies alike. Our blue chip companies represent well the Hungarian economy, with the total market capitalization of listed firms standing at approximately US $33.8 billion. We are set to further develop the capital market ecosystem where issuers are creating exciting opportunities for domestic and international investors, both retail and institutional.</li><li>We recently introduced Xtend as a special market for medium sized companies to join the exchange. Furthermore, BSE has a joint programme together with ELITE, a company of the London Stock Exchange Group, which gives mentorship to up and coming Hungarian companies to learn about the ways they can grow using diverse financing opportunities. BSE is powered by Xetra, one of the fastest and most reliable trading systems in the world. <a href=\"https://ie.linkedin.com/company/budapest-stock-exchange\">(Source).</a></li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":98,"Country":"Iceland","cc":"IS","Name0":"Nasdaq Iceland","Link":"/stock-exchange/nasdaq-iceland","Name":"<a href=\"https://www.nasdaqomxnordic.com/bonds/iceland\">Nasdaq Iceland</a>","nlc":21,"dmc":18632,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Iceland-Nadaq-Iceland.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li>Released in March 2017 across Nasdaq's Nordic and Baltic Exchanges.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>Nasdaq Nordic and Baltic exchanges run a pilot program on ESG reporting.</li></ul><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No<br><ul><li>While not every Nasdaq office has a sustainability bond listing segment, Nasdaq Stockholm launched a new list for sustainable corporate bonds in 2015.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.nasdaqomxnordic.com/shares/listed-companies/first-north\">Nasdaq First North</a>, since 2006.</li></ul>","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://business.nasdaq.com/discover/corporate-responsibility-and-sustainability/index.html\">Nasdaq Progress Report 2014,</a> United Nations Global Compact The Nasdaq speaks, moderates, sponsors, or otherwise exhibits at key industry events related to sustainability. <a href=\"https://business.nasdaq.com/discover/corporate-responsibility-and-sustainability/index.html\">(Source)</a>.</li><li>Nasdaq and CERES’ Investor Network on Climate Risk (INCR) is working with other partners to create an investor-centric sustainability reporting proposal for public companies and stock exchanges. <a href=\"https://www.ceres.org/news-center/press-releases\">(Source).</a></li><li>Nasdaq had a three-part article series in 2013, called Doing Well by Doing Good. <a href=\"https://business.nasdaq.com/marketinsite\">(Source).</a></li><li>Nasdaq is a member of the United Nations Global Compact and Chair of the WFE Sustainability Working Group. <a href=\"https://www.unglobalcompact.org/what-is-gc/participants/18220-The-NASDAQ-OMX-Group-Inc-\">(Source)</a>.</li><li>Board Member, US Global Compact US Network; Advisory Board Member, SASB.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in:<ul><li>NASDAQ - 2000</li><li>OMX - 1993.</li></ul></li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fme.is/\">Icelandic Financial Supervisory Authority</a>.</li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>Regulatory practices with regards to this exchange vary slightly from country to country. However, the exchanges operated by Nasdaq in each country appear to have basic regulatory oversight. However, the ultimate regulatory authority for each market lies with the regulatory bodies listed.</li></ul><p>","About_the_stock_exchange":"HQ Location: New York, New York<p><ul><li>Nasdaq (Nasdaq: NDAQ) is a leading provider of trading, exchange technology, information and public company services across six continents. Through its diverse portfolio of solutions, Nasdaq enables customers to plan, optimize and execute their business vision with confidence, using proven technologies that provide transparency and insight for navigating today’s global capital markets. As the creator of the world’s first electronic stock market, its technology powers more than 70 marketplaces in 50 countries, and 1 in 10 of the world's securities transactions. Nasdaq is home to more than 3,500 listed companies with a market value of over $8.8 trillion and more than 10,000 corporate clients. To learn more, click <a href=\"https://www.nasdaq.com/ambition\">here</a>&#160;or <a href=\"https://business.nasdaq.com\">here</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":99,"Country":"India","cc":"IN","Name0":"Bombay Stock Exchange","Link":"/stock-exchange/bseindia","Name":"<a href=\"https://www.bseindia.com/\">BSE India Ltd.</a>","nlc":4695,"dmc":1116275,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/india-bse.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.bseindia.com/static/investor_relations/annualreport.html\">Yes</a><br><ul><li><a href=\"https://www.bseindia.com/downloads\">2018-19 Annual Report</a></li><li><a href=\"https://www.bseindia.com/downloads1/BSE_Annual_Report_2017_18.pdf\">2017-18 Annual Report</a></li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>Dependent on size of company. (<a href=\"https://www.bseindia.com/static/about/regulatory_requirements.aspx?expandable=4\">Source</a>)</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>BSE (2018)&#160;<a href=\"https://www.bseindia.com/downloads1/BSEs_Guidance_doc_on_ESG.pdf\">Guidance Document on ESG Disclosures</a></li><li>BSE signed Memorandum of Understanding with GRI for creating awareness amongst companies and investors regarding ESG Disclosures<br><a href=\"https://www.bseindia.com/static/about/sustainability.aspx?expandable=4#3\">BSE – Carbon Disclosure Project (CDP) initiative.</a>&#160;BSE signed Memorandum of Understanding with CDP India to jointly carry out activities for creating awareness about filing sustainability data / Environment, Social and Governance (ESG) data with CDP. CDP India is actively in touch with Top 200 (BSE-200 constituents) companies to encourage them to report non financial data. The data received from CDP will be used for the calculations of S&P BSE Carbonex.</li><li>Business Responsibility Report is mandatory for to 500 listed companies as per Market Capitalisation. BSE being a listed company and one the Top 500 Companies will be filing Business Responsibility Reporting every quarter.</li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>BSE is organising workshops for corporates and investors with Global as well as Indian partners to provide traing in the area of ESG.</li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li>S&P BSE CARBONEX,</li><li>S&P BSE 100 ESG</li><li>S&P BSE GREENEX</li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>The Bombay Stock Exchange (<a href=\"https://www.bseindia.com/\" rel=\"noopener noreferrer\">BSE</a>)’s international arm, India International Exchange (India INX), announced in 2019 its exclusive green listing and trading platform called Global Securities Market (GSM). GSM Green will serve as a platform for fundraising and trading green, social, and sustainable bonds exclusively.&#160;<a href=\"https://mercomindia.com/bse-green-bond-platform/\">Source</a></li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>BSE SME, since 2012</li></ul>","wom":"Yes","womt":"Yes<br><ul><li>There is a mandatory minimum rule of at least 1 woman on boards.<br>Source: Indian Parliament. (2013).<a href=\"https://www.mca.gov.in/SearchableActs/Section149.htm\" target=\"_blank\" rel=\"noopener\"> Section 149(1)(b) of Companies act 2013</a>.</li></ul>","Additional_information":"<ul><li>BSE is a member of WFE Sustainability Working Group</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Demutualized for profit; demutualized in 2005</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.sebi.gov.in/\">Securities and Exchange Board of India (SEBI)</a></li></ul><p></p>","Regulatory_model":"Strong Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>SEBI has the ability to install laws and regulations that dictate the operations of the stock markets in India. However, the Bombay Stock Exchange still possesses significant regulatory powers. For instance, the exchange can install its own listing requirements, such as the requirement for company's of a certain size to disclose a CSR report, and it possesses its own market and member regulation responsibilities.</li></ul><p>","About_the_stock_exchange":"Location: Mumbai, India<ul><li>Established in 1875, BSE Ltd. (formerly known as Bombay Stock Exchange Ltd.), is Asia’s first Stock Exchange and one of India’s leading exchange groups. Over the past 143 years, BSE has facilitated the growth of the Indian corporate sector by providing it an efficient capital-raising platform. Popularly known as BSE, the bourse was established as “The Native Share & Stock Brokers’ Association” in 1875. BSE is a corporatized and demutualised entity, with a broad shareholder-base which includes two leading global exchanges, Deutsche Bourse and Singapore Exchange as strategic partners. BSE provides an efficient and transparent market for trading in equity, debt instruments, derivatives, mutual funds. It also has a platform for trading in equities of small-and-medium enterprises (SME). More than 5000 companies are listed on BSE making it world’s No. 1 exchange in terms of listed members. The companies listed on BSE Ltd command a total market capitalization of USD 2.37 Trillion as of December 2017.&#160;<a href=\"https://www.bseindia.com/static/about/introduction.aspx?expandable\">(Source)</a></li><li>Largest shareholder is Deutsche Börse AG</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Possible launch in 2025. India's power ministry had released a draft blueprint for development of a domestic carbon market.","Source_lnk":"https://www.businesstoday.in/latest/economy/story/govt-finalises-scheme-for-indian-carbon-market-steering-committee-to-be-formed-388004-2023-07-03 https://www.spglobal.com/commodityinsights/en/market-insights/latest-news/energy-transition/031723-india-may-announce-details-of-national-carbon-market-scheme-in-june-official#"},{"id":100,"Country":"India","cc":"IN","Name0":"National Stock Exchange of India","Link":"/stock-exchange/nse-india","Name":"<a href=\"https://www.nseindia.com/\">National Stock Exchange of India (NSE)</a>","nlc":2013,"dmc":3279016.24,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/India-National-Stock-Exchange-of-India-NSE.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://static.nseindia.com//s3fs-public/inline-files/NSE%20Annual%20Report%202022-23_0.pdf\">Yes</a><br>The sustainability report is integrated into the annual report since 2011. The annual reports can be found <a href=\"https://www.nseindia.com/investor-relations/annual-reports\">here</a>.<p>","ESGrr":"Yes","ESGrrt":"Yes<br>See the <a href=\"/sites/sseinitiative/files/documents/sebi-format-for-business-responsibility-report-2015.pdf\">CIRCULAR CIR/CFD/CMD/10/2015</a> issued on November 04, 2015 on the&#160; Format for Business Responsibility Report (BRR) by the Securities and Exchange Board in India (SEBI).<p>In 2021, SEBI updated the listing rules by introducing new reporting requirements on&#160; ESG parameters called&#160; the Business&#160;&#160; Responsibility&#160;&#160; and&#160;&#160; Sustainability&#160;&#160; Report&#160;&#160; (BRSR). <a href=\"https://www.sebi.gov.in/legal/circulars/may-2021/business-responsibility-and-sustainability-reporting-by-listed-entities_50096.html\">Source</a></p>","hwg":"Yes","hwgt":"Yes<br><ul><li>NSE in association with Stakeholders Empowerment Services (SES) have carried out a study to assess and compare the disclosure practices reported in Business Responsibility Report (BRR) by Top 100 listed companies. The study has analysed BRR as well as Sustainability Reports of the sample companies by capturing data which is either straight forward quantitative or which can be quantified from BRR as well as Sustainability Reports of the sample companies. Report can be found&#160;<a href=\"https://www.nseindia.com/regulations/exchange-disclosures-nse-business-responsibility-report\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.nseindia.com/regulations/exchange-disclosures-nse-business-responsibility-report&source=gmail&ust=1657993692505000&usg=AOvVaw01gNSFG-9jSuk805Y1NsMv\">here</a>.</li><li>NSE in July 2020 published an analysis of&#160;ESG practices across 50 companies listed on National Stock Exchange of India Limited, spread across 12 different sectors.&#160; This assessment of ESG practices gives a broader picture of India’s ESG footprint. The study is intended to act as a catalyst and inspire companies to follow better ESG practices.&#160;Additionally, it will provide investors with a tool to benchmark companies.&#160;<a href=\"https://static.nseindia.com/s3fs-public/inline-files/ESG%2050%20Companies%20NSE%2011Jul2020.pdf\" data-saferedirecturl=\"https://www.google.com/url?q=https://static.nseindia.com/s3fs-public/inline-files/ESG%252050%2520Companies%2520NSE%252011Jul2020.pdf&source=gmail&ust=1657993692505000&usg=AOvVaw0GcdyV72ASpWsLH0ZrB-lO\">Report on ESG practices of companies listed on National Stock Exchange of India Limited</a></li><li>NSE undertakes a lot of capacity building initiatives in the area of corporate governance. Various reports and links to the roundtable discussions have been hosted on the&#160;<a href=\"https://www.nseindia.com/resources/insights-panel-discussions-seminars-corporate-governance\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.nseindia.com/resources/insights-panel-discussions-seminars-corporate-governance&source=gmail&ust=1657993692505000&usg=AOvVaw2UY3zmwwauDJeYIAr8FU_w\">NSE webpage</a>.<a name=\"m_-9092865002373991707__Hlk107925433\"></a></li><li>Business Responsibly and Sustainability Reporting (BRSR) sector specific guidance:<ul><li>NSE&#160;in association with Stakeholders Empowerment Services (SES)&#160;has published a comprehensive guide that explains BRSR parameters along with guidance on how to measure and disclose for every Essential as well as Leadership Indicator.&#160; The Guide has been specifically tailored for 38 Sub Sectors – as per SASB Standards&#160;to cover sector specific sustainability disclosure guidance. Every BRSR Indicator has been mapped to 5 Global frameworks viz. GRI, SDG, TCFD, CDP & SASB.&#160;The report can be found&#160;<a href=\"https://www.nseindia.com/resources/research-initiative-corporate-governance-integrated-guide-brsr\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.nseindia.com/resources/insights-panel-discussions-seminars-corporate-governance&source=gmail&ust=1657993692505000&usg=AOvVaw2UY3zmwwauDJeYIAr8FU_w\">here</a>.</li></ul></li></ul><p>","oert":"Yes","oertt":"Yes<br>In 2021, NSE provided a series of webinars on ESG topics: “<a href=\"https://www.youtube.com/watch?v=Qh0w0HVrrn4\">ESG: An antidote to adversity</a>“<p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://pressroom.ifc.org/all/pages/PressDetail.aspx?ID=21185\">S&P ESG India Index.</a></li><li><a href=\"https://www.niftyindices.com/indices/equity/thematic-indices/nifty100-esg\">NIFTY100 ESG</a></li><li><a href=\"https://www.niftyindices.com/indices/equity/thematic-indices/nifty100-enhanced-esg\">NIFTY100 Enhanced ESG</a></li><li><a href=\"https://www.niftyindices.com/indices/equity/thematic-indices/nifty100-esg-sector-leaders-index\">NIFTY100 ESG Sector Leaders Index</a></li></ul><p>See the list of thematic indices <a href=\"https://www.nseindia.com/products-services/indices-thematic\">here</a><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.niftyindices.com/indices/fixed-income/sovereign-green-bond-indices/nifty-india-sovereign-green-bond-jan-2033\">NIFTY India Sovereign Green Bond Jan 2033 Index</a></li><li><a href=\"https://www.niftyindices.com/indices/fixed-income/sovereign-green-bond-indices/nifty-india-sovereign-green-bond-jan-2028\">NIFTY India Sovereign Green Bond Jan 2028 Index</a></li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://static.nseindia.com//s3fs-public/inline-files/Emerge%20Brochure.pdf\">NSE India Emerge</a>, since 2012.</li></ul>","wom":"Yes","womt":"Yes<br><ul><li>Further, Indian Capital Market Regulator &#160;- Securities and Exchange Board of India, has mandated top 1000 listed entities to have at least one independent woman director on their Boards. This has been introduced in phased manner where by April 01, 2019 top 500 companies required to comply with this requirement and by April 01, 2020 it was extended to top 1000 listed entities (by market capitalization as at the end of the immediate previous financial year). Given the regulatory push high compliance has been observed in this area. From the submissions made by companies listed on NSE mainboard, for quarter ended December 2021 we observe that 98% of them have women representation on their Board. More information on: <a href=\"https://www.sebi.gov.in/legal/regulations/apr-2022/securities-and-exchange-board-of-india-listing-obligations-and-disclosure-requirements-regulations-2015-last-amended-on-april-25-2022-_58418.html\" target=\"_blank\" rel=\"noopener\">Securities and Exchange Board of India (Listing Obligations and Disclosure Requirements) Regulations, 2015 [Last amended on April 25, 2022]</a></li></ul>","Additional_information":"<ul><li>NSE India has put immense focus on issues around Inclusion – Gender Equality & Women on Boards. NSE India has 34% women employees on its role. They celebrate International Women’s Day every year to encourage women inclusion and appreciation in Financial Services.</li><li>NSE has been publishing Integrated report since past 3 years. Its report is also aligned to the recommendations made in the publication titled “How exchanges can embed sustainability within their operations” published by the United Nations Sustainable Stock Exchanges (SSE) initiative in collaboration with World Federation of Exchanges (WFE). The Global Reporting Initiative (GRI) standards and Sustainability Accounting Standards Board (SASB) standards have been referenced for devising Key Performance Indicators (KPIs) for material topics. Additionally, contributions to the United Nations Sustainable Development Goals (SDGs) have been mapped throughout its report.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Demutualized for profit.</li></ul><p>","Regulatory_bodies":"Indian Capital Markets are regulated and monitored by the Ministry of Finance, the Securities and Exchange Board of India and the Reserve Bank of India.<p><ul><li><a href=\"https://www.sebi.gov.in/\">Securities and Exchange Board of India (SEBI)</a>.</li><li><a href=\"https://www.rbi.org.in/\">Reserve Bank of India (RBI)</a></li></ul><p>The Securities and Exchange Board of India (SEBI) is the regulatory authority established under the SEBI Act 1992 and is the principal regulator for Stock Exchanges in India. SEBI’s primary functions include protecting investor interests, promoting and regulating the Indian securities markets. All financial intermediaries permitted by their respective regulators to participate in the Indian securities markets are governed by SEBI regulations, whether domestic or foreign. Foreign Portfolio Investors are required to register with DDPs in order to participate in the Indian securities markets. More information on: <a href=\"https://www1.nseindia.com/int_invest/content/www.sebi.gov.in\">www.sebi.gov.in</a> The Reserve Bank of India (RBI) is governed by the Reserve Bank of India Act, 1934. The RBI is responsible for implementing monetary and credit policies, issuing currency notes, being banker to the government, regulator of the banking system, manager of foreign exchange, and regulator of payment & settlement systems while continuously working towards the development of Indian financial markets. The RBI regulates financial markets and systems through different legislations. It regulates the foreign exchange markets through the Foreign Exchange Management Act, 1999. More information on: <a href=\"https://www1.nseindia.com/int_invest/content/www.rbi.gov.in\">www.rbi.gov.in</a> NSE is governed by SECC Regulations issued by SEBI, SEBI Act, various regulations/ circulars/ guidelines etc. issued there under, RBI directives on forex trading, interest rate futures trading, debt securities trading, Prevention of Money Laundering Act and several other statutes that govern any employer/ corporate body in the country. NSE is a front line regulator with a focus on disciplined market development, market integrity and investor protection.<p>","Regulatory_model":"<ul><li>Limited Exchange Self-Regulatory Organization (SRO) Model</li></ul><p>&#160;</p><p>","About_the_stock_exchange":"Location: Mumbai, India<p><ul><li>Incorporated in 1992, NSE was recognised as a stock exchange by Securities and Exchange Board of India (SEBI) in April 1993, commenced operations in 1994 and has been consistently ranked as the largest stock exchange in India in terms of total and average daily turnover for equity shares since 1995 (based on SEBI data). It is the largest derivatives exchange globally in terms of the number of contracts traded.</li><li>NSE is head-quartered in Exchange Plaza, Mumbai, India, with client-facing regional offices in Mumbai, Kolkata, Delhi, Chennai and Ahmedabad. NSE has 25 locations &#160;in India where business is undertaken by the company, including offices in Indore, Kanpur, Pune, Jaipur, Cochin, Hyderabad, Bangalore, Patna, Lucknow, Vadodara, Raipur, Jammu, Shimla, Panjim, Ranchi, Guwahati, Chandigarh, Bhubaneshwar and Dehradun.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Possible launch in 2025. India's power ministry had released a draft blueprint for development of a domestic carbon market.","Source_lnk":"https://www.businesstoday.in/latest/economy/story/govt-finalises-scheme-for-indian-carbon-market-steering-committee-to-be-formed-388004-2023-07-03 https://www.spglobal.com/commodityinsights/en/market-insights/latest-news/energy-transition/031723-india-may-announce-details-of-national-carbon-market-scheme-in-june-official#"},{"id":101,"Country":"Indonesia","cc":"ID","Name0":"Indonesia Stock Exchange","Link":"/stock-exchange/idx","Name":"<a href=\"https://www.idx.co.id/en-us\">Indonesia Stock Exchange (IDX)</a>","nlc":852,"dmc":604638.24,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Indonesia-IDX.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.idx.co.id/en/about-idx/sustainability-report\">Yes</a><br><ul><li>First sustainability report published in 2018 Annual Report.</li></ul><p>","ESGrr":"Yes","ESGrrt":"Yes<br>Sustainability reporting is required under Indonesia Financial Services Authority (Otoritas Jasa Keuangan) rule number&#160;<a href=\"https://www.ojk.go.id/id/regulasi/Documents/Pages/Bentuk-dan-Isi-Laporan-Tahunan--Emiten-atau-Perusahaan-Publik/SEOJK%20-%2016%20-%202021.pdf\">51/POJK.03/2017 (in Indonesian)</a>: Implementation of Sustaianability Finance for Financial Services Institutions, Issuers and Public Companies. (<a href=\"https://esg.idx.co.id/our-commitments-towards-esg-implementation-in-indonesian-capital-market\">Source</a>).<p><a class=\"waffle-rich-text-link\" data-sheets-formula-bar-text-link=\"https://www.idx.co.id/Media/8266/i-i-kep-308bej07-2004.pdf\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:''docs-Calibri'';font-style:normal;text-decoration-skip-ink:none;\">Delisting and Relisting Regulation</a> requires Environmental Impact Reporting","hwg":"Yes","hwgt":"Yes<br><ul><li>Guidance for Sustainability Reporting can be found on Indonesia Financial Services Authority (Otoritas Jasa Keuangan) rule number 51/POJK.03/2017 regarding. The guidance and appendices can be found <a href=\"https://www.ojk.go.id/id/kanal/perbankan/regulasi/peraturan-ojk/Pages/POJK-Penerapan-Keuangan-Berkelanjutan-bagi-Lembaga-Jasa-Keuangan%2c-Emiten%2c-dan-Perusahaan-Publik.aspx\">here</a>, in Indonesian.</li><li><a href=\"https://drive.google.com/file/d/1VCzACmOoPtvGMUD4S6PJYAJ8Rx3RMhU-/view?usp=sharing\">Environmental Reporting Guidance in Sustainability Reports (GRI & CDP)</a> more guides on sustainability topics in English <a href=\"https://esg.idx.co.id/other-information\">here</a></li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>25 April 2019: Seminar Collaboration IDX With GRI “Business Reporting on the Sustainable Development Goals” (<a href=\"https://www.idx.co.id/berita/berita-detail/?id=7760&newsId=13261\">source 1</a>,&#160;<a href=\"https://www.merdeka.com/uang/bei-dorong-perusahaan-tercatat-terapkan-pembangunan-berkelanjutan.html\">source 2</a>,&#160;<a href=\"https://www.liputan6.com/bisnis/read/3950084/bei-dorong-perusahaan-tercatat-terapkan-pembangunan-berkelanjutan\">source 3</a>).</li><li>5 February 2018: Introducing Green Bonds and Climate Bonds Initiative (<a href=\"https://bonds1375.rssing.com/chan-63951432/all_p16.html\">source</a>).</li><li>List of ESG related training held in 2021 <a href=\"https://esg.idx.co.id/events/past\">here</a></li><li>May 2022: provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/indonesia-tcfd-101-workshop-training/\">source</a>)</li><li>For more details on the on ESG training refer to the <a href=\"https://www.idx.co.id/id/tentang-bei/laporan-keberlanjutan\">IDX sustainability reports</a></li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><a href=\"https://esg.idx.co.id/rise-of-esg-investments\">The Indonesia Stock Exchange has issued four ESG-based Indices.</a><p>","hsbls":"Yes","hsblst":"Yes<br><ul class=\"checked-list\"><li>The issuance of regulation that supports sustainability based financial instruments, such as Rule No. I-B which incentivizes the issuance of green bonds by giving annual listing fee discounts for the issuance of green bonds. (<a href=\"https://esg.idx.co.id/our-commitments-towards-esg-implementation-in-indonesian-capital-market\">source</a>)</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>As of 22 July 2019, the IDX launched a new listing board for SMEs named Acceleration Board. IDX now has three listing boards: Main Board, Development Board and Acceleration Board. See Acceleration Board <a href=\"https://www.idx.co.id/en/products/stocks/\">here</a>.</li><li>Please find the link to the regulation for the SME listing board&#160;<a href=\"https://www.idx.co.id/media/7503/i-v_kep-00059_bei_07-2019.pdf\">here</a>&#160;in Indonesian.</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Non Profit.</li></ul><p>","Regulatory_bodies":"<ul><li>IDX is operating under supervision of Indonesia Financial Services Authority (Otoritas Jasa Keuangan), however, IDX under OJK’s approval, provides its own Listing Rule and Listing Requirement.</li></ul><p>","Regulatory_model":"Strong Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>In Indonesia, the capital markets are regulated by the Indonesian Capital Market and Financial Supervisory Agency. The agency is responsible for the supervision of the Indonesia Stock Exchange, the enforcement of the Capital Markets Act and of its own rules and regulations. The Indonesia Stock Exchange, on the other hand, is self-regulatory and regulates its own market and possesses the ability to enact rules on listing and membership requirements. However, there is no evidence that the exchange is able to regulate its members' business conduct or participate in any more significant regulatory functions. Several additional tasks are handled by two other regulatory bodies: the Indonesian Central Securities Depository and the Indonesian Clearing and Guarantee Corporation.</li></ul><p>","About_the_stock_exchange":"Location: Jakarta, Indonesia<ul><li>Indonesia Stock Exchange (IDX) is a nonprofit Self-Regulatory Organization (SRO). IDX operates under the supervision of Indonesia Financial Services Authority (Otoritas Jasa Keuangan). As the only Stock Exchange in Indonesia, IDX consistently promotes Indonesia Capital Market integrity and ensures that securities trading activities are exercised in an orderly, fair and efficient manner. IDX headquarter is in Jakarta, the capital city of Indonesia. To make sure financial iteration are spreading across Indonesia, IDX has 29 Representatives Offices and 412 Investment Galleries.</li></ul>","am":true,"os":false,"nz":false,"VCM":"Yes","CCM":"Yes","Notes":"IDX has been issued with a carbon trading license by the Indonesian Financial Services Authority (OJK) with carbon trading launching in September 2023. The market will trade carbon credit certificates issued for activities or projects that remove carbon from the atmosphere or companies that emit pollution below a limit set by the government.","Source_lnk":"https://www.straitstimes.com/asia/se-asia/indonesia-to-launch-carbon-exchange-in-september https://www.green.earth/news/indonesia-prepares-for-carbon-exchange-trading-implementation https://jakartaglobe.id/business/idx-set-to-launch-carbon-trading-platform https://www.reuters.com/sustainability/indonesia-plans-first-carbon-trade-next-week-2023-09-18/"},{"id":102,"Country":"Iran (Islamic Republic of)","cc":"IR","Name0":"Iran Fara Bourse Securities Exchange","Link":"/stock-exchange/ifb","Name":"<a href=\"https://www.ifb.ir/\">Iran Fara Bourse Securities Exchange</a>","nlc":148,"dmc":48495.158,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2021/08/Partner-Exchange-Commitment-Letter-IRAN.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.ifb.ir/Files/AnnualReport/98-en.pdf\">Yes</a><br>Iran Fara Bourse is reporting key measures of sustainability for the second consecutive year in its <a href=\"https://www.ifb.ir/Files/AnnualReport/98-en.pdf\">Annual Proxy Statement</a>.<p></p>","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>The local regulator authority has released a directive for corporate governance since 2018: <a href=\"https://codal.ir/Reports/Attachment.aspx?LetterSerial=U6EQCUiBsyw4B4WsBOi1pQ%3d%3d\">Corporate Governance Instructions of Companies Listed in Tehran Stock Exchange and OTC Iran</a><p><p>&#160;</p><p>","oert":"Yes","oertt":"Yes<br>Regular Corporate Governance courses are given for issuers.<p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><a href=\"https://www.ifb.ir/MFI/FinancialInstrument.aspx?lang=en\">Sukuks Market&#160;</a><p><p>Sukuk securities are Sharia-compliant. Shariah-compliant instruments have been widely accepted as sustainable products.</p><p>","HSMElp":"Yes","HSMElpt":"Yes<br><a href=\"https://www.ifb.ir/markets.aspx?id=4&lang=en\">SME Market | شرکت فرابورس ایران (ifb.ir)</a><p><p>&#160;</p><p>","wom":"No","womt":"No","Additional_information":"&#160;<p><p>&#160;</p><p>","Organizational_model_of_stock_exchange":"Public Joint Stock Company, Listed<p>","Regulatory_bodies":"<a href=\"https://en.seo.ir/\">Securities and Exchanges Organization (SEO),</a> an ordinary member of IOSCO as of Nov 27, 2018.<p>","Regulatory_model":"• Limited exchange SRO<p>","About_the_stock_exchange":"IFB headquartered in Tehran with no subsidiary. Founded in 2008, with over 190 employees, Iran Fara Bourse is operating the largest debt market and the second stock market of the country (by size and volume). Iran Fara Bourse mission is to foster innovation and entrepreneurship in private sector by delivering diverse Sharia-compliant financial instruments and platforms to the markets.<br>• Stock<br>Main market (First market, Second market) - Listed<br>SME market – Listed<br>UTP market (Yellow-board, Orange-board, Red-board) – Admitted<br>Third market (Intellectual Property, Merger & Acquisition, Underwriting corporation, bulk and wholesale offerings) – Unlisted<br>• Structured Financial Instruments<br>(Sukuks, Islamic Treasury Bills, Mortgage Rights)- Listed<br>• Funds<br>(ETF, ETFCF, VC, PE) – Listed<br>• Derivatives<br>(Call option, Put option, Embedded put option)<p><p>• Crowdfunding Platforms<br>• FinStars Owner (A platform to boost start-ups)<br>• Iran Capital Market SandBox</p>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No domestic carbon trading mechanism","Source_lnk":"https://www.timesofisrael.com/to-fill-vacuum-ngo-seeks-to-create-local-regional-carbon-trading-scheme/"},{"id":103,"Country":"Iran (Islamic Republic of)","cc":"IR","Name0":"Tehran Stock Exchange","Link":"/stock-exchange/tse","Name":"<a href=\"https://tse.ir/en/\">Tehran Stock Exchange</a>","nlc":380,"dmc":1160180.83,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2020/01/Iran-Tehran-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br>TSE's new listing rules have been proposed by the Exchange to the market's regulator – Securities and Exchange Organization – for its review and final approval. Once ratified, it includes updated and more inclusive regulations for observing the corporate governance standards, as well as formation of a new premier board for the blue-chips with advanced adherence to such standards.<p></p>","hwg":"No","hwgt":"No<br>The directive for corporate governance is ratified and announced for implementation by the regulator, with a one-year period of groundwork.<p><p><a href=\"https://codal.ir/Reports/Attachment.aspx?LetterSerial=U6EQCUiBsyw4B4WsBOi1pQ%3d%3d\">https://codal.ir/Reports/Attachment.aspx?LetterSerial=U6EQCUiBsyw4B4WsBOi1pQ%3d%3d</a><p>","oert":"Yes","oertt":"Yes<br><br><p></p>","mcbsri":"No","mcbsrit":"No<br>TSE has started since last year to collect the listed companies' self-assessments and disclosures on corporate governance issues to provide the CG grade. With more data accumulated, introducing related indices will be applicable.<p>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br>The SMEs are eligible to be listed in a regulated market with less stringent though transparent and supportive standards. The market is Iran Fara Bourse (IFB), in which TSE has 20% stakes.<p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"Listed (self-listed exchange)<p>","Regulatory_bodies":"Securities and Exchange Organization (of Iran)<p><p><a href=\"https://en.seo.ir/\">https://en.seo.ir/</a><p>","Regulatory_model":"Limited exchange SRO<p>","About_the_stock_exchange":"TSE's profile: <a href=\"https://tse.ir/cms/Page55.html\">https://tse.ir/cms/Page55.html</a><p><p>Our history: <a href=\"https://tse.ir/cms/Page56.html\">https://tse.ir/cms/Page56.html</a></p><p>The legal structure: <a href=\"https://tse.ir/cms/Page57.html\">https://tse.ir/cms/Page57.html</a></p><p>TSE's chart of organization: <a href=\"https://tse.ir/cms/Page58.html\">https://tse.ir/cms/Page58.html</a></p>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":104,"Country":"Ireland","cc":"IE","Name0":"Euronext Dublin","Link":"/stock-exchange/euronext-dublin","Name":"<a href=\"https://www.euronext.com/en/markets/dublin\">Euronext Dublin</a>","nlc":40,"dmc":124081,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Ireland-Euronext-Dublin.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.euronext.com/en/investor-relations/financial-information/financial-reports\">Yes</a><br><ul><li>There is a chapter in the annual report dedicated to sustainability activities, find all reports <a href=\"https://www.euronext.com/en/investor-relations/financial-information/financial-reports\">here</a>.</li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>The <a href=\"https://www.europarl.europa.eu/RegData/etudes/BRIE/2021/654213/EPRS_BRI%282021%29654213_EN.pdf\">European directive on non-financial information reporting (NFRD)</a> has been implemented into the Irish legal environment.</li><li>Moreover, Euronext Dublin supports and implements ESMA’s and National Competent Authorities stringent rules with regards to governance among its community of listed companies.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"/sites/sseinitiative/files/documents/euronext-esg-guide-2022.pdf\">ESG Reporting Guide – Target 1.5°C</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br>Through the Euronext Academy, see more details&#160;<a href=\"https://www.corporateservices.euronext.com/academy?s=ESG\">here</a>.<p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li>See the list of indices on the Euronext website&#160;<a href=\"https://live.euronext.com/en/products/indices/all-indices-documents\">here</a>. ESG/ISR indices fall under the tab “theme indices”. This list is automatically updated.</li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.euronext.com/en/list-products/bonds/green-bonds\">Euronext ESG Bonds</a> is a community of ESG bond issuers where green, sustainability, social, blue and sustainability-linked bonds listed on all Euronext locations are consolidated onto one highly visible area. Details of the securities <a href=\"https://live.euronext.com/en/products/fixed-income/esg-bonds\">here</a>.</li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.ise.ie/Products-Services/List-your-company/ESM/\">Enterprise Securities Market</a>, since 2005 (Irish Stock Exchange now known as Euronext Dublin)</li><li>Euronext Growth,&#160;Euronext Access,&#160;Euronext Access+. More information <a href=\"https://www.euronext.com/en/raise-capital/sme\">here</a>.</li></ul>","wom":"No","womt":"No","Additional_information":"<ul><li>Euronext Dublin facilitates the listing of sustainable products through existing markets for equities, bonds and investment funds.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit.</li></ul><p>","Regulatory_bodies":"&#160;<p><ul><li><a href=\"https://www.centralbank.ie/\">Central Bank of Ireland (CBI).</a></li><li><a href=\"https://www.finance.gov.ie/\">The Irish Ministry of Finance.</a></li><li><a href=\"https://www.esma.europa.eu/\">European Union (ESMA)</a>.</li></ul><p>&#160;</p><p></p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>The Markets in Financial Instruments Directive (MiFID)&#160;classifies Euronext’s European cash markets as a regulated market. As such, the real-time monitoring performed by Euronext’s cash market operations and technical support is formally enforced, and trading rules and procedures are approved by six regulators. This regulatory and organizational system gives Euronext the power to efficiently manage crisis situations and extraordinary circumstances. Some of the markets organized by Euronext are exchange regulated, which means they are subject to a body of rules laid down by the market operator, Euronext. They are not regulated markets as defined by&#160;The Markets in Financial Instruments Directive (MiFID). These structured, exchange regulated markets (or MTF’s) offer simplified access to financial markets and streamlined listing requirements for companies from every sector of the economy, while ensuring compliance with rules on investor disclosure and the control of financial information.&#160;<a href=\"https://www.euronext.com/en/equities/market-regulation\">(Source)</a>.</li></ul><p></p>","About_the_stock_exchange":"Location: Dublin, Ireland<ul><li>The Irish Stock Exchange Plc trading as Euronext Dublin (‘Euronext Dublin’) is authorized by the Central Bank of Ireland (‘CBI’) as a market operator pursuant to Article 56 (2) of the European Union (Markets in Financial Instruments) Regulation 2017 (S.I. 375/2017). As a market operator, Euronext Dublin operates one regulated market and three multi-lateral trading facilities and adopts rules for each of these markets to ensure fair and orderly trading and efficient order execution. In addition, Euronext Dublin has been appointed as the competent authority for listing by the department of Business, Enterprise and Innovation pursuant to the European Communities (Admission to Listing and Miscellaneous Provisions) Regulations 2007, as amended. The CBI is responsible for the regulation and supervision of regulated markets and market operators authorised in Ireland. Euronext Dublin is required to meet various legislative and regulatory requirements and failure to comply with these requirements could subject it to enforcement action by the CBI including significant penalties and/ or revocation of its authorisation as a market operator. <a href=\"https://www.euronext.com/en/markets/dublin%c2%a0Euronext\" target=\"_blank\">https://www.euronext.com/en/markets/dublin&#160;Euronext</a> is the leading pan-European exchange in the Eurozone, spanning Belgium, France, Ireland, Norway, the Netherlands, Portugal, the UK and Ireland. Created in 2000, it unites markets which date back to the start of the 17th century. It is the primary exchange in the Euro zone with nearly 1,500 listed issuers worth more than €4.5 trillion in market capitalization as of end May 2019,&#160;an unmatched blue chip franchise consisting of 20+ issuers in the Morningstar® Eurozone 50 Index℠ and a strong diverse domestic and international client base</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":105,"Country":"Israel","cc":"IL","Name0":"Tel-Aviv Stock Exchange","Link":"/stock-exchange/tase","Name":"<a href=\"https://www.tase.co.il/en\">Tel-Aviv Stock Exchange</a>","nlc":546,"dmc":250226.33,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2021/01/TASE-SSE-initiative-public.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><a href=\"/wp-content/uploads/2022/05/TASE-ESG_report_eng.pdf\">2021 Sustainability report</a><p></p>","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>However, a <a class=\"waffle-rich-text-link\" href=\"https://content.tase.co.il/media/cvslzasa/esg_glossary_of_terms_eng.pdf\" data-sheets-formula-bar-text-link=\"https://content.tase.co.il/media/cvslzasa/esg_glossary_of_terms_eng.pdf\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:''docs-Calibri'';font-style:normal;text-decoration-skip-ink:none;\">glossary of terms</a> has been published.<p>","oert":"No","oertt":"No<br>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.tase.co.il/en/market_data/index/150/about\">TA-MAALA index</a></li><li><a href=\"https://www.tase.co.il/en/market_data/index/185/about\">TA-125 Fossil Free index</a></li><li><a href=\"https://www.tase.co.il/en/market_data/index/184/about\">TA CLEANTECH index</a></li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>Bonds Index based on social responsibility: <a class=\"waffle-rich-text-link\" href=\"https://market.tase.co.il/en/market_data/index/731/about\" data-sheets-formula-bar-text-link=\"https://market.tase.co.il/en/market_data/index/731/about\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:''docs-Calibri'';font-style:normal;text-decoration-skip-ink:none;\">Tel Bond-CPI Linked Maala SRI</a> ; </li><li>Launched first social impact bond (<a href=\"https://www.tase.co.il/en/content/news-lobby/20230517_pr\">source</a>)</li></ul><p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Listed since August 2019</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.isa.gov.il/sites/ISAEng/Pages/default.aspx\">Israel Securities Authority</a></li></ul><p>","Regulatory_model":"<ul><li>Strong exchange SRO</li><li>The Tel-Aviv Stock Exchange (TASE) has strong regulatory jurisdiction when it comes to market operation. TASE’s own rules govern membership, listing and registration of companies and securities,&#160; and obligations of listed companies. Any additional regulation comes from the Israel Securities Authority, which acts as a second layer of regulation and market oversight.</li></ul><p>","About_the_stock_exchange":"The Tel Aviv Stock Exchange (TASE) was established in Israel in September 1953.<p><p>TASE plays a central role in the Israeli economy and provides a market infrastructure that is central to the economy’s growth. As TASE is the only securities exchange in Israel, where access to it is protected by high barriers to entry in terms of regulation and the need for reliable technological infrastructure, Israeli companies and the Israeli government rely on TASE’s markets for capital and liquidity.</p><p>TASE is the “home court” for Israeli companies seeking to raise capital to meet their growth and liquidity objectives. In so doing, TASE contributes significantly to Israel’s economic growth and employment.</p><p>TASE is also the “home court” for the Israeli investment community and provides investors with a reliable and comprehensive trading platform for the buying and selling of a wide range of securities and other financial instruments. TASE serves hundreds of thousands of investors, including households, who invest in TASE’s markets, largely through investment management companies including pension funds, insurance companies, provident funds, advanced study funds and other entities.</p><p>TASE provides markets for the listing and trading of a vast range of securities and derivative instruments. These include shares, corporate bonds, government bonds, Treasury bills, ETFs, convertible securities, single stock options, options and futures on equity indices, and options and futures on foreign currency exchange rates. Trading is fully automated, order-driven, real-time and continuous through our sophisticated Tel Aviv Continuous Trading “TACT” system.<br>TASE members (banks or brokerage houses) conduct all trading on TASE.</p><p>As of August 1, 2019, the Tel Aviv Stock Exchange is a TASE traded public company, following its IPO at the end of July 2019. At that time, TASE floated 31.7% of its shares to foreign and Israeli institutional investors and to the public at large. The shares trade under ticker symbol “TASE”.</p><p>As a vertically integrated platform that is a “one-stop-shop” for clients across asset classes, TASE’s wholly-owned subsidiaries include the Tel Aviv Stock Exchange Clearing House, the MAOF Clearing House (derivatives) and the Tel Aviv Stock Exchange Nominee Company, which provide the only clearing and settlement infrastructure in Israel and securities registration services.</p><p><a href=\"https://www.tase.co.il/en\">Source</a>The Tel Aviv Stock Exchange (TASE) was established in Israel in September 1953.<p><p>TASE plays a central role in the Israeli economy and provides a market infrastructure that is central to the economy’s growth. As TASE is the only securities exchange in Israel, where access to it is protected by high barriers to entry in terms of regulation and the need for reliable technological infrastructure, Israeli companies and the Israeli government rely on TASE’s markets for capital and liquidity.</p><p>TASE is the “home court” for Israeli companies seeking to raise capital to meet their growth and liquidity objectives. In so doing, TASE contributes significantly to Israel’s economic growth and employment.</p><p>TASE is also the “home court” for the Israeli investment community and provides investors with a reliable and comprehensive trading platform for the buying and selling of a wide range of securities and other financial instruments. TASE serves hundreds of thousands of investors, including households, who invest in TASE’s markets, largely through investment management companies including pension funds, insurance companies, provident funds, advanced study funds and other entities.</p><p>TASE provides markets for the listing and trading of a vast range of securities and derivative instruments. These include shares, corporate bonds, government bonds, Treasury bills, ETFs, convertible securities, single stock options, options and futures on equity indices, and options and futures on foreign currency exchange rates. Trading is fully automated, order-driven, real-time and continuous through our sophisticated Tel Aviv Continuous Trading “TACT” system.<br>TASE members (banks or brokerage houses) conduct all trading on TASE.</p><p>As of August 1, 2019, the Tel Aviv Stock Exchange is a TASE traded public company, following its IPO at the end of July 2019. At that time, TASE floated 31.7% of its shares to foreign and Israeli institutional investors and to the public at large. The shares trade under ticker symbol “TASE”.</p><p>As a vertically integrated platform that is a “one-stop-shop” for clients across asset classes, TASE’s wholly-owned subsidiaries include the Tel Aviv Stock Exchange Clearing House, the MAOF Clearing House (derivatives) and the Tel Aviv Stock Exchange Nominee Company, which provide the only clearing and settlement infrastructure in Israel and securities registration services.</p><p><a href=\"https://www.tase.co.il/en\">Source</a></p>The Tel Aviv Stock Exchange (TASE) was established in Israel in September 1953.<p><p>TASE plays a central role in the Israeli economy and provides a market infrastructure that is central to the economy’s growth. As TASE is the only securities exchange in Israel, where access to it is protected by high barriers to entry in terms of regulation and the need for reliable technological infrastructure, Israeli companies and the Israeli government rely on TASE’s markets for capital and liquidity.</p><p>TASE is the “home court” for Israeli companies seeking to raise capital to meet their growth and liquidity objectives. In so doing, TASE contributes significantly to Israel’s economic growth and employment.</p><p>TASE is also the “home court” for the Israeli investment community and provides investors with a reliable and comprehensive trading platform for the buying and selling of a wide range of securities and other financial instruments. TASE serves hundreds of thousands of investors, including households, who invest in TASE’s markets, largely through investment management companies including pension funds, insurance companies, provident funds, advanced study funds and other entities.</p><p>TASE provides markets for the listing and trading of a vast range of securities and derivative instruments. These include shares, corporate bonds, government bonds, Treasury bills, ETFs, convertible securities, single stock options, options and futures on equity indices, and options and futures on foreign currency exchange rates. Trading is fully automated, order-driven, real-time and continuous through our sophisticated Tel Aviv Continuous Trading “TACT” system.<br>TASE members (banks or brokerage houses) conduct all trading on TASE.</p><p>As of August 1, 2019, the Tel Aviv Stock Exchange is a TASE traded public company, following its IPO at the end of July 2019. At that time, TASE floated 31.7% of its shares to foreign and Israeli institutional investors and to the public at large. The shares trade under ticker symbol “TASE”.</p><p>As a vertically integrated platform that is a “one-stop-shop” for clients across asset classes, TASE’s wholly-owned subsidiaries include the Tel Aviv Stock Exchange Clearing House, the MAOF Clearing House (derivatives) and the Tel Aviv Stock Exchange Nominee Company, which provide the only clearing and settlement infrastructure in Israel and securities registration services.</p><p><a href=\"https://www.tase.co.il/en\">Source</a></p>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":106,"Country":"Italy","cc":"IT","Name0":"Borsa Italiana (Euronext)","Link":"/stock-exchange/borsa-italiana","Name":"<a href=\"https://www.borsaitaliana.it/homepage/homepage.en.htm\">Borsa Italiana (Euronext)</a>","nlc":398,"dmc":1610000,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Italy-BorsaItaliana.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.euronext.com/en/investor-relations/financial-information/financial-reports\">Yes</a><br><ul><li>There is a chapter in the annual report dedicated to sustainability activities, find all reports&#160;<a href=\"https://www.euronext.com/en/investor-relations/financial-information/financial-reports\">here</a>.</li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><a href=\"https://www.europarl.europa.eu/RegData/etudes/BRIE/2021/654213/EPRS_BRI%282021%29654213_EN.pdf\">The Non-financial Reporting Directive (NFRD) applies to the members of the European Union.</a>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"/sites/sseinitiative/files/documents/euronext-esg-guide-2022.pdf\">ESG Reporting Guide – Target 1.5°C</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>Events dedicated to Sustainable Finance organized by Borsa Italiana can be found <a href=\"https://www.borsaitaliana.it/finanza-sostenibile/eventi/eventi.en.htm\">here</a>.</li><li>More ESG-related courses are available on the <a href=\"https://www.borsaitaliana.it/borsaitaliana/academy/academy/formazione-academy.en.htm\">Academy website</a></li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.euronext.com/en/about/media/euronext-press-releases/euronext-and-borsa-italiana-launch-new-mib-esg-index\">MIB® ESG Index</a>: The MIB® ESG index combines measurement of economic performance with ESG considerations, in line with the United Nations (UN) Global Compact principles2. The composition of the index is based on ESG assessments performed by V.E, part of Moody’s ESG Solutions, who engage with issuers on their ESG performance.</li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br>Find more information here: <a href=\"https://www.borsaitaliana.it/obbligazioni/greenbonds/socialbonds.en.htm\">Green and Social Bonds</a><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br>Euronext Growth, Euronext Access, Euronext Access+. More information <a href=\"https://www.euronext.com/en/raise-capital/sme\">here</a><p><ul><li><a href=\"https://www.borsaitaliana.it/azioni/mercati/mercati-landingpage/slidedoc.en.pdf\">The listing process for SME’s on Borsa Italiana markets </a></li></ul><p></p>","wom":"Yes","womt":"Yes<br><ul><li>There is a 40% mandatory minimum rule for women on boards.<br>Source: <a href=\"https://www.altalex.com/documents/leggi/2011/08/30/legge-12-07-2011-n-120\" target=\"_blank\" rel=\"noopener\">Law, 12/07/2011 n° 120</a> and <a href=\"https://www.consob.it/web/consob-and-its-activities/laws-and-regulations/documenti/english/laws/fr_decree58_1998.htm\" target=\"_blank\" rel=\"noopener\">Law, 2020</a></li></ul>","Additional_information":"<ul><li><a href=\"https://www.borsaitaliana.it/finanza-sostenibile/home-page/home.en.htm\">Sustainable Finance – Borsa Italiana</a></li></ul><p></p>","Organizational_model_of_stock_exchange":"Borsa Italiana S.p.A., reckoning that a fair and transparent running of the company, consistent with its mission, calls for a suitable process of identification, management and monitoring of the main company risks and the adoption and effective implementation of models capable of preventing commission of the penal offences, approved an&#160;Organizational, Management and Control Model, designed to prevent these offences, pursuant to legislative decree of 8 June 2003, which introduced the concept of “administrative responsibility” for companies, resulting from offences committed in the interest or to the advantage of the company itself by individuals in apical position or by employees subject to the direction or supervision of one of the aforesaid persons. More details <a href=\"https://www.borsaitaliana.it/borsaitaliana/chi-siamo/modelloorganizzativoecodicedicomportamento/codcomportam.en.htm\">here</a>.<p></p>","Regulatory_bodies":"<ul><li><a href=\"https://www.consob.it/\">Commissione Nazionale per le Societa e la Borsa (CONSOB)</a>.</li></ul><p></p>","Regulatory_model":"The new segment of Borsa Italiana is the result of important regulatory changes introduced in 2012 with the “Decreto Sviluppo” and the “Decreto Sviluppo-Bis” and enriched later during 2013 and 2014 with “Piano Destinazione Italia”,”Decreto Competitività 2014″ and IVASS Regulations.<p><p>These innovations have the purpose to facilitate access to capital markets for Italian private companies, other than micro enterprises, particularly sensitive in times of financial crisis, given the average composition of their funding sources strongly focused on short-term bank debt. Two directions have been taken. On one side, to facilitate companies using capital instruments in order to reach a new equilibrium in the liabilities composition. On the other side, to direct institutional investors towards the real italian economy.</p><p>For more detail visit: <a href=\"https://www.borsaitaliana.it/pro-link/extramot/ilcontestonormativo/ilcontestonormativo.en.htm\">The regulatory framework – Borsa Italiana</a><p></p>","About_the_stock_exchange":"<p>The Borsa di commercio di Milano (Milan Stock Exchange) was established by <a href=\"https://en.wikipedia.org/wiki/Eug%C3%A8ne_de_Beauharnais\">Eugène de Beauharnais</a>, viceroy of the Napoleonic <a href=\"https://en.wikipedia.org/wiki/Kingdom_of_Italy_%28Napoleonic%29\">Kingdom of Italy</a>, through decrees dated 16 January and 6 February 1808. It operated under public ownership until 1998, when it was privatized. In 1997, all the Italian stocks were merged. Before that year, other smaller stocks exchanges were based in Naples, Turin, Trieste, Venice, Genoa, Florence, Bologna, Rome, and Palermo. In 1991, the electronic exchanges were approved, and in 1994, the market with grids (A,B,C) was abolished. In Milan were also the currencies exchange rates fixing and the commodities fixing.<p><p>On 1 October 2007, Borsa Italiana was merged with the <a href=\"https://en.wikipedia.org/wiki/London_Stock_Exchange\">London Stock Exchange</a> in an all-share takeover, thus becoming part of the London Stock Exchange Group. In March 2016, the London Stock Exchange Group announced the agreement to merge in an all-stock deal with <a href=\"https://en.wikipedia.org/wiki/Deutsche_B%C3%B6rse\">Deutsche Borse</a>, but was subsequently blocked by the EU Competition Regulator.</p><p>On 18 September 2020, the <a href=\"https://en.wikipedia.org/wiki/London_Stock_Exchange_Group\">London Stock Exchange Group</a> entered into exclusive talks to sell the Italian Bourse to <a href=\"https://en.wikipedia.org/wiki/Euronext\">Euronext</a>. On 29 April 2021, following the entry of <a href=\"https://en.wikipedia.org/wiki/CDP_Equity\">CDP Equity</a> and <a href=\"https://en.wikipedia.org/wiki/Intesa_Sanpaolo\">Intesa San Paolo</a> (Italian institutional investors) as shareholders of Euronext, the European group assumed control of the company.</p><p>For more detail visit <a href=\"https://www.borsaitaliana.it/borsaitaliana/storia/storia/scenari-economici-finanziari.en.htm\">the history of Borsa Italiana</a><p></p>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":107,"Country":"Jamaica","cc":"JM","Name0":"Jamaica Stock Exchange","Link":"/stock-exchange/jamstockex","Name":"<a href=\"https://www.jamstockex.com/\">Jamaica Stock Exchange (JSE)</a>","nlc":95,"dmc":12154.87,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Jamaica-Jamaica-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.jamstockex.com/investor-centre/junior-market-information/\">Junior Market,&#160;</a>since 2009.</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Privately owned, limited liability company.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fscmauritius.org/en\">Financial Services Commission</a>.</li></ul><p>","Regulatory_model":"","About_the_stock_exchange":"Location: Kingston, Jamaica<p><ul><li>The Jamaica Stock Exchange (“JSE”) is an august institution which was incorporated in 1968 and started operation in 1969. The JSE started its operation at the Bank of Jamaica (BOJ) building and moved to its present building situated at 40 Harbour Street in 1998. The JSE’s principal mandate is the mobilization of capital to facilitate the growth and development of companies and by extension the economy.&#160;<a href=\"https://www.jamstockex.com/about/\">(Source)</a>.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":108,"Country":"Japan","cc":"JP","Name0":"Japan Exchange Group","Link":"/stock-exchange/jpx","Name":"<a href=\"https://www.jpx.co.jp/english/\">Japan Exchange Group</a>","nlc":3924,"dmc":6066496.3,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/japan-jpx.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li>“Environment and Regional Communities” and “Engagement with Society” sections in the Annual Report for 2017 and 2016. “Ensuring the sustainability of corporate value” section including subsection on “relationships with society and the natural environment” in 2014 and 2015 Annual Report. CSR section (including environment) in 2013 Annual Report</li><li><a href=\"/sites/sseinitiative/files/documents/japan-jpx.pdf\">JPX Report 2022</a></li><li><a href=\"https://www.jpx.co.jp/english/corporate/investor-relations/ir-library/integrated-report/tvdivq0000008t9q-att/JPXReport2021_A4.pdf\">JPX Report 2021</a></li><li><a href=\"https://www.jpx.co.jp/english/corporate/investor-relations/ir-library/integrated-report/tvdivq0000008t9q-att/JPXReport2020.pdf\">JPX Report 2020</a></li><li><a href=\"https://www.jpx.co.jp/english/corporate/investor-relations/ir-library/integrated-report/tvdivq0000008t9q-att/JPXReport2019.pdf\">JPX Report 2019</a></li><li><a href=\"https://www.jpx.co.jp/english/corporate/investor-relations/ir-library/integrated-report/tvdivq0000008t9q-att/JPXReport2018_English.pdf\">JPX Report 2018</a></li><li><a href=\"https://www.jpx.co.jp/english/corporate/investor-relations/ir-library/integrated-report/tvdivq0000008t9q-att/JPXReport2017_English.pdf\">JPX Report 2017</a></li><li><a href=\"https://www.jpx.co.jp/english/corporate/investor-relations/ir-library/integrated-report/tvdivq0000008t9q-att/JPXreport2016e_all.pdf\">JPX Report 2016</a></li><li>Access the reports since 2013 <a href=\"https://www.jpx.co.jp/english/corporate/investor-relations/ir-library/integrated-report/index.html\">here</a></li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>The Exchange requires every listed company to prepare a report on corporate governance, including some ESG issues, which provides investors with information on corporate governance in a comparable format.</li><li>If any environmental or social information is deemed to have a material effect on investors’ investment decisions, it must be immediately disclosed using TDnet as required by the Exchanges’ Listing Rule and the issuer must file a material change report on TDnet if a change or correction should be made to the information disclosed.</li><li>Japan's Financial Services Agency has made reporting on sustainability, including initiatives on climate change and human capital, <a href=\"https://www.fsa.go.jp/news/r4/sonota/20221107/20221107.html\" target=\"_blank\" rel=\"noopener\">mandatory in Annual Securities Reports</a>, starting from those covering fiscal years ending March 2023. (Japanese)</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>JPX published a “<a href=\"https://www.jpx.co.jp/english/corporate/sustainability/esg-investment/handbook/index.html\">Practical Handbook for ESG Disclosure</a>” (also in <a href=\"https://www.jpx.co.jp/corporate/sustainability/esg-investment/handbook/nlsgeu000004n8p1-att/handbook.pdf\">Japanese</a>). The Handbook is to support listed companies who are choosing to work on ESG disclosure, linking their company's mid- to long-term corporate value improvement to its sustainable growth.</li><li>On 3 June 2019, JPX announced the publication of the Japanese Translation of “<a href=\"https://www.jpx.co.jp/english/corporate/news/news-releases/0060/20190603-01.html\">Model Guidance for Companies on Reporting on ESG Information</a>“. Download the Japanese translation&#160;<a href=\"https://www.jpx.co.jp/english/corporate/news/news-releases/0060/b5b4pj000002wxpa-att/SSE_Initiatives_j.pdf\">here</a>.</li><li>Corporate Governance Code incorporated into the Tokyo Stock Exchange listing rules not only sets forth comprehensive principles on governance issues, but also calls for taking appropriate measures to address sustainability issues, including the provision of non-financial information, on comply or explain basis.</li><li>Compliance with the corporate governance code can be found <a href=\"https://www.jpx.co.jp/english/equities/listing/cg/\">here</a>.</li><li>See also: <a class=\"waffle-rich-text-link\" href=\"https://www.jpx.co.jp/english/corporate/sustainability/esgknowledgehub/index.html\">JPX ESG Knowledge Hub</a> :<ul><li><a class=\"waffle-rich-text-link\" href=\"https://www.jpx.co.jp/corporate/sustainability/esgknowledgehub/disclosure-framework/index.html\">Introductions to the Main ESG Disclosure Frameworks</a> (japanese),</li><li><a class=\"waffle-rich-text-link\" href=\"https://www.jpx.co.jp/corporate/sustainability/esgknowledgehub/esg-investor/index.html\">ESG investment by institutional investors</a> (japanese),</li><li><a class=\"waffle-rich-text-link\" href=\"https://www.jpx.co.jp/corporate/sustainability/esgknowledgehub/esg-rating/index.html\">Introductions to ESG Ratings Agencies and Data Providers, and ESG Finance Ratings Providers </a>(Japanese)</li></ul></li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>JPX and TSE offer research and booklets, e-learning and seminars/events on corporate value improvement, roles of an independent director, analysis on trends of governance structure at listed companies, integrated reporting and responsible investment (as of March 2018).</li><li><a href=\"https://www.jpx.co.jp/equities/listed-co/seminar/management/index.html\">Training program</a> for company executives (in Japanese).</li><li><a href=\"https://www.jpx.co.jp/equities/listed-co/seminar/e-learning/index.html\">E-learning</a> (in Japanese).</li><li><a href=\"https://www.jpx.co.jp/corporate/news-releases/0065/20170213-01.html\">Responsible Investment event</a> (in Japanese).</li><li><a href=\"https://www.jpx.co.jp/news/0010/20151106-01.html\">Briefing on methodology for gender specific thematic listings</a> (in Japanese).</li><li>8 March 2019:&#160;<a href=\"https://www.jpx.co.jp/english/corporate/news/monthly-headline/201903.html\">Ceremony and Symposium on the Occasion of International Women's Day.</a></li><li>12 Feb 2019:&#160;<a href=\"https://www.jpx.co.jp/english/corporate/sustainability/news-events/20190212-01.html\">JPX Co-hosted symposium on the TCFD Framework, welcoming Mary Schapiro, Special Advisory to the Chairman of the TCFD.</a></li><li>5 Nov 2018:&#160;<a href=\"https://www.jpx.co.jp/english/corporate/news/news-releases/0010/20181119-01.html\">JPX hosted Mark Carney, Governor of the Bank of England and Chair of the FSB for a discussion with issuers and investors on the FSB's Task Force on Climate-related Financial Disclosures (TCFD)</a></li><li>4 Sept 2018:&#160;<a href=\"https://www.jpx.co.jp/english/corporate/sustainability/news-events/20181015-01.html\">Symposium on responsible business conduct and ESG investment</a></li><li>A list of events co-hosted or supported by JPX can also be found&#160;<a href=\"https://www.jpx.co.jp/english/corporate/sustainability/our-sustainability/partnerships/01.html\">here</a>.</li><li>See also for 2022 activities <a class=\"waffle-rich-text-link\" href=\"https://www.jpx.co.jp/english/corporate/sustainability/esgknowledgehub/index.html\">JPX ESG Knowledge Hub</a> :<ul><li><a class=\"waffle-rich-text-link\" href=\"https://www.jpx.co.jp/corporate/sustainability/esgknowledgehub/practical-disclosure-seminar/index.html\">ESG Information Disclosure Practical Seminar</a> ,</li><li><a class=\"waffle-rich-text-link\" href=\"https://www.jpx.co.jp/english/corporate/sustainability/esgknowledgehub/p1j4l40000000thn-att/p1j4l40000000tlh.pdf\">List of Practical Seminars</a>,</li><li><a class=\"waffle-rich-text-link\" href=\"https://www.jpx.co.jp/corporate/sustainability/esgknowledgehub/esg-seminar/index.html\">Related seminars</a></li></ul></li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.jpx.co.jp/english/markets/indices/jpx-nikkei400/\">&#160;JPX-Nikkei Index 400</a></li><li><a href=\"https://www.jpx.co.jp/english/markets/indices/jpx-nikkei400/01-01.html\">&#160;JPX-Nikkei Mid and Small Cap Index</a></li><li><a href=\"https://www.jpx.co.jp/english/news/1044/20160427-01.html\">JPX/S&P CAPEX&HUMAN CAPITAL INDEX</a>.</li><li>See also <a href=\"https://www.jpx.co.jp/corporate/sustainability/esg-investment/products/index.html\">here</a> (in Japanese)</li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>JPX launched a dedicated<a href=\"https://www.jpx.co.jp/english/equities/products/tpbm/green-and-social-bonds/index.html\"> platform for Green and Social bonds</a> on January 22, 2018.&#160;The platform allows issuers, at their discretion, to post information pertaining to Green and Social bonds, from among those listed on TOKYO PRO-BOND Market. If an issuer wishes to post information pertaining to a bond listed on TOKYO PRO-BOND Market through the platform for Green and Social bonds, the issuer is required to submit to TSE the information about green or social use of proceeds pertaining to said bond, and such information will be posted on the platform. In addition, issuers can post such information as external reviews, continued reporting after bond issuance, and other related information.</li><li>Japan's Environmental Ministry issued Green bond guidelines in 2017,&#160;<a href=\"https://www.env.go.jp/en/policy/economy/gb/guidelines.html\">found here</a>.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.jpx.co.jp/english/derivatives/products/domestic/mothers-futures/index.html\">Mothers,&#160;</a>since 2006.</li></ul>","wom":"No","womt":"No<br>In October 2023, TSE changed its listing rules in line with the targets set out by the Japanese government for the ratio of female executives at Prime Market-listed companies. This requires such companies to “strive to appoint at least one female executive by 2025” and “aim to raise the ratio of female executives to at least 30% by 2030”. For details, see <a href=\"https://www.jpx.co.jp/english/rules-participants/public-comment/detail/d01/20230728-01.html\" target=\"_blank\" rel=\"noopener\">here</a>.","Additional_information":"<ul><li>TSE and the Ministry of Economy, Trade and Industry (METI) annually select listed companies in recognition of outstanding efforts in promoting women empowerment and employee health and productivity.</li><li>TSE operates an infrastructure fund market to facilitate investment in renewable energy facilities and other infrastructure.</li><li><a href=\"https://www.jpx.co.jp/english/corporate/sustainability/index.html\">Sustainability section of the website</a></li><li>List of partners can be found&#160;<a href=\"https://www.jpx.co.jp/english/corporate/sustainability/our-sustainability/partnerships/index.html\">here</a>.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; TSE & OSE demutualized in 2001.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fsa.go.jp/en/\">Financial Services Agency</a>.</li></ul><p>","Regulatory_model":"Strong Exchange SRO Model<p><ul><li>The Financial Instruments and Exchange Act (FIEA) requires financial instruments exchanges to fulfill self-regulatory functions. Japan Exchange Regulation (JPX-R) is a self-regulatory organization established by JPX, to perform self-regulation on behalf of TSE and Osaka Exchange. Independence and fairness of JPX-R is assured by many arrangements, including its organization structure where a majority of board of governors is comprised of outside governors. At the same time, JPX-R can leverage its proximity to the market operators and expertise across corporate group, and this enables JPX-R to respond swiftly to new market developments.</li></ul><p>","About_the_stock_exchange":"Location: Tokyo, Japan.<p><ul><li>JPX offers Japan's most comprehensive integrated market infrastructure, with its business domain covering cash and derivatives market operation, self-regulation, and clearing. Tokyo Stock Exchange is home to more than 3,600 companies and a wide variety of ETP and REIT products, while Osaka Exchange provides highly liquid derivative products. In addition to efficient, stable and transparent market mechanisms offered by two bourses, self-regulation at Japan Exchange Regulation and CCP functions provided by Japan Securities Clearing Corporation also contribute to trust and confidence in its market infrastructure. JPX also drives efforts to enhance corporate value and sustainability, through advancing corporate governance reforms and offering ESG related indices and products. For more information about JPX and JPX subsidiaries:<ul><li>Japan Exchange Group, Inc. <a href=\"https://www.jpx.co.jp/english/corporate/jpx-profile/jpx/index.html\">(Company Profile)</a></li><li>Tokyo Stock Exchange, Inc. (<a href=\"https://www.jpx.co.jp/english/corporate/about-jpx/profile/01.html\">Company Profile</a>)</li><li>Osaka Exchange, Inc. <a href=\"https://www.jpx.co.jp/english/corporate/jpx-profile/ose/index.html\">(Company Profile)</a></li><li>Japan Exchange Regulation <a href=\"https://www.jpx.co.jp/english/corporate/jpx-profile/jpx-r/index.html\">(Company Profile)</a></li><li>Japan Securities Clearing Corporation <a href=\"https://www.jpx.co.jp/english/corporate/index.html\">(About JSCC)</a></li></ul></li></ul>","am":true,"os":false,"nz":true,"VCM":"Yes","CCM":"No","Notes":"The Tokyo Stock Exchange performed trade simulations for the Japanese government supporting the launch of a voluntary ETS.","Source_lnk":"https://www.jpx.co.jp/english/news/2040/20230609-01.html"},{"id":109,"Country":"Jordan","cc":"JO","Name0":"Amman Stock Exchange","Link":"/stock-exchange/ase","Name":"<a href=\"https://www.ase.com.jo/en\">Amman Stock Exchange (ASE)</a>","nlc":167,"dmc":24668.55,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/jordan-amman-stock-exchange.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br>ASE started to issue the sustainability from the year 2020 as integrated into the annual report:<p><a href=\"https://www.exchange.jo/sites/default/files/2021-11/Annual%20Report%202020.pdf\">2020</a></p><p><a href=\"https://www.exchange.jo/sites/default/files/2022-10/Annual%20report%202021.pdf\">2021</a></p>","ESGrr":"Yes","ESGrrt":"Yes<br>ASE has mandatory sustainability reporting as a listing rule for companies listed on ASE20. (<a href=\"https://feas.org/amending-the-directives-for-listing-securities-and-the-directives-of-the-over-the-counter-market-and-approving-the-rules-for-submitting-the-sustainability-report-to-the-ase/\">source</a>)<p><p>See also article <a href=\"https://www.ase.com.jo/en/Legislation/Directives/Listing-Securities-Directives\">9.4 from the Listing Securities Directives</a>.","hwg":"Yes","hwgt":"Yes<br><a href=\"https://ase.com.jo/sites/default/files/2022-10/Guidance%20on%20Sustainability%20Reporting.pdf\">In 2022, ASE published a guidance on ESG</a><p></p>","oert":"Yes","oertt":"Yes<br>In 2021, ASE held <a href=\"https://www.ase.com.jo/en/news/cooperation-United-Nations-Development-Program-UNDP-Amman-Stock-Exchange-ASE-holds-Training\">training for companies listed on the ASE20 index</a>, and held a <a href=\"https://www.ase.com.jo/en/news/ASE-partnership-UNDP-and-UNGC-Jordan-held-roundtable-discussion-importance-sustainability\">roundtable for CEOs and Chairpersons on sustainability.</a><p><p>In 2022, ASE launched the <a href=\"https://www.ase.com.jo/en/news/Launching-Initiative-Corporate-Disclosure-Climate-Change\">Corporate Climate Disclosure Initiative with IFC.</a> More details can also be found <a href=\"https://www.ase.com.jo/en/news/First-Middle-East-Exchange-launches-Corporate-Climate-Change-Disclosure-Initiative\">here</a>.</p><p>In 2023, ASE participated in an event entitle <a href=\"https://www.ase.com.jo/en/news/Amman-Stock-Exchange-Participates-Event-ESG-Sustainability\">“DEMYSTIFYING ESG: What regulated companies and their advisors need to Know”</a><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li>Hosted 3rd annual<a href=\"https://www.exchange.jo/en/ringing-bell-gender-equality-stock-exchange-conference\">&#160;“Ringing Bell for Gender Equality Stock Exchange Initiative”</a>&#160;in March 2017, in cooperation with the IFC, to celebrate Women’s International Day.</li><li>The exchange launched two sustainability brochures in 2018:&#160;<a href=\"https://www.exchange.jo/sites/default/files/2018-11/Sustainability%201_9.pdf\">Sustainability 1</a>&#160;focuses on Sustainable Development and the UN’s Sustainable Development Goals, with information for companies on sustainability reporting and sustainable business practices.&#160;<a href=\"https://www.exchange.jo/sites/default/files/2018-11/Sustainability%202_1.pdf\">Sustainability 2</a>&#160;dives deeper into sustainability reports and reporting frameworks.</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>A for profit public shareholding company completely owned by the government.</li></ul><p>","Regulatory_bodies":"<ul><li>The ASE is governed by a seven-member board of directors appointed by the council of ministers and full-time chief executive officer. The ASE is supervised by the Jordan Securities Commission (JSC).</li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>The Amman Stock Exchange is able to administer and implement its own rules, however the Jordan Securities Commission oversees the activities and rule making of the exchange itself. Thus, although the exchange does indeed possess this self-regulatory ability, the ultimate decision falls upon the Jordan Securities Commission. Because of the level of supervision implemented upon the exchange by the Jordan Securities Commission, the exchange is classified as a ‘Limited Exchange Self-Regulatory Organization (SRO) Model'.</li></ul><p>","About_the_stock_exchange":"Location: Amman, Jordan<p><ul><li>The Amman Stock Exchange (ASE) was established in March 1999 as a non-profit independent institution; authorized to function as a regulated market for trading securities in Jordan. On February 20th 2017, the ASE has been registered as a public shareholding company completely owned by the government under the name “The Amman Stock Exchange Company (ASE Company).” The ASE Company shall be the legal and factual successor to the ASE. The ASE Company is governed by a seven-member board of directors appointed by the Council of Ministers and a full time chief executive officer oversees day-to-day responsibilities. The ASE Company aims to operate, manage and develop the operations and activities of securities, commodities, and derivatives markets inside and outside Jordan. The ASE membership is comprised of Jordan’s 59 brokerage firms.&#160;<a href=\"https://www.ase.com.jo/en/about-ase\">(Source)</a>.</li></ul>","am":true,"os":false,"nz":true,"VCM":"No","CCM":"No","Notes":"Ministry of Environment has developed a national carbon registry focused on monitoring, reporting and verification","Source_lnk":"http://www.moenv.gov.jo/ebv4.0/root_storage/ar/eb_list_page/jordan_a6_policy_framework_draft.pdf"},{"id":110,"Country":"Kazakhstan","cc":"KZ","Name0":"Kazakhstan Stock Exchange","Link":"/stock-exchange/kase","Name":"<a href=\"https://kase.kz/en/\">Kazakhstan Stock Exchange (KASE)</a>","nlc":147,"dmc":65696.92,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Kazakhstan-KASE.pdf\">Yes</a>","asr":"No","asrt":"No<br>","ESGrr":"Yes","ESGrrt":"Yes<br>See <a href=\"https://kase.kz/files/normative_base/rules_emitent_eng.pdf\">Rules for Information Disclosure by Admittance Initiators of securities: Appendix 3 Requirements of the Exchange for the disclosure of information by the issuer in its annual report</a>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://kase.kz/files/normative_base/met_ekolog_soc_eng.pdf\">Methodology on preparing an ESG report</a>, first version released in 2016, updated in 2018 in cooperation with IFC.</li></ul><p>","oert":"Yes","oertt":"Yes<br>Over the past years, KASE together with local and international experts have been holding regular events and trainings to explain and promote ESG information disclosure and green finance among issuers and wide range of local companies.<p><p>In 2021, KASE provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/kazakhstan-kyrgyz-stock-exchanges-tcfd-101-workshop-training/\">source</a>)<p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br>In November 2020 the Asian Development Bank (ADB) issued first green bonds on KASE. To date KASE created infrastructure for the issuance and placement of green, social and other sustainable bonds.&#160;In particular, KASE determined the conditions for listing sustainable bonds, established listing fee incentives.<p>","HSMElp":"Yes","HSMElpt":"Yes<br>The Alternative platform on KASE, in addition to the Main platform, is a separate platform integrated to the systems with a unique structure.&#160; It was based on the international practice of allocating separate platform for securities of small and medium-sized enterprises (SME), as well as establishing requirements for such companies to disclose information only within the limits established by law, more information <a href=\"https://kase.kz/en/future-listing-kase/\">here</a>.<p>","wom":"No","womt":"No","Additional_information":"<ul><li>Attracting international rating and audit companies that have the right to provide an independent assessment (verification) of “green” and other ESG bonds for compliance with international standards</li><li>Since 2018, an annual bell-ringing ceremony has been held in KASE as part of the “Ring the Bell for Gender Equality” global initiative.</li><li>In October 2020, KASE approved its own Sustainable Development Policy</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Private company for profit; demutualized in 1993.</li></ul><p>","Regulatory_bodies":"<ul><li>Agency of the Republic of Kazakhstan for Regulation and Development of the Financial Market (<a href=\"https://www.gov.kz/memleket/entities/ardfm?lang=en\">webpage</a>)</li></ul><p>","Regulatory_model":"Limited Exchange&#160;Self-Regulatory Organization Model<p><ul><li>The National Bank of Kazakhstan is responsible for the regulation of the securities market in Kazakhstan as delegated by the Republic of Kazakhstan National Commission on Securities in 2001. However, by looking at the stock exchange's website it appears that the stock exchange has limited regulatory authority over listing rules and disclosure.</li></ul><p>","About_the_stock_exchange":"<p>Location: Almaty, Kazakhstan</p><ul><li>KASE was founded on November 17, 1993 under the name “Kazakh Interbank Currency Exchange” two days after the introduction of the national currency of Kazakhstan – tenge</li><li>KASE is a commercial organization operating in the organizational and legal form of a joint stock company</li><li>KASE mission: Contribute to the economic growth of Kazakhstan by providing a wide range of tools to attract financing from domestic issuers, providing a platform for redistributing liquidity in the financial system, and providing a transparent investment environment for local and foreign investors</li><li>Today KASE is the universal financial market with established mechanisms for interaction of all participants. It is a trading platform for corporate and government securities, bonds of international financial institutions, foreign currencies, money market operations – repo and swap, as well as derivatives. KASE is a member of the International Federation of Stock Exchanges (WFE), the Federation of Eurasian Stock Exchanges (FEAS) and other international and domestic professional associations, as well as a participant in the UN initiative “Stock Exchanges for Sustainable Development”.</li></ul>","am":true,"os":false,"nz":true,"VCM":"No","CCM":"No","Notes":"Kazakhstan Emissions Trading System. There are plans to introduce alternative carbon regulation tools along with KazETS","Source_lnk":"https://www.undp.org/kazakhstan/press-releases/balanced-carbon-burden-kazakhstan-mobilizes-all-economic-sectors"},{"id":111,"Country":"Kenya","cc":"KE","Name0":"Nairobi Securities Exchange","Link":"/stock-exchange/nse-kenya","Name":"<a href=\"https://www.nse.co.ke/\">Nairobi Securities Exchange (NSE)</a>","nlc":62,"dmc":22915.78,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Kenya-Nairobi-Securities-Exchange.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.nse.co.ke/wp-content/uploads/NSE-Annual-Report-2022-Integrated-Report.pdf\">Yes</a><br>Included in the Integrated Report and Financial Statements. All of the reports can be found <a href=\"https://www.nse.co.ke/annual-reports/\">here</a>.<p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>In its <a href=\"/wp-content/uploads/2021/12/NSE-ESG-Disclosures-Guidance.pdf\"> ESG Guidance</a>, published in 2021, NSE requires ESG reporting for listed companies. More information <a href=\"/all-news/exchange-in-focus-nairobi-securities-exchange-launches-esg-disclosure-guidance-and-mandatory-reporting/\">here</a>.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"/wp-content/uploads/2021/12/NSE-ESG-Disclosures-Guidance.pdf\">Nairobi Securities Exchange ESG Disclosures</a></li></ul><p>","oert":"Yes","oertt":"Yes<br>Nairobi Securities Exchange co-hosted TCFD training in March 2023, in collaboration with the SSE, IFC and CDP. (<a href=\"/sse-event/kenya-tcfd-101-workshop-training/\">source</a>)<p><p>In 2023, NSE held several times courses on ESG-related topics (ESG Masterclass), see the <a href=\"https://www.nse.co.ke/digitalacademy/wp-content/uploads/sites/4/2023/01/2023-Training-Calendar-Final.pdf\">2023 Training Calendar</a><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No<br><ul><li>However, published draft document of The Kenya Green Bond Programme, outlining a way forward for green bonds in Kenya. <a href=\"https://www.nse.co.ke/wp-content/uploads/gbpk-background-document-2.pdf\">(Source)</a>. NSE also has a <a href=\"https://www.nse.co.ke/green-bonds/\">dedicated page on Green Bonds</a>.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.nse.co.ke/growth-enterprise-market-segment/\">NSE Growth and Enterprise Market Segment</a> (Kenya), since 2013.</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li>Part of the UN Global Compact.</li><li>Signed the Code of Ethics for Business in Kenya.</li><li>Promotes the Fire Award, a prestigious award in East Africa for businesses that prioritize integrated ESG reporting in financial reports.</li><li>Participated in “Ring the Bell for Gender Equality” in 2016.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Public listed company. Demutualised. June 2014.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cma.or.ke/\">Capital Markets Authority (CMA)</a>.</li></ul><p>","Regulatory_model":"<ul><li>The NSE is subject to regulation by the CMA. However, from&#160;September 2016, the Exchange will become a Limited Self-Regulatory Organisation.</li></ul><p>","About_the_stock_exchange":"Location: Nairobi, Kenya.<p><p>The Nairobi Securities Exchange (NSE) is a leading African Exchange, based in Kenya – one of the fastest-growing economies in Sub-Saharan Africa. Founded in 1954, NSE has a six decade heritage in listing equity and debt securities. It offers a world class trading facility for local and international investors looking to gain exposure to Kenya and Africa’s economic growth.</p><p>NSE demutualized and self-listed in 2014. Its Board and management team are comprised of some of Africa’s leading capital markets professionals, who are focused on innovation, diversification and operational excellence in the Exchange.</p><p>NSE is playing a vital role in the growth of Kenya’s economy by encouraging savings and investment, as well as helping local and international companies access cost-effective capital. NSE operates under the jurisdiction of the Capital Markets Authority of Kenya. It is a full member of the World Federation of Exchange, a founder member of the&#160;<a href=\"https://african-exchanges.org/\">African Securities Exchanges Association (ASEA)</a> and the East African Securities Exchanges Association (EASEA). The NSE is a member of the Association of Futures Market and is a partner exchange in the United Nations-led SSE initiative. <a href=\"https://www.nse.co.ke/about-nse/\">Source</a>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Climate Change Amendment bill of 2023 has come up to develop and regulate carbon trade in the country. Planning to establish a carbon trading exchange in the country to allow small-scale trade-in credits.","Source_lnk":"https://bowmanslaw.com/insights/energy/what-the-carbon-series-2-kenya-opens-a-path-to-carbon-trading-proposed-climate-change-amendment-bill-2023/ https://www.ncmc.sua.ac.tz/news/regulatory-hurdles-hampering-carbon-trading"},{"id":112,"Country":"Kuwait","cc":"KW","Name0":"Boursa Kuwait","Link":"/stock-exchange/boursa-kuwait","Name":"<a href=\"https://www.boursakuwait.com.kw/\">Boursa Kuwait</a>","nlc":167,"dmc":136620.46,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Kuwait-Boursa-Kuwait.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.boursakuwait.com.kw/api/documents/boursa/1681627414107.pdf\">Yes</a><br><p><a href=\"https://www.boursakuwait.com.kw/api/documents/boursa/1649054880123.pdf\">2021 Sustainability Report</a></p><p></p>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li>ESG Reporting Guide 2021: <a href=\"https://www.boursakuwait.com.kw/api/documents/boursa/1630909195602.pdf\">Unified Direction for a Sustainable Future</a></li><li>Boursa Kuwait produced a&#160;<a href=\"https://cis.boursakuwait.com.kw/Portal/BoursaReports/BKSustainability2017.pdf\">Sustainability Disclosure Guide</a>&#160;in December 2017.</li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li><a href=\"https://cis.boursakuwait.com.kw/Portal/BoursaReports/BKSustainabilityE.pdf\">Sustainability action plan</a>, December 2017</li><li>Group engagement sessions presenting the business case of sustainability and how investors use ESG information.</li><li>Individual engagement sessions with top tier listed issuers to ensure progress on adoption in sustainability reporting.</li><li>Training sessions for senior executives on the business case of sustainability and its implications.</li></ul><p></p>","mcbsri":"No","mcbsrit":"No<br><ul><li>Boursa Kuwait has plans to set an ESG index to further stimulate ESG disclosure among listed issuers.</li></ul><p>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li>Boursa Kuwait has partnered with Sustainability Excellence – a leading provider of sustainability reporting, research, and advisory services in the Middle East – to support Boursa Kuwait and its issuers in their sustainability journey.&#160;<a href=\"https://cis.boursakuwait.com.kw/Portal/BoursaReports/BKSustainabilityE.pdf\">(Source)</a>.</li><li>Through an external service provider, every listed company in the main market has independently received a comprehensive and free ESG assessment of current ESG performance.</li><li>Sustainability is listed as key element within corporate governance framework.</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Unlisted private company for profit - demutualized in October 2016.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cma.gov.kw/en/web/cma\">Capital Markets Authority (Kuwait)</a>.</li></ul><p></p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model</p><ul><li>Boursa Kuwait has a basic level of regulatory authority. However, Capital Markets Authority (Kuwait) is the overall regulator of Boursa Kuwait.</li></ul><p>","About_the_stock_exchange":"<p>Location: Kuwait City, Kuwait</p><ul><li>Boursa Kuwait is the private entity that was established in April 2014 with the aim to manage the exchange and progressively develop Kuwait’s stock market operations, while delivering transparency, efficiency and accessibility.Boursa Kuwait’s strategic approach focuses on the development of investment tools, restructuring the market to increase its competitiveness, working to increase liquidity, and attracting investments.To ensure its successful transition, Boursa Kuwait has brought in a pool of experts and has devised a specific transition strategy. This strategy focuses on ensuring smooth progress as the company’s services expand and on enhancing the overall status of the Kuwait market. It addresses market needs by introducing new products and tools, and upgrading Kuwait Stock Exchange’s infrastructure and business environment to international standards. Through this approach Boursa Kuwait is creating a robust, transparent and fair capital market platform that serves all relevant asset classes, whilst focusing on clients’ interests. For more information on Boursa Kuwait, please click <a href=\"https://www.boursakuwait.com.kw/\">here</a>.</li></ul>","am":true,"os":true,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":113,"Country":"Kyrgyzstan","cc":"KG","Name0":"Kyrgyz Stock Exchange","Link":"/stock-exchange/kse","Name":"<a href=\"https://www.kse.kg/\">Kyrgyz Stock Exchange</a>","nlc":37,"dmc":407.16,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2021/08/Kyrgystan-KSE.pdf\">Yes</a>","asr":"No","asrt":"No<br>","ESGrr":"Yes","ESGrrt":"Yes<br><p><a href=\"https://www.kse.kg/files/upload/24556fd5bf556c06960219cfbecb5d43_ListingRules_old.pdf\">Listing rules, 2014</a> (in Kyrgyz)</p>","hwg":"Yes","hwgt":"Yes<br><p><a href=\"https://www.kse.kg/files/files/ESG_Guide_KSE_en.pdf\">ESG Guide, 2023</a></p><p>","oert":"Yes","oertt":"Yes<br><p>In 2021, the Kyrgyz Stock Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/kazakhstan-kyrgyz-stock-exchanges-tcfd-101-workshop-training/\">source</a>)</p><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><p>See the <a href=\"https://www.kse.kg/en/Sustainable\">sustainability page of the Stock Exchange</a></p><p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<p>Not For Profit</p><p>","Regulatory_bodies":"<p>Board of Directors of KSE - listing requirements; Financial Market Regulatory Board - regulation for the exchange market</p><p>","Regulatory_model":"<p>• Strong exchange SRO</p><p>","About_the_stock_exchange":"<p>Kyrgyz Stock Exchange CJS 172, Moskov Street Bishkek 720010, Kyrgyzstan Borsa Istanbul (16.3%); Kazakhstan Stock Exchange (7.05%); Russian-Kyrgyz Development Fund (5.4%); BNC Finance (5.4%); State Property Fund (4.8%)</p>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":114,"Country":"Latvia","cc":"LV","Name0":"Nasdaq Riga","Link":"/stock-exchange/nasdaq-riga","Name":"<a href=\"https://nasdaqbaltic.com/lv/?lang=lv\">Nasdaq Riga</a>","nlc":22,"dmc":917,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Latvia-Nasdaq-Riga.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li>Sustainability Section on&#160;<a href=\"https://www.nasdaqomx.com/aboutus/sustainability\">Website</a>.</li><li><a href=\"https://business.nasdaq.com/media/2017%20Nasdaq%20Sustainability%20Report%20Digital%20ver%202_tcm5044-50886.pdf\">Sustainability Report 2017.</a></li><li>Corporate Governance section in&#160;<a href=\"https://files.shareholder.com/downloads/NDAQ/6080571804x0x935088/840666D1-613E-4C65-BBC3-F04DC78ABDC3/2017_proxy.pdf\">2017 Annual Report</a>.</li></ul><p>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.nasdaq.com/ESG-Guide\">ESG Report Guide</a> released in March 2017 across Nasdaq's Nordic and Baltic Exchanges.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>Nasdaq Nordic and Baltic exchanges run <a href=\"https://www.nasdaq.com/ESG-Guide\">a pilot program on ESG reporting</a>.</li></ul><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><ul><li>Riga/Tallinn/Vilnius, Nasdaq Baltic Market, June 18, 2018–&#160;<a href=\"https://globenewswire.com/news-release/2018/06/18/1525578/0/en/Nasdaq-Highlights-Sustainable-Bond-Issues-in-the-Baltics.html\">Nasdaq.</a></li></ul><p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://business.nasdaq.com/Docs/Nasdaq%20UNGC%20COP%202014%20RevFinal.pdf\">Nasdaq Progress Report 2014</a>, United Nations Global Compact.</li><li>The Nasdaq speaks, moderates, sponsors, or otherwise exhibits at key industry events related to sustainability.&#160;<a href=\"https://www.nasdaqomx.com/aboutus/sustainability/sustainabilityevents\">(Source).</a></li><li>Nasdaq and CERES’ Investor Network on Climate Risk (INCR) is working with other partners to create an investor-centric sustainability reporting proposal for public companies and stock exchanges.&#160;<a href=\"https://www.ceres.org/press/press-releases/world2019s-largest-investors-launch-effort-to-engage-global-stock-exchanges-on-sustainability-reporting-standard-for-companies\">(Source)</a>.</li><li>Nasdaq had a three-part article series in 2013, called Doing Well by Doing Good.&#160;<a href=\"https://www.nasdaqomx.com/aboutus/sustainability/articles\">(Source)</a>.</li><li>Nasdaq is a member of the United Nations Global Compact and Chair of the WFE Sustainability Working Group.&#160;<a href=\"https://www.unglobalcompact.org/participant/18220-The-NASDAQ-OMX-Group-Inc-\">(Source).</a></li><li>Board Member, US Global Compact US Network; Advisory Board Member, SASB.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in:<ul><li>NASDAQ - 2000</li><li>OMX - 1993</li></ul></li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fktk.lven/\">Latvia - Financial and Capital Market Commission</a>.</li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model.<p><ul><li>Regulatory practices in regards to this exchange vary slightly from country to country. However, the exchanges operated by Nasdaq in each country appear to have basic regulatory oversight. However, the ultimate regulatory authority for each market lies with the regulatory bodies listed.</li></ul><p>","About_the_stock_exchange":"HQ Location: New York, New York.&#160;Nasdaq<p><ul><li>(Nasdaq: NDAQ) is a leading global provider of trading, clearing, exchange technology, listing, information and public company services. Through its diverse portfolio of solutions, Nasdaq enables customers to plan, optimize and execute their business vision with confidence, using proven technologies that provide transparency and insight for navigating today's global capital markets. As the creator of the world's first electronic stock market, its technology powers more than 90 marketplaces in 50 countries, and 1 in 10 of the world's securities transactions. Nasdaq is home to approximately 3,900 total listings with a market value of approximately $13 trillion. To learn more, click <a href=\"https://business.nasdaq.com\">here</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":115,"Country":"Lithuania","cc":"LT","Name0":"Nasdaq Vilnius","Link":"/stock-exchange/nasdaq-vilnius","Name":"<a href=\"https://nasdaqbaltic.com/lt/?lang=lt\">Nasdaq Vilnius</a>","nlc":32,"dmc":5746,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Lithuania-Nasdaq-Vilnius.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li>Sustainability Section on&#160;<a href=\"https://www.nasdaqomx.com/aboutus/sustainability\">Website</a>.</li><li><a href=\"https://business.nasdaq.com/media/2017%20Nasdaq%20Sustainability%20Report%20Digital%20ver%202_tcm5044-50886.pdf\">Sustainability Report 2017.</a></li><li>Corporate Governance section in&#160;<a href=\"https://files.shareholder.com/downloads/NDAQ/6080571804x0x935088/840666D1-613E-4C65-BBC3-F04DC78ABDC3/2017_proxy.pdf\">2017 Annual Report</a>.</li></ul><p></p>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.nasdaq.com/ESG-Guide\">ESG Report Guide</a> released in March 2017 across Nasdaq's Nordic and Baltic Exchanges.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>Nasdaq Nordic and Baltic exchanges run <a href=\"https://www.nasdaq.com/ESG-Guide\">a pilot program on ESG reporting</a>.</li></ul><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><ul><li>Riga/Tallinn/Vilnius, Nasdaq Baltic Market, June 18, 2018–&#160;<a href=\"https://globenewswire.com/news-release/2018/06/18/1525578/0/en/Nasdaq-Highlights-Sustainable-Bond-Issues-in-the-Baltics.html\">Nasdaq</a>.</li></ul><p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://business.nasdaq.com/Docs/Nasdaq%20UNGC%20COP%202014%20RevFinal.pdf\">Nasdaq Progress Report 2014</a>, United Nations Global Compact.</li><li>The Nasdaq speaks, moderates, sponsors, or otherwise exhibits at key industry events related to sustainability.&#160;<a href=\"https://www.nasdaqomx.com/aboutus/sustainability/sustainabilityevents\">(Source).</a></li><li>Nasdaq and CERES’ Investor Network on Climate Risk (INCR) is working with other partners to create an investor-centric sustainability reporting proposal for public companies and stock exchanges.&#160;<a href=\"https://www.ceres.org/press/press-releases/world2019s-largest-investors-launch-effort-to-engage-global-stock-exchanges-on-sustainability-reporting-standard-for-companies\">(Source).</a></li><li>Nasdaq had a three-part article series in 2013, called Doing Well by Doing Good.&#160;<a href=\"https://www.nasdaqomx.com/aboutus/sustainability/articles\">(Source).</a></li><li>Nasdaq is a member of the United Nations Global Compact and Chair of the WFE Sustainability Working Group.&#160;<a href=\"https://www.unglobalcompact.org/participant/18220-The-NASDAQ-OMX-Group-Inc-\">(Source).</a></li><li>Board Member, US Global Compact US Network; Advisory Board Member, SASB.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in:<ul><li>NASDAQ - 2000</li><li>OMX - 1993</li></ul></li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.lb.lt/en_index.htm\">Lithuania - Bank of Lithuania</a>.</li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model.<p><ul><li>Regulatory practices in regards to this exchange vary slightly from country to country. However, the exchanges operated by Nasdaq in each country appear to have basic regulatory oversight. However, the ultimate regulatory authority for each market lies with the regulatory bodies listed.</li></ul><p>","About_the_stock_exchange":"HQ Location: New York, New York.<ul><li>Nasdaq (Nasdaq: NDAQ) is a leading global provider of trading, clearing, exchange technology, listing, information and public company services. Through its diverse portfolio of solutions, Nasdaq enables customers to plan, optimize and execute their business vision with confidence, using proven technologies that provide transparency and insight for navigating today's global capital markets. As the creator of the world's first electronic stock market, its technology powers more than 90 marketplaces in 50 countries, and 1 in 10 of the world's securities transactions. Nasdaq is home to approximately 3,900 total listings with a market value of approximately $13 trillion. To learn more, click <a href=\"https://business.nasdaq.com\">here</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":116,"Country":"Luxembourg","cc":"LU","Name0":"Bourse de Luxembourg","Link":"/stock-exchange/luxse","Name":"<a href=\"https://www.bourse.lu/home\">Bourse de Luxembourg (Luxembourg Stock Exchange)</a>","nlc":120,"dmc":47365,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Luxembourg-Luxembourg-Stock-Exchange.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li>All LuxSE CSR related information and news, including latest sustainability report, can be found&#160;<a href=\"https://www.bourse.lu/csr\" rel=\"noopener noreferrer\" data-saferedirecturl=\"https://www.google.com/url?q=https://secure-web.cisco.com/1rP0xXEYR4YEiKcy5_0lIa7Zo2evkcMc6QG_tJVc6QwJWM0itr3h9Vf9D0CPjn1RjNNiQjNTwTyr3UQlH1jHJcPTWByAMCphHvxDh-lOjhYgrULKx40VCYk5PCe606deBttWCJKGfUa1VuA_gfvKcuoVpbOPRe-tB9N5oEMD2qLju-4dMf_VYNrOgn-2OYdh8ejeZdwKM1k6gWpB-MugCvKdPez4GWlPv30eyIXreieWJYcCdw72mQLKoEpycw8ju/https%253A%252F%252Fwww.bourse.lu%252Fcsr&source=gmail&ust=1601646569597000&usg=AFQjCNEardjdmiSPXHylE6ZTFsxw3U5DHw\">here</a>.</li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>LuxSE’s <a href=\"https://www.bourse.lu/corporate-governance\">X Principles of Corporate Governance</a> requires listed companies to develop, implement, and report on their CSR policies.</li></ul>","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><ul><li>In May 2020, LuxSE established the LGX Academy to strengthen sustainable finance knowledge among financial professionals, market participants, law firms, professional services firms, public authorities, students and other groups, and has since trained hundreds of professionals from different countries, including emerging markets.</li><li>Through the LGX Academy, LuxSE’s team of sustainable finance experts provides courses for participants of all levels on the fundamentals of sustainable finance, sustainable products & standards, the sustainable bond ecosystem and in 2023, it launched a brand new module dedicated to gender finance. More <a href=\"https://www.luxse.com/discover-lgx/additional-lgx-services/lgx-academy\">here</a>.</li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.bourse.lu/documents/brochure-TRADING-indices-LuxRI_fund_index.pdf\">Lux RI Fund Index</a>&#160;measures the overall performance of a basket of responsible investing funds in Luxembourg.</li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br>LuxSE created the Luxembourg Green Exchange (LGX) in 2016 as a contribution to the Paris Agreement and the UN SDGs. LGX is the world’s leading platform dedicated exclusively to sustainable securities, and its mission is to facilitate sustainable investment and help mobilise and redirect capital flows towards sustainable development projects. As of June 2023, LGX displays 1,700+ green, social, sustainability and sustainability-linked bonds from 278 issuers in 56 countries, raising a total of EUR 918+ billion for specific green and social investments and sustainable development across the world. More <a href=\"https://www.luxse.com/discover-lgx/sustainable-securities-on-lgx\">here</a>.<p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.bourse.lu/documents/brochure-LISTING-euro_mtf.pdf\">Euro MTF</a>, since 2005.</li></ul><p></p>","wom":"No","womt":"No","Additional_information":"In 2020, LuxSE increased the scope of its services in the field of sustainable finance to include education and data.<p><p>In September 2020, LuxSE launched the LGX DataHub, a centralised database of structured sustainability data now covering 11,000 green, social, sustainability and sustainability-linked bonds listed worldwide. The LGX DataHub allows investors and asset managers to better understand and compare the environmental and social impact of different securities and thereby make more informed and sustainable investment decisions.&#160;&#160;</p><p>In 2022, LuxSE entered into an MoU with UN Women to advance gender finance and has since flagged gender-focused bonds on LGX to make it easier for investors to identify debt instruments which contribute to women’s empowerment and gender equality objectives. <p>","Organizational_model_of_stock_exchange":"<ul><li>Private company for profit.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cssf.lu/en/\">Commission de Surveillance du Secteur Financier (CSSF).</a></li><li><a href=\"https://www.esma.europa.eu/\">European Securities and Markets Authority (ESMA).</a></li></ul><p></p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li style=\"font-weight:400;\" aria-level=\"1\">Due to the involvement of the CSSF and the European Union, LuxSE wields relatively little regulatory power. LuxSE has the power to set rules for the companies listed on the exchange, but ultimate authority falls upon the CSSF and general laws and regulations established by the European Union.</li></ul><p>","About_the_stock_exchange":"Location: Luxembourg<ul><li aria-level=\"1\" style=\"font-weight:400;\">LuxSE is an independent exchange and the world’s leading listing venue for the listing of international debt securities.&#160;</li></ul><p>With more than 41,000 listed securities, including 37,000 debt instruments, from 1,800 issuers in 100 countries, LuxSE has a global footprint and is recognised by issuers across the world as a gateway to the international investor community.&#160;</p><p>A renowned market infrastructure provider, LuxSE has contributed to the development of international capital markets for the past 60 years. LuxSE offers a unique and integrated service offering covering listing, trading and information services.</p><p>To know more, go to <a href=\"http://www.luxse.com\">http://www.luxse.com</a></p>","am":true,"os":true,"nz":true,"VCM":"No","CCM":"No","Notes":"","Source_lnk":"https://www.luxse.com/discover-lgx"},{"id":117,"Country":"Malaysia","cc":"MY","Name0":"Bursa Malaysia","Link":"/stock-exchange/bursa-malaysia","Name":"<a href=\"https://www.bursamalaysia.com/market/\">Bursa Malaysia (Malaysian Exchange)</a>","nlc":976,"dmc":370837.5,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/malaysia-bursamalaysia.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.bursamalaysia.com/sites/5d809dcf39fba22790cad230/assets/640ad76039fba203314fc5a2/Bursa_SR22_Hi_Res_.pdf\">Yes</a><br><ul><li>Bursa Malaysia has several years’ worth of standalone sustainability reports available on its&#160;<a href=\"https://www.bursamalaysia.com/about_bursa/sustainability/sustainability_reports\">website</a>.</li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>In October 2015, Bursa Malaysia issued amendments to the&#160;Main Market Listing Requirements&#160;(“Main LR”) and&#160;ACE Market Listing Requirements&#160;(“ACE LR”) (collectively referred to as the “LR”) relating to sustainability statements in annual reports (“Sustainability Amendments”). Under the Sustainability Amendments, listed issuers are required to disclose a narrative statement of the management of material economic, environmental and social (“EES”) risks and opportunities (“Sustainability Statement”) in their annual reports. This replaces the existing statement on the corporate social responsibility (“CSR”) activities or practices required to be disclosed by listed issuers. For the Main Market listed issuers, they are also required to include in their Sustainability Statement, the prescribed information as set out in Practice Note 9 of the Main LR such as the governance structure, the scope of the Sustainability Statement and the management of material EES risks and opportunities (“material sustainability matters”). The prescribed disclosure is not applicable to ACE Market listed corporations given the type and size of the listed corporations. In addition to the above, the LR also encourages all listed issuers to refer to the Sustainability Reporting Guide (described below) as a best practice when preparing the Sustainability Statement and in identifying material sustainability matters. The Sustainability Amendments take effect on a staggered basis over a period of 3 years, starting from 31 December 2016 to 31 December 2018.</li><li>For more details refer to&#160;<a href=\"https://www.bursamalaysia.com/sites/5bb54be15f36ca0af339077a/content_entry5ce3b50239fba2627b2864be/5ce3b5b939fba26395e738a1/files/MAIN_Chap9_COI_Ors_Amendments_1July2023_.pdf?1688122449\">Chapter 9 of the Main Market Listing Requirements</a> and to <a href=\"https://www.bursamalaysia.com/sites/5bb54be15f36ca0af339077a/content_entry5ce3b50239fba2627b2864be/5ce3ba6139fba262ff56e9ad/files/ACE_Chap9_COI_Ors_Amendments_1July2023_.pdf?1688122493\">Chapter 9 of the ACE Market Listing Requirements</a></li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>The Sustainability Reporting Guide (3rd Edition) can be found <a href=\"https://bursasustain.bursamalaysia.com/droplet-details/resources/sustainability-reporting-guide-3rd-edition\">here</a>.</li><li>More resources are available <a href=\"https://bursasustain.bursamalaysia.com/pillar-details/resources\">here</a>.</li></ul><p></p>","oert":"Yes","oertt":"Yes<br>In 2022, Bursa Malaysia provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/malaysia-tcfd-101-workshop-training/\">source</a>)<p><p>Bursa Malaysia provides an e-learning course <a href=\"https://bursasustain.bursamalaysia.com/droplet-details/e-learning/introduction-to-sustainability\">“Introduction to Sustainability”</a></p><p>See also past event on ESG-related topics <a href=\"https://bursasustain.bursamalaysia.com/pillar-details/events\">here</a>.<p></p>","mcbsri":"Yes","mcbsrit":"Yes<br>FTSE4Good Bursa Malaysia Index, FTSE4Good Bursa Malaysia Shariah Index, FTSE Bursa Malaysia Top 100 ESG Low Carbon Select Index, FTSE Bursa Malaysia Top 100 ESG Low Carbon Select Shariah Index. <a href=\"https://www.bursamalaysia.com/trade/our_products_services/indices/ftse_bursa_malaysia_indices/overview\">Source</a><p></p>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.bursamalaysia.com/trade/market/securities_market/ace_market\">ACE Market</a></li><li><a href=\"https://www.bursamalaysia.com/trade/market/securities_market/leap_market\">LEAP&#160;</a></li><li>since 2009.</li></ul><p></p>","wom":"Yes","womt":"Yes<br><a href=\"https://www.bursamalaysia.com/bm/about_bursa/media_centre/bursa-malaysia-applauds-progressive-plcs-for-embracing-board-gender-diversity-and-censures-plcs-with-all-male-boards#:~:text=For%20instance%2c%20the%20revised%20Malaysian%2cat%20least%2030%25%20women%20directors.\" target=\"_blank\" rel=\"noopener\">Busa Malaysia had announced the requirement for PLCs with market capitalisation of RM2 billion as at 31 December 2021, to appoint at least one woman Board member by 1 September 2022. For the remaining PLCs, the requirement must be complied with by 1 June 2023.</a><br>See also Bursa Malaysia Listing Requirements on Corporate Governance <a href=\"https://www.bursamalaysia.com/sites/5bb54be15f36ca0af339077a/content_entry5ce3b50239fba2627b2864be/5ce3b5ce5b711a163beae1bd/files/MAIN_Chap15_COI_Ors_Amendments_1July2023_.pdf?1688122456\" target=\"_blank\" rel=\"noopener\">here.</a><p>According to the Malaysian Code on Corporate Governance 2027, p.24, “For Large Companies, the board must have at least 30% women directors.” (<a href=\"https://www.sc.com.my/api/documentms/download.ashx?id=4d1f5610-cf41-455c-9c20-21fa4c310f46\" target=\"_blank\" rel=\"noopener\">source</a>)</p>","Additional_information":"<ul><li>Bursa Malaysia launched on April 24, 2018&#160;<a href=\"https://bursasustain.bursamalaysia.com/\">BURSASUSTAIN</a>, a one-stop portal on corporate governance and sustainability. It provides users (i.e. listed issuers, investors and other stakeholders) with ease of access to current information on corporate governance, sustainability as well as responsible investment.</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2004.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.sc.com.my/\">Securities Commission</a>.</li></ul><p></p>","Regulatory_model":"Strong Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>Bursa Malaysia is an exchange holding company approved under section 15 of the Capital Markets and Services Act 2007 by the Securities Commission (“SC”) being the primary regulator of the capital market. Bursa Malaysia is the frontline regulator and has the duty to maintain a fair and orderly market in the securities and derivatives that are traded through its facilities. In this regard, Bursa Malaysia has put in place a comprehensive and effective regulatory and supervisory framework to regulate the market, its participants and listed issuers. In this respect, Bursa Malaysia has issued various sets of rules to stipulate the requirements that need to be met by the regulated entities either upon admission and/or on a continuing basis. It administers and monitors compliance with these rules and takes strict, prompt and objective enforcement action for breaches of these rules. Bursa Malaysia actively supervises the listed issuers and the participants. It also undertakes surveillance over the trading activities in the marketplace. The SC supervises and monitors Bursa Malaysia to ensure that Bursa Malaysia performs its regulatory duties and obligations in an effective manner. Under the law, the SC's approval is required for changes to Bursa Malaysia’s rules.</li></ul><p>","About_the_stock_exchange":"Location: Kuala Lumpur, Malaysia.<ul><li>Established in 1973, Bursa Malaysia demutualised and became an exchange holding company in 2004, and subsequently listed on Bursa Malaysia Securities Berhad (MYX: 1818) in 2005. Today, it is one of the largest bourses in Asia, hosting more than 900 public listed companies across 60 economic activities. We operate and regulate a fully integrated exchange offering a comprehensive range of exchange-related facilities including listing, trading, clearing, settlement and depository services. We offer a diverse spread of products covering equities, derivatives, offshore listings and services and bonds and Islamic offerings. In assisting the development of the Malaysian capital market, Bursa Malaysia is committed to provide the infrastructure needed to create a globally competitive and vibrant marketplace.&#160;<a href=\"https://www.bursamalaysia.com/corporate/about-us/\">(Source)</a>.</li></ul>","am":true,"os":true,"nz":true,"VCM":"Yes","CCM":"No","Notes":"Facilitates the trading of physical credits.","Source_lnk":""},{"id":118,"Country":"Malta","cc":"MT","Name0":"Malta Stock Exchange","Link":"/stock-exchange/borzamalta","Name":"<a href=\"https://www.borzamalta.com.mt/\">Malta Stock Exchange</a>","nlc":112,"dmc":16451.3,"SSEPE":"No","SSEPEt":"No","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br>A seminar on Sustainable Finance was recently held with the theme “Financing the Transition”, which was part of the #ClimateOn campaign. (<a href=\"https://www.borzamalta.com.mt/news-and-articles/articles/climateon\">Source</a>)<p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br>In 2021, Malta Stock Exchange introduced the ‘Malta Stock Exchange: Green Marke' (<a href=\"https://www2.deloitte.com/mt/en/pages/financial-services/articles/alerts/2021/mt-fsi-alert-21-01-malta-stock-exchange-introduces-the-green-market.html\">Source</a>)<p>","HSMElp":"Yes","HSMElpt":"Yes<br>MSE Alternative Companies List (Malta), since 1999. (EU Regulated Market) Prospects MTF (Exchange Regulated) (<a href=\"https://www.borzamalta.com.mt/markets/prospects-mtf\">source</a>)<p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>100% Government owned</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://mfsa.com.mt/\">Malta Financial Services Authority.</a></li></ul><p>","Regulatory_model":"Government (Statutory) Model<p><ul><li>The MFSA is the only regulator in Malta and is a public institution that reports to the Maltese government. The Malta Stock Exchange does not appear to have any regulatory authority.</li></ul><p>","About_the_stock_exchange":"Location: Valetta, Malta<p><ul><li>The Malta Stock Exchange (MSE) provides a structure for admission of financial instruments to its recognised lists which may subsequently be traded on a regulated, transparent and orderly secondary marketplace. It also offers a comprehensive<br>nge of back–office services including maintenance of share and bond registers, clearing and settlement and custody services through its in-house Central Securities Depository. Access to the market may be achieved through admission to listing on the Regulated Main Market, or the Institutional Financial Securities Market (IFSM), both of which are<br>egulated by the MFSA and enjoy full passporting rights within the EU. Alternatively, admission to the Malta Stock Exchange is possible the MSE’s SME-oriented market, Prospects MTF, which is regulated by the MSE itself. The MSE has always been very keen to promote financial literacy in Malta. For this reason, it has set up the Malta Stock Exchange which runs a number of short courses aimed at candidates with different knowledge and financial literacy levels. In the current COVID-19 situation the courses are running online, and an updated schedule of the courses is available on the MSE website: <a href=\"https://www.borzamalta.com.mt/\">www.borzamalta.com.mt/</a></li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":119,"Country":"Mauritius","cc":"MU","Name0":"Stock Exchange of Mauritius","Link":"/stock-exchange/mauritius","Name":"<a href=\"https://www.stockexchangeofmauritius.com/\">Stock Exchange of Mauritius</a>","nlc":95,"dmc":8933.78,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Mauritius-MauritiusStockExchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.stockexchangeofmauritius.com/products-market-data/indices/semsi\">The SEM Sustainability Index (SEMSI)</a></li></ul><p>","hsbls":"No","hsblst":"No<br><ul><li>Currently spear-heading a project based on capacity-building for the development of a Green Bonds Market in Mauritius.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.stockexchangeofmauritius.com/downloads/publications/brochure_dem.pdf\">SEMDEM Development & Enterprise Market</a> (Mauritius), since 2006.</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Public company; demutualized in 2000.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fscmauritius.org/en\">Financial Services Commission of Mauritius.</a></li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>Under the Securities Act 2005, the Financial Services Commission is responsible for monitoring the operations of the stock exchange. However, the Stock Exchange of Mauritius has full regulation over listing requirements, compliance and market supervision.</li></ul><p>","About_the_stock_exchange":"Location: Port Louis, Republic of Mauritius.<p><ul><li>The Stock Exchange of Mauritius Ltd (SEM) is a multi-asset class internationalised Exchange which lists a variety of products. In the years to come, the split of listings on SEM is expected to consist of more international funds, international issuers, specialised debt instruments, Africa-based ventures, mineral companies a broader range of ETFs and structured products. The SEM has a multi-currency capital-raising, listing , trading and settlement platform and is the only Exchange in Africa that can list and trade products in USD, Euro, GBP and ZAR. The SEM also aspires to become a centre of attraction for regional and global capital. SEM is today a full-fledged member of the World Federation of Exchanges (WFE) and has been awarded for the second consecutive year in 2012, the “Most Innovative African Stock Exchange of the Year Award”.&#160;&#160;<a href=\"https://www.stockexchangeofmauritius.com/sem-at-a-glance\">(Source).</a></li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":120,"Country":"Mexico","cc":"MX","Name0":"Bolsa Institucional de Valores (BIVA)","Link":"/stock-exchange/biva","Name":"<a href=\"https://www.biva.mx/\">Bolsa Institucional de Valores (BIVA)</a>","nlc":64,"dmc":17300,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/biva-commitment-letter-sse-antonio-guterres.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br><ul><li>Developing ESG reporting guide for SME issuers</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>BIVA institute provides training in Impact Investment, Sustainable Finance, Socially Responsible Investments, Gender Focus Investment. More <a href=\"https://www.biva.mx/instituto_biva/cursos\">here</a>.</li><li>BIVA co-launched the Institute of Sustainable Finance (IFS), an initiative of the Advisory Council for Green Finance (CCFV), which is aimed at the training of professionals, responding to the market need for the incorporation of human capital ready to make decisions within a new investment paradigm. More <a href=\"/sites/sseinitiative/files/documents/200506-lanzamiento-del-instituto-de-finanzas-sostenibles-1.pdf\">here</a> (Spanish).</li><li>In 2022, BIVA provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/mexico-tcfd-101-workshop-training/\">source</a>)</li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li>The <a href=\"https://research.ftserussell.com/Analytics/FactSheets/temp/f66c8c98-fbc1-46d3-b99c-896d3ed78ffd.pdf\">FTSE4Good BIVA Index</a> has been designed to measure the performance of liquid Mexican companies demonstrating strong Environmental, Social and Governance (ESG) practices.</li></ul><p></p>","hsbls":"No","hsblst":"No<br><ul><li>Since its operations started in 2018, 19 labeled bonds have been issued through BIVA, in terms of social matters, gender, sustainability, agriculture, among others, an amount of around $47,000,000,000 has been placed.</li><li>BIVA offers support to all listing companies and guides them in the process to comply with the requirements to be considered a Sustainable Bond.</li></ul><p>","HSMElp":"No","HSMElpt":"No<br><ul><li>BIVA promotes SME listings through our 360° Model, a service given to companies before, during, and after being listed.</li></ul><p>","wom":"No","womt":"No<br>Awaiting market regulator's authorization, BIVA proposed to include in its internal regulations applicable to issuers, the delivery of a questionnaire related to information on gender equality, in regards to requests for stock listing , long-term debt and annually for its maintenance. The information included in the questionnaire is set to be disclosed starting on 2026 with information from 2025.","Additional_information":"","Organizational_model_of_stock_exchange":"<p>Not listed</p><p>","Regulatory_bodies":"<ul><li>Mexican Banking and Securities Commission (Comisión Nacional Bancaria y de Valores)</li></ul><p>","Regulatory_model":"<p>Regulatory model Multilateral Traiding Facility (MTF)</p>","About_the_stock_exchange":"BIVA is part of Central de Corretajes S.A.P.I. of C.V. (CENCOR) (1988), is a Mexican company with more than 25 years of experience that manages a group of companies dedicated to the development of infrastructure of financial markets in Mexico, USA and Latin America. In February 2013,&#160;CENCOR&#160;submitted the project to create a new stock exchange to the Mexican financial authorities. In October 2015,&#160;CENCOR&#160;formally applied for a concession to organize and operate the Bolsa Institucional de Valores BIVA, which was granted in August 2017. After this delivery, BIVA began operations on July 25, 2018 under the Financial Reform, implemented to promote competition in the sector. We have technology supplied by Nasdaq, a global leader in trading and surveillance platforms. More details about BIVA <a href=\"https://biva.mx/en/web/portal-biva\">here</a>.","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":121,"Country":"Mexico","cc":"MX","Name0":"Bolsa Mexicana de Valores (Mexican Stock Exchange)","Link":"/stock-exchange/bmv","Name":"<a href=\"https://www.bmv.com.mx/\">Bolsa Mexicana de Valores (Mexican Stock Exchange)</a>","nlc":144,"dmc":459707.62,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/mexico-bvm.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.bmv.com.mx/en/investor-relations/sustainability-report\">Yes</a><br>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li>Detailed <a href=\"https://www.bmv.com.mx/docs-pub/SERVICIOS_EMISORAS/3q2wk7r8jj6746k46q1n.pdf\">sustainability guide</a> launched in 2017</li><li><a href=\"/sites/sseinitiative/files/documents/codigo_de_mejores_practicas_corporativas_cce_2010-1.pdf\">Best Practice Corporate Governance Code</a>&#160;(in Spanish)</li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>Offers&#160;<a href=\"https://www.bmv.com.mx/es/escuela-bolsa-mexicana/cursos\">diplomas</a>&#160;in corporate governance and climate finance.</li><li>In 2022, Bolsa Mexicana de Valores provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/mexico-tcfd-101-workshop-training/\">source</a>)</li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://us.spindices.com/indices/equity/sp-bmv-total-mexico-esg-index#overview\">S&P/BMV Total Mexico ESG Index</a>, more details in <a href=\"/all-news/exchange-in-focus-bmv-launches-a-new-esg-index/\">English</a> and <a href=\"https://blog.bmv.com.mx/2020/06/22/lanzamiento-de-nuestro-nuevo-indice-esg-sp-bmv-total-mexico-esg-index/#more-5124\">Spanish</a>.</li><li>ISRS Sustainability Index:&#160;<a href=\"https://www.bmv.com.mx/en/Grupo_BMV/Mercado_responsabilidad_social#.VbjCo_mqpBc\">Índice IPC Sustentable (ISRS)</a>.</li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>10 labeled bonds have been issued in Mexico, 4 of which were Sustainable Bonds with a special designation in their ticker symbol.</li><li>Developed&#160;<a href=\"https://www.bmv.com.mx/docs-pub/MI_EMPRESA_EN_BOLSA/CTEN_MINGE/GREEN_BONDS_PRIN_MX2.pdf\">Green Bonds Principles MX</a>&#160;along with Climate Finance Advisory Group (CCFC) in 2017.</li></ul><p></p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li>Social responsibility section on&#160;<a href=\"https://www.bmv.com.mx/en/Grupo_BMV/Mercado_responsabilidad_social#.VbjCo_mqpBc\">website</a></li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2008</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cnbv.gob.mx/Paginas/default.aspx\">Comision Nacional Bancaria de Valores&#160;(CNBV)</a></li></ul><p></p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model</p><ul><li>The Bolsa Mexicana de Valores does not require the Comision Nacional Bancaria de Valores' (CNBV) permission to install regulations. However, the CNBV has the authority to veto any installed regulations, remove officers or directors and revoke the self-regulatory status of the exchange. Additionally, exchanges must report to the CNBV on their adherence to any imposed self-regulatory practices.</li></ul><p>","About_the_stock_exchange":"<p>Location: Mexico City, Mexico</p><ul><li>BMV Group is a fully integrated Exchange Group that operates cash, listed derivatives and OTC markets for multiple asset classes, including equities, fixed income and exchange traded funds, as well as custody, clearing and settlement facilities and data products for the local and international financial community. BMV is the second largest stock exchange in Latin America with a total market capitalization of over US$ 530 billion. (<a href=\"https://www.bmv.com.mx/en/bmv-group/about-us\">More here</a>)</li></ul>","am":true,"os":false,"nz":true,"VCM":"Yes","CCM":"Yes","Notes":"MÉXICO2 (The Mexican Carbon Platform), which forms part of the Mexican Stock Exchange Group and Environmental Defense Fund (EDF) with funding from the World Bank, was established to trade carbon credits for voluntary purposes and for compliance with Mexico’s national carbon tax.","Source_lnk":"https://www.mexico2.com.mx/ https://icapcarbonaction.com/en/ets/mexico https://www.mexico2.com.mx/uploadsmexico/file/Reporte%20General%20Final%20SIM%203%20(ENG).pdf"},{"id":122,"Country":"Mongolia","cc":"MN","Name0":"Mongolian Stock Exchange","Link":"/stock-exchange/mse-mongolia","Name":"<a href=\"https://www.mse.mn/mn\">Mongolian Stock Exchange</a>","nlc":386,"dmc":1840,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Mongolia-Mongolian-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br><ul><li>However, as of February 2018, the MSE allows certain exemptions from some listing rules as well as a 20% discount on listing fees to any company that is implementing the SDGs.</li></ul>","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>State-owned for-profit organization.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.frc.mn/en/\">Financial Regulatory Commission.</a></li></ul><p>","Regulatory_model":"<ul><li>Specialized government body.</li></ul><p>","About_the_stock_exchange":"Location: Ulaanbaatar, Mongolia.<ul><li>The MSE was established in January 1991 in order to implement state privatization during the country’s transition to market economy from a planned economy. The secondary market trading started in 1995. MSE currently has 58 members, from whom 24 companies hold underwriting licenses. Main products are equities, government bonds and corporate bonds. Main market index is TOP-20, consisting of the top 20 companies by market capitalization and turnover. More information can be found&#160;<a href=\"https://www.mse.mn/en/content/list/6\">here</a>.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":"https://www.mse.mn/en"},{"id":123,"Country":"Mongolia","cc":"MN","Name0":"Ulaanbaatar Securities Exchange","Link":"/stock-exchange/ubx","Name":"<a href=\"https://ubx.mn/mn/\">Ulaanbaatar Securities Exchange</a>","nlc":1,"dmc":1258,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Mongolia-Mongol-Securities-ExchangeMSX.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br><ul><li>However, has committed to amend UBX listing requirements reflecting ESG reporting requirements.</li></ul><p></p>","hwg":"No","hwgt":"No<br><ul><li>However, guidance is currently being developed.</li></ul><p>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No<br><ul><li>However,&#160;UBX offers a development board for SMEs and they can be listed on the main board once they meet the main board requirements.</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li>UBX has been committed to promoting sustainable development and long-term sustainable investment. The exchange also has additional requirements for mining and infrastructure companies and require them to submit reports written and signed by Competent Persons complying with global standard codes.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Privately-owned exchange.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.frc.mn/en/\">Financial Regulatory Commission of Mongolia</a>.</li></ul><p>","Regulatory_model":"Limited exchange Self-Regulatory Organisation (SRO)<p><ul><li>UBX is a recognized exchange under the Securities Market Law of Mongolia and has acquired trading and clearing licenses from FRC. The regulatory body, FRC, performs a lead role in market regulation and approves the exchange rules. The exchange is responsible for supervising trading activities to ensure a transparent, fair & orderly market within the framework of applicable rules & regulations.</li></ul><p>","About_the_stock_exchange":"Location: Ulaanbaatar, Mongolia<p><ul><li>UBX is the only private-owned for profit stock exchange in Mongolia, and has developed its’ rules and regulations reflecting global standards and benchmarks. The Exchange has introduced several concepts to the Mongolian capital market for the first time, including market makers, compliance advisors, different market systems and clearing process. UBX aims to be an exchange with a world-leading platform which meets investors’ demand, and to gradually develop the better stock market for the benefit of all, reaching global benchmarks.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Plan to establish carbon registry/trading platform","Source_lnk":"https://www.iges.or.jp/sites/default/files/inline-files/5_P3_S1-1-4_%5BFinal%5D%20Mongolia.Sukhragchaa.2023.pdf"},{"id":124,"Country":"Morocco","cc":"MA","Name0":"Bourse de Casablanca","Link":"/stock-exchange/casablanca_bourse","Name":"<a href=\"https://www.casablanca-bourse.com/bourseweb/en/index.aspx\">Bourse de Casablanca (Casablanca Stock Exchange)</a>","nlc":76,"dmc":76293.28,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/morocco-casablancaexchange.pdf\">Yes</a>","asr":"No","asrt":"No<br><ul><li>Annual Report contains a few highlights in the area of sustainability.</li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li><a href=\"https://www.ammc.ma/sites/default/files/Circulaire%20AMMC%20n%C2%B0%2003-19%20_op%C3%A9rations_%20et%20_informations_%20financi%C3%A8res.pdf\"> AMMC Circular No. 03/19, Chapitre II. Gouvernance, deontologie et rapport <>. Section 3: Rapport ESG </a></li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>Released&#160;<a href=\"https://www.casablanca-bourse.com/BourseWeb/UserFiles/File/2017/Mai/Guide%20RSEESGVersion%20soumise%20consultation.pdf\">Guide sur la Responsabilité Sociétale des Entreprises et le reporting ESG</a>&#160;(in French) on CSR and ESG reporting in May 2017, in conjunction with the AMMC.</li></ul><p></p>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No<br><ul><li>Organized the&#160;<a href=\"https://www.casablanca-bourse.com/BourseWeb/UserFiles/File/rapports_annuels/2016/Rapport_Annue_%20UK_2016_site.pdf\">Marrakech Pledge for Fostering Green Capital Markets</a>&#160;during COP22 in September 2016.</li><li>Partnered with the Moroccan Capital Markets Authority and the SSE in a conference during COP22, titled “Encouraging green capital markets in the South.”</li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.casablanca-bourse.com/bourseweb/en/content.aspx?IdLink=233&Cat=5\">Development Market</a>.</li></ul><p></p>","wom":"Yes","womt":"Yes<br><ul><li>There is a 30% mandatory minimum rule for women on boards (<a href=\"https://www.moroccoworldnews.com/2021/09/344635/un-women-congratulates-morocco-on-efforts-to-achieve-gender-equality\" target=\"_blank\" rel=\"noopener\">Source</a>)</li></ul>","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Private company for profit.</li></ul><p>","Regulatory_bodies":"<ul><li>The Conseil Deontologique des Valeurs Mobilières (CDVM).</li></ul><p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model</p><ul><li>Very few exchanges in the MENA region are entirely self-regulated. The Conseil Deontologique des Valeurs Mobilières (CDVM) is the primary regulatory authority in Morocco and is responsible for issuing listing requirements and overseeing the Casablanca Stock Exchange. Additionally, most regulatory laws adhered to in Morocco have come by royal decree. As a result, the Casablanca Stock Exchange has limited regulatory power.</li></ul><p>","About_the_stock_exchange":"<p>Location: Casablanca, Morocco</p><ul><li>The Casablanca Stock Exchange was established in 1929. At that time, it was known as the “Office de Compensation des Valeurs Mobilières” (Office for Clearing of Transferable Securities). The growing importance of the securities market and the introduction of foreign exchange controls prompted the authorities at that time to improve and regulate the Stock Exchange’s organisation and operations. The market’s organisational shortcomings hindered however its attractiveness at a time when domestic investors showed a growing interest in stock market investment. To overcome such shortcomings, reforms were undertaken in 1967, providing Morocco’s financial markets with a well-organised legal and technical framework. Following these reforms, in 1986, Morocco embarked on a Structural Adjustment Programme which was completed ten years later. This Programme enabled Morocco to consolidate its fundamentals and successfully bring under control its high level of debt and inflation.&#160;<a href=\"https://www.casablanca-bourse.com/bourseweb/en/content.aspx?IdLink=201&Cat=1\">(Source)</a></li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":125,"Country":"Namibia","cc":"NA","Name0":"Namibia Securities Exchange","Link":"/stock-exchange/nsx","Name":"<a href=\"https://nsx.com.na/\">Namibia Securities Exchange</a>","nlc":39,"dmc":2388.25,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Namibia-Namibia-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No<br>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>NSX requires companies to adhere to the&#160;<a href=\"http://nsx.com.na/images/reports/Namcode-Inside.pdf\">NamCode</a>, the Corporate Governance Code for Namibia, which includes sections on corporate governance and sustainability.</li></ul>","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br>NSX in collaboration with JSE provided Sustainability training on 16 November 2019. (<a href=\"https://nsx.com.na/index.php/training-2/nsx-jse-training-2\">Source</a>)<p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.nsx.com.na/images/news/2021_09_28_Botswana__Namibia_outline_efforts_towards_green_bonds__sustainable_stock_exchanges.pdf\">First green bond launched in September 2021.</a></li><li>The Namibian Stock Exchange has 5 listed green bonds, see <a href=\"https://nsx.com.na/index.php/data/trading-products/bond-market\">NSX's website</a> and CEO of NSX, <a href=\"https://www.observer24.com.na/five-green-and-sustainable-bonds-listed-on-the-nsx/\">Tiaan Bazuin's interview in the observer</a>.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.newswire.ca/news-releases/giyani-gold-lists-onto-the-namibian-stock-exchange-512687641.html\">Alternative Investment Board (AIX)</a>, since 2013.</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Members Association.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.namfisa.com.na/\">Namibian Financial Institutions Supervisory Authority (NAMFISA).</a></li></ul><p>","Regulatory_model":"<ul><li>Regulated by NAMFISA in terms of the 1985 Stock Exchanges Control Act. However, the Stock Exchange has full regulation over listing requirements, compliance and market supervision.</li></ul><p>","About_the_stock_exchange":"Location: Windhoek, Namibia.<p><ul><li>Initially founded in 1904 due to the diamond rush, the exchange closed shortly thereafter in 1910. It reopened in 1992 after independence. More information&#160;<a href=\"https://nsx.com.na/?page_id=276\">here</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Adopted Carbon Markets Framework aimed toward design of a national emissions trading scheme, the development of a comprehensive carbon markets framework, and the provision of technical capacity building.","Source_lnk":"https://www.thesouthernafricantimes.com/namibia-adopts-carbon-markets-framework-for-sustainable-development/ https://www.observer24.com.na/namibians-to-benefit-from-trade-in-carbon-credits/"},{"id":126,"Country":"Netherlands","cc":"NL","Name0":"Euronext Amsterdam","Link":"/stock-exchange/euronext-amsterdam","Name":"<a href=\"https://www.euronext.com/en\">Euronext Amsterdam</a>","nlc":164,"dmc":1131876,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/netherlands-euronext-amsterdam.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li>There is a chapter in the annual report dedicated to sustainability activities, find all reports <a href=\"https://www.euronext.com/en/investor-relations/financial-information/financial-reports\">here</a>.</li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>The <a href=\"https://www.europarl.europa.eu/RegData/etudes/BRIE/2021/654213/EPRS_BRI%282021%29654213_EN.pdf\">European directive on non-financial information reporting (NFRD)</a> has been implemented into the Dutch legal environment.</li><li>Moreover, Euronext Amsterdam supports and implements ESMA’s and National Competent Authorities stringent rules with regards to governance among its community of listed companies</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"/sites/sseinitiative/files/documents/euronext-esg-guide-2022.pdf\">ESG Reporting Guide – Target 1.5°C</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br>Through the Euronext Academy, see more details <a href=\"https://www.corporateservices.euronext.com/academy?s=ESG\">here</a>.<p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li>See the list of indices on the Euronext website <a href=\"https://live.euronext.com/en/products/indices/all-indices-documents\">here</a>. ESG/ISR indices fall under the tab “theme indices”. This list is automatically updated.</li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.euronext.com/en/list-products/bonds/green-bonds\">Euronext ESG Bonds</a> is a community of ESG bond issuers where green, sustainability, social, blue and sustainability-linked bonds listed on all Euronext locations are consolidated onto one highly visible area. Details of the securities <a href=\"https://live.euronext.com/en/products/fixed-income/esg-bonds\">here</a>.</li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>Euronext Growth,&#160;Euronext Access,&#160;Euronext Access+. More information <a href=\"https://www.euronext.com/en/raise-capital/sme\">here</a>.</li></ul><p>&#160;</p><p></p>","wom":"No","womt":"No","Additional_information":"Euronext supports climate friendly innovations by financing Cleantech SME’s benefitting from major Euronext initiatives:<p><ul><li>TechShare: 27 Cleantech have followed the program on how to leverage capital markets</li><li>Tech40 Index: 10% of this increasingly important index is made up of Cleantech SME’s</li><li>Morningstar: the program fully covers the scope of Cleantech SME issuers (55).</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2000</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.dnb.nl/en/home/\">De Nederlandsche Bank.</a></li><li><a href=\"https://www.afm.nl/en\">The Netherlands Authority for the Financial Markets (AFM).</a></li><li><a href=\"https://www.government.nl/ministries/ministry-of-finance\">The Dutch Ministry of Finance.</a></li><li><a href=\"https://www.esma.europa.eu/\">European Union (ESMA).</a></li></ul><p>&#160;</p><p></p>","Regulatory_model":"<p>Government (Statutory) Model</p><ul><li>The Markets in Financial Instruments Directive (MiFID) classifies Euronext’s European cash markets as a regulated market. As such, the real-time monitoring performed by Euronext’s cash market operations and technical support is formally enforced, and our trading rules and procedures are approved by our five regulators. This regulatory and organizational system gives Euronext the power to efficiently manage crisis situations and extraordinary circumstances. Some of the markets organized by Euronext are exchange regulated, which means they are subject to a body of rules laid down by the market operator, Euronext. They are not regulated markets as defined by the Markets in Financial Instruments Directive (MiFID). These structured, exchange regulated markets offer simplified access to financial markets and streamlined listing requirements for companies from every sector of the economy, while ensuring compliance with rules on investor disclosure and the control of financial information. <a href=\"https://www.euronext.com/en/equities/market-regulation\">(Source)</a>.</li></ul><p></p>","About_the_stock_exchange":"Location of the listed holding: Amsterdam, Netherlands.<p><ul><li>Both Euronext and Euronext Amsterdam have an exchange licence from the Dutch authorities to operate regulated markets. This means that they are subject to the regulation and supervision of the Dutch Minister of Finance and the Autoriteit Financiële Markten (“AFM”). Since the creation of Euronext in 2000, the Dutch regulators have taken the view that the direct parent company of Euronext Amsterdam, as controlling shareholder, has to be seen as co-market operator and, accordingly, also requires an exchange licence. Pursuant to section 5:26 paragraph 1 of the Dutch Financial Supervision Act it is prohibited in the Netherlands to operate or to manage a regulated market without a licence granted by the Dutch Minister of Finance. The Dutch Minister of Finance may, at any time, amend or revoke the licence if necessary to ensure the proper functioning of the markets or the protection of investors. The licence may also be revoked for non-compliance with applicable rules. Euronext is the leading pan-European exchange in the Eurozone, spanning Belgium, France, Ireland, Norway, the Netherlands, Portugal, the UK and Ireland. Created in 2000, it unites markets which date back to the start of the 17th century. It is the primary exchange in the Euro zone with nearly 1,500 listed issuers worth more than €4.5 trillion in market capitalization as of end May 2019, an unmatched blue chip franchise consisting of 20+ issuers in the Morningstar® Eurozone 50 Index℠ and a strong diverse domestic and international client base.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":127,"Country":"New Zealand","cc":"NZ","Name0":"New Zealand Stock Exchange","Link":"/stock-exchange/nzx","Name":"<a href=\"https://www.nzx.com/\">New Zealand Stock Exchange</a>","nlc":125,"dmc":108121,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/New-Zealand-NZX.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li>Published&#160;<a href=\"https://s3-ap-southeast-2.amazonaws.com/nzx-prod-c84t3un4/comfy/cms/files/files/000/002/924/original/NZX_ESG_Guidance_Note_-_11_December_2017_%28final_for_publication%29.pdf\">ESG Guidance</a> in December 2017, which was updated in April 2023. See the updated version <a href=\"https://nzx-prod-c84t3un4.s3.ap-southeast-2.amazonaws.com/FwCpVvRmo8WsfFGbQteyQMR8?response-content-disposition=inline%3b%20filename%3D%22NZX%20ESG%20Guidance%20Note%20-%208.2.4.23.pdf%22%3b%20filename%2a%3DUTF-8%27%27NZX%2520ESG%2520Guidance%2520Note%2520-%25208.2.4.23.pdf&response-content-type=application/pdf&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIA2NFHJDRLNWWMDHPT/20230508/ap-southeast-2/s3/aws4_request&X-Amz-Date=20230508T093153Z&X-Amz-Expires=300&X-Amz-SignedHeaders=host&X-Amz-Signature=eb4d7ff2b92a3347e1d94e22ca3e9bcd3ebbcd59168aa81267e6e699e304c099\">here</a>.</li><li>Published&#160;Corporate Governance Code in May 2017, which was updated in April 2023. See the updated version <a href=\"https://nzx-prod-c84t3un4.s3.ap-southeast-2.amazonaws.com/FwCpVvRmo8WsfFGbQteyQMR8?response-content-disposition=inline%3b%20filename%3D%22NZX%20ESG%20Guidance%20Note%20-%208.2.4.23.pdf%22%3b%20filename%2a%3DUTF-8%27%27NZX%2520ESG%2520Guidance%2520Note%2520-%25208.2.4.23.pdf&response-content-type=application/pdf&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIA2NFHJDRLNWWMDHPT/20230508/ap-southeast-2/s3/aws4_request&X-Amz-Date=20230508T120521Z&X-Amz-Expires=300&X-Amz-SignedHeaders=host&X-Amz-Signature=21c7333ffb11be7a8957159cdc2b8b11c45417ef4f9584dbfc8dd5e99ba41e54\">here</a>. The Code now requires the issuer to provide non-financial ESG disclosure at least annually.</li></ul><p>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No<br><ul><li>Promoting growth of local green bond market (<a href=\"https://s3-ap-southeast-2.amazonaws.com/nzx-prod-c84t3un4/comfy/cms/files/files/000/003/239/original/FINAL_NZX_Annual_Report_2017.pdf\">Annual Report 2017, pg 11</a>).</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.nxt.co.nz/\">NXT</a></li><li><a href=\"https://www.nzx.com/markets/NZAX\">NZX Alternative Market (NZAX)</a></li><li>since 2015</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li>Signed an&#160;<a href=\"https://s3-ap-southeast-2.amazonaws.com/nzx-prod-c84t3un4/comfy/cms/files/files/000/003/239/original/FINAL_NZX_Annual_Report_2017.pdf\">MOU in January 2018</a>&#160;with the Hong Kong Exchanges and Clearing Limited (HKEX) to promote cooperation as well as sustainability and green finance initiatives across the Asia-Pacific markets.</li><li>Signed a similar&#160;<a href=\"https://www.nzx.com/announcements/315212\">MOU in March 2018</a> with the Singapore Exchange (SGX).</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2002.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://fma.govt.nz/\">Financial Markets Authority.</a></li></ul><p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model</p><ul><li>The New Zealand Exchange (NZE) co-regulates the stock exchange with the Financial Markets Authority (FMA). However, the FMA has ultimate regulatory approval and is in charge of enforcing securities, company reporting, and company laws.</li></ul><p>","About_the_stock_exchange":"<p>Location: Wellington, New Zealand.</p><ul><li>NZX provides high quality information, data and tools to support business decision making. We build and operate capital, risk and commodity markets and the infrastructure required to support them. We strive to make a meaningful difference to wealth creation for our shareholders, and the individuals, businesses and economies in which we operate.&#160;<a href=\"https://www.nzx.com/about-nzx/organization-structure\">(Source)</a>.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"New Zealand Emissions Trading Scheme (ETS)","Source_lnk":"https://www.nzx.com/about-nzx/organization-structure https://environment.govt.nz/what-government-is-doing/areas-of-work/climate-change/ets/about-nz-ets/"},{"id":128,"Country":"Nicaragua","cc":"NI","Name0":"Bolsa de Valores de Nicaragua (BVN)","Link":"/stock-exchange/bvn","Name":"<a href=\"https://www.bolsanic.com/\">Bolsa de Valores de Nicaragua (BVN)</a>","nlc":4,"dmc":1264,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/un-0904202.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p>In 2022, BVN provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/central-america-tcfd-101-workshop-training/\">source</a>)</p><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<p>For Profit</p><p>","Regulatory_bodies":"<p><a href=\"http://www.siboif.gob.ni\">Superintendency of banks and other financial institutions</a></p><p></p>","Regulatory_model":"<p>Limited exchange SRO</p><p>","About_the_stock_exchange":"<p>The Nicaragua Stock Exchange (BVN) is the result of an initiative of the Nicaraguan private sector founded with the objective of promoting the development and modernization of the Nicaraguan financial system, within the framework of a market liberalization process undertaken since 1990. The first stock market operations in the history of Nicaragua were carried out on January 31, 1994. The Nicaraguan Stock Exchange is the only organized securities market that exists in the country and that guarantees the transparency and security of the operations of purchase and sale of securities. This institution is a private limited company, founded by the majority of private banks, and by solid business groups representing different sectors of the national economy. The Nicaraguan Stock Exchange offers investors and issuers of securities, residents and non-residents in our country, an efficient platform to carry out their operations within the framework of a completely free and open economy abroad. The Stock Exchange is a company that registers and authorizes securities issues to be traded through accredited Stock Markets, develops securities trading mechanisms, supervises the execution of securities transactions, regulating their success, and reports on transactions. that are carried out within it and promote the Nicaraguan stock market. The Nicaraguan Stock Exchange is a market full of opportunities for investors and issuers of securities. The main characteristics of this market are the following:</p><ul><li>In the BVN, fixed income financial instruments are traded with high yields in dollars and in local currency indexed to the dollar.</li><li>There is no type of restriction on inflows and outflows of foreign capital flows.</li><li>The custody and settlement of securities is specialized.</li><li>There is an effective regulatory framework on trading activity.</li><li>There is a wide network of established stock exchanges, with international relations and in the Central American region.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Nicaragua has neither set a net-zero emissions goal nor outlined a long-term low-carbon strategy.","Source_lnk":"https://www.global-climatescope.org/markets/ni/"},{"id":129,"Country":"Nigeria","cc":"NG","Name0":"Nigerian Exchange (NGX)","Link":"/stock-exchange/nse_nigeria","Name":"<a href=\"https://ngxgroup.com/\">Nigerian Exchange (NGX)</a>","nlc":174,"dmc":86163,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Nigeria-Nigerian-Stock-Exchange-SSE.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li>Sustainability Section and Corporate Governance Section on&#160;<a href=\"https://ngxgroup.com/corporate-governance/\">website</a>.</li><li>Annual Sustainability Reports. 2020 Report - “<a href=\"https://ngxgroup.com/?wpdmdl=31244&ind=1630095390425\">EVOLVING For Better Value Creation</a>“.</li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>Effective January 2019, for all issuers on the Premium Board of the exchange.</li><li>SEC Approved Rules&#160;<a href=\"https://sec.gov.ng/sec-corporate-governance-guideline-and-revised-form-01/\">here</a>.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://ngxgroup.com/ngx-download/sustainability-disclosure-guidelines/?ind=1604672225156&filename=Sustainability%20Disclosure%20Guidelines.pdf&wpdmdl=25949&refresh=61499a451a2581632213573\">Sustainability Disclosure Guidelines (2018)</a>.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>The NGX provides various trainings through its <a href=\"https://ngxgroup.com/exchange/x-academy/x-academys-upcoming-programmes/\">X Academy</a>. Some have key ESG integrations, and more are scheduled to in the future. See the full program <a href=\"https://ngxgroup.com/exchange/x-academy/x-academys-upcoming-programmes/\">here</a></li><li>On June 2023, The International Sustainability Standards Board (ISSB), Financial Reporting Council of Nigeria (FRCN), and NGX Regulation Limited (NGX RegCo), recently organized five webinars to prepare companies for the imminent release of the ISSB’s first two IFRS Sustainability Disclosure Standards, see <a href=\"https://ngxgroup.com/frcn-issb-and-ngx-regco-build-stakeholders-capacity-on-sasb-standards-in-preparation-for-issb-standard-effectiveness/\">full press release&#160;</a></li><li><a href=\"https://www.nse.com.ng/mediacenter/pressreleases/Pages/nse-gri-host-round-table-on-sustainable-development-goals.aspx\">NSE, GRI Host Round-table on Sustainable Development Goals</a> (18 July 2019).</li><li><a href=\"https://www.nse.com.ng/mediacenter/pressreleases/Pages/NSE-GRI-Host-Sustainability-Reporting-Workshop.aspx\">NSE, GRI Host Sustainability Reporting Workshop</a> (19 March 2019).</li><li><a href=\"https://www.nse.com.ng/mediacenter/news_and_events/Pages/NSE-EY-Partner-to-Promote-Sustainable-Business-Practices.aspx\">Governance and Sustainability Seminar</a> (16 March 2018).</li><li>Seminar - Beyond Reporting: Real Value Proposition (8 June 2016).</li><li><a href=\"https://www.nse.com.ng/aboutus-site/Corporate-Social-Responsibility-site/PublishingImages/about-us/corporate-social-responsibility/marketplace/COMMUNIQUE%20%282%29.pdf\">Inaugural capital market sustainability conference</a> (13 Nov 2015).</li><li>In 2022, NGX provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/nigeria-tcfd-101-workshop-training/\">source</a>)</li></ul><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://ngxgroup.com/exchange/sustainable-bond-market/\">Sustainable Bond Market</a></li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.nse.com.ng/Listings-site/listing-your-company/asem\">NSE Alternative Securities Market,&#160;</a>since 2013.</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://www.mondovisione.com/media-and-resources/news/nigerian-stock-exchange-admitted-to-gold-community-of-global-reporting-initiativ/\">Admitted to “Gold Community” of the Global Reporting Initiative</a>.</li><li>Reported the NSE Sustainability Report in line with the GRI G4 Guidelines.</li><li>Celebrated the&#160;<a href=\"https://www.nse.com.ng/mediacenter/news_and_events/Pages/NSE-Calls-on-Women-to-Rise-up-against-Gender-Limitation.aspx\">2017 International Women’s Day</a>&#160;with a half day symposium, playing host to over 200 business and thought leaders and participated in the Ring the Bell for Gender Equality program.</li><li>Celebrated International Women's Day in March 2016 with over 150 business and thought leaders. Participated in the “Ring the Bell for Gender Equality” program.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Not For profit, limited by guarantee with no shareholding structure. (In discussions to demutualize).</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://sec.gov.ng/\">Securities and Exchange Commission of Nigeria</a>.</li></ul><p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model.</p><ul><li>Pursuant to the Investment and Securities Act 2007, the Securities and Exchange Commission of Nigeria (SEC) engages in registration, inspection, surveillance, investigation, enforcement and rulemaking activities. The Investment and Securities Act 2007, the SEC Consolidated Rules and Regulations 2013, and the license issued to The Nigerian Stock Exchange (“The Exchange”) by the SEC empowers The Exchange to engage in registration, inspection, surveillance, enforcement and&#160;rule making&#160;activities in respect of its dealing&#160;members and listed companies. The rules of The Exchange however need to be approved by the SEC before they can become operational.</li></ul><p>","About_the_stock_exchange":"<p>Location: Lagos, Nigeria.</p><ul><li>The Nigerian Stock Exchange (NSE or the Exchange) was founded in 1960 and today services the second largest financial center in sub-Saharan Africa. The NSE is licensed under the Investments and Securities Act (ISA), and is registered and regulated by the Securities and Exchange Commission (SEC) of Nigeria. The Exchange is a founding member and executive committee member of the African Securities Exchanges Association (ASEA), a member of the Intermarket Surveillance Group (ISG), an affiliate member of the World Federation of Exchanges (WFE), and an affiliate member of the International Organization of Securities Commissions (IOSCO).The NSE continues to evolve to meet the needs of its valued customers, and to achieve the highest level of competitiveness. Along with securities listing and trading services, the Exchange offers market data dissemination services, market indices, ancillary technology services and much more. The Nigerian Stock Exchange also offers electronic clearing, settlement and delivery (CSD) services through Central Securities Clearing Systems Plc (CSCS), an associate company of the NSE. With over 250 listed securities and 223 active brokers, the Exchange operates a fair, orderly and transparent market that brings together the best of African enterprises, and the local and global investor communities. The Nigerian Stock Exchange is poised to champion the acceleration of Africa's economic development, and to become “the Gateway to African Markets”.&#160;<a href=\"https://ngxgroup.com/exchange/about-us/\">(Source)</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Launched Emissions Trading Scheme, ETS, to provide policy recommendations that will guide National transition of a green economy","Source_lnk":"https://climatechange.gov.ng/2022/08/24/nigerian-government-launches-emission-trading-scheme-ets/#:~:text=The%20government%20says%20the%20establishment,meet%20its%20Net%20Zero%20target."},{"id":130,"Country":"North Macedonia","cc":"MK","Name0":"Macedonian Stock Exchange","Link":"/stock-exchange/mse_macedonia","Name":"<a href=\"https://www.mse.mk/en\">Macedonian Stock Exchange</a>","nlc":368,"dmc":32470,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Macedonia-Macedonian-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><a href=\"/wp-content/uploads/2019/11/MSE-ESG-Reporting-Guide.pdf\">MSE - ESG reporting guidelines</a><p>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>Within the official market of the MSE, there are special sub segments for<a href=\"https://www.mse.mk/en/content/15/2/2018/listing\"> listing</a> of small joint stock companies.</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>The MSE is organized as a joint-stock company, governed by a Board of Directors composed of one executive member, Chief Executive Director - and seven non-executive directors (one-tier management system), operating on a for profit basis. MSE is not listed on the Official Listing tier, although its shares are traded on the Free Market sub-segment of its Regular Market.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.sec.gov.mk/Pages/Home.aspx\">Securities and Exchange Commission of the Republic of Macedonia (SEC)</a></li></ul><p>","Regulatory_model":"<ul><li>SEC's supervision authority legally prescribes SRO functions for the MSE (limited SRO) The SEC is the primary regulatory authority for the capital market in Macedonia. The SEC regulates, supervises and monitors enforcement of the Law on Capital Market, Takeover Law and Law on Investment Funds. The SEC's main responsibilities in regulating the stock exchange operations are to supervise the legality of the stock exchange organization and proper conduct of stock exchange trading, operations and membership. Rules of the MSE that regulate membership, trading, listing and business conduct are subject to the SEC's approval, hence the limited self-regulatory powers of the Macedonian Stock Exchange. The SRO status of the MSE is regulated in the Law on Securities, art. 82, which stipulates that MSE as a self-regulatory organization adopted conduct rules for its members regarding implementation of the MSE's regulations and the Law on Securities. Under the positive legislation, MSE determines listing criteria for the companies in its listing rules, although this concept will be changed once the MIFID II is introduced into domestic legislation.</li></ul><p>","About_the_stock_exchange":"Location: Skopje, former Yugoslav Republic of Macedonia Macedonian stock exchange was founded in 1995.<p><ul><li>On September 13 the inaugural meeting of the MSE took place. This is the official date of the establishment of the first organized securities exchange in the history of the Republic of Macedonia considering that the country had never before had a stock exchange. The total number of initial founders of the MSE was 19 (13 banks. 3 insurance companies and 3 savings houses). These founders simultaneously became the first exchange members with right to trade securities. MSE started trading on March 28, 1996. Today, MSE is a modern and regulated market operator which operates the only securities exchange in the country. Currently, MSE has 11 members (4 brokerage houses and 7 banks). It organizes trading in financial instruments in a fair, efficient and transparent manner. Additional services include data vending, index development and specialized educational seminars and training courses.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":131,"Country":"Norway","cc":"NO","Name0":"Oslo Børs (Euronext)","Link":"/stock-exchange/oslo-bors","Name":"<a href=\"https://www.oslobors.no/ob_eng/\">Oslo Børs (Euronext)</a>","nlc":341,"dmc":433117,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Norway-Oslo-Bors.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.euronext.com/en/investor-relations/financial-information/financial-reports\">Yes</a><br>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"/wp-content/uploads/2022/05/Euronext-ESG-guide-2022.pdf\">ESG Reporting Guide - Target 1.5°C</a></li></ul><p>","oert":"Yes","oertt":"Yes<br>Oslo Børs offers a number of interesting events focusing on different areas in the securities market, such as ESG. More details <a href=\"https://www.euronext.com/en/markets/oslo/courses-seminars\">here</a>.<p><p>As part of Euronext, Oslo Børs, provides ESG related training through the <a href=\"https://www.corporateservices.euronext.com/academy?s=ESG\">Academy</a>.</p><p>&#160;</p><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li>See the list of ESG indices on the Euronext website&#160;<a href=\"https://live.euronext.com/en/products/indices/esg-indices\">here</a>.</li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.euronext.com/en/list-products/bonds/green-bonds\">Euronext ESG Bonds</a>&#160;is a community of ESG bond issuers where green, sustainability, social, blue and sustainability-linked bonds listed on all Euronext locations are consolidated onto one highly visible area. Details of the securities&#160;<a href=\"https://live.euronext.com/en/products/fixed-income/esg-bonds\">here</a>.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>Euronext Growth,&#160;Euronext Access,&#160;Euronext Access+. More information&#160;<a href=\"https://www.euronext.com/en/raise-capital/sme\">here</a>.</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Demutualised for profit; demutualized in 2001.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.finanstilsynet.no/en/\">The Financial Supervisory Authority of Norway</a>.</li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>The Oslo Børs exchange operates under statutory law and supervision by the Financial Supervisory Authority of Norway, which is the primary regulatory body for security exchanges in Norway. The exchange possesses basic self-regulatory authority abilities.</li></ul><p>","About_the_stock_exchange":"Location: Oslo, Norway.<p><ul><li>Oslo Børs VPS Holding ASA owns Oslo Børs ASA, Verdipapirsentralen ASA and Oslo Market Solutions AS. The Oslo Børs VPS group offers coordinated and attractive marketplaces for listing and trade in securities, registration of ownership and settlement of securities in Norway, market data and on-line solutions. Oslo Børs VPS Holding is the result of a merger between Oslo Børs Holding and VPS Holding that took place in November 2007.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":132,"Country":"Oman","cc":"OM","Name0":"Muscat Stock Exchange","Link":"/stock-exchange/msm","Name":"<a href=\"https://www.msx.om/\">Muscat Stock Exchange</a>","nlc":110,"dmc":61018,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2022/03/Oman-Muscat-Stock-Exchange.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.msx.om/MSMDOCS/downloads/en_1683614240441_2-MSX-AR2022-ENGLISH.pdf\">Yes</a><br>There is a sustainability chapter in the annual report since 2021. Access all annual reports <a href=\"https://www.msx.om/downloads.aspx?b1=Publications&b2=MSX-Annual-Report&c=13&ti=MSX-Annual-Report\">here</a>.<p>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br>In 2023, MSX published an <a href=\"https://www.msx.om/MSMDOCS/downloads/ESG-MSX-E.pdf\">ESG Disclosure Guidance document</a><p>","oert":"Yes","oertt":"Yes<br>In 2023, <a class=\"waffle-rich-text-link\" href=\"https://www.msx.om/msmdocs/downloads/MSX%20Sustainability%20Initiative.pdf\" data-sheets-formula-bar-text-link=\"https://www.msx.om/msmdocs/downloads/MSX%20Sustainability%20Initiative.pdf\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:'docs-Calibri';font-style:normal;text-decoration-skip-ink:none;\">MSX hosted the first Capital Market Industry Participant, IRO & CEO Workshop on the Fundamentals of ESG with Sustainable Square (page 6)</a><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li>MSM is a leader in the region in implementing&#160;<a href=\"https://www.msm.gov.om/MSMDOCS/downloads/en_1349586496956_MSM%20Bro%20New%20Pages.pdf\">transparent corporate governance</a>.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed in third market</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cma.gov.om/\">Capital Market Authority.</a></li></ul><p>","Regulatory_model":"<ul><li>Closed Omani joint-stock company</li></ul><p>","About_the_stock_exchange":"Location: Sultanate of Oman, Oman<p><ul><li>The Muscat Securities Market (MSM) was established by the Royal Decree (53/88) issued on 21 June 1988 to regulate and control the Omani securities market and to participate, effectively, with other organizations for setting up the infrastructure of the Sultanate’s financial sector. According to the Royal Decree 5/2021 (the Muscat Securities Market was converted convert into a closed Omani joint-stock company under the name “Muscat Stock Exchange Company”. Muscat Stock Exchange provides a comprehensive range of products and services and works to encourage savings, develop investment awareness and protect investors. It also works to create ways to invest money in securities for the joint benefit of the national economy and investors. Muscat Stock Exchange seeks to become a leading stock exchange with a global presence, as well It aims to provide an efficient investment environment that operates according to the best standards and practices with prospects of diverse opportunities integrated with the national economy trends.</li></ul>","am":true,"os":true,"nz":true,"VCM":"No","CCM":"No","Notes":"Oman is working on a roadmap to govern the issuance of ESG-compliant securities, as well as how to treat and trade carbon credits.","Source_lnk":"https://oxfordbusinessgroup.com/reports/oman/2023-report/capital-markets/taking-stock-recent-reforms-and-credit-ratings-upgrades-put-the-sultanates-financial-markets-on-a-strong-footing-for-growth-overview/"},{"id":133,"Country":"Pakistan","cc":"PK","Name0":"Pakistan Stock Exchange","Link":"/stock-exchange/pakistan-stock-exchange","Name":"<a href=\"https://www.psx.com.pk/\">Pakistan Stock Exchange</a>","nlc":523,"dmc":24900,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2022/06/Pakistan-PSX.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br>In 2024, PSX launched the <a href=\"https://www.psx.com.pk/psx/themes/psx/uploads/PSX_Primer_on_ESG.pdf\" target=\"_blank\" rel=\"noopener\">PSX Primer on Environmental, Social and Governance (ESG) Reporting Guidance for Companies</a>. You can find more information on PSX’s ESG <a href=\"https://www.psx.com.pk/psx/environmental-social-governance\" target=\"_blank\" rel=\"noopener\">page</a>.","oert":"Yes","oertt":"Yes<br>PSX provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC (<a href=\"/sse-event/pakistan-tcfd-101-workshop-training/\">source</a>) and has also conducted various webinars on this front.<p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><a href=\"https://www.psx.com.pk/psx/files/?file=177956-1.pdf\">The Growth Enterprise Market (GEM) Board</a> was launched in 2020 to facilitate small to medium growth enterprises. At present, three companies are listed on the GEM Board of PSX (<a href=\"https://www.psx.com.pk/psx/files/?file=187152-1.pdf\">press release</a>).<p>","wom":"Yes","womt":"Yes<br>See <a href=\"https://www.secp.gov.pk/document/listed-companies-code-of-corporate-governance-regulations-2019/?wpdmdl=36088&refresh=64b12d0abb87d1689333002\" target=\"_blank\" rel=\"noopener\">The Listed Companies (Code of Corporate Governance) Regulations, 2019</a>, Chapter II&#160;(Number of Directorship and Composition of Board), regulation 7 on Page 3.","Additional_information":"PSX encourages listed companies to report on Sustainability vis SDGs. The PSX website consists of a webpage dedicated to SDGs and their reporting for listed companies. Furthermore, for the PSX Top 25 Companies Awards, PSX has included significant weightage for reporting on SDGs, diversity and inclusivity by listed companies to win the Award.<p>","Organizational_model_of_stock_exchange":"PSX is a listed company (June 2017) which underwent corporatisation and demutualisation in August, 2012. The three exchanges namely LSE (Lahore Stock Exchange), ISE (Islamabad Stock Exchange), & KSE (Karachi Stock Exchange) were integrated as a single entity, PSX, in January 2016.<p>","Regulatory_bodies":"<ul><li>Securities & Exchange Commission of Pakistan (Apex Regulator)</li></ul><p>","Regulatory_model":"<ul><li>Strong exchange SRO</li></ul><p>","About_the_stock_exchange":"Pakistan Stock Exchange is the national bourse of Pakistan and is located in Karachi, Pakistan.","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Ministry of Climate Change is planning to establish a credit-based trading mechanism, carbon registry and a domestic ETS framework","Source_lnk":"https://icapcarbonaction.com/system/files/document/ICAP%20Emissions%20Trading%20Worldwide%202023%20Status%20Report_0.pdf"},{"id":134,"Country":"Panama","cc":"PA","Name0":"Bolsa Latinoamericana de Valores (Latinex)","Link":"/stock-exchange/bvp","Name":"<a href=\"https://www.latinexbolsa.com/en/\">Bolsa Latinoamericana de Valores (Latinex)</a>","nlc":214,"dmc":18013,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/panama-bvp.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.latinexbolsa.com/biblioteca/Sostenibilidad/Reportes/Sustainability%20Report%20Latinex%202022.pdf\">Yes</a><br><a href=\"/stock-exchange/bvp/\">Bolsa Latinoamericana de Valores (Latinex)</a> sustainability report and strategy available in Spanish and English contains information regarding the group’s environmental, social and corporate governance (ESG) management and performance. All sustainability-related reports and strategies can be accessed <a href=\"https://www.latinexbolsa.com/es/bvp/reportes/\">here</a>.<p></p>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"/all-news/exchange-in-focus-panama-stock-exchange-issues-esg-reporting-guidelines-for-issuers/\">Latinex launched in 2021 its ESG reporting guidelines for issuers</a>: &#160;<a href=\"https://www.panabolsa.com/biblioteca/Sostenibilidad/Guias_Sostenibilidad/Guia_para_el_Reporte_y_Divulgacion_Voluntaria_de_Factores_ASG_v1.pdf\">“Guide for Reporting and Voluntary Disclosure of Environmental, Social and Corporate Governance Factors (ASG)”</a></li><li>Also available in English <a href=\"https://www.latinexbolsa.com/biblioteca/Sostenibilidad/Guias_Sostenibilidad/Guide%20for%20the%20Voluntary%20Reporting%20and%20Disclosure%20of%20ESG%20Factors.pdf\">here</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br>In 2022, Latinex provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/central-america-tcfd-101-workshop-training/\">source</a>)<p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.panabolsa.com/es/emisores/como-ser-parte-de-la-bvp/guia-para-la-emision-de-valores-negociables-svs/\">Guidelines for the issuance of Social, Green and Sustainable Securities</a> in <a href=\"https://www.panabolsa.com/es/wp-content/uploads/2019/10/Guia-para-Emision-de-Valores-Negociables-SVS.pdf\">Spanish</a> and <a href=\"https://www.panabolsa.com/es/wp-content/uploads/2019/10/2019-10-23-Guidelines-for-the-Issuance-of-SGS-Securities.pdf\">English</a></li></ul><p></p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>The holding company (Latinex Holdings), which owns 100% of the stock exchange, as well as the CSD, is a listed company for profit. On October 22, 2009, both BVP and Latin Clear's shareholders approved the corporate reorganization and creation of Latinex Holdings, which would own both companies. On February 2011, the SMV authorized the registry of Latinex Holdings' common stock and the new shares begun trading publicly.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.smv.gob.pe/\">Superintendencia del Mercado de Valores (SMV)</a>.</li></ul><p></p>","Regulatory_model":"<ul><li>Bolsa de Valores de Panamá (BVP) is a private company registered under SMV as a Stock Exchange, which along with the local CSD Latin Clear (Central Latinoamericana de Valores) are under the same holding company. The holding company, Latinex Holdings, is also a listed company and its shares are listed in BVP. BVP is under SMV’s jurisdiction, and so, all activities are subject to SMV direct oversight. BVP is responsible for monitoring and overseeing market participants acting as members registered in BVP. BVP is also responsible and in charge of listing procedures that private companies must fulfill after having SMV public offering authorization. BVP provides SMV daily information of market operations and all other issues and documents required. BVP collaborates with the regulator for the local capital market development.</li></ul><p>","About_the_stock_exchange":"Location: Panama City, Panama.<ul><li>BVP is the only stock exchange in Panama. Founded on June 26, 1990 and ended the first year with traded volumes of USD 3.3 MM. Latin Clear was created in 1997 as a stand-alone company. Since May, 2017, it has a direct integration project with El Salvador's Stock Exchange via the remote operator figure, which allows authorized brokerage houses to trade directly in the foreign exchange with the same benefits and obligations. In 2018, the BVP participated in the SSE's “Ring the Bell for Gender Equality”.</li></ul>","am":true,"os":true,"nz":true,"VCM":"UD","CCM":"No","Notes":"Latinex has been working with the Ministry of Environment on the development of a voluntary carbon market in Panama.  Verra and Panama have signed MOU to support development of a national carbon market.","Source_lnk":"https://verra.org/verra-and-panama-sign-mou-to-support-development-of-a-national-carbon-market/"},{"id":135,"Country":"Papua New Guinea","cc":"PG","Name0":"Papua New Guinea National Stock Exchange","Link":"/stock-exchange/pngx","Name":"<a>Papua New Guinea National Stock Exchange</a>","nlc":12,"dmc":2246,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2022/04/Papua-New-Guinea-PNGX.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br>In July 2023, PNGX issued a <a href=\"https://www.pngx.com.pg/wp-content/uploads/2023/06/PNGX-Corporate-Governance-Code-Effective-03-July-2023.pdf\">Corporate Governance Code for Listed Issuers</a>. It is not mandatory to comply with it but companies are encouraged to adopt the standards from the Code. Among them, Standard n. 10 “The Board should maintain a sound system of internal control to safeguard shareholders’ investment and the company’s assets. The Board should ensure the integrity of the company’s accounting and reporting systems for financial and sustainability disclosure, including the independent audit, and that appropriate systems of control are in place, in compliance with the law and relevant standards.”","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>For Profit</li></ul><p>","Regulatory_bodies":"<ul><li>Securities Commission of Papua New Guinea</li><li>Investment Promotion Authority</li></ul><p>","Regulatory_model":"<ul><li>Strong exchange SRO</li></ul><p>","About_the_stock_exchange":"PNGX is Papua New Guinea’s national stock exchange and is located in Port Moresby, Papua New Guinea.&#160; It commenced operations in 1999.&#160; PNGX is currently redeveloping its markets which will include the introduction of a SME platform, new listing requirements for its main market including revised corporate governance standards and introduction of voluntary ESG reporting, and introduction of a corporate debt market including sustainability bonds.","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Working on amendment of The Climate Change Management Act that will facilitate trading of carbon credits","Source_lnk":"https://www.postcourier.com.pg/carbon-market-act-set-to-go-before-parlt/"},{"id":136,"Country":"Paraguay","cc":"PY","Name0":"Bolsa de Valores &#038; Productos de Asunción S.A. (BVPASA)","Link":"/stock-exchange/bvpasa","Name":"<a href=\"https://www.bvpasa.com.py/\">Bolsa de Valores & Productos de Asunción S.A. (BVPASA)</a>","nlc":52,"dmc":1523,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/commitment-letter-bvpasa.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"Not for Profit<p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cnv.gov.py/\">Comisión Nacional de Valores (CNV)</a></li></ul><p></p>","Regulatory_model":"Limited exchange SRO<p>","About_the_stock_exchange":"BVPASA is Paraguay´s only stock Exchange that also runs as Depositary, helping investor and issuers to raise capital for 27 years. We offer to the market an electronic platform for exchange trading, securities listing, initial public offering and market data services. As Depositary we offer a wide range of services including registry keeping, clearing and settlement, asset and registry servicing.<p><p>Mission: Provide services, information and infrastructure, efficiently, transparent and reliable, for the development of the market</p><p>Vision: Be the center of business, reference in transparency and innovation, the driving force of the country´s economic development, integrated to the world markets","am":false,"os":false,"nz":false,"VCM":"","CCM":"","Notes":"","Source_lnk":""},{"id":137,"Country":"Peru","cc":"PE","Name0":"Bolsa de Valores de Lima (nuam)","Link":"/stock-exchange/bvl","Name":"<a href=\"https://www.bvl.com.pe/\" target=\"_blank\" rel=\"noopener\">Bolsa de Valores de Lima (nuam)</a>","nlc":266,"dmc":78025.83,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/bolsa-valores-lima-commitment-letter-sse.pdf\" target=\"_blank\" rel=\"noopener\">Yes</a>","asr":"Yes","asrt":"<a href=\"https://www.bvl.com.pe/emisores/detalle?companyCode=90000\" target=\"_blank\" rel=\"noopener\">Yes</a>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li><a href=\"https://www.smv.gob.pe/sil/RGG0211199800000007.pdf\" target=\"_blank\" rel=\"noopener\">Resolution SMV N. 033-2015-SMV/01</a>&#160;passed 15 November 2015 requires issuers to present a corporate sustainability report and a report on good corporate governance as an annex to its annual report. The format for these reports can be found on the&#160;Market Regulator's website, as well as on the BVL website.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>The BVL worked with the PIR, which it is a founding associate of, to publish in 2017 <a href=\"https://www.bvl.com.pe/ipgc/PIR_guia.pdf\" target=\"_blank\" rel=\"noopener\">a user guide</a> for filling in the corporate sustainability report required by the market regulator (SMV).</li></ul>","oert":"Yes","oertt":"Yes<br><ul><li>The BVL offers courses on ESG themes through its Education Facilities “<a href=\"https://www.bursen.com.pe/web/guest/programas-de-especializacion\" target=\"_blank\" rel=\"noopener\">Bursen BVL</a>” (Stock market education center).</li><li>The BVL also participates in various conferences in Peru to discuss topics related to ESG. Some events include:<ul><li>May 2022: <a href=\"https://www.linkedin.com/feed/update/urn:li:activity:6937171417738178560/\" target=\"_blank\" rel=\"noopener\">Panel: Sustainability and market.</a> The Lima Stock Exchange organized a space to discuss the application of environmental, social and good corporate governance indicators in some companies in the country.</li><li>May 2022: <a href=\"https://www.linkedin.com/feed/update/urn:li:activity:6935705382447185920/\" target=\"_blank\" rel=\"noopener\">Ring the Bell ESG</a>. The Lima Stock Exchange offered a Ringing the Bell Ceremony in honor of the components of the index.</li><li>May 2022: <a href=\"https://www.linkedin.com/feed/update/urn:li:activity:6930198860233330688/\" target=\"_blank\" rel=\"noopener\">Presentación de Indicadores Materiales ASG para el sector minero en el Perú</a>. The Lima Stock Exchange and PIR, the Responsible Investment Program organized a webinar where they presented the ESG Material Indicators for the mining sector.</li><li>March 2022: <a href=\"https://www.linkedin.com/feed/update/urn:li:activity:6907332969384845312/\" target=\"_blank\" rel=\"noopener\">Ring the Bell for Gender Equality</a>. The Lima Stock Exchange participates to commemorate International Women's Day in order to raise awareness among companies in the stock market to reduce gender equity gaps within the environment labor.</li><li>March 2021: Ring the Bell for Gender Equality. The Lima Stock Exchange participates to commemorate International Women's Day in order to raise awareness among companies in the stock market to reduce gender equity gaps within the environment labor.</li><li>August 2021: <a href=\"https://www.linkedin.com/video/live/urn:li:ugcPost:6833516982063636480/\" target=\"_blank\" rel=\"noopener\">BVL Entrevista</a>: Cálidda y su estrategia en Gobierno Corporativo. The Lima Stock Exchange premiered an interview to showcase the benefits of corporate governance in companies.</li><li>April 2021: Entrevista BVL: Petroperú. The BVL discusses the advantages and transformation in ASG factors of Petroperú.</li><li>September 2020: Peru Sostenible - <a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_peraeqsostenible-activity-6708901824113500160-RujD\" target=\"_blank\" rel=\"noopener\">Participation in the SDG 8 Action Table</a>: Decent Work and Economic Growth under the routes of sustainable economic reactivation and responsible business conduct.</li><li>August 2020: <a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_nueva-cartera-spbvl-ibgc-2020-2021-activity-6699765257948196864-hdvh\" target=\"_blank\" rel=\"noopener\">Presentation of the Good Corporate Governance Index</a> - As every year, the Lima Stock Exchange and S&P Global Indices released the list of companies with the best corporate governance in the market.</li><li>August 2020: <a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_bvlevento-pir-activity-6698639315959992320-RA5G\" target=\"_blank\" rel=\"noopener\">Thematic bonds: Why are they relevant in the context of economic reactivation?</a> – Programa de Inversión Responsible (PIR). Claudia Cooper and Miguel Angel Zapatero participated in this virtual event on sustainable thematic bonds.</li><li>August 2020: <a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_primercampanazovirtual-activity-6700072348004958208-pBxO\" target=\"_blank\" rel=\"noopener\">First Virtual Ring the Bell Bosques Amazónicos</a> – The Lima Stock Exchange for the first time for the accession of Bosques Amazónicos to the Alternative Securities Market.</li><li>March 2020: <a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_cambiemoslasestadisticas-bvl-activity-6643205143791755264-lGYu/\" target=\"_blank\" rel=\"noopener\">Ring The Bell For Gender Equality</a>. The Lima Stock Exchange, for the fifth consecutive year and together with 60 stock exchanges around the world, commemorated International Women's Day in order to raise awareness among companies in the stock market to reduce gender equity gaps within the environment labor.</li><li>March 2020: <a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_bvl-sostenibilidad-activity-6641054018523197440-sbuu/\" target=\"_blank\" rel=\"noopener\">Regulation in Sustainable Finance</a>. Event organized with the British Embassy in Lima, A2G and Mexico2. The speakers discussed the necessary legal framework to promote programs and strategies that contribute to the creation of a financial ecosystem that supports the fight against climate change and the construction of an environment that favors sustainable development.</li><li>February 2020: <a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_bvl-activity-6635658335628644352-Myq-\" target=\"_blank\" rel=\"noopener\">Fundamentals of the SAM Corporate Sustainability Assessment (CSA) and latest developments</a></li><li>February 2020: Workshop “<a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_bvl-activity-6636021749815267328-KeH-/\" target=\"_blank\" rel=\"noopener\">ASG Materiality</a>“. Participants: Manuel Gonzales, Senior Director Latam North Cone S&P Dow Jones Indices; Jvan Gaffuri, Director ESG Benchmarking, S&P Global Switzerland; and Miguel Angel Zapatero Alba, Vice President PIR, Deputy General Manager of Business of the BVL.</li><li>January 2020: <a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_bvl-activity-6625505963086532608-9MRs\" target=\"_blank\" rel=\"noopener\">First conference on financial stability and sustainability</a></li><li>July 2019: Conference organized with EY titled “<a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_xii-edici%C3%B3n-del-reconocimiento-spbvl-ibgc-activity-6559551087781699584-TPk8/\" target=\"_blank\" rel=\"noopener\">XII edition of the recognition of the S&P BVL Good Corporate Governance Index</a>“</li><li>June 2019:&#160;<a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_colombia-peraeq-esg-activity-6541825179650183168-G7sr/\" target=\"_blank\" rel=\"noopener\">Presentation of BVL sustainable initiatives</a>&#160;to graduated students of Costa CUC University - Colombia in support of the Pontificia Universidad Catolica del Perú (PUCP).</li><li>June 2019: Conference organizated with Women CEO Perú titled “<a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_la-bvl-se-uni%C3%B3-a-womenceoperu-asociaci%C3%B3n-activity-6544696500276998144-MKFI/\" target=\"_blank\" rel=\"noopener\">Board Director platform launch</a>” in which BVL commits to the initiative of 30% of women on boards by 2030.</li><li>May 2019: Conference organized with IFC titled “<a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_la-bolsa-de-valores-de-lima-y-la-corporaci%C3%B3n-activity-6535262634298662912-VXAt/\" target=\"_blank\" rel=\"noopener\">How is my business evolving? Presentation of the corporate governance for SMEs</a>“.</li><li>May 2019: Conference organized by EY, titled “<a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_gobiernocorporativo-bvl-buenaspracticas-activity-6532732058593218560-a-Ec/\" target=\"_blank\" rel=\"noopener\">Challenges of corporate governance in investment funds</a>“.</li><li>April 2019: Conference organized by RoceboSAM training companies on ESG information titled “<a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_compartimos-con-ustedes-la-presentaci%C3%B3n-del-activity-6522154960690442240-u0rY/\" target=\"_blank\" rel=\"noopener\">Corporate Sustainability Assessment</a>“.</li><li>March 2019: Conference organized with the British Embassy titled “<a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_la-bolsa-de-valores-de-lima-y-la-embajada-activity-6511989728844353536-53UG/\" target=\"_blank\" rel=\"noopener\">Climate Finance in the Pacific Alliance</a>“.</li><li>February 2019: Conference organizated with the Peruvian Securities Market Regulator (SMV) and Women Corporate Directors titled “<a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_el-d%C3%ADa-de-ayer-se-llev%C3%B3-a-cabo-el-conversatorio-activity-6501955552879403008-zzei/\" target=\"_blank\" rel=\"noopener\">Board of Directors under the SMV guidelines</a>“</li><li>November 2018: Conference organized with Women Corporate Directors and KPMG Peru titled “<a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_hoy-se-realiz%C3%B3-el-foro-directorio-360-organizado-activity-6471876062585372672-w3Uw/\" target=\"_blank\" rel=\"noopener\">360 board of directors</a>“.</li></ul></li></ul>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li>BVL created the&#160;<a href=\"https://www.bvl.com.pe/ipgc/MetodologiadeCalculo.pdf\" target=\"_blank\" rel=\"noopener\">Good Corporate Index (IBGC)</a>&#160;in 2008.</li><li>On 16 Feb 2017 the MILA exchanges (which includes BVL) announced an&#160;<a href=\"/sites/sseinitiative/files/documents/mila_-comunicado-indice-esg.pdf\" target=\"_blank\" rel=\"noopener\">agreement</a>&#160;with S&P Dow Jones Indices, the IFC, and RobecoSAM to develop a new ESG index for the region.</li><li>Launch of S&P/BVL Peru General ESG Index in 2021. Currently the index has 17 constituents.</li></ul>","hsbls":"Yes","hsblst":"Yes<br><ul><li>The Lima Stock Exchange uses a “V” for Green Bonds and “S” for social Bonds at the beginning of the Ticker in order to differentiate the nature of the bond.</li><li>Guide for listing green bonds published by the BVL found&#160;<a href=\"https://www.bvl.com.pe/bonosGuia.html\" target=\"_blank\" rel=\"noopener\">here</a> in Spanish.</li><li>Guide for listing social, sustainable and bonds aligned with the Sustainable Development Goals of the United Nations published by the BVL found <a href=\"https://s3.us-east-1.amazonaws.com/site.documents.cdn.prod.bvl.com.pe/Gu%C3%ADa_de_Bonos_Sociales%2c_Sustentables_y_Alineados_a_los_ODS_de_las_Naciones_Unidas_para_el_Per%C3%BA.pdf\" target=\"_blank\" rel=\"noopener\">here</a> in Spanish.</li><li><a href=\"https://documents.bvl.com.pe/hhii/BVL013/20211220172155//EXPBAM02.pdf\" target=\"_blank\" rel=\"noopener\">2021</a> Sustainable Short-Term Instruments Review</li><li><a href=\"https://s3.us-east-1.amazonaws.com/site.documents.cdn.prod.bvl.com.pe/Segunda_Opinion_BonoSostenible2019-COFIDE.pdf\" target=\"_blank\" rel=\"noopener\">2019</a> and <a href=\"https://documents.bvl.com.pe/hhii/L01785/20211223175847//EXPBAM1BC01.pdf\" target=\"_blank\" rel=\"noopener\">2021</a> Sustainable Bond Reviews</li><li><a href=\"https://s3.us-east-1.amazonaws.com/site.documents.cdn.prod.bvl.com.pe/BVL_-_socialReport.pdf\" target=\"_blank\" rel=\"noopener\">2019</a>, <a href=\"https://s3.us-east-1.amazonaws.com/site.documents.cdn.prod.bvl.com.pe/CajaArequipa-Segunda_Opinion.pdf\" target=\"_blank\" rel=\"noopener\">2020</a> and <a href=\"https://s3.us-east-1.amazonaws.com/site.documents.cdn.prod.bvl.com.pe/COFIDE_Segunda_Opinion.pdf\" target=\"_blank\" rel=\"noopener\">2021</a> Social Bond Reviews</li><li>2018 Green Bond Reviews, <a href=\"https://www.bvl.com.pe/BonosVerdesReporte.pdf\" target=\"_blank\" rel=\"noopener\">here</a> and <a href=\"https://www.bvl.com.pe/BonosVerdesReporte_Vigeo.pdf\" target=\"_blank\" rel=\"noopener\">here</a></li></ul>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.bvl.com.pe/scr/english/ppt/brochure.pdf\" target=\"_blank\" rel=\"noopener\">BVL Venture Exchange</a>, since 2000.</li></ul>","wom":"No","womt":"No","Additional_information":"In 2022, Bolsa de Valores de Lima (BVL) and Global Growth Institute (GGGI) established an inter-institutional alliance in order to strengthen the capacities of companies and interest groups to promote sustainability in the local market.<p><ul><li>For the second time in history a woman is President of the Board Directors of the Lima Stock Exchange. In&#160;<a href=\"https://www.linkedin.com/posts/bolsa-de-valores-de-lima_damos-la-bienvenida-a-claudia-cooper-la-activity-6521155353554481152-GfXC/\" target=\"_blank\" rel=\"noopener\">March 2019</a>, the General Meeting of shareholders named to Claudia Cooper Fort as President of the Board Directors of BVL.</li><li>The BVL is a founding associate of the Asociación para la Promoción de la Inversión Responsable y Sostenible (<a href=\"https://www.pir.pe/\">PIR</a>), a network supporter of the UN Principles of Responsible Investment (PRI). Through the PIR, the BVL promotes investment policy and practices that incorporate ESG information. In 2022, together with the other PIR partners, BVL signed the letter of commitment to progressively incorporate by 2025 the TCFD recommendations on the evaluation and disclosure of climate risks for decision-making in our investment processes.</li><li>The BVL has had its carbon footprint calculation certified by A2G Sostenibilidad y Cambio Climático. See the certificate&#160;<a href=\"/sites/sseinitiative/files/documents/bvl_certificado-huella-carbono.pdf\" target=\"_blank\" rel=\"noopener\">here</a>.</li><li>The BVL works with EY to produce a yearly report on Good Corporate Governance in Peru, based on a yearly survey The Voice of the Market (La Voz del Mercado). See the 2016 report&#160;<a href=\"/sites/sseinitiative/files/documents/bvl_lvdm2016.pdf\" target=\"_blank\" rel=\"noopener\">here</a>. The report educates the market on good corporate governance. Past reports:&#160;<a href=\"/sites/sseinitiative/files/documents/bvl_lvdm2015.pdf\" target=\"_blank\" rel=\"noopener\">2015</a>,&#160;<a href=\"/sites/sseinitiative/files/documents/bvl_lvdm2014.pdf\" target=\"_blank\" rel=\"noopener\">2014</a>.</li><li>Gender equality initiatives: For the third consecutive year, the BVL participated in the SSE's “<a href=\"/all-news/global-markets-support-gender-equality-65-stock-exchanges-ring-their-bells-to-raise-awareness-on-gender-equality/\" target=\"_blank\" rel=\"noopener\">Ring the Bell for Gender Equality</a>” in 2018, in support of SDG 5 - Gender Equality.</li><li>In 2017, the BVL, the American Embassy and the Woman Corporate Directors developed a leadership workshop called “Breaking the Glass Ceiling - BTGC Peru” aimed at CEO's, women VPs and senior managers of companies listed on the BVL, with the aim of training them in leadership and awareness in their working environment to implement policies aimed at closing the gender gap and publicly disseminate them to achieve a multiplier effect.</li><li>In 2017, the BVL Group participated in the OWIT Day 2017 BTGC Peru sharing program and the current situation of the gender gap in the market.</li><li>In 2017, the BVL Group participated in the 1st meeting of “Women in the Profession Leadership 3.60 WIP” that seeks to promote visibility and leadership of the lawyers, through the creation of a professional network. This event was published in an article in G Management on leadership and how to overcome the barriers.</li><li>In 2017, the BVL in alliance with SP & Robeco Sam launched the ESG Sustainability Index MILA Regional, where companies that make up the index must disclose whether or not they comply with policies gender equality.</li><li>In 2018, the BVL launched Allied Group Ranking Par (a free and confidential platform) that allows companies to measure gender equality. A long - term goal is that more companies listed on the BVL can measure the gender gap, awareness and implement improvements in their organizations on this issue.</li></ul>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit.</li></ul>","Regulatory_bodies":"<ul><li style=\"text-align:left;\"><a href=\"https://www.smv.gob.pe/\" target=\"_blank\" rel=\"noopener\">Superintendencia de Mercado de Valores (SMV) (Peruvian Superintendency of Securities Market)</a>.</li></ul>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>The Superintendencia de Mercado de Valores (SMV) has ultimate authority over securities market regulations. However, the Bolsa de Valores Lima has the authority to regulate the trading and transactions carried out through centralized trading mechanisms under their responsibility, as well as the activity of intermediation agents in such mechanisms.&#160;The BVL has supervision power, which entails supervising compliance with the market's regulations and self-regulation rules by the intermediaries.</li></ul>","About_the_stock_exchange":"Location: Lima, Peru<p><ul><li><a href=\"https://www.bvl.com.pe/acercalaempresa.html\" target=\"_blank\" rel=\"noopener\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.bvl.com.pe/acercalaempresa.html&source=gmail&ust=1567152329712000&usg=AFQjCNH2gCKU379s2JOTw0LV3Hrt7BdCpA\">About BVL</a> (Spanish).</li><li>At present, the BVL has 97.32% of the shares of CAVALI S.A. I.C.L.V. [<a href=\"https://www.cavali.com.pe/acerca-de-cavali/empresa/estructura-accionaria.html\" target=\"_blank\" rel=\"noopener\">Source</a>]</li></ul>","am":true,"os":false,"nz":false,"VCM":"","CCM":"","Notes":"","Source_lnk":""},{"id":139,"Country":"Philippines","cc":"PH","Name0":"Philippine Stock Exchange","Link":"/stock-exchange/pse","Name":"<a href=\"https://www.pse.com.ph/\">Philippine Stock Exchange</a>","nlc":288,"dmc":259770,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/philippines-pse.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://sustainability.pse.com.ph/sustainability-report/\">Yes</a><br><ul><li><a href=\"https://documents.pse.com.ph/wp-content/uploads/sites/14/2023/05/2022-Sustainability-Report-Philippine-Stock-Exchange-Inc.-Final.pdf\">2022 Sustainability Report</a></li><li><a href=\"https://documents.pse.com.ph/wp-content/uploads/sites/14/2022/10/SR-2021-FINAL-1.pdf\">2021 Sustainability Report</a></li><li><a href=\"https://documents.pse.com.ph/wp-content/uploads/sites/14/2021/09/PSE-Sustainability-Report-2020_publicatione.pdf\">2020 Sustainability Report</a></li><li><a href=\"https://documents.pse.com.ph/wp-content/uploads/sites/14/2021/09/PSE-Sustainability-Report-2019-Final_0629.pdf\">2019 Sustainability Report</a></li><li><a href=\"https://documents.pse.com.ph/wp-content/uploads/sites/14/2020/06/2018-PSE-Digital-Sustainability-Report.pdf\">2018 Sustainability Report</a></li><li><a href=\"https://documents.pse.com.ph/wp-content/uploads/sites/14/2020/06/2017-PSE-Sustainability-Report.pdf\">2017 Sustainability Report</a></li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>ESG reporting is not a general requirement for initial and additional listing, but compliance with ESG reporting constitutes a continuing listing requirement for listed companies in the Exchange.</li><li>In 2019 the Philippines SEC launched a guidance on sustainability reporting and announced a penalty for an “Incomplete Annual Report” provided under SEC Memorandum Circular No. 6, Series of 2005 (Consolidated Scale of Fines). The guidance on Sustainability Reporting for Publicly-Listed Companies can be found <a href=\"https://www.sec.gov.ph/mc-2019/mc-no-04-s-2019-sustainability-reporting-guidelines-for-publicly-listed-companies/\">here</a></li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>The Philippines Securities and Exchange Commission announced in 2019 the requirement of sustainability reporting on a comply or explain basis for all listed companies, together with the publication of a guidance. The guidance is intended to help listed companies assess and manage non-financial performance across economic, environmental and social aspects of their organization and enable listed companies to measure and monitor their contributions towards achieving universal targets of sustainability, such as the UN's Sustainable Development Goals as well as national policies and programs, such as AmBisyon Natin 2040. The announcement and guidance document can be found&#160;<a href=\"https://www.sec.gov.ph/corporate-governance/sustainability-report/\">here</a>.</li><li>The sock exchange also offers guidance on corporate governance: through the <a href=\"https://www.sec.gov.ph/wp-content/uploads/2019/11/2016_memo_circular_no.19.pdf\">Code of Corporate Governance of 2016 (SEC Memorandum Circular No. 19, Series of 2016)</a>. This Code is based on the G20/OECD Principles of Corporate Governance and the ASEAN Corporate Governance Scorecard.</li></ul><p>","oert":"Yes","oertt":"Yes<br>2022<p><ul><li>PSE collaborated with Maybank Investment Banking Group (MIBG) for the online webinar entitled “<a href=\"https://www.youtube.com/watch?v=xP2FwusN87U\">ASEAN ESG Alpha and the Role of PSE in the ESG Narrative</a>” ESG in the Philippines has been gaining traction with both corporates and investors. The PSE partnered with MIBG to bring a spotlight on whether ESG is driving performance of stocks in the ASEAN-6 countries, to what extent, and through which sectors. The event also covered the role of PSE in the ESG narrative and the use of ESG as an important investment tool in today’s evolving business and social landscape.</li><li>SEC and PSE Collaborated to Create a Platform for Sustainability Discussions. The theme of the 9th SEC-PSE Corporate Governance Forum was “Safe Spaces: Fortifying Corporate Governance and Sustainability in the Philippines”. (<a href=\"https://sustainability.pse.com.ph/\">source</a>)</li><li><a href=\"https://climate.gov.ph/news/720\">PSE collaborated with the Climate Change Commission for the Climate Investment Forum 2022: Turning Climate Commitments to Action.</a> The event served as a platform for government leaders to present their national targets on mitigation and adaptation, identify financing requirements, and enjoin stakeholders from the private sector to invest on the country’s priorities on climate action. Other event partners included the Department of Finance, Securities and<br>Exchange Commission, United Nations Development Programme, and World Bank Group.</li><li>Climate Disclosure Training Program for PLCs. The PSE, in partnership with the United Nations Sustainable Stock Exchange, International Finance Corporation and the Carbon Disclosure Project, conducted a training program for publicly listed companies. This training program is a CPD-certified course and was offered free of charge. The objective was to facilitate a multi-stakeholder dialogue on TCFD disclosure and provide an understanding of the importance of climate-related disclosure. (<a href=\"/sse-event/philippines-tcfd-101-workshop-training/\">source</a>)</li></ul><p>2021</p><ul><li>SEC and PSE Collaborated to Create a Platform for Sustainability Discussions. The theme of the <a href=\"https://www.sec.gov.ph/8th-annual-sec-pse-corporate-governance-forum/#gsc.tab=0\">8th SEC-PSE Corporate Governance Forum</a> was “Corporate Governance and Sustainability for the Next Normal”.</li><li>Capacity Building Seminar for PLCs in Partnership w/ AIM. PSE conducted a training for PLCs in partnership with the Asian Institute of Management – Ramon V. Del Rosario, Sr. Center for Corporate Responsibility entitled “Inclusion of Gender in Sustainability Reporting of Publicly-Listed Companies and other Private Companies” to promote and raise awareness on gender inclusion and equality. (<a href=\"https://sustainability.pse.com.ph/\">source</a>)</li></ul><p>2020</p><ul><li>SEC and PSE Collaborated to Create a Platform for Sustainability Discussions. The theme of the <a href=\"https://www.sec.gov.ph/notices-2020/7th-sec-pse-corporate-governance-forum/#gsc.tab=0\">7th SEC-PSE Corporate Governance Forum</a> was “Business Resiliency and Innovation in a New Normal Era”.</li></ul><p>2019</p><ul><li>SEC and PSE Collaborated to Create a Platform for Sustainability Discussions. The theme of the <a href=\"https://www.sec.gov.ph/notices-archive/6th-sec-pse-corporate-governance-forum/#gsc.tab=0\">6th SEC-PSE Corporate Governance Forum</a> was “Sustainable Businesses: Taking the Lead in Achieving Sustainable Development Goals”.</li><li>SEC-PSE Sustainability Writing Workshop PSE and SEC, in partnership with the Australia’s Department of Foreign Affairs and Trade (DFAT) through the Global Reporting Initiative (GRI), conducted a workshop series on Sustainable Business and Reporting. (<a href=\"https://www.sec.gov.ph/notices-archive/the-securities-and-exchange-commission-sec-in-partnership-with-the-philippine-stock-exchange-pse-and-global-reporting-initiative-gri-would-like-to-invite-you-to-a-series-of-workshops-on-sustaina/#gsc.tab=0\">source</a>)</li></ul><p>2018</p><ul><li>SEC and PSE Collaborated to Create a Platform for Sustainability Discussions. The 5th SEC-PSE CG Forum became the first sustainability-themed CG forum. The SEC and the PSE annually hosts the Corporate Governance Forum, to provide a platform for the government and the private sector to discuss relevant trends and updates in corporate governance and sustainability. (<a href=\"https://www.sec.gov.ph/wp-content/uploads/2020/02/2018NOTICE_5thSEC-PSECGFORUM_NEWforREGISTRATION.pdf\">source</a>)</li></ul><p>See the full list of ESG milestones <a href=\"https://sustainability.pse.com.ph/\">here</a><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>SME Board, since 2001.</li><li><a href=\"https://www.pse.com.ph/listing-application-process/\">Listing application process</a></li></ul><p>","wom":"No","womt":"No<br>Currently, there are no rules that require a minimum number of women in the boardroom. We note, however, that Recommendation 1.4 of <a href=\"https://www.sec.gov.ph/wp-content/uploads/2019/11/2016_memo_circular_no.19.pdf\" target=\"_blank\" rel=\"noopener\">SEC Memorandum Circular No. 19 Code of Corporate Governance for Publicly Listed Companies</a> provides that “The Board should have a policy on board diversity.” (p.7)","Additional_information":"<ul><li>The Philippine Stock Exchange, Inc. recognizes its pivotal role in driving sustainability in the capital market. As a self-regulatory organization and as a listed company, we are committed to furthering the advancement of sustainable<br>finance and developing short, medium, and long term projects to champion corporate sustainability and boost multi-stakeholder relations. The ESG Milestones of PSE can be found <a href=\"https://sustainability.pse.com.ph/\">here</a>.</li><li>Bell Ringing for Gender Equality PSE annually participates in the worldwide UN-initiated event “Ring the Bell for<br>Gender Equality”. The Ring the Bell for Gender Equality program is organized by the World Federation of Exchanges, Sustainable Stock Exchanges Initiative, UN Global Compact, UN Women, and International Finance Corporation. This annual event continues to this day. (<a href=\"https://sustainability.pse.com.ph/esg-stories/\">source</a>)</li></ul><p>","Organizational_model_of_stock_exchange":"Limited Exchange Self-Regulatory Organization (SRO) Model.<p><ul><li>Regulates listed companies through its Listing and Disclosure Rules, and Trading Participants (securities brokers) through its Revised Trading Rules and Rules Governing Trading Rights and Trading Participants and through its independent surveillance, investigation and audit arm, Capital Markets Integrity Corporation (CMIC), which enforces the CMIC Rules.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.sec.gov.ph/\">Republic of the Philippines Securities and Exchange Commission</a>.</li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model&#160;.<p><ul><li>Regulates listed companies through its Listing and Disclosure Rules, and trading participants (securities brokers) through its Rules Governing Trading Rights and Trading Participants and through its surveillance and audit arm Capital Markets Integrity Corporation (CMIC) and CMIC Rules.</li></ul><p>","About_the_stock_exchange":"Location: PSE Tower, 5th Avenue corner 28th Street, Bonifacio Global City, Taguig City, 1634 Philippines<p><p>Website Links:<br><a href=\"https://www.pse.com.ph/\">https://www.pse.com.ph/</a><br><a href=\"https://corporate.pse.com.ph/\">https://corporate.pse.com.ph/</a>","am":true,"os":false,"nz":true,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":140,"Country":"Poland","cc":"PL","Name0":"Warsaw Stock Exchange","Link":"/stock-exchange/gpw","Name":"<a href=\"https://www.gpw.pl/\">Warsaw Stock Exchange</a>","nlc":810,"dmc":197389.02,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Poland-WSE.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li>GPW published its <a href=\"https://www.gpw.pl/pub/GPW/ESG/ESG_Reporting_Guidelines.pdf\">ESG Reporting Guidelines</a> in 2021</li><li><a href=\"https://www.gpw.pl/dobre-praktyki\">Best Practices of WSE Listed Companies</a> (in Polish) - code of corporate governance implemented in January 2016.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>27th of September there is a conference - “<a href=\"https://www.gpw.pl/all-news?ph_main_01_start=show&ph_main_01_cmn_id=107403&title=Konferencja%20\">Non-financial reporting – as an entrance to the RESPECT Index</a>“.</li><li>In 2022, the Warsaw Stock Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/poland-tcfd-101-workshop-training/\">source</a>)</li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li>In August 2019 the exchange launched a new equity index which provides exposure to blue-chip stocks listed in Poland while tilting to those with the strongest environmental, social, and governance (ESG) profiles. The&#160;WIG-ESG Index&#160;includes 60 of the largest and most-liquid securities trading on GPW, deriving its constituents from the large-cap&#160;WIG20 Index&#160;and mid-cap&#160;mWIG40 Index.&#160;Constituents are assigned ESG scores using insights from Amsterdam-based ESG analytics firm&#160;Sustainalytics.&#160;<a href=\"https://www.etfstrategy.com/warsaw-stock-exchange-launches-poland-esg-equity-index/\">(Source)</a>.</li><li><a href=\"https://www.respectindex.pl/\">RESPECT Index</a>:&#160;&#160;The RESPECT Index is Central and Eastern Europe’s first social responsibility index (SRI). The project was initiated by Warsaw Stock Exchange in 2009 when the first index portfolio was published. The RESPECT Index portfolio covers Polish and foreign companies listed on the WSE Main Market which follow the highest corporate governance, disclosure and investor relations standards, and which also take into account environmental, social and governance factors. The participating companies are screened by WSE and the Association of Listed Companies (SEG) in a three-stage process of review of all these factors and additionally audited by the project partner since the first edition:&#160;<a href=\"https://www2.deloitte.com/pl/pl/pages/zarzadzania-procesami-i-strategiczne/articles/respect-index-2.html\">Deloitte</a>.</li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><p>In June 2023, GPW Launched Warsaw Sustainable Segment (<a href=\"https://www.gpw.pl/news?cmn_id=114051&title=GPW+Launches+Warsaw+Sustainable+Segment\">source</a>)</p><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://newconnect.pl/\">WSE NewConnect</a>, since 2007.</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Public listed company; IPO in 2010.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.knf.gov.pl/en/\">Polish Financial Supervision Authority (PFSA)</a>.</li></ul><p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model</p><ul><li>The Warsaw Stock Exchange publishes a set of rules and regulations and possesses its own regulations management board and supervisory board. &#160;However, the Polish Financial Supervision Authority appears to dictate market rules and develop the acts that the exchange must follow. The Warsaw Stock Exchange is able to engage in limited self-regulatory activities, including tasks such as market monitoring.</li></ul><p>","About_the_stock_exchange":"<p>Location: Warsaw, Poland</p><ul><li>WSE started operation in 1991 as a company held 100% by the State Treasury. In 2010, the State Treasury arranged a public offering of WSE shares; as a result, shares of the Exchange were newly listed on the WSE Main Market on 9 November 2010. Warsaw Stock Exchange is the largest national financial instruments exchange in the region of Central and Eastern Europe1 and one of the fastest-growing exchanges in Europe. The Group offers a wide range of products and services within its trading markets of equity, derivative, debt and structured products, electricity, natural gas, property rights, as well as clearing of transactions, operation of the Register of Certificates of Origin of electricity and sale of market data. As at 31 December 2013, WSE was a leader in the CEE Region in terms of capitalisation of listed companies, the value of turnover in shares and the volume of turnover in derivatives. The share of WSE in trading in shares in the Region increased from 54.3% in 2012 to 58.5% in 20132 . Furthermore, the electricity market comprised of the spot and the forward market operated by the Polish Power Exchange (“PolPX”), was the largest electricity market as measured by the volume of trade in 2013 in the CEE Region.&#160;More details&#160;<a href=\"https://www.gpw.pl/pub/GPW/files/PDF/RI/2018_03_GPW_Fact_sheet_EN.pdf\">here.&#160;</a></li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":141,"Country":"Portugal","cc":"PT","Name0":"Euronext Lisbon","Link":"/stock-exchange/euronext-lisbon","Name":"<a href=\"https://www.bolsadelisboa.com.pt/\">Euronext Lisbon (Bolsa de Lisboa)</a>","nlc":53,"dmc":81627,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/portugal-euronext-lisbon.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li>There is a chapter in the annual report dedicated to sustainability activities, find all reports <a href=\"https://www.euronext.com/en/investor-relations/financial-information/financial-reports\">here</a>.</li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>The <a href=\"https://www.europarl.europa.eu/RegData/etudes/BRIE/2021/654213/EPRS_BRI%282021%29654213_EN.pdf\">European directive on non-financial information reporting (NFRD)</a> has been implemented into the Portuguese legal environment.</li><li>Moreover, Euronext Lisbon supports and implements ESMA’s and National Competent Authorities stringent rules with regards to governance among its community of listed companies.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"/sites/sseinitiative/files/documents/euronext-esg-guide-2022.pdf\">ESG Reporting Guide – Target 1.5°C</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br>Through the Euronext Academy, see more details&#160;<a href=\"https://www.corporateservices.euronext.com/academy?s=ESG\">here</a>.<p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li>See the list of indices on the Euronext website&#160;<a href=\"https://live.euronext.com/products-indices/index-rules\">here</a>. ESG/ISR indices fall under the tab “theme indices”. This list is automatically updated.</li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.euronext.com/en/list-products/bonds/green-bonds\">Euronext ESG Bonds</a> is a community of ESG bond issuers where green, sustainability, social, blue and sustainability-linked bonds listed on all Euronext locations are consolidated onto one highly visible area. Details of the securities <a href=\"https://live.euronext.com/en/products/fixed-income/esg-bonds\">here</a>.</li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>Euronext Growth,&#160;Euronext Access,&#160;Euronext Access+. More information <a href=\"https://www.euronext.com/en/raise-capital/sme\">here</a>.</li></ul><p></p>","wom":"No","womt":"No","Additional_information":"Euronext supports climate friendly innovations by financing Cleantech SME’s benefitting from major Euronext initiatives:<p><ul><li>TechShare: 27 Cleantech have followed the program on how to leverage capital markets</li><li>Tech40 Index: 10% of this increasingly important index is made up of Cleantech SME’s</li><li>Morningstar: the program fully covers the scope of Cleantech SME issuers (55).</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2000.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cmvm.pt/en/Pages/homepage.aspx\">The Portuguese Securities Market Commission (CMVM).</a></li><li><a href=\"https://www.portugal.gov.pt/en/ministries/mf/the-team.aspx\">The Portuguese Ministry of Finance.</a></li><li><a href=\"https://www.esma.europa.eu/\">European Union (ESMA).</a></li></ul><p></p>","Regulatory_model":"Government (Statutory) Model<p><ul><li>The Markets in Financial Instruments Directive (MiFID) classifies Euronext’s European cash markets as a regulated market. As such, the real-time monitoring performed by Euronext’s cash market operations and technical support is formally enforced, and our trading rules and procedures are approved by our five regulators. This regulatory and organizational system gives&#160; Euronext the power to efficiently manage crisis situations and extraordinary circumstances. Some of the markets organized by Euronext are exchange regulated, which means they are subject to a body of rules laid down by the market operator, Euronext. They are not regulated markets as defined by the Markets in Financial Instruments Directive (MiFID). These structured, exchange regulated markets offer simplified access to financial markets and streamlined listing requirements for companies from every sector of the economy, while ensuring compliance with rules on investor disclosure and the control of financial information.&#160;<a href=\"https://www.euronext.com/en/equities/market-regulation\">(Source)</a>.</li></ul><p></p>","About_the_stock_exchange":"Location of the listed holding: Portugal, Lisbon.<ul><li>As a market operator, Euronext Lisbon is governed by Portuguese Decree of Law No. 357-C/2007 of 31 October 2007 which, along with the Portuguese Securities Code and regulations of the Comissão do Mercado de Valores Mobiliários (“CMVM”), governs the regime applicable to regulated markets and MTFs, market operators and other companies with related activities in Portugal. The creation of regulated market operators requires the prior authorisation in the form of a decree-law from the Portuguese Minister of Finance, following consultation with the CMVM. The CMVM is an independent public authority that supervises and regulates markets and market participants, public offerings and collective investment undertakings. Its objectives are to ensure investor protection and an efficient and regular functioning of markets, monitor information, prevent risk and prevent and suppress illegal actions. The entities subject to the supervision of the CMVM should co-operate with the CMVM as requested. The CMVM carries out “on-site” supervision of the entities subject to its supervision and makes public infringements and fines imposed in accordance with applicable law. Euronext is the leading pan-European exchange in the Eurozone, spanning Belgium, France, Ireland, Norway, the Netherlands, Portugal, the UK and Ireland. Created in 2000, it unites markets which date back to the start of the 17th century. It is the primary exchange in the Euro zone with nearly 1,500 listed issuers worth more than €4.5 trillion in market capitalization as of end May 2019, an unmatched blue chip franchise consisting of 20+ issuers in the Morningstar® Eurozone 50 Index℠ and a strong diverse domestic and international client base.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":142,"Country":"Qatar","cc":"QA","Name0":"Qatar Stock Exchange","Link":"/stock-exchange/qe","Name":"<a href=\"https://www.qe.com.qa/\">Qatar Stock Exchange</a>","nlc":51,"dmc":200834,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Qatar-Qatar-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br><ul><li>However, in 2009 the Qatar Financial Market Authority (QFMA) introduced&#160;the Corporate Governance Code (the QFMA Code).&#160;Qatar’s listed companies are required to operate within a ‘comply or explain’ corporate governance code administered by QFMA.</li></ul><p></p>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"/wp-content/uploads/2015/11/Guidance-on-ESG-Reporting.pdf\">Guidance on ESG reporting</a>.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>In&#160;<a href=\"https://www.mondovisione.com/media-and-resources/news/qatar-stock-exchange-promotes-sustainability-and-esg-disclosure-among-qatari-liste/\">October 2017</a>, the Qatar Stock Exchange held a senior level sustainability engagement session with listed companies to promote the business case for ESG and sustainability in partnership with Sustainability Excellence, a leading provider of sustainability and ESG strategy and disclosure services in Qatar and the Middle East.</li></ul><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>QSE SME Bourse, since 2017.</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Private company for profit.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.qfma.org.qa/English/Home.aspx\">Qatar Financial Markets Authority (QFMA).</a></li></ul><p>","Regulatory_model":"Independent Member Self-Regulatory Organization (SRO) Model<p><ul><li>The Qatar Financial Markets Authority has full regulatory oversight and enforcement of the capital markets in Qatar. However, it should be noted that this institution was developed as a result of governmental law.</li></ul><p>","About_the_stock_exchange":"Location:&#160;Doha, Qatar.<p><ul><li>Established in 1995, the Doha Securities Market (DSM) officially started operations in 1997. Since then the exchange has grown to become one of the leading stock markets in the GCC region. In June 2009, Qatar Holding, the strategic and direct investment arm of Qatar Investment Authority (QIA), and NYSE Euronext, the world’s leading exchange group, signed an agreement to form a major strategic partnership to establish the Exchange as a world-class market. The DSM was renamed the Qatar Stock Exchange on the conclusion of the deal. The primary aim of the Qatar Stock Exchange is to support Qatar’s economy by providing a venue for capital raising for Qatari companies as part of their corporate strategy and giving investors a platform through which they can trade a variety of products in a transparent and efficient manner. The Qatar Stock Exchange also provides the public with access to market information and ensures correct disclosure of information.&#160;<a href=\"https://www.qe.com.qa/about-qse\">(Source)</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Plans to invest in developing the carbon markets","Source_lnk":"https://thepeninsulaqatar.com/article/01/02/2023/qatar-eyes-carbon-credits-to-meet-emission-cut-target"},{"id":143,"Country":"Korea, Republic of","cc":"KR","Name0":"Korea Exchange","Link":"/stock-exchange/krx","Name":"<a href=\"https://global.krx.co.kr/main/main.jsp\">Korea Exchange (KRX)</a>","nlc":2406,"dmc":2218658.14,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Korea-KoreaStockExchangeKRX.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br><ul><li>The Financial Services Commission’s &#160;Green Posting System (2012) requires around 500 firms to post the amount of GHG emission and energy usage and the certification of green technology and green business. Moreover, if the firms are listed on the Korean Stock Exchange, they are required to include the information in their annual reports.&#160;<a href=\"https://www.globalreporting.org/information/policy/initiatives-worldwide/Pages/South-Korea.aspx\">(Source)</a>.</li><li>KOSPI listed companies with total assets of more than KRW 2 trillion are required to submit their corporate governance reports from 2019, <a href=\"https://global.krx.co.kr/contents/GLB/02/0203/0203000000/GLB0203000000.jsp#ab8758eced0475769e200e7e309baf77=1&view=20496\">here</a>.</li></ul>","hwg":"No","hwgt":"No<br><ul><li>KRX published ‘Guidelines on Disclosure of Corporate Governance'&#160;for listed companies on April 2019.</li><li>You can find press release and the guidelines with <a href=\"https://global.krx.co.kr/contents/GLB/02/0203/0203000000/GLB0203000000.jsp#ab8758eced0475769e200e7e309baf44=1&ab8758eced0475769e200e7e309baf77=1&view=20496\">this link</a>.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>2019&#160;<a href=\"https://eindex.krx.co.kr/board/GLB0202010104/bbs#view=13\">KRX Index Conference,</a>&#160;which focused on ESG investment.</li><li>In 2022, KRX provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/south-korea-tcfd-101-workshop-training/\">source</a>)</li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><p><a href=\"https://eindex.krx.co.kr/contents/GLB/05/0502/0502030400/GLB0502030400.jsp\">KRX Indices</a>:</p><ul><li>KRX ESG Leaders 150</li><li>KRX Governance Leaders 100</li><li>KRX Eco Leaders 100</li><li>KRX ESG Social Index</li><li>KOSPI 200 ESG.</li></ul>&#160;<p><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>KRX launched on June 2020 the <a href=\"https://sribond.krx.co.kr/en/\">SRI (Socially Responsible Investment) Bonds</a><ul><li>The issuing proceeds of SRI bonds are used for projects that are eco-friendly or generate social benefits, and they are called green, social and sustainable bonds. They are also referred to as ESG, thematic and social contribution bonds.</li></ul></li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://global.krx.co.kr/contents/GLB/02/0201/0201010301/GLB0201010301.jsp\">KOSDAQ (Korea).</a></li></ul><p>","wom":"Yes","womt":"Yes<br><ul><li>There is a mandatory minimum rule of at least 1 woman on boards. Source: MSCI. (2020). <a href=\"https://www.msci.com/documents/10199/9ab8ea98-25fd-e843-c9e9-08f0d179bb85\">Women on Boards: 2020 Progress Report</a>. Details of the rule: As of July 2020, a large listed company should not have a board comprising only one gender.</li></ul>","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Demutualized for profit; demutualization in progress.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fsc.go.kr/eng/\">Financial Services Commission.</a></li><li><a href=\"https://english.fss.or.kr/fss/eng/main.jsp\">Financial Supervisory Service.</a></li><li><a href=\"https://eng.kofia.or.kr/index.do\">Korean Financial Investment Association.</a></li></ul><p>&#160;</p><p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model</p><ul><li>The Korea Exchange has regulatory authority over the listing requirements and certain trading rules such as membership eligibility. The Securities and Futures Commission (SFC) is a sub committee of the Financial Services Commission (FSC); the organisation with the responsibility of Korea's financial markets. The SFC's primary regulatory responsibilities are: market surveillance, company accounting standards and audit reviews, as well as other responsibilities delegated from the FSC. There is a mix of regulatory authority but the majority, and some of the most important, responsibilities fall under Korea's SFC and FSC.</li></ul><p>","About_the_stock_exchange":"<p>Location: Seoul, Republic of Korea</p><ul><li>The Korea Exchange (KRX), which was launched in January 2005 by consolidating the four domestic markets, is committed to further the market credibility, customer-oriented management and confidence of organization, thus building up itself as a leading capital market in Northeast Asia. The Management Strategy Division establishes the business strategy and management reform agenda, and proposes the long-term vision necessary for enhancement of the KRX’s reputation.&#160;<a href=\"https://global.krx.co.kr/contents/GLB/01/0101/0101000000/GLB0101000000.jsp\">(Source)</a>.</li></ul>","am":true,"os":true,"nz":false,"VCM":"No","CCM":"Yes","Notes":"Facilitates trading of allowances for the Korea ETS.","Source_lnk":"https://icapcarbonaction.com/en/news/south-korea-approves-initial-wave-near-term-ets-reforms"},{"id":144,"Country":"Romania","cc":"RO","Name0":"Bucharest Stock Exchange","Link":"/stock-exchange/bvb","Name":"<a href=\"https://bvb.ro/\">Bucharest Stock Exchange (BVB)</a>","nlc":82,"dmc":32288.88,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/romania-bvb.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.bvb.ro/AboutUs/UNSSEinitiative\">Yes</a><br><ul><li>Bucharest Stock Exchange, as a listed company, prepares an Annual Environmental & Social Reporting, as part of the BVB Directors’ Consolidated Reports, available <a href=\"https://www.bvb.ro/InvestorRelations/FinancialFigures/FinancialReports\">here</a>.</li><li><a href=\"https://www.ebrd.com/news/publications/policies/environmental-and-social-policy-esp.html\">The Annual Environmental & Social Reporting is made based on the EBRD Environmental and Social Policy</a>.</li></ul><p></p>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"/sites/sseinitiative/files/documents/bvb-esg_reporting_guidelines.pdf\">ESG Reporting Guidelines</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>Bucharest Stock Exchange conducted workshops and seminar on ESG and Green finance topics in collaboration with partners such as CSDB (on TCFD recommendations), Sustainalytics and IFC.</li></ul><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://www.bvb.ro/AboutUs/UNSSEinitiative\">Sustainability</a> section on the website.</li><li>BVB&#160;<a href=\"https://www.bvb.ro/info/Rapoarte/Diverse/ENG_Corporate%20Governance%20Code_WEB_revised.pdf\">Code of Corporate Governance.</a></li><li>Information about new&#160;<a href=\"https://www.bvb.ro/AboutUs/MediaCenter/PressItem/Bucharest-Stock-Exchange-launches-a-new-reporting-system-for-listed-companies-IRIS/4308\">Issuers Reporting Information System (IRIS).</a></li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Public listed company. Demutualised in 2005.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://asfromania.ro/en/\">Financial Supervisory Authority (ASF).</a></li></ul><p></p>","Regulatory_model":"<ul><li>Romanian Financial Supervisory Authority (ASF) sets the operational principles of the capital markets in Romania, as well as the rules applied to the market and system operators, listed companies and investment funds. firms. Bucharest Stock Exchange (BVB), as the market operator for the Regulated Market and system operator for the Alternative Trading System, has the authority to regulate the organization and carry out the specific activities of its markets in terms of financial instruments available for trading, as well as specific rules applied to listed companies and investment firms. BVB also carries out monitoring activities, within the specific framework that is in line with applicable regulation. Taking all of the above into consideration and due to the regulatory role of ASF, Bucharest Stock Exchange is a limited self regulatory organization.</li></ul><p>","About_the_stock_exchange":"<p>Location: Bucharest, Romania</p><ul><li>About BVB:&#160;Click&#160;<a href=\"https://bvb.ro/AboutUs/Overview\">Here</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":145,"Country":"Russian Federation","cc":"RU","Name0":"Moscow Exchange","Link":"/stock-exchange/moex","Name":"<a href=\"https://www.moex.com/en/\">Moscow Exchange</a>","nlc":832,"dmc":517348.65,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Russia-MoscowExchangeMOEX.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.moex.com/s1354\">Yes</a><br><ul><li><a href=\"https://www.moex.com/s1354\">Moscow Exchange’s 2019 Sustainability Report</a> is the first non-financial report ever produced by the Company for the general interested public. The publication of this Report is an important milestone for Moscow Exchange, as it affirms their commitment to continuing the journey of sustainability and encouraging responsible business practices both within the Moscow Exchange Group and among our partners and issuers.</li><li>MOEX also has a&#160;<a href=\"https://www.moex.com/s975\">Social Responsibility and Charity</a>&#160;Section on website.</li><li>All sustainability reports can be found <a href=\"https://www.moex.com/s975\">here</a></li></ul><p></p>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br>On 19 January 2022, Moscow Exchange announced an updated version of its ESG Guide,&#160;<a href=\"https://fs.moex.com/f/16010/mosbirzha-esg-rus-book-1012.pdf\">“A Guide for Issuers: How to Comply with Best Sustainability Practices”</a>. (in Russian)<p>","oert":"Yes","oertt":"Yes<br>In 2021, the Moscow Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/russia-tcfd-101-workshop-training/\">source)</a><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li class=\"m_965943476275165350m_-6196547366330090492gmail-m_-1878879534192118653MsoListParagraph\"><a href=\"https://www.moex.com/en/index/MRSV\">MOEX - RSPP Sustainability Vector Index.</a></li><li class=\"m_965943476275165350m_-6196547366330090492gmail-m_-1878879534192118653MsoListParagraph\"><a href=\"https://www.moex.com/en/index/MRRT\">MOEX - RSPP Responsibility and Transparency Index .</a></li><li><a href=\"https://www.moex.com/n23092/?nt=206\">Both launched in 2019.</a></li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>Updates to the Moscow Exchange Listing Rules taking effect on 12 August 2019 created a <a href=\"https://www.moex.com/n24637\">Sustainability Sector</a> for financing projects in the fields of environmental and social sustainability. The new sector will consist of three independent segments: green bonds, social bonds and national projects.</li><li>The segments for green and social bonds are for Russian and international securities that meet requirements for a bond issue, issuer and investment project as set forth in the Green Bond Principles of the International Capital Market Association (ICMA) or the standards of the Climate Bonds Initiative (CBI). Whether a bond meets these requirements requires confirmation from an external review provider. This corresponds with the concept currently developed for green, social and sustainability bonds by the Russian Ministry of Economic Development, relevant government agencies, the Bank of Russia and business community. The concept will provide tax incentives for issuers and financial support from the Bank of Russia for investors (including provisioning benefits).&#160;The segment for national projects will include Russian and international bonds that meet the objectives of national projects such as “Environment”, “Demography” and “Public Health”.</li><li>On 12 November 2019, Moscow Exchange’s Sustainability Sector welcomed its first instrument – a <a href=\"https://www.moex.com/n25802\">green bond issued by Center-invest Bank</a>. &#160;The RUB 250 mln one-year bond will be offered on 15 November. The funds raised will be used to finance and refinance outstanding loans given to promote energy-saving initiatives, renewable energy sources and green transport.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.moex.com/s396\">Innovation and Investment Market (ilM)</a>, since 2012.</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2011.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cbr.ru/eng/\">The Central Bank of Russia.</a></li></ul><p>","Regulatory_model":"Government (Statutory)&#160;Model<p><ul><li>The Bank of Russia Financial Markets Service, operated under the Central Bank of Russia, has full regulation, control and supervision of the financial markets. The Moscow Exchange does not appear to have any regulatory authority.</li></ul><p>","About_the_stock_exchange":"Location: Moscow, Russian Federation<p><ul><li>Moscow Exchange is Russia's largest securities exchange group. Established on 19 December 2011 with the merger of MICEX Group (created in 1992) and RTS Group (1995), it ranks among world's top 20 exchanges by trading volume and total market cap of shares traded, and among the top 10 derivatives exchanges. Its participants enjoy the state of the art, hi tech infrastructure to trade stocks, bonds, currency, fund shares, ETFs, commodities (grain, gold, silver), and derivatives, including OTC.&#160;<a href=\"https://www.moex.com/s348\">(Source)</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"Yes","CCM":"No","Notes":"In late 2022, the Russian National Commodity Exchange, part of the Moscow Exchange Group, started trading of carbon credits. Carbon units were generated from voluntary climate projects or certified emission reduction units, rather than carbon credits or allowances.","Source_lnk":"https://www.green.earth/news/russias-carbon-credit-methodologies-to-cut-emissions"},{"id":146,"Country":"Rwanda","cc":"RW","Name0":"Rwanda Stock Exchange","Link":"/stock-exchange/rse","Name":"<a href=\"https://www.rse.rw/\">Rwanda Stock Exchange (RSE)</a>","nlc":10,"dmc":3572.55,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Rwanda-RwandaStockExchange-RSE.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br><ul><li>However, does require&#160;<a href=\"https://www.rse.rw/documents/RSE_RULE_BOOK.pdf\">a statement of main corporate governance practices</a>&#160;for listing companies.</li></ul>","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>RSE Alternative Market Segment, since 2013.</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Demutualized at start in 2005.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cma.rw/index.php?id=43\">Rwanda's Capital Market Authority (CMA)</a>.</li></ul><p>","Regulatory_model":"<ul><li>Capital Market Authority (CMA) was established by the Prime Minister’s Order of 28 March 2007 to initially guide the development of a Capital Market in Rwanda. It was previously referred to as the Capital Market Advisory Council (CMAC) till June 9th ,2011 , CMAC operated as the Capital Market Regulator, pending the creation of the CMA as provided in the Law N°11/2011 of 18/05/2011 published on 9th June, 2011.</li><li>CMAC facilitated the creation of the RSE as a Stock Exchange and admitted 10 members of the RSE awaiting licensing powers provided in the newly published CMA law. One of the statutory objectives of the Capital Market Authority, CMA is to promote and develop the capital markets industry in Rwanda. Investor education is one of the ways of attaining this goal.</li></ul><p>","About_the_stock_exchange":"Location: Kigali, Rwanda<p><ul><li>The Rwanda Stock Exchange Limited was incorporated on 7th October 2005 with the objective of carrying out stock market operations.&#160; The Stock Exchange was demutualised from the start as it was registered as a company limited by shares.</li></ul>","am":false,"os":false,"nz":true,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":147,"Country":"Saudi Arabia","cc":"SA","Name0":"Saudi Exchange","Link":"/stock-exchange/tadawul","Name":"<a href=\"https://www.tadawul.com.sa/wps/portal/tadawul/home/\">Saudi Exchange</a>","nlc":227,"dmc":2827166.57,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Saudi-Arabia-Tadawul-Stock-Exchange.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://saudire.net/images/ESG/ESG_report_Ar_2020.pdf\">Yes</a><br>","ESGrr":"No","ESGrrt":"No<br><ul><li>New corporate governance rules issued by the Saudi Capital Market Authority (CMA) were adopted in February 2017. The rules enhance the rights of shareholders and board members and provide greater clarity and more transparency around determining commercial strategic planning, roles, responsibilities and oversight of corporate entities and third parties.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>Has committed to publishing a guidance in 2019.</li></ul><p>","oert":"Yes","oertt":"Yes<br><p>In 2022, the Saudi Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/saudi-arabia-tcfd-101-workshop-training/\">source</a>)</p><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>Parallel market - <a href=\"https://www.tadawul.com.sa/wps/portal/tadawul/markets/nomu\">Nomu.</a></li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li>All of Tadawul’s sustainability work is underpinned by honoring its national responsibilities of adopting regulatory and market best practices, fostering market literacy and investor protection and delivering on its socio-economic responsibilities. Tadawul has a strong commitment to reducing its footprint on the natural environment by better utilizing resources in order to achieve a higher level of efficiency and sustainability. One environmental initiative in Tadawul is the development of a Recycling & Waste Management Program.</li><li><a href=\"https://www.tadawul.com.sa/wps/wcm/connect/7ea9ab40-5d5a-4f6c-a200-c18f849e913f/Tadawul+AR2017-English.pdf?MOD=AJPERES&CONVERT_TO=url&CACHEID=ROOTWORKSPACE-7ea9ab40-5d5a-4f6c-a200-c18f849e913f-mjHc2WS\">Annual Report 2017.</a></li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Unlisted private company for profit.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://cma.org.sa/en\">Capital Market Authority (CMA).</a></li></ul><p>","Regulatory_model":"<p>Government (Statutory) Model.</p><ul><li>The Saudi Exchange has regulatory power over the following rules & regulations which have been approved by CMA: The Updated Securities Depository Center Rules, Securities Borrowing and Lending Regulations, Short Selling Regulations, The Updated Exchange and Centre Procedures, Orders Aggregation Accounts Regulations, and Listing Rules. You can see the Rules & Regulations&#160;<a href=\"https://www.tadawul.com.sa/wps/portal/tadawul/knowledge-center/rules-%26-regulations/Exchange-and-Centre-Procedures\">here</a>.</li></ul><p>","About_the_stock_exchange":"<p>Location: Riyadh, Saudi Arabia.</p><ul><li>On the 19th of March 2007, the Council of Ministers approved the formation of The Saudi Stock Exchange (Tadawul). This was in accordance with Article-20 of the Capital Market Law establishing Tadawul as a joint stock company. Tadawul is the sole entity authorized in the Kingdom of Saudi Arabia to act as the Securities Exchange (the Exchange). It mainly carries out listing and trading in securities, as well as deposit, transfer, clearing, settlement, and registry of ownership of securities traded on the Exchange. The legal status, duties, and responsibilities of the Exchange and Depository Center are explicitly defined in the Capital Market Law (CML) issued by Royal Decree Number (M/30), dated on June 16, 2003. The Exchange is also the official source of all market information.</li><li>Tadawul is an affiliate member of the International Organization of Securities Commissions (IOSCO), the World Federation of Exchanges (WFE), and the Arab Federation of Exchanges (AFE).</li><li><a href=\"https://www.tadawul.com.sa/wps/portal/tadawul/home/\">Website</a></li></ul>","am":true,"os":true,"nz":true,"VCM":"Yes","CCM":"No","Notes":"The exchange’s parent company, Saudi Tadawul Group, owns 20% of the Saudi Voluntary Carbon Market Company.","Source_lnk":"https://www.spa.gov.sa/2395130"},{"id":148,"Country":"Serbia","cc":"RS","Name0":"Belgrade Stock Exchange","Link":"/stock-exchange/belex","Name":"<a href=\"https://www.belex.rs/eng/\">Belgrade Stock Exchange</a>","nlc":342,"dmc":4731,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/serbia-belgrade-stock-exchangepdf.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br><ul><li>However, listed companies have to abide by a Corporate Governance Code they adopted themselves or by some other CG Code, like CG Code of the Serbian Chamber of Commerce.</li></ul>","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><ul><li>A yearly training course is held called “Fundamentals of Corporate Governance” started on 14 July 2017, and the second year was held on 16 March 2018.</li><li>In 2022, the Belgrade Stock Exchange provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/banja-luka-and-belgrade-stock-exchanges-tcfd-101-workshop-training/\">source</a>)</li></ul><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>Smart Listing – offering relaxed listing requirements for SMEs.</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li>Belgrade Stock Exchange Rules of Business Conduct.</li><li>Questionnaire on Corporate Governance practices of companies.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Belgrade Stock Exchange is a joint stock company, for profit. It doesn't have the status of a public company. Shares of the Belgrade Stock Exchange can be transacted, respecting pre-emptive rights of existing shareholders of the Exchange. Exchange Articles of Association regulate the procedure for the secondary transactions of the Exchange shares.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.sec.gov.rs/index.php/en/\">Securities and Exchange Commission</a> (SEC).</li><li><a href=\"https://www.mfin.gov.rs/?change_lang=en\">Ministry of Finance of the Republic of Serbia.</a></li></ul><p></p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model</p><ul><li>The Belgrade Stock Exchange as a market operator operates a Regulated Market and multilateral trading facility (MTP) in accordance with the Law on Capital Market, by-laws and rules & regulations.</li><li>Securities and Exchange Commission is the primary regulatory authority for the capital market in Serbia. The Securities and Exchange Commission regulates, supervises and monitors enforcement of the Law on Capital Market, Takeover Law, Law on Investment Funds and Law Prevention of Money Laundering and Terrorism Financing, when it comes to custody and broker-dealer activities. The SEC main responsibilities in regulating the stock exchange operations is to supervise the legality of the stock exchange organization and the decisions made by the bodies of the exchange as well as the proper conduct of stock exchange trading. Rules on Business Conduct and Listing requirements are defined by the Belgrade Stock Exchange. However, as they are subject to the SEC’s approval hence the limited self-regulatory powers of the Belgrade Stock Exchange.</li></ul><p>","About_the_stock_exchange":"<p>Location: Belgrade, Serbia</p><ul><li>Belgrade Stock Exchange was founded in 1894 with the first transactions concluded in 1895. After the World War II it was closed and resumed operations in 1989 as the Yugoslav Capital Market. In 1992, the Yugoslav Capital Market changed its name to the Belgrade Stock Exchange. In the 1990s, the trading material mostly consisted of corporate debt instruments, government bonds and the like. Although the first trades in shares were carried out in 1991, it was only in 2000 that a significant step forward was made, when shares from the privatization processes were included in the secondary market.</li><li>Today, Belgrade Stock Exchange is a modern market-oriented exchange which operates the only securities exchange in Serbia. It organizes trading in financial instruments in a fair, efficient and transparent manner. Additional services include data vending, index development and specialized educational seminars and training courses.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No visible plans on carbon trading mechanisms","Source_lnk":"https://serbia-business.eu/the-low-carbon-development-strategy-was-adopted-in-serbia-but-is-it-too-late/"},{"id":149,"Country":"Seychelles","cc":"SC","Name0":"MERJ Exchange","Link":"/stock-exchange/merj","Name":"<a href=\"https://merj.exchange/\">MERJ Exchange  (previously Trop-X)</a>","nlc":51,"dmc":1213.04,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Seychelles-Trop-X.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br><ul><li>However, has&#160;<a href=\"/esg-guidance/\">committed</a>&#160;to publishing a guidance.</li></ul><p>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.trop-x.com/markets\">Trop-X SME Board</a>, since 2012.</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li>The board and management of Trop-X view corporate social responsibility as a key business objective. Responsible business is embedded within the Company’s Strategy and is supported across the business. Clear governance structures and visible leadership play a vital role in embedding corporate responsibility throughout the Company. <a href=\"https://www.trop-x.com/about-trop-x/company/corporate-social-responsibility\">(Source)</a>.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Trop-X (Seychelles) Limited is a wholly owned private company licensed as a Seychelles Securities Exchange and owns AfriClear Limited (a licensed Seychelles Clearing Agency) and AfriDep (a licensed Seychelles Securities Facility). The exchange went live in August of 2013 with the launch of its first listing on its Equities Markets.</li><li>Shareholders include a combination of institutional and private investors.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fsaseychelles.sc/index.php\">Seychelles Financial Services Authority.</a></li></ul><p>","Regulatory_model":"<ul><li>The Seychelles Financial Services Authority is responsible for monitoring the operation of the securities exchange, however, Trop-X regulates its members, issuers and service providers by using its approved regulatory framework.</li></ul><p>","About_the_stock_exchange":"<ul><li>Trop-X is a multi-asset, multi-currency modern financial exchange that launched in 2013. More info&#160;<a href=\"https://www.trop-x.com/legal/terms-and-conditions\">here</a>.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":150,"Country":"Singapore","cc":"SG","Name0":"Singapore Exchange (SGX Group)","Link":"/stock-exchange/sgx","Name":"<a href=\"https://www2.sgx.com/\">Singapore Exchange (SGX Group)</a>","nlc":643,"dmc":606802.61,"SSEPE":"Yes","SSEPEt":"Yes","asr":"Yes","asrt":"Yes <a href=\"https://api2.sgx.com/sites/default/files/2022-09/FY%202022%20Annual%20Report%20%28Sustainability%20Report%20pages%2044-82%29_0.pdf\">Yes</a><br><ul><li>Sustainability Section in the annual report.</li><li>The annual reports can be accessed <a href=\"https://investorrelations.sgx.com/financial-information/annual-reports\">here</a></li></ul><p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li><a href=\"http://rulebook.sgx.com/rulebook/practice-note-76-sustainability-reporting-guide\">Sustainability Reporting Guide</a> as of January 2022: listing rules <a href=\"https://rulebook.sgx.com/rulebook/711a\">711A</a> and <a href=\"https://rulebook.sgx.com/rulebook/711b\">711B</a></li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://api2.sgx.com/sites/default/files/2018-07/Sustainability%20Reporting%20Guide%20%28220218%29.pdf\">Guide to Sustainability Reporting for Listed Companies</a> (<a href=\"http://rulebook.sgx.com/rulebook/practice-note-76-sustainability-reporting-guide\">Practice note 7.6 - Sustainability Reporting Guide</a>)</li><li><a href=\"https://www.sgx.com/sustainability\">Sustainability reporting portal</a> on SGX Group website containing resources relating to sustainability reporting, including materials contributed by sustainability consultants, information on sustainability workshops and global reporting frameworks.</li><li>For more information see the <a href=\"https://www.sgx.com/sustainable-finance/sustainability-knowledge-hub\">Sustainability Knowledge Hub</a></li></ul><p>","oert":"Yes","oertt":"Yes<br>In 2022, SGX Group provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/singapore-tcfd-101-workshop-training/\">source</a>)<p><p>Capacity Building and Training Intiatives and programs on ESG related topics can be found <a class=\"waffle-rich-text-link\" href=\"https://www.sgx.com/sustainable-finance/capacity-building-training#SGX%20Academy\">here</a>.<p>","mcbsri":"Yes","mcbsrit":"Yes<br>All SDG and ESG Indices <a class=\"waffle-rich-text-link\" href=\"https://www.sgx.com/sustainable-finance/indices\" data-sheets-formula-bar-text-link=\"https://www.sgx.com/sustainable-finance/indices\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:''docs-Calibri'';font-style:normal;text-decoration-skip-ink:none;\">here</a> , ESG Stock Ratings <a class=\"waffle-rich-text-link\" data-sheets-formula-bar-text-link=\"https://www.sgx.com/sustainable-finance/stock-ratings\" data-sheets-formula-bar-text-style=\"font-size:16px;color:#1155cc;font-weight:normal;text-decoration:underline;font-family:''docs-Calibri'';font-style:normal;text-decoration-skip-ink:none;\">here</a><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.sgx.com/fixed-income/green-social-sustainability-fixed-income-securities\">Green, Social & Sustainability Fixed Income Securities</a> More <a href=\"https://www.sgx.com/sustainable-finance/fixed-income\">here</a></li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.sgx.com/catalist\">SGX Catalist</a>, since 2008.</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://www.sgx.com/sustainable-finance/sustainability-knowledge-hub\">SGX Group - Sustainability Knowledge Hub&#160;</a></li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 1999.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.mas.gov.sg/\">Monetary Authority of Singapore</a>.</li></ul><p>","Regulatory_model":"Strong Exchange Model.<p><ul><li>The Singapore Exchange states on its website that it is ‘the frontline regulator' and that the Monetary Authority of Singapore's primary role is to simply evaluate the exchange's performance as a regulatory organisation.</li></ul><p>","About_the_stock_exchange":"Location: Singapore<ul><li><a href=\"https://www.sgx.com/wps/portal/sgxweb/home/about_us/overview/%21ut/p/a1/04_Sj9CPykssy0xPLMnMz0vMAfGjzOKNHB1NPAycDSz9TXwtDBwNHL3MPUL9DI2MzYAKIoEKDHAARwNC-sP1o1CVuIe4GIKUBBv4h3gZGlgYoivwDzMwN_AM9XcKDg4LMwx0NYYqwOOGgtwIg0xPR0UAXlYW5g%21%21/dl5/d5/L2dBISEvZ0FBIS9nQSEh/\">Singapore Exchange</a> is Asia’s leading and trusted market infrastructure, operating equity, fixed income and derivatives markets to the highest regulatory standards. As Asia’s most international, multi-asset exchange, SGX Group provides listing, trading, clearing, settlement, depository and data services, with about 40% of listed companies and 75% of listed bonds originating outside of Singapore.</li><li>SGX Group is the world’s most liquid offshore market for the benchmark equity indices of China, India, Japan and ASEAN and offers commodities and currency derivatives products. Headquartered in AAA-rated Singapore, SGX is globally recognised for its risk management and clearing capabilities.</li></ul>","am":true,"os":true,"nz":true,"VCM":"Yes","CCM":"No","Notes":"Singapore’s Climate Impact X, or CIX, launched in 2021 acts as a global marketplace and exchange for carbon credits (VCM), jointly developed by DBS Bank, Singapore Exchange Group, Standard Chartered, and the Singapore sovereign wealth fund Temasek.","Source_lnk":"https://www.climateimpactx.com/"},{"id":151,"Country":"Slovenia","cc":"SI","Name0":"Ljubljana Stock Exchange","Link":"/stock-exchange/ljse","Name":"<a href=\"https://www.ljse.si/cgi-bin/jve.cgi?doc=1468\">Ljubljana Stock Exchange (LJSE)</a>","nlc":26,"dmc":10898.97,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Slovenia-LJSE.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><ul><li>In 2018 the Ljubljana Stock Exchange launched its&#160;<a href=\"https://www.ljse.si/media/Attachments/Produkti_in_Storitve/trg_zelenega_financiranja_2018.pdf\">Green Exchange</a>. (in English,&#160;<a href=\"https://www.ljse.si/media/Attachments/EnglishAttachment/green_exchange_2018_web.pdf\">here</a>).</li></ul><p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li>SME market -&#160;<a href=\"https://progress.market/en\">MTF Progress.</a></li><li><a href=\"https://www.ljse.si/cgi-bin/jve.cgi?doc=%201539\">LJSE Rules.</a></li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>The Ljubljana Stock Exchange (LJSE) is a private joint-stock company, which complies with and implements the corporate governance principles arising out of legal norms, the company's internal acts and established best practices.</li><li>&#160;The company is operated by a two-tier system of governance, where the Management Board runs the business and is monitored by the Supervisory Board. The company's Articles of Association in addition to the General Meeting of Shareholders also provides for two additional bodies the Board of Members and the Board of Issuers which have no direct influence on the LJSE governance but make indirect contributions to its reaching its objectives and strategy.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.a-tvp.si/Eng/Default.aspx\">The Securities Market Agency (ATVP)</a>.</li></ul><p>","Regulatory_model":"<ul><li>The Securities Market Agency (ATVP) is a legal entity of public law. It is independent in performing its tasks. Its basic mission is to maintain a safe, transparent and efficient market in financial instruments. By exercising control over the brokerage companies, banks engaged in investment transactions and services, management companies, investment funds, mutual pension funds, public companies, public-limited companies governed by the Takeovers Act and performing other regulatory tasks, it creates a level playing field for efficient operation of market in financial instruments.</li><li>The Agency makes annual reports to the National Assembly of the Republic of Slovenia on the situation and conditions on the market in financial instruments. The funds for the work of the Agency are provided by taxes charged for issuing decisions in individual matters and fees for exercising control. The amount of taxes and fees is determined by the tariff issued by the Agency in agreement with the Government of the Republic of Slovenia. The National Assembly gives approval for the annual statement of account and financial plan of the Agency. The lawfulness, purpose, economic and efficient use of the Agency’s funds are supervised by the Court of Auditors of the Republic of Slovenia. The Agency has set up an Information Security Management System complying with the requirements of ISO/IEC 27001:2013 on the regulation and supervision of the securities market in Republic of Slovenia.</li></ul><p>","About_the_stock_exchange":"Location:&#160;Ljubljana, Slovenia<ul><li><a href=\"https://www.ljse.si/cgi-bin/jve.cgi?doc=1394\">LSJE Profile</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":152,"Country":"Somalia","cc":"SO","Name0":"Somali Stock Exchange","Link":"/stock-exchange/somalia","Name":"<a href=\"https://www.sse.so/\">Somali Stock Exchange</a>","nlc":7,"dmc":47,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Somalia-Somali-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"","Regulatory_bodies":"","Regulatory_model":"<ul><li>Independent member SRO.</li></ul><p>","About_the_stock_exchange":"<ul><li>Historically, shares in Somalian businesses have been bought and sold informally through close networks. However, economists have noted that in recent years, the emergence of various stock exchanges in African states have played a pivotal role in fostering economic and private sector growth. The substantial demand for capital is increasing by the day for Somali businesses, consisting of both large firms and SME’s.&#160; According to the latest figures, over 3 billion USD flows in to Somalia every year, a large stake of which is aimed solely at business. Liquidity is an essential element of any industry, but it’s impossible to create it without a viable market, which is why the Somali Stock Exchange was born. The SSE is creating an entirely new securities market, where buyers of financial securities can do business with sellers in a more organised, secure and profitable way. Our aim is to create a sustainable securities market in Somalia, where holders of financial securities, bonds and buyers or investors can meet and share in long-term growth. The Somali Stock Exchange (SSE) was founded by the management of Somali Economic Forum (SEF), whose principal aim is to encourage Foreign Direct Investment (FDI) into Somalia's growing economy. The company has already made history by becoming the first ever stock exchange to operate inside of Somalia, with the first shares sold on 1st September 2015 at the exchange's headquarters.</li></ul>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":153,"Country":"South Africa","cc":"ZA","Name0":"Cape Town Stock Exchange (CTSE)","Link":"/stock-exchange/ctse","Name":"<a href=\"https://www.ctexchange.co.za/\">Cape Town Stock Exchange (CTSE)</a>","nlc":10,"dmc":447,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/cape-town-stock-exchange-i-commitment-letter.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br><p>The Cape Town Stock Exchange conducted webinars in Q1 2022 on Environmental, Social and Governance.</p><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Unlisted and for profit</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fsca.co.za/Pages/Default.aspx\">Financial Sector Conduct Authority&#160;</a></li><li><a href=\"https://www.resbank.co.za/en/home/what-we-do/Prudentialregulation/functions-of-the-prudential-authority\">Prudential Authority</a></li></ul><p></p>","Regulatory_model":"<ul><li>Strong exchange SRO&#160;</li></ul><p>CTSE has two independent committees that consist of &#160;independent board members that oversee the exchange listing &#160;requirements and exchange rules as well as associated decision making regarding the latter. Committee mandates are available&#160;on request. </p><p>","About_the_stock_exchange":"The Cape Town Stock Exchange (CTSE) is South Africa’s stock exchange for small- and medium-sized businesses. We’re aimed at growth companies looking to build up both the South African and broader African economies. We’re also only one of two exchanges South Africa with a licence to list both equity and debt.","am":false,"os":false,"nz":true,"VCM":"No","CCM":"No","Notes":"There is mention that SA has a compliance market but unable to confirm with other sources","Source_lnk":"https://chinadialogue.net/en/climate/can-carbon-markets-help-africa-meet-its-climate-financing-goals/"},{"id":154,"Country":"South Africa","cc":"ZA","Name0":"Johannesburg Stock Exchange (JSE)","Link":"/stock-exchange/jse","Name":"<a href=\"https://www.jse.co.za/\">Johannesburg Stock Exchange (JSE)</a>","nlc":297,"dmc":1150027.95,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/SouthAfrica-JohannesburgStockExchange.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://group.jse.co.za/sites/default/files/media/documents/JSE%20Ltd%20-%20Sustainability%20Report%202022%20-%20as%20published_0.pdf\">Yes</a><br><ul><li><a href=\"https://www.jse.co.za/about/sustainability\">Sustainability Section on Website</a></li><li>See also <a href=\"https://group.jse.co.za/sustainability\">here</a>&#160;to find the latest report</li></ul><p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>Requires (on an apply and explain basis) that listed companies annually report the extent to which they comply with the King Code. King IV includes sustainability reporting as well as integrated reporting.&#160;<a href=\"https://www.jse.co.za/about/sustainability/regulator-influencer-advocate\">(Source)</a>.</li><li>JSE also has mandatory governance disclosure requirements beyond the principles of King.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.jse.co.za/our-business/sustainability/jses-sustainability-and-climate-disclosure-guidance\">JSE Sustainability Disclosure Guidance</a> - This paper is issued as a guidance tool that may be used by issuers on a voluntary basis to: - Assist local companies to navigate the global sustainability and ESG landscape - Provide for South Africa’s specific sustainability challenges - Improve the quality of sustainability and ESG information available to enable more informed investment decisions - Drive improved sustainability performance, accountability, and business leadership.</li><li>The <a href=\"https://www.jse.co.za/sites/default/files/media/documents//JSE%20Sustainability%20Recommended%20Disclosures%20and%20Metrics_FA_.pdf\">JSE Sustainability Disclosure Guidance – Narrative Disclosures and Metrics </a>is aligned with, and draws on, the most influential global initiatives on sustainability and climate change disclosure – including the GRI Sustainability Reporting Standards, the Taskforce on Climate-related Financial Disclosures (TCFD) recommendations, and the IIRC’s International (IR) Framework – as well as an extensive range of other frameworks and standards (Annex 1), and the Sustainability/ESG guidance of various peer exchanges. <a href=\"https://www.jse.co.za/sites/default/files/media/documents//JSE%20Climate%20Disclosure%20Guidance%202021_SPS.pdf\">This Disclosure Guidance</a> is not intended to replace any of these global initiatives but rather seeks to help companies navigate the landscape of reporting standards, and to provide explicitly for the South African context.</li><li>The JSE is a member of the standing King Committee. <a href=\"https://www.iodsa.co.za/\">King III</a> and <a href=\"https://www.iodsa.co.za/page/KIVPracticeNotes?\">King IV</a> are available online.</li><li>From an investment tool perspective, the FTSE/JSE Responsible Investment (RI) index series was introduced in October 2015 and replaced the SRI Index that had been running since 2004. The methodology measures eligible companies ESG strategies and performance, thus also influencing the way companies should operate and provides a model for the kinds of ESG data companies should be disclosing.&#160;<a href=\"https://www.jse.co.za/services/market-data/indices/ftse-jse-africa-index-series/responsible-investment-index\">(Source)</a>.</li></ul><p>","oert":"Yes","oertt":"Yes<br>In 2021, JSE provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/south-africa-tcfd-101-workshop-training/\">source</a>)<p><p><a href=\"https://www.jse.co.za/services/jse-training-courses\">JSE Training Academy</a> provides courses on ESG-related topics.<p>","mcbsri":"Yes","mcbsrit":"Yes<br><p class=\"page-header\"><a href=\"https://www.jse.co.za/services/indices/ftsejse-responsible-investment-index\">FTSE/JSE Responsible Investment Index</a></p><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>The <a href=\"https://www.jse.co.za/trade/debt-market/bonds/green-bonds\">Green Bond&#160;</a></li><li>See&#160;<a href=\"https://www.jse.co.za/news/the-johannesburg-stock-exchange-lists-its-first-green-bond\">here</a> for the announcement of first green bond listing in 2014</li><li><a href=\"https://www.jse.co.za/raise-capital/debt-market/transition-segment\">The Transition Segment is a platform on JSE’s Main Board to list Transition Debt Securities, where issuers can raise funds for the climate or just transition-related purposes.</a></li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.jse.co.za/capital/altx\">AltX (JSE)</a>, since 2003.</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://www.jse.co.za/sites/default/files/media/documents//JSE%20Climate%20Disclosure%20Guidance%202021_SPS.pdf\">JSE Climate Disclosure Guidance 2021</a></li><li><a href=\"https://www.jse.co.za/our-business/sustainability\">Sustainability at JSE</a></li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2005 and listed in 2006.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fsca.co.za/Pages/Default.aspx\">Registrar of Securities Services, Financial Services Board.</a></li></ul><p>","Regulatory_model":"Strong Exchange Self-Regulatory Organisation (SRO) Model<p><ul><li>Because of the level of authority possessed by the exchange.</li><li>The JSE is the frontline regulator for the exchange, setting and enforcing listing and membership requirements and trading rules. The Financial Services Board (FSB) supervises the JSE in the performance of its regulatory duties.</li><li>The regulatory landscape is set to change significantly in the future, as South Africa looks to implement a twin peaks model of oversight. Under the new system, prudential supervision will be transferred to the South African Reserve Bank (SARB) and market conduct regulation will be led by a bolstered FSB.</li></ul><p>","About_the_stock_exchange":"Location: Johannesburg, South Africa<p><ul><li>The Johannesburg Stock Exchange (“JSE”) offers secure, efficient primary and secondary capital markets across a diverse range of securities, supported by our post-trade and regulatory services. We are the market of choice for local and international investors looking to gain exposure to the leading capital markets in South Africa and the broader African continent. The JSE is currently ranked the 17th largest stock exchange in the world by market capitalisation and the largest exchange in the African continent. The JSE was formed in 1887 during the first South African gold rush. Following the first legislation covering financial markets in 1947, the JSE joined the World Federation of Exchanges in 1963 and upgraded to an electronic trading system in the early 1990s. The bourse demutualised in 2005 and listed on its own exchange in 2006. In 2003, we launched an alternative exchange, AltX, for small and mid-sized listings, followed by the Yield X for interest rate and currency instruments. The JSE acquired the South African Futures Exchange (SAFEX) in 2001 and the Bond Exchange of South Africa (BESA) in 2009. Today we offer five financial markets namely Equities and Bonds as well as Financial, Commodity and Interest Rate Derivatives.&#160;<a href=\"https://www.jse.co.za/about/history-company-overview\">(Source)</a>.</li></ul>","am":true,"os":true,"nz":false,"VCM":"Yes","CCM":"No","Notes":"The JSE's VCM initiative was launched in October 2023 under a separate legal entity called JSE Ventures Voluntary Carbon Market. It is fully integrated with Xpansiv CBL, and allows local participants to buy or sell carbon credits and renewable energy certificates that are held in either local or global registries. The market completed its first trades of carbon credits eligible for offsetting South Africa’s Carbon Tax, in February 2025.","Source_lnk":"https://www.jse.co.za/services/jse-ventures-carbon-market"},{"id":155,"Country":"Spain","cc":"ES","Name0":"Bolsas y Mercados Españoles (BME)","Link":"/stock-exchange/bme","Name":"<a href=\"https://www.bolsasymercados.es/ing/Home\">Bolsas y Mercados Españoles (BME)</a>","nlc":2504,"dmc":1024803,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2020/01/Spain-Bolsas-y-Mercados-Españoles.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.bolsasymercados.es/docs/inf_legal/ing/economico/2021/NonFinancialInfo_2021.pdf\">Yes</a><br><ul><li><a href=\"https://www.bolsasymercados.es/docs/inf_legal/ing/economico/2021/NonFinancialInfo_2021.pdf\">Consolidated Non-Financial Information Statement 2021</a></li><li><a href=\"https://www.bolsasymercados.es/ing/Sustainability\">Sustainability section on BME website</a></li><li><a href=\"https://www.globalreporting.org/\">Committed to GRI reporting guidelines</a></li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>Spanish companies and, therefore, BME’s listed companies, are under the scope of Directive 2014/95/EU “Non-Financial Reporting Directive (NFRD)”. According to this, large companies which are public-interest entities exceeding on their balance sheet dates the criterion of the average number of 500 employees during the financial year shall include in the management report a non-financial statement containing information to the extent necessary for an understanding of the company’s development, performance, position and impact of its activity, relating to, as a minimum, environmental, social and employee matters, respect for human rights, anti-corruption and bribery matters.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>Updated in 2023: <a href=\"https://www.bolsasymercados.es/docs/BME/docsSubidos/Estudios-Articulos/BME-voluntary-guidance-sustainability-information-listed-companies.pdf\">BME Voluntary Guidance on Sustainability Information for Listed Companies</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>Instituto BME, covers ESG and Sustainability issues in its mFIA Master Degree (consisting of 640 lecture hours). It is covered within the Ethics module and two chapters about Socially Responsible Investments and ESG are also included. Information found <a href=\"https://www.institutobme.es/esp/curso/M%C3%A1ster_en_Mercados_Financieros_e_Inversiones_Alternativas__mFIA_.aspx\">here</a>.</li><li>Instituto BME also has issued in 2022 a specific course about Sustainable Financing in which the different sustainable financing products and their basic characteristics are explained during 60 hours. Information found <a href=\"https://www.institutobme.es/esp/curso/Financiaci%C3%B3n_Sostenible.aspx\">here</a>.</li><li>BME co-hosted with the SSE initiative, TCFD training sessions in February 2023, in collaboration with IFC and CDP. (<a href=\"/sse-event/espana-tcfd-101-taller-de-capacitacion/\">source</a>)</li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.bolsamadrid.es/docs/Indices/Ibex/Criterios_FTSE4GOODIBEX_ESP.pdf\">FTSE4Good IBEX Index</a></li><li><a href=\"https://www.bolsasymercados.es/ing/Media/Press-Release/20211130/nota_20211130_2/BME_launches_the_IBEX_Gender_Equality_Index_to_promote_gender_equality\">IBEX Gender Equality Index</a></li></ul><p></p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.bolsasymercados.es/ing/Sustainability/Sustainable-Finance/ESG-Bonds\">ESG BONDS</a></li></ul><p></p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.bmegrowth.es/ing/Home.aspx\">BME Growth</a>, since 2008</li></ul><p></p>","wom":"Yes","womt":"Yes<br><ul><li>There is a 40% mandatory minimum rule for women on boards. Source: <a href=\"https://www.bolsasymercados.es/ing/Corporate-Information/Corporate-Governance/Board-Directors-Committees/Regulations-Board\" target=\"_blank\" rel=\"noopener\">Exchange Rules</a> and&#160; <a href=\"https://www.coe.int/t/pace/campaign/stopviolence/Source/spain_constitutionalact3_2007_en.pdf\" target=\"_blank\" rel=\"noopener\">National Law</a></li></ul><p></p>","Additional_information":"BME has taken part in the Sustainable Stock Exchanges initiative since 2016. The company encourages the issuers of securities and the new companies listed on the markets and systems managed by BME to report non-financial, social and corporate governance information in their periodic reports.<p><ul><li><a href=\"https://www.bolsasymercados.es/docs/inf_legal/ing/economico/2021/NonFinancialInfo_2021.pdf\">Consolidated Non-Financial Information Statement 2021</a></li></ul><p>As SSE member, BME celebrates the Ring the Bell for Gender Equality since 2018.</p><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Private company for profit; demutualized in 2001.</li></ul><p>BME was incorporated in 2001. It was a listed company from 2006 to 2020, when it was excluded after being acquired by SIX Group. BME structured its business in this units: Equity, Fixed-Income, Derivatives, Clearing, Settlement, Market Data and Value Added Services. As a Financial Markets Infrastructure, BME is regulated by the Comisión Nacional del Mercado de Valores (CNMV).<p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cnmv.es/\">Comisión Nacional del Mercado de Valores (CNMV).</a></li></ul><p></p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model<p><ul><li>The Comisión Nacional del Mercado de Valores (CNMV) acts as the supervisory body for capital markets in Spain. The CNMV possesses the authority to impose changes in the markets and continuously monitors the BME Group. As such, the exchange wields limited regulatory authority although it is still considered to be self-regulated.</li></ul><p>","About_the_stock_exchange":"<ul><li><a href=\"https://www.bolsasymercados.es/docs/BME/docsSubidos/Comunicacion_Media/BME-overview.pdf\">BME</a> is the operator of all stock markets and financial systems in Spain. It is part of SIX Group, the third largest exchange group in Europe. The company has presence in Madrid, Barcelona, Bilbao and Valencia.</li></ul>","am":true,"os":false,"nz":false,"VCM":"Yes","CCM":"Yes","Notes":"BME, through Iberclear, and ClimateTrade, have developed a Voluntary Registry for carbon and biodiversity inventories that allows companies to offset their carbon footprint through green credits. Trading takes place through ClimateTrade’s Marketplace, Iberclear maintains the registry and certifies the transfer and cancellation of carbon credits. Iberclear also maintains the National Registry for Greenhouse Gas Emission Allowances (RENADE).","Source_lnk":"https://www.finextra.com/pressarticle/91562/bme-runs-blockchain-based-carbon-offestting-poc https://www.bolsasymercados.es/ing/Sustainability/Environment/Renade"},{"id":156,"Country":"Sri Lanka","cc":"LK","Name0":"Colombo Stock Exchange","Link":"/stock-exchange/cse_srilanka","Name":"<a href=\"https://www.cse.lk/home/market\">Colombo Stock Exchange (CSE)</a>","nlc":323,"dmc":30941,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/sri-lanka-cse.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No<br><ul><li>However, good corporate governance is a listing rule.&#160;<a href=\"https://www.cse.lk/home/listingRules\">(Source)</a>.</li><li><a href=\"https://www.cse.lk/home/sustainabilityGuide\">CSE Sustainability Guide</a>&#160;provides specific guidance for companies on ESG reporting.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://cdn.cse.lk/pdf/sustainability-document.pdf\">Six Recommendations for Communicating Sustainability</a> – guide released in early 2019.</li><li><a href=\"https://cdn.cse.lk/pdf/Corporate_Governance_Code_2013_book.pdf\">Code of best practice</a>&#160;on corporate governance also includes sustainability section.</li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>CSE recently formalized an arrangement with the&#160;<a href=\"https://www.globalreporting.org/\">Global Reporting Initiative (GRI)</a>&#160;to provide guidance to listed companies on ESG disclosures in Sri Lanka and conducted workshops on corporate transparency and sustainability reporting.</li><li><a href=\"https://www.cse.lk/home/cse-events/2018/cse-gri-programme-transparency-sustainability\">CSE, GRI conduct programme to foster transparency and sustainability among listed companies</a> (March 2019).</li><li>CSE in collaboration with Tundra Fonder recently hosted the ‘CSE – Tundra Fonder Sustainability Forum’ to discuss, understand and integrate ESG analytics into business planning and operations.</li><li>In 2022, CSE provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/sri-lanka-tcfd-101-workshop-training/\">source</a>)</li></ul><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br><p>The Colombo Stock Exchange (CSE) announced the introduction of listing and trading of Green Bonds for the first time in the Sri Lankan stock market, with effect from 25th April 2023. (<a href=\"https://cdn.cse.lk/cms-internal/news/jpCwsV3taSrLrBPm_25Apr2023160233GMT_1682438553143.pdf\">source</a>)</p><p></p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li>Corporate Sustainability Statement in&#160;<a href=\"https://www.cse.lk/pdf/CSE_Annual_Report_2014.pdf\">2014 Annual Report</a> (Pg. 60).</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Not for Profit Organization. Legal Form: Company Limited by Guarantee.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.sec.gov.lk/\">Securities and Exchange Commission of Sri Lanka</a>.</li></ul><p></p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model</p><ul><li>Although the Colombo Stock Exchange is a self-regulating exchange, its functions are fairly limited. Essentially, the exchange is responsible for monitoring its market but the greater authority falls upon the Securities and Exchange Commission (SEC) of Sri Lanka. The SEC, Sri Lanka, possesses a variety of powers and functions that allow it to supervise and enforce regulations in the Sri Lankan capital markets.</li></ul><p>","About_the_stock_exchange":"<p>Location: Colombo, Sri Lanka</p><ul><li>The CSE is a company limited by guarantee, established under the Companies Act No. 17 of 1982 and is licensed by the Securities & Exchange Commission of Sri Lanka (SEC). The CSE is a mutual exchange and has 15 full members and 16 Trading Members licensed to trade both equity and debt securities, while three members are licensed to trade in debt securities only. All members are licensed by the SEC to operate as stockbrokers. All members are corporate entities and some are subsidiaries of large financial institutions. At present the CSE functions as a market operator and through its fully owned subsidiary, Central Depository Systems (Pvt.) Limited (CDS), acts as a clearing and settlement system facilitator. The CSE also oversees compliance through a set of rules, promotes standards of corporate governance among listed companies and is actively involved in educating investors. In the course of its operations, the CSE interacts with many customers and stakeholders which include issuers (such as companies, corporations and unit trusts), commercial banks, investment banks, fund managers, stockbrokers, financial advisers, market data vendors and investors.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":157,"Country":"Sweden","cc":"SE","Name0":"Nasdaq Stockholm","Link":"/stock-exchange/nasdaq-stockholm","Name":"<a href=\"https://www.nasdaqomxnordic.com/\">Nasdaq Stockholm</a>","nlc":384,"dmc":4400000,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Sweden-Nasdaq-Stockholm.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li><a href=\"https://business.nasdaq.com/discover/corporate-responsibility-and-sustainability/index.html\">Sustainability Section</a>&#160;on Website.</li><li>Corporate Governance section in&#160;<a href=\"https://ir.nasdaq.com/static-files/a6d84f2a-c05a-484d-9d3b-06573888344f\">2017 Annual Report</a>.</li><li><a href=\"https://www.lacp.com/2017vision/pdf/12755.pdf\">2017 Sustainability Report</a>.</li></ul><p>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.nasdaq.com/ESG-Guide\">ESG Reporting Guide</a> released in March 2017 across Nasdaq's Nordic and Baltic Exchanges.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>Nasdaq Nordic and Baltic exchanges run <a href=\"https://www.globenewswire.com/news-release/2017/08/29/1101564/0/en/Nasdaq-Nordic-and-Baltic-Exchanges-Announce-Pilot-Program-for-ESG-Reporting.html\">a pilot program on ESG reporting</a>.</li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br>Nasdaq offers&#160;<a href=\"https://business.nasdaq.com/discover/corporate-responsibility-and-sustainability/index.html\">70 sustainability-related indexes</a>&#160;(not all actively traded), including:<p><ul><li>OMX GES Ethical indexes:</li><li>OMX GES Ethical Nordic Index</li><li>OMX GES Ethical Norway Index</li><li>OMX GES Ethical Sweden Index</li><li>OMX GES Ethical Denmark Index</li><li>OMX GES Ethical Finland Index</li><li>OMX GES OMXS30 Ethical Index</li><li>OMX GES Sustainability Nordic and OMX GES Sustainability Sweden:<ul><li>OMX GES Sustainability Nordic Index</li><li>OMX GES Sustainability Sweden Index</li><li>OMX GES Sustainability Sweden Ethical Index.</li></ul></li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>Nasdaq Stockholm and Nasdaq Helsinki launched <a href=\"https://www.nasdaq.com/solutions/listing-of-sustainable-bonds\">a sustainable bond list</a> in 2015 on the main market and another, the First North Sustainable Bond List, on the First North market in the beginning of 2018.</li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.nasdaqomxnordic.com/firstnorth/\">Nasdaq First North</a> (Nordic Exchanges), since 2006.</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://business.nasdaq.com/Docs/Nasdaq%20UNGC%20COP%202014%20RevFinal.pdf\">Nasdaq Progress Report 2014, United Nations Global Compact.</a></li><li>The Nasdaq speaks, moderates, sponsors, or otherwise exhibits at key industry events related to sustainability.&#160;<a href=\"https://business.nasdaq.com/discover/corporate-responsibility-and-sustainability/index.html\">(Source).</a></li><li>Nasdaq and CERES’ Investor Network on Climate Risk (INCR) is working with other partners to create an investor-centric sustainability reporting proposal for public companies and stock exchanges.&#160;<a href=\"https://www.ceres.org/press/press-releases/world2019s-largest-investors-launch-effort-to-engage-global-stock-exchanges-on-sustainability-reporting-standard-for-companies\">(Source)</a>.</li><li>Nasdaq had a three-part article series in 2013, called Doing Well by Doing Good.&#160;<a href=\"https://www.nasdaqomx.com/aboutus/sustainability/articles\">(Source)</a>.</li><li>Nasdaq commemorated Gender Equality International Women's day in March 2017 with a celebratio at Nasdaq Marketsite in Times Square.</li><li>Nasdaq is a member of the United Nations Global Compact and Chair of the WFE Sustainability Working Group.&#160;<a href=\"https://www.unglobalcompact.org/what-is-gc/participants/18220-The-NASDAQ-OMX-Group-Inc-\">(Source).</a></li><li>Board Member, US Global Compact US Network; Advisory Board Member, SASB.</li></ul><p>","Organizational_model_of_stock_exchange":"Listed company for profit; demutualized in:<p><ul><li>NASDAQ - 2000</li><li>OMX - 1993.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fi.se/sv/\">Swedish Financial Supervisory Authority.</a></li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model.<p><ul><li>Regulatory practices in regards to this exchange vary slightly from country to country. However, the exchanges operated by Nasdaq in each country appear to have basic regulatory oversight. However, the ultimate regulatory authority for each market lies with the regulatory bodies listed.</li></ul><p>","About_the_stock_exchange":"HQ Location: New York, New York.<ul><li>Nasdaq (Nasdaq: NDAQ) is a leading global provider of trading, clearing, exchange technology, listing, information and public company services. Through its diverse portfolio of solutions, Nasdaq enables customers to plan, optimize and execute their business vision with confidence, using proven technologies that provide transparency and insight for navigating today's global capital markets. As the creator of the world's first electronic stock market, its technology powers more than 90 marketplaces in 50 countries, and 1 in 10 of the world's securities transactions. Nasdaq is home to approximately 3,900 total listings with a market value of approximately $13 trillion. To learn more, click <a href=\"https://business.nasdaq.com\">here</a>.</li></ul>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":158,"Country":"Switzerland","cc":"CH","Name0":"SIX Swiss Exchange","Link":"/stock-exchange/six","Name":"<a href=\"https://www.six-swiss-exchange.com/index.html\">SIX Swiss Exchange</a>","nlc":248,"dmc":2327707.01,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2022/01/Switzerland-SIX-1.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://www.six-group.com/en/home/company/reponsibility/society-and-environment.html\">Yes</a><br><ul><li><a href=\"https://www.six-group.com/en/home/company/reponsibility/society-and-environment.html\">Sustainability section on website</a>.</li><li>Sustainability section in&#160;<a href=\"https://www.six-group.com/dam/download/report/annual/2015/six-annual-report-2015-en.pdf\">Annual Report 2015</a>.</li><li>Committed to GRI reporting guidelines: SIX follows the internationally recognized guidelines of the&#160;<a href=\"https://www.globalreporting.org/\">Global Reporting Initiative (GRI)</a></li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><p>The Swiss Authority has recently approved a new law on non-financial reporting (legal basis: <a href=\"https://www.fedlex.admin.ch/eli/cc/27/317_321_377/de\">964a-c</a>) that entered into force Jan-2022. It applies to the vast majority of SIX’s listed companies requiring double materiality and covers information of business’ impact environment matters and social issues and also information of&#160; employee-related issues, respect for human rights, and combating corruption. The new legal framework is based on EU Directive 2014/95/EU “Non-Financial Reporting Directive (NFRD), the ordinance on climate reporting can be found <a href=\"https://www.newsd.admin.ch/newsd/message/attachments/70878.pdf\">here</a> and additional information is available <a href=\"https://www.admin.ch/gov/de/start/dokumentation/medienmitteilungen/bundesrat.msg-id-87790.html\">here</a> and <a href=\"https://www.newsd.admin.ch/newsd/message/attachments/70879.pdf\">here</a> Until this new law, SIX’s listed companies could choose voluntarily opt-in sustainability reporting through Art. 9 DCG in conjunction with Art. 9 Point 2.03 DRRO where issuers have the opportunity, to inform SIX Exchange Regulation that they issued a sustainability report in accordance with an internationally recognised standard recognized by SIX. Issuers who opt into the SIX regime are then obliged to adopt the sustainability report in accordance with the chosen internationally recognised standard and to publish it on their website within eight months of the balance sheet date for the annual financial statements for a period of five years. In addition, companies remain free to issue and publish a sustainability report in line with an internationally recognised standard without reporting this to SIX Exchange Regulation. It is also permissible to include certain sustainability topics in their annual report.</p><ul><li><a href=\"https://www.six-group.com/en/products-services/the-swiss-stock-exchange/trading/sustainability.html\">SIX Investing Sustainably</a>.</li><li><a href=\"https://www.six-group.com/en/products-services/the-swiss-stock-exchange/market-data/shares/sustainability-reporting.html\">SIX Sustainability Reporting</a>.</li><li><a href=\"https://www.ser-ag.com/en/topics/regular-reporting.html\">SIX Reporting Standards</a>.</li><li><a href=\"https://www.ser-ag.com/dam/downloads/publication/obligations/guidelines/standards-sustainability-en.pdf\">International Standards recognised by SIX</a>.</li></ul>","hwg":"Yes","hwgt":"Yes<br><p>See Chapter 10. “IR and Sustainability” from p.132 of the <a href=\"https://www.six-group.com/dam/download/sites/exchange-services/investor-relations-handbook/investor-relations-handbook-en.pdf\">Investor Relations Handbook (5th edition)</a></p><p>","oert":"Yes","oertt":"Yes<br><p class=\"p1\">Supporting and/or sponsoring ESG related training from third party providers for our equity issuers.</p><p class=\"p1\">In 2022, SIX provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/switzerland-tcfd-101-workshop-training/\">source</a>)</p><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.six-group.com/en/products-services/the-swiss-stock-exchange/market-data/indices/esg-indices/esg-equity-indices.html\">SPI ESG indices</a></li><li><a href=\"https://www.six-group.com/en/products-services/the-swiss-stock-exchange/market-data/indices/esg-indices/esg-bond-indices.html\">SBI ESG indices</a></li><li><a href=\"https://www.six-group.com/en/products-services/the-swiss-stock-exchange/market-data/indices/esg-indices/spi-gender-equality.html\">SPI Gender Equality index</a></li><li><a href=\"https://www.six-group.com/en/products-services/the-swiss-stock-exchange/market-data/indices/esg-indices/esg-strategy-indices.html\">ESG Strategy indices</a></li><li><a href=\"https://www.six-swiss-exchange.com/indices/data_centre/shares/sxi_ssust_en.html\">SIX Switzerland Sustainability 25</a></li><li><a href=\"https://www.six-group.com/en/products-services/the-swiss-stock-exchange/market-data/indices/customized-indices/ethos-swiss-governance-indices.html\">Ethos Swiss Corporate Governance Index</a></li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li><a href=\"https://www.six-group.com/en/products-services/the-swiss-stock-exchange/market-data/bonds/green-bonds.html\">Sustainable Bonds on SIX</a></li></ul><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.six-group.com/en/products-services/the-swiss-stock-exchange/listing/equities/sme-ipo/sparks-sme-stock-exchange.html\">Sparks: the SME Stock Exchange</a></li></ul><p>","wom":"Yes","womt":"Yes<br><ul><li>There is a 30% mandatory minimum rule for women on boards. Source: <a href=\"https://www.fedlex.admin.ch/eli/fga/2020/1302/de\" target=\"_blank\" rel=\"noopener\">Swiss Law</a></li></ul>","Additional_information":"<ul><li>SIX Group participates in the annual survey produced by WFE, <a href=\"https://www.world-exchanges.org/storage/app/media/WFE%20Annual%20Sustainability%20Survey%202021%20Final.pdf\">WFE 2021 Sustainability Survey</a></li><li>SIX Group is a member of Swiss Sustainable Finance which aims to inform on best practice and creating supportive frameworks and tools to support its members</li><li>As a member of the Zurich Energy Model, SIX Group committed to improving its energy efficiency by around 11% in the target agreement period from 2013 to 2020. In fact, SIX managed to increase its energy efficiency by twice as much: According to Zurich Energy Model calculations, the increase in this eight-year period was around 22%. In absolute terms, SIX saved approximately 25,000 MWh of energy.</li><li>SIX Group is also a member of the Advance network for “Gender Equality in Business,” which offers mentoring and further education opportunities specifically for women.</li></ul><p>","Organizational_model_of_stock_exchange":"<p>Private company for profit; demutualized in 2002</p><ul><li>SIX Group Ltd (SIX) is an unlisted public limited company domiciled in Zurich.</li><li>The company is&#160;<a href=\"https://www.six-group.com/en/home/company/governance.html\">owned by around 140 national and international financial institutions</a>, who are also the main users of the services provided by SIX.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.finma.ch/en#Order=4\">Swiss Financial Market Supervisory Authority</a></li></ul><p>","Regulatory_model":"<p>Limited Exchange Self-Regulatory Organization (SRO) Model.</p><ul><li>The SIX Swiss Exchange has the authority to issue, monitor and enforce regulations as per Swiss law. The exchange has created rules and regulations that apply to listing requirements, company disclosure, company obligations, and market Surveillance and enforcement. However, it should be noted that the Swiss Financial Market Supervisory Authority (FINMA) has to ultimately approve proposed rules and regulations changes by the exchange, giving it ultimate regulatory authority.</li></ul><p>","About_the_stock_exchange":"<p>Location: Zurich, Switzerland.</p><ul><li>SIX operates a competitive infrastructure for the Swiss financial center, catering to a broad, international client base. Its four business areas provide a comprehensive range of services in the areas of securities transactions, financial information processing and cashless payment transactions.</li></ul>","am":true,"os":false,"nz":false,"VCM":"Yes","CCM":"No","Notes":"The Spanish BME exchange, which is active in the VCM environment, forms part of the SIX Group. SIX has also carried out its own research on the state of VCMs and the role of financial market infrastructure (FMI) providers.","Source_lnk":"https://www.six-group.com/en/blog/2022/tackling-climate-change.html"},{"id":159,"Country":"Tajikistan","cc":"TJ","Name0":"Central Asian Stock Exchange (CASE)","Link":"/stock-exchange/central-asian-stock-exchange","Name":"<a href=\"https://www.case.com.tj/en/\">Central Asian Stock Exchange (CASE)</a>","nlc":40,"dmc":286,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/tajikistan-central-asian-stock-exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<p>Listed, For Profit</p><p>","Regulatory_bodies":"<p>Shareholders’ meeting</p><p>","Regulatory_model":"<p>Non-SRO</p><p>","About_the_stock_exchange":"<p>Legal and Mailing Address: Bokhtar street 37/1, Bokhtar Business Center, 734025, Dushanbe, Tajikistan</p><p>Phone No: +992372273493</p><p>Website: www.case.com.tj</p><p>Email: info@case.com.tj, director@case.com.tj</p><p>Ownership (Any owner with more than 4% of the exchange): GMEX Group, Ubaydulloi Mahmadullo</p>","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":160,"Country":"Thailand","cc":"TH","Name0":"Stock Exchange of Thailand","Link":"/stock-exchange/set","Name":"<a href=\"https://www.set.or.th/set/mainpage.do?language=en&country=US\">Stock Exchange of Thailand</a>","nlc":821,"dmc":563037.58,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Thailand_SET.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://media.set.or.th/set/Documents/2023/Jun/SD_Highlight_2022_ENG.pdf\">Yes</a><br><ul><li>SET has continued to provide its annual sustainability report in alignment with global sustainability reporting frameworks, including GRI Standards, SDGs and IIRC's Integrated Reporting.</li><li>SET's Annual Sustainability Reports <a href=\"https://www.set.or.th/en/about/overview/report/sd-report\">here</a>.</li></ul><p>&#160;</p><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>In Thailand, the Securities and Exchange Commission mandates sustainability reporting in the <a href=\"https://view.officeapps.live.com/op/view.aspx?src=https://publish.sec.or.th/nrs/8617pe.doc&wdOrigin=BROWSELINK\">56-1 One Report </a>annual public filing.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>SET has provided a variety of guidelines and tools on sustainability disclosures that can be accessed <a href=\"http://setsustainability.com/page/disclosure\">here</a>.</li><li>Apart from the publications, SET has offered a variety of learning tools for listed companies, to keep them abreast with the up-and-coming sustainability-related trends in the global business world. See more about Principles and Guidelines <a href=\"http://setsustainability.com/page/principles-and-guidelines\">here</a>.</li><li>In addition, a series of guidance documents and manuals can be found on <a href=\"http://setsustainability.com/\">SET's Sustainability website</a>.</li><li><a href=\"https://www.setsustainability.com/download/32jt9usirmoqa7w\">Corporate Sustainability Guide</a></li><li><a href=\"https://www.setsustainability.com/libraries/1119/item/SD_REPORTING\">Sustainability Reporting Guide</a></li></ul><p>&#160;</p><p>","oert":"Yes","oertt":"Yes<br><ul><li>SET has regularly organized capacity-building and training activities to promote corporate sustainability management, ESG reporting and responsible investing. Several e-learning programs are available <a href=\"https://www.setsustainability.com/libraries/907/item/-e-learning\">here</a>.</li><li>Corporate Sustainability Strategy' is one of the most well-received capacity-building programs among Thai listed companies. The 7-day course offers hands-on experience for participants through four modules:<ul><li>S01: Sustainability Commitment</li><li>S02, S04: Value Chain and Materiality Analysis</li><li>S03: Sustainability Strategy and Initiative</li></ul></li><li>SET, in partnership with GRCF, CDP and GRI, recently hosted a series of TCFD & SDGs workshops to raise awareness of climate change issues and related risks to business and promote climate resiliences among Thai listed companies. More about it <a href=\"https://www.setsustainability.com/libraries/1034/item/-climate-change\">here</a>.</li><li>In addition, SET has partnered with Walk Free and FAST to produce a set of practical tools to manage human rights risks, specifically modern slavery and labor exploitation. Read more about it <a href=\"/all-news/exchange-in-focus-set-launches-guidance-on-modern-slavery-risks/\">here.</a></li><li>See also the <a href=\"https://www.setsustainability.com/trainings\">Training Page</a>, <a href=\"https://www.setsustainability.com/events/2023\">Events page</a> and <a href=\"https://www.setsustainability.com/libraries\">Knowledge Library on sustainability</a></li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.setsustainability.com/download/m9ras73u6xobdlt\">SETTHSI index</a> is the SET's sustainability-themed index.</li><li>In addition, SET annually announces <a href=\"http://setsustainability.com/page/thsi-thailand-sustainability-investment\">Thailand Sustainability Investment (THSI</a>), a list of Thai listed companies with outstanding sustainability performance.</li><li>On top of this, SET also gives <a href=\"https://www.setsustainability.com/page/sustainability-awards\">SET Sustainability Awards</a> to the most outstanding firms on the list.</li><li>SET continues to promote a better understanding of <a href=\"http://setsustainability.com/page/sustainable-investment\">sustainable investing</a> and sustainability indices among Thai investors.</li></ul><p>","hsbls":"No","hsblst":"No<br><a href=\"https://www.thaibma.or.th/EN/BondInfo/ESG.aspx\">ThaiBMA lists various sustainability bonds </a>; and according to their regulations they use the stock exchange's platform for trading (<a href=\"https://www.thaibma.or.th/EN/Education/ThaiBondMarket.aspx\">source</a>).<p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.set.or.th/en/market/index/mai/profile\">Market for Alternative Investment (mai)</a>, since 1998</li></ul><p>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>A non-profit organization, set up under the Securities Exchange of Thailand Act B.E. 2535&#160;(1992) (“Act.”)</li><li>The Securities and Exchange Act of B.E. 2535 (1992) does not prescribe and allow the SET to raise any fund from the public for the purpose of the shareholder structure. As a result, the SET is unable to issue any share to be held by any Party.</li></ul><p>&#160;</p><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.sec.or.th/EN/Pages/Home.aspx\">The Securities and Exchange Commission of Thailand (SEC)</a></li></ul><p>","Regulatory_model":"Limited Exchange SRO Model<p><ul><li>The Act stipulates the SEC as the regulator of the Thai capital market, including both the primary and secondary markets. The SET Board of Governors has the power and duty to formulate policies, supervise SET operations, and perform any other functions in accordance with the Act.</li></ul><p>","About_the_stock_exchange":"Location: Bangkok, Thailand<p><ul><li>Vision: To make the capital market “work” for everyone. The capital market is an integral tool for economic growth, and should not be privileged to only some. Hence the SET works hard to make the capital market benefit all stakeholders both directly and indirectly, in the belief that good business growth will lead to national strength and this in turn leads to the betterment of society.</li><li>Missions:<ul><li>To plant state-of-the-art financial platform development that is both innovative and accessible to our customers locally, regionally and globally.</li><li>To innovatively grow product development that is not only relevant to market needs but also resonate with the sustainability of future growth.</li><li>To foster people development to ensure that our people will be best equipped with business competencies and professional integrity.</li><li>To implant an inclusive growth approach that will enable us to perform as the best business partners and social supporters.</li><li>To continuously cultivate ourselves and our stakeholders by investing in knowledge management creating, sharing and generating knowledge as part of an intangible asset.</li></ul></li><li>SET’s key operations include securities listing, trading, clearing and settlement, depository, securities trading and information disclosure supervision, market participant protection and information dissemination. SET has actively engaged its stakeholders in promoting sustainability management in the Thai capital market ecosystem to benefit market participants and the general public. As the center of securities trading, SET has been promoting long-term fundraising among businesses to ensure corporate competitive advantage and benefit the Thai economic growth. In addition, SET has continued to develop financial literacy to enhance well-being of people in society.</li></ul><p>For more information see <a href=\"https://www.set.or.th/th/home\">SET's website</a>.</p>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"FTIX platform facilitates the government's existing voluntary emission reduction programme (T-VER credits), serving as a trading platform for carbon credits","Source_lnk":"https://asia.lombardodier.com/en/contents/corporate-news/corporate/2023/march/thailand-tackles-sustainability-.html"},{"id":161,"Country":"Tunisia","cc":"TN","Name0":"Bourse des Valeurs Mobilières de Tunis","Link":"/stock-exchange/bvmt","Name":"<a href=\"https://www.bvmt.com.tn/\">Bourse des Valeurs Mobilières de Tunis</a>","nlc":80,"dmc":8079.99,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/tunisia-tunis-stock-exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>Tunis Stock Exchange Alternative Market, since 2007. <a href=\"https://oxfordbusinessgroup.com/analysis/finding-alternative-opportunities-boost-small-and-medium-sized-enterprise-financing-alternative\">(Source)</a></li></ul><p></p>","wom":"No","womt":"No","Additional_information":"<ul><li>The TSE tries to favor the economic efficiency and the good governance in companies, control of the risks bound to their activity to reassure investors and investors, but also the other stakeholders. It considers social responsibility is favorable for listed companies, because it helps them anticipate the crises, face instabilities and consequently make the good decisions.</li><li>In 2017, the stock exchange achieved a set of actions concerning in particular the realization of seminaries dedicated to the stakeholders of the market, training employees of TSE for the implementation of an approach of CSR according to the ISO 26000 standards, the participation in the quarterly webinar gathering of the members registered in the SSE Initiative, the dissemination of their reporting of CSR on the web site of the SSE Initiative, the participation on the university demonstrations and debates on the CSR, and the celebrating of the world day for the promotion of the gender equality on March 8th.</li></ul><p>&#160;</p><p>","Organizational_model_of_stock_exchange":"<ul><li>Limited company equally held by brokerage firms. Minister of finance is represented by a government commissioner.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cmf.org.tn/\">Conseil du Marché Financier.</a></li></ul><p></p>","Regulatory_model":"<ul><li>CMF is a public authority with legal personality and financial autonomy. The CMF is responsible for ensuring the protection of savings invested in securities, the organization of markets and ensuring their smooth operation to prevent practices that may impede the proper functioning. It is also responsible for monitoring financial reporting and punishment of breaches or violations of the regulations. It oversees the Tunis Stock Exchange, the Brokers and Tunisian Clearing. <a href=\"https://www.cmf.org.tn/\">(Source).</a></li></ul><p></p>","About_the_stock_exchange":"<ul><li>In February 1969, the BVMT was created as a public establishment. In November 1995, the Tunis Stock Exchange was created as a limited company held by the brokers, 23 in total. <a href=\"https://www.bvmt.com.tn/\">(Source)</a>.</li></ul>","am":false,"os":false,"nz":true,"VCM":"No","CCM":"No","Notes":"Project developer","Source_lnk":"https://climate-laws.org/documents/updated-ndc-english-version_5f51"},{"id":162,"Country":"Türkiye","cc":"TR","Name0":"Borsa İstanbul","Link":"/stock-exchange/borsa-istanbul","Name":"<a href=\"https://www.borsaistanbul.com/en/\">Borsa İstanbul</a>","nlc":575,"dmc":385485,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/turkey-borsa-istanbul.pdf\">Yes</a>","asr":"Yes","asrt":"<a href=\"https://www.borsaistanbul.com/files/bist-2020-integrated-annual-reportand-financial-statements.pdf\">Yes</a><br>Borsa Istanbul published sustainability reports for 2015 and 2016.&#160; As of 2017, the company’s annual reports started to be published in integrated report format and information on sustainability performance and ESG data were included in integrated reports. &#160;The company’s annual integrated reports are prepared in accordance with IIRC integrated reporting framework and GRI Standards. You can reach the latest annual integrated report&#160;<a href=\"https://www.borsaistanbul.com/en/sayfa/2676/reports\">here</a><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><a href=\"https://cmb.gov.tr/data/6281521a1b41c617eced0ee8/ab21a9093d112e6f9dea44abbd3c4341.pdf\">The Sustainability Principles Compliance Framework (The Outline)</a> &#160;was put into practice with the amendment to <a href=\"https://cmb.gov.tr/data/6281521a1b41c617eced0ee8/3606055f44464de4b6fe9dad9f1cec7b.pdf\">Capital Markets Board of Türkye’s Communiqué</a> (No II-17.1) on 02.10.2020. The Outline contains fundamental sustainability principles and metrics expected to be disclosed by listed companies under the “Comply or Explain” principle.","hwg":"Yes","hwgt":"Yes<p>The Sustainability Guide, updated in 2024, seeks to provide companies with comprehensive guidance on developing and reporting sustainability practices. It includes a section on the implementation of IFRS S1 and S2 standards, which are prepared in accordance with the “<a href=\"https://sseinitiative.org/publication/model-guidance-issb\">Model Guidance on Sustainability-Related Financial Disclosures</a>.”</p><p>The Integrated Reporting Guide, prepared in collaboration with the Integrated Reporting Turkiye Foundation (ERTA) in 2022, underscores Borsa Istanbul's commitment to integrated reporting and serves as a reference for best practices in Turkish.</p><p>The Climate Reporting Guide, also prepared in 2022, delineates strategies for addressing the financial impacts of the climate crisis. It identifies key steps for assessing corporate exposure and offers guidance on the critical elements of climate-related financial disclosures.</p><p>The guidance documents are available <a href=\"https://www.borsaistanbul.com/en/sayfa/10925/sustainability-guideline\" style=\"font-size:14px;\">here</a> in Turkish.​</p><p></p>","oert":"Yes","oertt":"Yes<p>Borsa Istanbul provides training to listed companies and also contributes to seminars, training and workshop activities on sustainability.</p><p>Apart from those trainings, Borsa Istanbul hosted a couple of events dedicated to ESG:</p><p><ul><li>8 October 2024: The “Green, Social, and Sustainability Bonds Executive Training” organized in partnership with the International Finance Corporation (IFC), to inspire green bond issuance in developing countries. The training program is organized under IFC's Green Bond Technical Assistance Program (GB-TAP).</li><li>19 October 2024: A full day training on financial literacy to high school teachers. Training was provided by Borsa Istanbul experts.</li><li>6 November 2024: International Sustainable Finance and Responsible Investment Conference.</li><li>3 December 2024: Annual Sustainable Finance Forum, organized jointly by the Business World and Sustainable Development Society Turkiye and Global Compact Turkiye</li></ul></p><p></p><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><br><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\"><a href=\"https://www.borsaistanbul.com/en/sayfa/2202/corporate-governance-index\">BIST Corporate Governance Index</a></p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\">The index, introduced in 2007, includes companies with high corporate governance ratings provided by the rating institutions authorized by CMB.</p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\"><a href=\"https://borsaistanbul.com/en/sayfa/10918/bist-sustainability-stock-indices\">BIST Sustainability Index</a></p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\">The index was introduced in 2014. In 2021, the calculation methodology has been revised in cooperation with Refinitiv whose ESG ratings are now being used to calculate the index.</p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\"><a href=\"https://borsaistanbul.com/en/sayfa/10918/bist-sustainability-stock-indices\">BIST Sustainability 25 Index</a></p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\">Introduced in 2022, the index comprises 25 companies with the highest daily average trading volume and the free float market value among the companies that provide minimum sustainability rating (provided by Refinitiv).</p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\"><a href=\"https://borsaistanbul.com/en/sayfa/10918/bist-sustainability-stock-indices\">BIST Participation Sustainability Index</a></p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\">The index, introduced in 2021, includes the companies compatible with Islamic finance and have high ESG scores.</p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\"><a href=\"https://borsaistanbul.com/en/sayfa/10921/bist-sustainability-themed-debt-securities-indices\">BIST Sustainability Themed Debt Securities Indices</a></p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\">These indices were created to measure the daily returns of debt securities that qualify as \"Sustainable Debt Security\" or \"Green Debt Security\" by the regulator (CMB).</p><br><br><p></p><p></p>","hsbls":"No","hsblst":"No<br>In February 2022,&#160;<a href=\"https://spk.gov.tr/data/6231ce881b41c612808a3a1c/b2d06c64099c9e7e8877743afc7d2484.pdf\">green debt instruments guideline</a>, a local version of ICMA’s GBP is published by the Capital Markets Board. For the green debt instruments, Borsa İstanbul waives its listing fee by 50%.<p></p>","HSMElp":"Yes","HSMElpt":"Yes&#160;<p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\">The Venture Capital Market, established on September 29, 2023, serves as a platform where companies that plan to go public in the future can raise capital exclusively through capital increases and by issuing shares solely to institutional and qualified investors. This market aims to provide these companies with the necessary financing for their growth. In this way, the aim is for these companies to achieve healthier growth, institutionalize, and mature, thereby becoming ready for an initial public offering (IPO).</p><br><br>","wom":"No","womt":"No","Additional_information":"<ul><li><p dir=\"ltr\" style=\"line-height:1.3199999999999998;background-color:#ffffff;margin-top:6pt;margin-bottom:0pt;padding:0pt 0pt 6pt 0pt;\">Sustainability section on&#160;<a href=\"https://borsaistanbul.com/en/sayfa/10916/sustainability\">website.</a></p>For sustainable capital market instruments (debt-related such as bonds) issued in Turkiye, please check <a href=\"https://gefas.gov.tr/en/sdi/detail-data\">https://gefas.gov.tr/en/sdi/detail-data</a>&#160;&#160;&#160;​</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Demutualized for profit; demutualized in 2012.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cmb.gov.tr/\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.cmb.gov.tr/&source=gmail&ust=1662399187591000&usg=AOvVaw057DiSpDVD-G79WRtbBlkX\">Capital Markets Board of Türkiye</a></li></ul><p></p>","Regulatory_model":"<p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\"><br>The legal framework of Turkish capital markets, as it currently stands, is mainly devised by two major pieces of legislation, namely&#160;Capital Markets Law No. 6362 and Turkish Commercial Code. Other regulations include Communiqués of Capital Markets Board and Regulations of Stock Exchange. For more information, please click <a href=\"https://cmb.gov.tr/legal-framework/capital-market-legislation\">here</a> .</p><br>","About_the_stock_exchange":"<p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\">Borsa Istanbul A.S. (Borsa Istanbul), with roots dating back to 1873, ensures fair and well-organized trading of securities, derivatives, precious metals and diamonds as the primary exchange of Turkiye.&#160;</p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\">Borsa Istanbul is integrated with post-trade institutions Istanbul Takas ve Saklama Bankasi A.S. - Takasbank (Central Counterparty - CCP) and Merkezi Kayit Kurulusu A.S. - MKK (Central Securities Depository). Borsa Istanbul, Takasbank and MKK all together constitute Borsa Istanbul Group.&#160;</p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\">Through its integrated pre-trade, trade and post-trade structures, cutting edge technology and diverse product range, Borsa Istanbul Group provides investors with a modern and highly liquid trading platform based on international standards and best practices.&#160;</p><p dir=\"ltr\" style=\"line-height:1.3199999999999998;margin-top:6pt;margin-bottom:6pt;\">Borsa Istanbul Group facilitates access for investors to Turkish capital markets and provides them with tools to hedge perceived risks. Turkiye's fast growing economy, strong financial and real sector with access to large domestic and regional markets, geographic proximity to Europe, Middle East and Asia, liberal investment climate with robust investor protection are just a few of the key factors that make it an attractive destination for investment. Turkish capital markets are preferred by the most renowned investors from all around the world.</p><br>​<br><br>","am":true,"os":false,"nz":false,"VCM":"No","CCM":"UD","Notes":"Borsa Istanbul has been working with the Ministry of Environment Urbanisation and Climate Change on the development of a national ETS. Establishing an Emission Trading System (ETS) in Türkiye is one of the targets defined in the Medium Term Programme (20232025) and Türkiye’s Green Deal Action Plan.","Source_lnk":"https://unfccc.int/sites/default/files/NDC/2023-04/T%C3%9CRK%C4%B0YE_UPDATED%201st%20NDC_EN.pdf https://iklim.gov.tr/db/turkce/icerikler/files/DoCC_PMI_STAKEHOLDER_ENGAGEMENT_STRATEGY.pdf"},{"id":163,"Country":"Uganda","cc":"UG","Name0":"Uganda Securities Exchange","Link":"/stock-exchange/use","Name":"<a href=\"https://www.use.or.ug/\">Uganda Securities Exchange</a>","nlc":10,"dmc":2347,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Uganda-Uganda-Securities-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.use.or.ug/uploads/legal/regulations/USE%20Growth%20Enterprise%20Market%20Segment%20%28GEMS%29%20Rules%202012.pdf\">Uganda Growth Enterprise Market Segment (GEMS)</a>, since 2012</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li>The Exchange has three segments which can be utilized by investors to raise capital:</li><li>EQUITIES<ul><li>i. Growth Enterprise Market Segment (GEMS) which aims at small and medium sized enterprises.</li><li>ii. Main Investment Market Segment (MIMS) is main market segment and attracts stringent eligibility, listing and disclosure requirements.</li></ul></li><li>FIXED INCOME<ul><li>iii. Fixed Income Securities Market Segment which provides a separate market for government bonds, corporate bonds, commercial paper, preference shares, debenture stocks and any other fixed income instruments.</li></ul></li></ul><p>&#160;</p><p>","Organizational_model_of_stock_exchange":"<ul><li>Demutualised entity</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cmauganda.co.ug/\">The Capital Markets Authority of Uganda (CMA)</a></li></ul><p>","Regulatory_model":"<ul><li>The CMA, established by an Act of Parliament, has overall supervisory powers over the capital markets industry. Its powers include licensing all market intermediaries and stock exchanges as well as approving all new issues and corporate actions.</li><li>The USE&#160; is a “first tier regulator”, having direct oversight over the listed entities and member firms, on behalf of the CMA as a self regulatory organization.</li><li>Pursuant to that, the USE enacts its own regulation that governs listing of securities and membership of brokerage firms as well as conduct of trading through its automated trading system.</li></ul><p>&#160;</p><p>","About_the_stock_exchange":"","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Exploring the option of carbon markets","Source_lnk":"https://www.undp.org/uganda/news/uganda-raises-ambition-deal-greenhouse-gas-emissions-new-climate-change-plan https://easternafricaalliance.org/download/carbon-market-profile_uganda/"},{"id":164,"Country":"United Arab Emirates","cc":"AE","Name0":"Abu Dhabi Securities Exchange","Link":"/stock-exchange/adx","Name":"<a href=\"https://www.adx.ae/English/Pages/default.aspx\">Abu Dhabi Securities Exchange</a>","nlc":62,"dmc":177547.12,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/united-arab-emirates_abu-dhabi-securities-exchange.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://adxservices.adx.ae/WebServices/DataServices/contentDownload.aspx?doc=2095138\">Yes</a><br><ul><li>ADX has launched its first Sustainability Report in June 2020. The report is aligned with ADX’s growth strategy, which aims to increase the adoption of sustainable financing in the Emirate and drive capital towards investments that have positive environmental, social and governance (ESG) impacts.</li><li><a href=\"https://adxservices.adx.ae/WebServices/DataServices/contentDownload.aspx?doc=2095138\">Sustainability Report 2019</a></li><li><a href=\"https://adxservices.adx.ae/WebServices/DataServices/contentDownload.aspx?doc=2430283\">Sustainability Report 2020</a></li><li><a href=\"https://adxservices.adx.ae/WebServices/DataServices/contentDownload.aspx?doc=2770915\">Sustainability Report 2021</a></li><li>You can find all Sustainability Reports <a href=\"https://www.adx.ae/english/pages/aboutadx/sustainability/reports.aspx\">here</a></li></ul><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><a class=\"in-cell-link\" href=\"https://www.sca.gov.ae/en/regulations/regulations-listing.aspx?id=198#page=1\">See Article 76 from the </a><a class=\"in-cell-link\" href=\"https://www.sca.gov.ae/en/regulations/regulations-listing.aspx?id=198#page=1\">Chairman of SCA’s Board of Directors’ Decision no. (3/Chairman) of 2020 concerning Approval of Joint Stock Companies Governance Guide</a>","hwg":"Yes","hwgt":"Yes<br><ul><li>Abu Dhabi Securities Exchange ESG Disclosure Guidance for Listed Companies (2019) (<a href=\"https://adxservices.adx.ae/WebServices/DataServices/contentDownload.aspx?doc=2660807\">English</a>, <a href=\"https://adxservices.adx.ae/WebServices/DataServices/contentDownload.aspx?doc=1664392\">Arabic</a>)</li><li>English News release: <a href=\"https://www.adx.ae/english/pages/NewsDetails.aspx?viewid=20190728113009\">https://www.adx.ae/english/pages/NewsDetails.aspx?viewid=20190728113009</a></li><li>Arabic News release: <a href=\"https://www.adx.ae/Arabic/pages/NewsDetails.aspx?viewid=20190728113009\">https://www.adx.ae/Arabic/pages/NewsDetails.aspx?viewid=20190728113009</a></li><li>See also <a href=\"https://www.adx.ae/English/Pages/AboutADX/Sustainability/default.aspx\">this page</a></li></ul><p>&#160;</p><p></p>","oert":"Yes","oertt":"Yes<br><ul><li>On 22 and 23 January 2019 ADX held two workshops on sustainability for listed companies, titled:<br>“<a href=\"https://www.adx.ae/English/Pages/NewsDetails.aspx?viewid=20190127175951\">Accelerating Sustainability in Listed Companies. Meeting investor needs on environmental, social and governance (ESG) information</a>“</li></ul><p></p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"Yes","hsblst":"Yes<br>In May 2022, Abu Dhabi Securities Exchange announces the secondary listing of Sweihan PV Power Company’s green bond (<a href=\"https://adxservices.adx.ae/cdn/contentdownload.aspx?doc=2521028\">source</a>)<p></p>","HSMElp":"No","HSMElpt":"No","wom":"Yes","womt":"Yes<br>There is a mandatory minimum rule of at least 1 woman on boards.<br>Source: <a href=\"https://www.sca.gov.ae/en/media-center/news/14/3/2021/board-of-directors-of-sca-approves-the-obligation-of-listed-companies-to-represent-women-in-the.aspx\" target=\"_blank\" rel=\"noopener\">SCA Board on Percentage of Women’s Representation on Boards</a>,&#160;<a href=\"https://adxservices.adx.ae/WebServices/DataServices/contentDownload.aspx?doc=1704806\" target=\"_blank\" rel=\"noopener\">ADX Disclosure ESG Guidance for Listed Companies</a> and <a href=\"https://adxservices.adx.ae/WebServices/DataServices/contentDownload.aspx?doc=2464772\" target=\"_blank\" rel=\"noopener\">ADX Listing and Disclosure Regulations 2022</a>.","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Governmental not for profit</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.sca.gov.ae/en/home.aspx\">Emirates Securities and Commodities Authority</a></li></ul><p></p>","Regulatory_model":"Government (Statutory) Model<p><ul><li>The Emirates Securities and Commodities Authority (ESCA) serves as the federal regulator of the UAE and licences and supervises all securities exchanges in the country - including the Dubai Financial Exchange. The ESCA implements regulations for the country's securities exchanges and is able to revoke or suspend the listing of securities. Furthermore, the ESCA implements bylaws for the country's brokers. Accordingly, the Abu Dhabi Securities Exchange possesses very little regulatory power and would not be considered self-regulatory.</li></ul><p>","About_the_stock_exchange":"","am":true,"os":true,"nz":false,"VCM":"No","CCM":"No","Notes":"In partnership with AirCarbon Exchange (now ACX), Abu Dhabi Global Market launched the world's first regulated voluntary carbon exchange and carbon clearing house. It has also added BeZero' Carbon's ratings for users to access real-time. It appears that ACX operates independently as both an Investment Exchange and Clearing House. It's not apparent if there's any direct integration with Abu Dhabi Securities Exchange (ADX) or other exchanges.","Source_lnk":"https://carbonherald.com/bezero-carbon-ratings-to-be-hosted-on-abu-dhabi-carbon-trading-exchange/ https://www.shearman.com/en/perspectives/2022/04/abu-dhabi-global-market-to-launch-worlds-first-voluntary-carbon-credit-exchange"},{"id":165,"Country":"United Arab Emirates","cc":"AE","Name0":"Dubai Financial Market","Link":"/stock-exchange/dubai-financial-market","Name":"<a href=\"https://www.dfm.ae/\">Dubai Financial Market</a>","nlc":62,"dmc":177547.12,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/united-arab-emirates-dfm.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://assets.dfm.ae/docs/default-source/investor-relations/sustainability-en.pdf?sfvrsn=9f5af381_2\">Yes</a><br><ul><li>Annual Reports Found&#160;<a href=\"https://www.dfm.ae/discover-dfm/investor-relations/reports-presentations\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.dfm.ae/discover-dfm/investor-relations/reports-presentations&source=gmail&ust=1692273825970000&usg=AOvVaw0uYtbDCOXcfMaGBLYxOGvU\">here</a>.</li><li>Sustainability Reports Found&#160;<a href=\"https://www.dfm.ae/discover-dfm/esg-sustainability\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.dfm.ae/discover-dfm/esg-sustainability&source=gmail&ust=1692273825970000&usg=AOvVaw2Lw9m_RGe6Nyf7M0m2PueS\">here</a>.</li></ul><p>.</p><p></p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>See Article 76 from the <a href=\"https://www.sca.gov.ae/en/regulations/regulations-listing.aspx?id=198#page=1\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.sca.gov.ae/en/regulations/regulations-listing.aspx?id%3D198%23page%3D1&source=gmail&ust=1692434239419000&usg=AOvVaw3SkDxBvYPEt5uPcaGCQI-l\">Chairman of SCA’s Board of Directors’ Decision no. (3/Chairman) of 2020 concerning Approval of Joint Stock Companies Governance Guide</a></li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>&#160;<a href=\"https://assets.dfm.ae/docs/default-source/dfm-documents/dfm-guide-to-esg-reporting-2023.pdf?sfvrsn=6b51f481_2\" data-saferedirecturl=\"https://www.google.com/url?q=https://assets.dfm.ae/docs/default-source/dfm-documents/dfm-guide-to-esg-reporting-2023.pdf?sfvrsn%3D6b51f481_2&source=gmail&ust=1692273825970000&usg=AOvVaw2OAuBANL5VF4MMRgjRWnub\">DFM’s Guide to ESG Reporting</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br><ul><li style=\"font-weight:400;\">DFM and HSBC Global Investor ESG Webinar –&#160;15th June 2020</li><li style=\"font-weight:400;\">The Powerful Role Women Can Play on Company Boards,&#160;Dubai Global Woman Forum – 17th&#160;February 2020</li><li style=\"font-weight:400;\">DFM hosted ESG Reporting Guidance workshop for issuers – 26th November 2019</li><li style=\"font-weight:400;\">DFM hosted its second <a href=\"/sites/sseinitiative/files/documents/dfm-esg-workshop-e.doc\">ESG workshop</a> to increase awareness of ESG best practices in the region and the new global report on 28 April 2019</li><li>DFM Company held board briefing on corporate governance practices in collaboration with the Hawkamah Institute for Corporate Governance on 17 April 2019</li><li class=\"m_-5037958134954632706MsoListParagraph\">DFM and Hawkamah graduate a new group of Certified Board Secretaries for DFM listed companies, Monday&#160;9th July 2018</li><li class=\"m_-5037958134954632706MsoListParagraph\">ESG workshop with UNPRI, Thursday&#160;25th&#160;January 2018</li><li class=\"m_-5037958134954632706MsoListParagraph\">ESG Master-Class Workshop IPO Forum 2017 , Monday 20th November 2017</li><li>In 2022, DFM provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/united-arab-emirates-tcfd-101-workshop-training/\">source</a>)</li><li><a href=\"/sites/sseinitiative/files/documents/7th-february-2023-dfm-hosted-esg-workshop-in-collaboration-with-hawkamah-and-middle-east-investor-relations-association.pdf\">On the 7th&#160;February 2023 DFM hosted ESG workshop in collaboration with Hawkamah and Middle East Investor Relations Association.</a></li><li><a href=\"https://www.dfm.ae/discover-dfm/news-media/events/cce63ff8-f602-6339-b0d9-ff00009be840\">Dubai Sustainable Finance Webinar</a></li></ul><p></p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li style=\"font-weight:400;\">DFM Listed companies are covered by:<ul><li style=\"font-weight:400;\"><a href=\"https://www.spglobal.com/spdji/en/indices/esg/sp-hawkamah-esg-uae-index/#overview\">S&P/Hawkamah UAE ESG Index</a> (More <a href=\"https://www.thenational.ae/business/markets/dfm-launches-index-to-gauge-uae-listed-companies-commitment-to-esg-1.1009774\">here</a>)</li><li style=\"font-weight:400;\"><a href=\"https://www.spglobal.com/spdji/en/indices/esg/sp-hawkamah-esg-pan-arab-index/#overview\">S&P/Hawkamah Pan Arab ESG Index</a></li><li><a href=\"https://www.dfm.ae/the-exchange/market-information/indices/uaeesgi\">USE ESG Index</a></li><li style=\"font-weight:400;\">DFM PJSC is included in the FTSE4Good</li></ul></li></ul><p></p>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"Yes","womt":"Yes<br>As part of its keen efforts to empower Emirati women and encourage them to play a greater role on the boards of listed companies, the SCA board agreed to oblige listed companies to have at least one woman appointed to their boards. This was done by amending Clause 3 of Article 9 of The SCA Board Chairman’s Decision No. (3/Chairman) of 2020 Approving the Governance Guide for Public Joint-Stock Companies. (<a href=\"https://www.sca.gov.ae/en/media-center/news/14/3/2021/board-of-directors-of-sca-approves-the-obligation-of-listed-companies-to-represent-women-in-the.aspx\" target=\"_blank\" rel=\"noopener\">source</a>)","Additional_information":"<ul><li><a href=\"https://www.dfm.ae/discover-dfm/esg-sustainability\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.dfm.ae/discover-dfm/esg-sustainability&source=gmail&ust=1692273825970000&usg=AOvVaw2Lw9m_RGe6Nyf7M0m2PueS\">ESG & Sustainability</a>&#160;section of website</li><li>DFM and DIFC launched “Dubai Sustainable Finance Working Group” in July 2019</li><li><a href=\"https://www.dfm.ae/the-exchange/news-disclosures/e-board/positions\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.dfm.ae/the-exchange/news-disclosures/e-board/positions&source=gmail&ust=1692273825970000&usg=AOvVaw2WiUFC2i1J0pprZDsVVB3g\">eBoard</a>&#160;Online application platform promoting board position applications in support of the Dubai Women Establishment and UAE Gender Balance Council to promote female board representation</li></ul><p>&#160;</p><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2007</li></ul><p>","Regulatory_bodies":"<a href=\"https://www.sca.gov.ae/en/home.aspx\" data-saferedirecturl=\"https://www.google.com/url?q=https://www.sca.gov.ae/en/home.aspx&source=gmail&ust=1692273825970000&usg=AOvVaw13Jf9itRU-6TmU-5a3zlY-\">Securities and Commodities Authority</a><p></p>","Regulatory_model":"The Securities and Commodities Exchange (SCA) serves as the federal regulator of the UAE and licenses and supervises all securities exchanges in the country including the Dubai Financial Market.<p>","About_the_stock_exchange":"","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"There is information that the UAE government has planned to start carbon-offset trading exchange in Abu Dhabi","Source_lnk":"https://www.bloomberg.com/news/articles/2022-11-11/uae-to-start-carbon-offset-trading-exchange-in-abu-dhabi#xj4y7vzkg"},{"id":167,"Country":"United Kingdom","cc":"GB","Name0":"London Stock Exchange","Link":"/stock-exchange/lse","Name":"<a href=\"https://www.londonstockexchange.com/home/homepage.htm\">London Stock Exchange</a>","nlc":1991,"dmc":3574555.01,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/UK-LSE.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"/wp-content/uploads/2016/07/LSEG-Corporate-Responsibility-Report-31Dec2015.pdf\">Yes</a><br>","ESGrr":"No","ESGrrt":"No<br><p>Listing rules are set by the regulator, not the LSE. In the UK the changes to the Companies Act 2006 (Strategic Report and Directors Report) regulations came into effect on 1 October 2013. This means extra reporting on greenhouse gas emissions, human rights and diversity is now required within the front half of the annual report.&#160;<a href=\"https://assets.publishing.service.gov.uk/government/uploads/system/uploads/attachment_data/file/206241/bis-13-889-companies-act-2006-draft-strategic-and-directors-report-regulations-2013.pdf\">Source</a></p>","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.londonstockexchange.com/raise-finance/sustainable-finance/your-guide-sustainability-reporting?utm_campaign=3003984_LSE%20Corporate%20Disclosure%20Campaign_005&elqCampaignId=25030&utm_source=LinkedIn&utm_medium=Paid%20Social&utm_content=tile%201&utm_term=reporting%20guide&referredBy=tile%201\" title=\"LSE - Guide to Sustainability Reporting\">LSE - Guide to Sustainability Reporting</a></li><li><a href=\"https://docs.londonstockexchange.com/sites/default/files/documents/LSE_guide_to_climate_reporting_final_0.pdf\">LSE Climate Report Guidance</a> for London-listed companies on the integration of climate reporting best practice and TCFD implementation.</li></ul>","oert":"Yes","oertt":"Yes<br><ul><li>Through FTSE, which is wholly owned by LSEG, detailed ESG ratings and data are provided to the investment community globally. These are presented at a variety of investor conferences globally and FTSE works with asset owners, asset managers and banks to develop tailor custom ESG services. <a href=\"https://www.ftse.com/products/indices/F4G-ESG-Ratings\">Source</a></li><li>Practicing Integrated Thinking & Reporting (with Fondazione Eni Enrico Mattei, 2014)</li><li>In 2022, LSEG provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/united-kingdom-tcfd-101-workshop-training/\">source</a>)</li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.ftse.com/products/indices/green-revenues\">FTSE Green Revenues Index Series</a></li><li><a href=\"https://www.ftse.com/products/indices/ftse4good\">FTSE4Good Index Series</a></li><li><a href=\"https://www.ftse.com/products/indices/Env-Markets\">FTSE Environmental Market Index Series</a></li><li><a href=\"https://www.ftse.com/products/indices/ex-fossil-fuels\">FTSE All-World Ex-Fossil Fuel Index Series</a></li></ul><p>","hsbls":"Yes","hsblst":"Yes<br><ul><li>LSEG has a range of dedicated green bond segments, launched in June 2015. There are currently 42 green bonds listed on LSE.</li><li>Green bond factsheet from April 2017 can be found <a href=\"https://www.lseg.com/sites/default/files/content/documents/20170403%20Green%20Bonds.pdf\">here</a>.</li></ul><p>&#160;</p><p>","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.londonstockexchange.com/companies-and-advisors/aim/aim/aim.htm\">Alternative Investment Market</a>, since 2005</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li><a href=\"https://docs.londonstockexchange.com/sites/default/files/documents/LSE_guide_to_climate_reporting_final_0.pdf\">Guidance on Climate Reporting Best Practice and TCFD implementation</a></li><li><a href=\"https://www.lseg.com/about-london-stock-exchange-group/corporate-responsibilty\">Sustainability Section</a> on website.</li><li><a href=\"https://www.lseg.com/investor-relations/sustainability/sustainability-report-2021\">2021 Corporate Social Responsibility Report </a></li><li>Sustainability Section in 2021 <a href=\"https://www.lseg.com/investor-relations/presentations-and-webcasts/annual-reports\">Annual Report</a></li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in UK in 2000</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.fca.org.uk/\">Financial Conduct Authority</a></li></ul><p>","Regulatory_model":"Government (Statutory) Model<p><ul><li>The Financial Conduct Authority (FCA) is responsible for regulating the financial services markets, exchanges and firms. They have full listing authority in the UK, and have full power to monitor the markets. The FCA looks after conduct, competition and actions that occur on the London Stock Exchange. This would thus be considered a Government (Statutory) Model.</li></ul><p>","About_the_stock_exchange":"","am":true,"os":true,"nz":true,"VCM":"Yes","CCM":"No","Notes":"The London Stock Exchange  Voluntary Carbon Market enables funds and operating companies to raise capital to be channelled into projects that are expected to generate carbon credits. The Voluntary Carbon Market designation will be applied to funds or operating companies that are admitted to Main Market or AIM and which invest in climate change mitigation projects that are expected to yield carbon credits.","Source_lnk":"https://www.londonstockexchange.com/raise-finance/equity/voluntary-carbon-market"},{"id":168,"Country":"United Republic of Tanzania","cc":"TZ","Name0":"Dar es Salaam Stock Exchange","Link":"/stock-exchange/dse_tanzania","Name":"<a href=\"https://www.dse.co.tz/\">Dar es Salaam Stock Exchange</a>","nlc":28,"dmc":6898.77,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/tanzania-dar-es-salaam-1.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br><ul><li><a href=\"/esg-guidance/\">In Q1 2017 committed to publishing guidance.</a></li></ul><p></p>","oert":"Yes","oertt":"Yes<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>DSE Enterprise Growth Market Segment, since 2012.</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li>The&#160;<a href=\"https://www.dse.co.tz/sites/default/files/dsefiles/ANNUAL%20REPORT%202016%20-%20Final.pdf\">DSE Annual Members Awards Program</a>&#160;for 2017 was concluded in September 2018. Companies and Member Firms that excelled in the areas of corporate governance, investor protection, sustainable business, and CSR were recognized and awarded trophies and certificates.</li><li>DSE was admitted as an affiliate member of the WFE in the 2015-2016 year. DSE has applied for Full Membership of the WFE.</li></ul><p></p>","Organizational_model_of_stock_exchange":"<ul><li>Listed, demutualized in 2015.</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.cmsa-tz.org/\">Capital Market & Securities Authority of Tanzania.</a></li></ul><p></p>","Regulatory_model":"<ul><li>DSE is a Self-Regulating Organization. The exchange is permitted to conduct regulatory functions tied to market operations but it must adhere to the regulations of the Capital Markets & Securities Authority of Tanzania.</li></ul><p>","About_the_stock_exchange":"","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"Setup a National Carbon Monitoring Center as the national coordinator for carbon trade projects","Source_lnk":"https://www.ncmc.sua.ac.tz/"},{"id":169,"Country":"United States","cc":"US","Name0":"Nasdaq","Link":"/stock-exchange/nasdaq-2","Name":"<a href=\"https://business.nasdaq.com/\">Nasdaq</a>","nlc":3723,"dmc":22464541.01,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/USA-NASDAQ.pdf\">Yes</a>","asr":"Yes","asrt":"Yes <a href=\"https://business.nasdaq.com/media/2017%20Nasdaq%20Sustainability%20Report%20Digital%20ver%202_tcm5044-50886.pdf\">Yes</a><br>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.nasdaq.com/docs/2019/11/26/2019-ESG-Reporting-Guide.pdf\">ESG Reporting Guide 2.0: A support resource for companies</a> (May 2019)</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>List of events <a href=\"https://business.nasdaq.com/discover/corporate-responsibility-and-sustainability/sustainability-events/index.html\">here </a></li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br>Offers <a href=\"https://business.nasdaq.com/discover/corporate-responsibility-and-sustainability/index.html\">70 sustainability-related indexes</a> (not all actively traded), including:<p><ul><li>OMX GES Ethical indexes</li><li>NASDAQ Clean Edge US Index (CLEN)</li><li>OMX CRD Global Sustainability Index</li></ul><p>","hsbls":"Yes","hsblst":"Yes<br>","HSMElp":"No","HSMElpt":"No","wom":"Yes","womt":"Yes<br><ul><li>There is a mandatory minimum rule of at least 1 woman on boards.<br>Source: NASDAQ. (2020). <a href=\"https://www.nasdaq.com/press-release/nasdaq-to-advance-diversity-through-new-proposed-listing-requirements-2020-12-01\">Nasdaq to Advance Diversity through New Proposed Listing Requirements.</a> Details of the rule: NASDAQ’s proposed rules are pending approval by the US SEC. If approved, they would require listed companies to have at least one director who self-identifies as female. In case of non-compliance, companies would have to explain the reasons.</li></ul>","Additional_information":"<a href=\"https://business.nasdaq.com/media/Nasdaq%20UNGC%20COP%202014%20RevFinal_tcm5044-19892.pdf\">Nasdaq Progress Report 2014</a>, United Nations Global Compact<p><ul><li>Nasdaq speaks, moderates, sponsors, or otherwise exhibits at key industry events related to sustainability. <a href=\"https://business.nasdaq.com/discover/corporate-responsibility-and-sustainability/index.html\">Source</a></li><li>Nasdaq and CERES’ Investor Network on Climate Risk (INCR) are working with other partners to create an investor-centric sustainability reporting proposal for public companies and stock exchanges. <a href=\"https://www.ceres.org/news-center/press-releases\">Source</a></li><li>Nasdaq had a three-part article series in 2013, called <a href=\"https://business.nasdaq.com/marketinsite#%21?tag=Corporate%20Responsibility\">Doing Well by Doing Good</a>.</li><li>Nasdaq is a member of the United Nations Global Compact and Chair of the WFE Sustainability Working Group. <a href=\"https://www.unglobalcompact.org/what-is-gc/participants/18220-The-NASDAQ-OMX-Group-Inc-\">Source</a>.</li><li>Board Member, US Global Compact US Network; Advisory Board Member, SASB.</li></ul><p>","Organizational_model_of_stock_exchange":"Listed company for profit; demutualized in:<p><ul><li>NASDAQ - 2000</li><li>OMX - 1993</li></ul><p>","Regulatory_bodies":"<ul><li>US- <a href=\"https://www.sec.gov/\">Securities and Exchange Commission</a></li><li>UK - <a href=\"https://www.fca.org.uk/\">Financial Conduct Authority</a></li></ul><p>&#160;</p><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model.<p><ul><li>Regulatory practices in regards to this exchange vary slightly from country to country. The exchanges operated by Nasdaq in each country appear to have basic regulatory oversight. However, the ultimate regulatory authority for each market lies with the regulatory bodies listed.</li></ul><p>","About_the_stock_exchange":"","am":true,"os":true,"nz":false,"VCM":"No","CCM":"No","Notes":"EEX will acquire Nasdaq’s European power trading and clearing business - Nasdaq’s Nordic, French, and German power futures as well as European carbon emission allowance futures (EUAs)","Source_lnk":"https://www.nasdaq.com/press-release/eex-and-nasdaq-commodities-announce-intention-to-transfer-nasdaqs-european-power"},{"id":170,"Country":"United States","cc":"US","Name0":"New York Stock Exchange","Link":"/stock-exchange/nyse","Name":"<a href=\"https://www.nyse.com/index\">New York Stock Exchange</a>","nlc":2525,"dmc":27686923.54,"SSEPE":"Yes","SSEPEt":"Yes","asr":"Yes","asrt":"Yes <a href=\"https://www.intercontinentalexchange.com/about/corporate-responsibility-report\">Yes</a><br>","ESGrr":"No","ESGrrt":"No","hwg":"Yes","hwgt":"Yes<br><ul><li><a href=\"https://www.nyse.com/esg-guidance\">Best Practices for Sustainability Reporting</a></li><li>NYSE also provides various sustainability resources for listed companies at https://www.nyse.com/esg/resource-center</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>The NYSE regularly conducts webinars and educational symposiums for investor relations, sustainability and governance teams of listed companies. These programs include the NYSE IR Summit, held annually at the NYSE and throughout the year in regional locations. For the past several years, each day-long summit has included several governance and board related topics and speakers have represented proxy advisory firms, hedge funds, small and large investment fund managers, heads of governance, ESG-focused investors, corporate secretaries and industry leaders.</li><li>The NYSE partnered with the CFA Institute and Principles for Responsible Investing (PRI) to host a <a href=\"https://www.intercontinentalexchange.com/publicdocs/2018_CR_Report.pdf\">workshop</a> in November of 2017 for professional investors designed to promote understanding of how ESG issues are impacting share prices, bond yields and bond spreads.</li><li>September 2018 - NYSE held a Panel discussion with its listed companies and Tensie Whelan, who heads the Center for Sustainable Business at the NYU Stern School of Business to discuss measuring the ROI on sustainability. Key takeaways in the <a href=\"https://www.ice.com/publicdocs/2019_CRR.pdf\">2019 CRR report p.14</a>.&#160;</li><li>October 2018 - NYSE held a webinar with NRG Energy Vice President of Sustainability and Janine Guillot, SASB Director of Capital Markets Policy and Outreach to discuss how incorporating ESG information into annual reports can help engage with investors. <a href=\"https://www.ice.com/publicdocs/2019_CRR.pdf\">See CRR report from 2019, p.14</a>.</li><li>May 2022 - NYSE provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC. (<a href=\"/sse-event/united-states-tcfd-101-workshop-training/\">source</a>)</li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><p>The NYSE administers, calculates or publishes nearly <a href=\"https://www.theice.com/market-data/indices/esg\">40 ESG indices</a> (more than 20 are environmental related specifically):</p><ul><li>ICE BoAML Green Bond Index·</li><li>NYSE Arca Environmental Services Index</li><li>MLCX Biofuels Index - Total Return (Intraday Indicative)</li><li>Barclays Women in Leadership Total Return USD Index</li><li>Return on Disability US LargeCap Excess Return Net USD Index</li><li>SPDR SSGA Gender Diversity Index</li><li>SSI Impact Index</li><li>Summit Zacks Global Water Index (Price Return)</li><li>Syntax U.S. Social Core Tier 1 Index</li><li>Syntax U.S. Social Core Tier 2 Index</li><li>WilderHill Clean Energy Index</li><li>WilderHill Progressive Energy Index</li><li>ZyFin India Quality and Governance Equity Index (USD PR)</li><li>S&P U.S. Activist Interest Index</li><li>Tortoise North American Water Index</li><li>Ardour Global Index Extra Liquid (USD)</li><li>Ardour Solar Energy Index (USD)</li><li>Northern Trust Developed Real Estate ESG Price Index (USD)</li><li>Northern Trust GRESB Developed Real Estate ESG Price Index (USD)</li><li>S-Net Nuclear Energy Index (USD)</li><li>Thomson Reuters Global Equal Opportunities Select Index</li><li>Thomson Reuters Global Large/Mid Diversity & Inclusion ex. Controversial Weapons Equal Weight Price Return Index</li><li>Thomson Reuters/S-Network Developed Markets ex-US Environmental Best Practices Index (USD)</li><li>Thomson Reuters/S-Network Developed Markets ex-US ESG Best Practices Index (USD)</li><li>Thomson Reuters/S-Network Developed Markets ex-US Governance Best Practices Index (USD)</li><li>Thomson Reuters/S-Network Developed Markets ex-US Social Best Practices Index (USD)</li><li>Thomson Reuters/S-Network Emerging Markets Environmental Best Practices Index (USD)</li><li>Thomson Reuters/S-Network Emerging Markets ESG Best Practices Index (USD)</li><li>Thomson Reuters/S-Network Emerging Markets Governance Best Practices Index (USD)</li><li>Thomson Reuters/S-Network Emerging Markets Social Best Practices Index (USD)</li><li>Thomson Reuters/S-Network Europe Environmental Best Practices Index (USD)</li><li>Thomson Reuters/S-Network Europe ESG Best Practices Index (USD)</li><li>Thomson Reuters/S-Network Europe Governance Best Practices Index (USD)</li><li>Thomson Reuters/S-Network Europe Social Best Practices Index (USD)</li><li>Thomson Reuters/S-Network US Large Cap Environmental Best Practices Index (USD)</li><li>Thomson Reuters/S-Network US Large Cap ESG Best Practices Index (USD)</li><li>Thomson Reuters/S-Network US Large Cap Governance Best Practices Index (USD)</li><li>Thomson Reuters/S-Network US Large Cap Social Best Practices Index (USD)</li></ul><p>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li><a href=\"https://www.nyse.com/markets/nyse-american\">NYSE American</a>, since 2008</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li>More information on NYSE's sustainability efforts can be found on their <a href=\"https://www.nyse.com/sustainability\">website</a>.</li><li>The Intercontinental Exchange Group also released a <a href=\"https://www.intercontinentalexchange.com/about/corporate-responsibility-report\">Corporate Responsibility Report</a> in 2019.</li><li>In 2019 the exchange launched the <a href=\"https://ir.theice.com/press/press-releases/all-categories/2019/06-25-2019-133029672\">NYSE Board Diversity Council</a> to advance gender board diversity</li></ul><p>&#160;</p><p>","Organizational_model_of_stock_exchange":"<ul><li>Listed company for profit; demutualized in 2006</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.sec.gov/\">U.S. Securities and Exchange Commission</a></li></ul><p>","Regulatory_model":"Limited Exchange Self-Regulatory Organization (SRO) Model.<p><ul><li>The NYSE's self-regulatory obligations are performed by NYSE Regulation, a unit of the NYSE Group, Inc. which is responsible for monitoring listed company compliance and for performing surveillance of exchange members’ trading and enforcement work related to trading on the exchange. Pursuant to a regulatory services agreement, the Financial Industry Regulatory Authority, Inc. (FINRA) performs certain regulatory work on behalf of NYSE Regulation, including examinations of NYSE member firms and certain cross-market surveillance and enforcement work.</li><li>In some instances, NYSE Regulation has concurrent jurisdiction with the US Securities and Exchange Commission and FINRA with respect to the NYSE’s member firms and persons associated with them.</li></ul><p>","About_the_stock_exchange":"","am":true,"os":false,"nz":false,"VCM":"No","CCM":"Yes","Notes":"KRBN (KraneShares Global Carbon Strategy ETF) trades on the New York Exchange (NYSE) and is the most accessible ETF for investing in carbon markets. This ETF tracks the top traded carbon credit futures contracts and covers a wide range of cap-and-trade carbon allowances. Carbon Fund Advisors also introduced the Carbon Strategy ETF with NYSE Ticker KARB to provide exposure to global compliance carbon markets.","Source_lnk":"https://www.green.earth/blog/carbon-green-stocks https://carboncredits.com/carbon-strategy-et-karb-on-nyse/"},{"id":171,"Country":"Uruguay","cc":"UY","Name0":"Bolsa Electrónica de Valores del Uruguay S.A. (BEVSA)","Link":"/stock-exchange/bolsa-electronica-de-valores-del-uruguay-s-a-bevsa","Name":"<a href=\"https://web.bevsa.com.uy/\">Bolsa Electrónica de Valores del Uruguay S.A. (BEVSA)</a>","nlc":19,"dmc":1514,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/uruguay-bevsa.pdf\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"No","oertt":"No<br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"","Regulatory_bodies":"","Regulatory_model":"","About_the_stock_exchange":"","am":false,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"No relevant information","Source_lnk":""},{"id":172,"Country":"Viet Nam","cc":"VN","Name0":"Hanoi Stock Exchange","Link":"/stock-exchange/hnx","Name":"<a href=\"https://www.hnx.vn/\">Hanoi Stock Exchange</a>","nlc":345,"dmc":22399.09,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Viet-Nam-HNX.jpg\">Yes</a>","asr":"No","asrt":"No<br>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li><a href=\"https://ssc.gov.vn/ssc/contentattachfile/idcplg?dID=103390&dDocName=APPSSCGOVVN162103170&Rendition=No.155-2015-TT-BTC&filename=C155mf6Oct15DisclosureInformationSecurities%20%28ban%20day%20du%29.pdf\">Circular 155/2015/TT-BTC</a>&#160;(dated 06/10/2015) on guidelines for information disclosure on securities market.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>HNX published Guidance on ESG Disclosure for listed companies in 2016 in accordance with sustainability reporting requirements by Circular 155/2015/TT-BTC dated October 6, 2015 on guidelines for information disclosure on securities market.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>Joint workshop by Hanoi Stock Exchange and Global Reporting Initiative – GRI “Information disclosure standards of Global Reporting Initiative (GRI)” on Aug 18th, 2017;</li><li>Joint workshop by CPA Australia, HNX and HOSE “International practices on investor relations” on May 23rd, 2018;</li><li>Joint workshop by HNX, HOSE and GRI “Sustainability Reporting for Public Listed Companies” in Jun 18th , 2018, Hanoi.</li><li>In 2022, provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC in a joint workshop with the Sate Securities Commission of Vietnam and HOSE. (<a href=\"/sse-event/vietnam-tcfd-101-workshop-training-2/\">source</a>)</li></ul><p>&#160;</p><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"Yes","HSMElpt":"Yes<br><ul><li>One of the function of UPCoM market is a trading platform for SMEs</li></ul><p>","wom":"No","womt":"No","Additional_information":"<ul><li class=\"value\">Currently, HNX operates 4 markets including listed stock market, UPCoM, Government bond market, and derivatives market.</li></ul><p>","Organizational_model_of_stock_exchange":"<ul><li>State-owned single member limited liability Company</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.ssc.gov.vn/ubck/faces/en/enmenu/enpages_home\">State Securities Commission (SSC)</a></li></ul><p>","Regulatory_model":"<ul><li>Hanoi Stock Exchange (HNX) was officially designated as a State-owned single member limited liability company with sole ownership by the Ministry of Finance and regulated by SSC.</li></ul><p>","About_the_stock_exchange":"","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"The government has issued a legal framework and has laid the ground for carbon markets initiative. The roadmap for the ETS states that regulations and a trading platform should be in place by 2025. A pilot voluntary ETS is planned for 2026-2027. The mandatory ETS should be implemented from 2028 onwards","Source_lnk":"https://www.vietnam-briefing.com/news/vietnams-carbon-market-2023.html/#:~:text=Despite%20the%20absence%20of%20a,to%20ensure%20seamless%20international%20trade."},{"id":173,"Country":"Viet Nam","cc":"VN","Name0":"Ho Chi Minh Stock Exchange","Link":"/stock-exchange/hsx","Name":"<a href=\"https://www.hsx.vn/\">Ho Chi Minh Stock Exchange</a>","nlc":404,"dmc":256394.98,"SSEPE":"Yes","SSEPEt":"<a href=\"/wp-content/uploads/2019/11/Vietnam-HOSE.pdf\">Yes</a>","asr":"Yes","asrt":"Yes<br><ul><li><a href=\"https://www.hsx.vn/Areas/Desktop/Web/DownloadAnnualReport?ownerId=ae7ecbef-06a1-42e1-a178-a23cec0a0de1&langId=10dd075f-c751-46d2-b598-022850e517f6\">2016 Annual Report </a></li></ul><p>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li><a href=\"https://ssc.gov.vn/ssc/contentattachfile/idcplg?dID=103390&dDocName=APPSSCGOVVN162103170&Rendition=No.155-2015-TT-BTC&filename=C155mf6Oct15DisclosureInformationSecurities%20%28ban%20day%20du%29.pdf\">Circular 155/2015/TT-BTC</a> (dated 06/10/2015) on guidelines for information disclosure on securities market.</li></ul>","hwg":"Yes","hwgt":"Yes<br><ul><li>The SSC, in cooperation with the IFC, published an <a href=\"/wp-content/uploads/2014/08/20161212_ES-Disclosure-Guideline-ENGLISH.pdf\">Environmental and Social Disclosure Guide</a> in 2016.</li></ul><p>","oert":"Yes","oertt":"Yes<br><ul><li>E&S training programme held in 2015. <a href=\"https://www.hsx.vn/Areas/Desktop/Web/AnnualReportView?fid=53b3300db569458d93ae9899e2c87d08\">Annual Report</a> details additional trainings held in 2016 for market participants on corporate governance (pg 34).</li><li>In 2022, provided training on Climate-related Financial Disclosures (TCFD recommendations) in collaboration with the SSE, CDP and IFC in a joint workshop with the State Securities Commission of Vietnam and HNX. (<a href=\"/sse-event/vietnam-tcfd-101-workshop-training-2/\">source</a>)</li></ul><p>","mcbsri":"Yes","mcbsrit":"Yes<br><ul><li><a href=\"https://www.hsx.vn/Modules/Listed/Web/StockIndexView/188802577\">Sustainability Index (VNSI)</a> launched on 24 July 2017. VNSI measures the performance of the top 20 sustainable listed companies on HOSE. Constituents are selected from the VN100 (100 largest companies on HOSE).</li></ul><p>","hsbls":"No","hsblst":"No<br><ul><li>Working on developing green listings</li></ul><p>","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"<ul><li>In parallel with the launch of the sustainability index, the HOSE exchange is working on implementing green corporate bond listing</li><li>HOSE is part of the governmental <a href=\"https://www.giz.de/de/downloads/VietNam-GreenGrowth-Strategy.pdf\">Vietnam Green Growth Strategy</a> with the support from GIZ (Germany)</li></ul><p>&#160;</p><p>","Organizational_model_of_stock_exchange":"<ul><li>Governmental not for profit</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.ssc.gov.vn/ubck/faces/en/enmenu/enpages_home\">State Securities Commission (SSC)</a></li></ul><p>","Regulatory_model":"<p>Government (Statutory) Model</p><ul><li>The State Securities Commission is an organization&#160;under the Ministry of Finance, charged with the functions of the state regulation of securities and securities market, direct regulation and&#160;supervision of activities in securities and securities market, management of&#160;public services in the fields of securities and securities market in accordance with applicable laws. HoChiMinh Stock Exchange is empowered to issue Regulations on Listing, Trading, Membership, Market Surveillance, etc. for those activities on its marketplace.</li></ul><p>","About_the_stock_exchange":"<p>Location: Ho Chi Minh City, Vietnam</p><ul><li>In an effort to industrialize and modernize the country, maintain stable economic growth and restructure the economy to enhance its efficiency and competition, Vietnam had needed huge capital for investment. Therefore, a securities market in Vietnam was in urgent demand in order to mobilize mid-term and long-term capital internally, as well as outside the country into economic investment through debt securities and capital securities. In addition, equitization of state-owned enterprises along with establishment and development of securities market would create a more open and healthier business environment.</li><li>On July 10th 1998, the Prime Minister signed Decree No. 48/1998/ND-CP on stock and securities market and a Decision to set up two securities trading centers at Hanoi and Ho Chi Minh City.</li><li>On July 20th 2000, the Ho Chi Minh City Securities Trading Center officially became operational and executed the first trading session on July 28th 2000 with 2 types of listing stocks.</li><li>After 7 years of growing and integrating into the global securities market, the government signed Decision No. 599/QD-TTg on May 11th 2007 to transfer the Ho Chi Minh City Securities Trading Center to Hochiminh Stock Exchange (HOSE). On August 8th 2007, Hochiminh Stock Exchange was officially opened.</li></ul><p>&#160;</p>Ownership of Exchange (Shares >4% only)ShareVietnam Ministry of Finance100.00%","am":true,"os":false,"nz":false,"VCM":"No","CCM":"No","Notes":"The roadmap for the ETS states that regulations and a trading platform should be in place by 2025. A pilot voluntary ETS is planned for 2026-2027. The mandatory ETS should be implemented from 2028 onwards","Source_lnk":"https://icapcarbonaction.com/system/files/document/ICAP%20Emissions%20Trading%20Worldwide%202023%20Status%20Report_0.pdf https://www.reuters.com/markets/carbon/asias-carbon-pricing-emission-trading-systems-2023-03-31/ https://winrock.org/wp-content/uploads/2023/02/LuatBVMT-Eng_20230203.pdf"},{"id":174,"Country":"Zimbabwe","cc":"ZW","Name0":"Zimbabwe Stock Exchange","Link":"/stock-exchange/zimbabwe","Name":"<a href=\"https://www.zse.co.zw/\">Zimbabwe Stock Exchange</a>","nlc":56,"dmc":28585.65,"SSEPE":"Yes","SSEPEt":"<a href=\"//wp-content/uploads/2019/11/Zimbabwe-Zimbabwe-Stock-Exchange.pdf\">Yes</a>","asr":"No","asrt":"No<br>","ESGrr":"Yes","ESGrrt":"Yes<br><ul><li>In June 2019 the exchange <a href=\"https://www.zse.co.zw/wp-content/uploads/2019/06/Press-Release-by-ZSE-Gazetting-of-Listing-Rules-14.06.2019.pdf\">announced</a> new listing requirements, which includes “Part XXI Sustainability Information and Disclosure (paragraphs 399 to 404, pages 157 to 158). The new listing requirements can be found <a href=\"https://www.zse.co.zw/wp-content/uploads/2019/06/S.I.-134-of-2019-Security-Exchange-.pdf\">here</a>.</li></ul><p></p>","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Yes<br>In April 2023, the ZSE in partnership with Institute for Sustainability Africa (INŚAF) hosted an ESG Training ; see <a class=\"waffle-rich-text-link\" href=\"https://www.linkedin.com/posts/zimbabwestockexchange_the-zse-in-partnership-with-institute-for-activity-7045010669930168320-tu8z?originalSubdomain=zw\">LinkedIn Source</a><p>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"<ul><li>Public Limited Company</li></ul><p>","Regulatory_bodies":"<ul><li><a href=\"https://www.seczim.co.zw/\">Securities and Exchange Commission of Zimbabwe (SECZ) </a></li><li><a href=\"https://www.rbz.co.zw/\">Reserve Bank of Zimbabwe</a></li><li><a href=\"https://www.icaz.org.zw/imisdocs/zia.pdf\">Zimbabwe Investment Authority</a></li><li><a href=\"https://www.zimra.co.zw/\">Zimbabwe Revenue Authority</a></li></ul><p>&#160;</p><p>","Regulatory_model":"<ul><li>The Zimbabwe Stock Exchange (ZSE) Act reached the statute book in January 1974. The members of the Exchange continued to trade as before. However for legal reasons, it became necessary to bring into being a new Exchange coincidental with the passing of the legislation.The present Exchange therefore dates back from the passing of the Act. In 2004, the Securities Act was promulgated to repeal the ZSE Act and became operational in September 2008. The Securities Commission of Zimbabwe is the capital market regulator and it became operational in October 2008 and is governed by commissioners appointed by the Minister of Finance with a tenure of four years. (<a href=\"https://www.zimbabwe-stock-exchange.com/about/about-us/\">source</a>)</li><li>The Zimbabwe Stock Exchange serves three critical functions:</li></ul><li>Providing a link between companies that need funds to set up new businesses or to expand current operations and investors that have excess funds to invest in such companies</li><li>Provide a regulated market place for buying and selling of shares at prices determined by supply and demand, not withstanding other macro economic fundamentals</li><li>Provide a properly constituted and regulated environment that ensures market integrity and fairness among stock market participants. (<a href=\"https://www.zimbabwe-stock-exchange.com/about/about-us/\">source</a>)</li><p>","About_the_stock_exchange":"Location: Harare, Zimbabwe<p><ul><li>The Zimbabwe Stock Exchange was founded in 1946. In 2009, Zimbabwe adopted the USD as its primary trading currency</li></ul>Ownership of Exchange (Shares >4% only)ShareGovernment of Zimbabwe32%","am":false,"os":false,"nz":false,"VCM":"No","CCM":"UD","Notes":"The Zimbabwean government has released a national carbon credit framework outlining guidance on the carbon markets in the country. Investors will be allowed to list carbon credits on the exchange on the Victoria Falls Stock Exchange (VFEX), which is a subsidiary of the Zimbabwe Stock Exchange (“ZSE”), after approval from the Environment Ministry and admission into the Zimbabwe Carbon Credit Registry.","Source_lnk":"https://www.bloomberg.com/news/articles/2023-05-24/carbon-credits-to-be-listed-on-zimbabwe-exchange-as-state-upends-trade https://finance.yahoo.com/news/belarus-group-kick-start-zimbabwe-095926643.html https://www.spglobal.com/commodityinsights/en/market-insights/latest-news/agriculture/051723-zimbabwe-looks-to-revamp-carbon-credit-trade-wants-more-revenues"},{"id":176,"Country":"Palestine, State of","cc":"PS","Name0":"Palestine Exchange","Link":"/stock-exchange/palestine-exchange","Name":"<a href=\"https://www.pex.ps/\" target=\"_blank\" rel=\"noopener\">Palestine Exchange</a>","nlc":49,"dmc":4304,"SSEPE":"Yes","SSEPEt":"<a href=\"/sites/sseinitiative/files/documents/palestine-pex.pdf\" target=\"_blank\" rel=\"noopener\">Yes</a>","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No","oert":"No","oertt":"No","mcbsri":"No","mcbsrit":"No","hsbls":"No","hsblst":"No","HSMElp":"No","HSMElpt":"No","wom":"No","womt":"No","Additional_information":"N/A","Organizational_model_of_stock_exchange":"Listed","Regulatory_bodies":"PCMA (Palestine Capital Market Authority)","Regulatory_model":"<ul><li>Government (Statutory)</li></ul>","About_the_stock_exchange":"<p>PEX was Established in 1995 as a private company aimed at promoting investment in Palestine the PEX held its inaugural trading session in February 1997. In 2010 PEX transformed itself to become the second publicly traded Arab stock exchange entirely owned by the private sector.</p><p>The Exchange provides investors with a fair transparent and fully automated trading venue. It focuses on attracting a wide range of regional and global investors including those among the Palestinian Diaspora. PEX is financially sound and able to weather a volatile world as demonstrated by its performance relative to other MENA exchanges during the global financial crisis.</p><p>Since inception the Palestine Exchange has leveraged the latest technology to ensure maximum transparency integrity and investor protection. PEX trading surveillance and CSD was always carried out using NASDAQ OMX systems. In 2019 trading will be shifted to NASDAQ’s next-gen “X-Stream” platform.</p><p>PEX listed companies are divided into five sectors: banking and financial services insurance investment industry and services. Shares trade in Jordanian dinars and US dollars. PEX member securities companies (brokerage firms) operations are extended across the West Bank and Gaza Strip and authorized custodians are available to work on behalf of foreign investors.</p><p>PEX is Classed as \"Frontier Market\" by FTSE Russell and as a stand-alone country within both MSCI and S&P indices the Palestine Exchange maintains an international presence via membership in several organizations including the World Federation of Exchanges (WFE) the Federation of Arab Stock Exchanges the Federation of Euro-Asian Stock Exchanges (FEAS) the Forum of Islamic Stock Exchanges the Africa & Middle East Depositories Association (AMEDA) and the Association of National Numbering Agencies (ANNA).</p><p>PEX is registered (562601187) with the Companies Controller at the Ministry of National Economy and operates under the supervision of the Palestinian Capital Market Authority.</p><p>Vision</p><p>To be a model national stock exchange with an international profile.</p><p>Mission</p><p>To provide a world-class trading environment characterized by equity transparency and efficiency.</p><p>Objectives</p><ul><li>Offer a trading environment designed to serve and protect investors.</li><li>Increase community awareness of financial markets and products.</li><li>Forge strong relationships with domestic and international financial institutions and associations.</li><li>Develop investment products that attract Palestinian Diaspora and foreign capital.</li><li>Increase market depth and offer an increasingly broad range of financial tools and services.</li><li>Foster an efficient innovative and professional working environment by investing in human capital and state-of-the-art technology.</li></ul>","am":false,"os":false,"nz":true,"VCM":"","CCM":"","Notes":"","Source_lnk":""},{"id":183,"Country":"Trinidad and Tobago","cc":"TT","Name0":"The Trinidad and Tobago Stock Exchange Limited","Link":"/stock-exchange/trinidadandtobago","Name":"<p style=\"margin:0cm;font-size:11pt;font-family:Aptos, sans-serif;\"></p><p style=\"margin:0cm;font-size:11pt;font-family:Aptos, sans-serif;\"><a href=\"https://www.stockex.co.tt/\">The Trinidad and Tobago\nStock Exchange Limited</a></p>","nlc":30,"dmc":11173,"SSEPE":"Yes","SSEPEt":"Yes","asr":"No","asrt":"No","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No","oert":"No","oertt":"No","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"Developing a Green Bond Guide with support of IDB Invest, expected launch in 2026. <br>","HSMElp":"Yes","HSMElpt":"Yes. Since 2012, SME listing platform established. Currently three SMEs are &#160;listed on our SME platform. See TTSE Website: https://www.stockex.co.tt/values-and-index<br>","wom":"No","womt":"No","Additional_information":"","Organizational_model_of_stock_exchange":"","Regulatory_bodies":"The Trinidad and Tobago Securities Exchange Commission<br>","Regulatory_model":"Strong exchange SRO Note: The TTSE is a self regulatory organisation which administers its &#160;rules for the Exchange. It operates under the Securities Act Ch. 83:02 and &#160;regulatory oversight of the securities sector is provided by The Trinidad &#160;and Tobago Securities and Exchange Commission.<br><br>","About_the_stock_exchange":"Location: The Trinidad and Tobago Stock Exchange Limited, Level 10, &#160;Nicholas Tower, 63-65 Independence Square, Port-of-Spain, Trinidad <br>Description: Established in 1981,The Trinidad and Tobago Stock Exchange Limited was demutualized in 1998 and is a limited liability company under the laws of the Republic of Trinidad and Tobago. It is also a Self Regulatory Organisation under the Securities Act Ch. 83:02. We are responsible for developing and administering the rules and guidelines for the operation within the local stock market. These rules and guidelines are followed by the brokerage firms, listed companies and entities listing securities on the Exchange. Settlement, registry, depository and custodial services for securities are provided by our wholly owned subsidiary The Trinidad and Tobago Central Depository Limited. (see TTSE Website - https://www.stockex.co.tt/)","am":true,"os":false,"nz":false,"VCM":"","CCM":"","Notes":"","Source_lnk":""},{"id":184,"Country":"Fiji","cc":"FJ","Name0":"South Pacific Stock Exchange","Link":"/stock-exchange/south-pacific","Name":"<p style=\"margin:0cm;font-size:11pt;font-family:Aptos, sans-serif;\"><a href=\"https://www.spx.com.fj/\">South Pacific Stock\nExchange</a></p>","nlc":20,"dmc":1612,"SSEPE":"Yes","SSEPEt":"Yes","asr":"No","asrt":"SPX has not released a fully-fledged sustainability report. However as part of our<br>2024 Annual Report we have included our impact on the UN SDGs. Please refer the document via: https://www.spx.com.fj/getattachment/Explore-SPX/Annual-Reports/SPX-Annual-Report-2024.pdf?lang=en-US","ESGrr":"No","ESGrrt":"No","hwg":"No","hwgt":"No<br>","oert":"Yes","oertt":"Commencing in 2024, SPX and IFC have partnered to deliver a number of<br>trainings/workshops to members of the corporate sector in Fiji to introduce ESG<br>and best practices including the implementation of ESG codes and standards. This<br>includes facilitating a training of trainers program to empower corporates and<br>training organizations to build capacity on ESG in Fiji.<br><br>More information here:&#160;<a href=\"https://www.ifc.org/en/pressroom/2024/ifc-and-the-spx-launch-esg-program-in-fiji-to-boost-sustainable-growth-spur-investment\">https://www.ifc.org/en/pressroom/2024/ifc-and-the-spx-launch-esg-program-in-fiji-to-boost-sustainable-growth-spur-investment</a><br>","mcbsri":"No","mcbsrit":"No<br>","hsbls":"No","hsblst":"No<br>","HSMElp":"No","HSMElpt":"SPX is presently working on drafting SME initial and continuous listing requirements as well as exploring the possibility of Equity Crowd Funding under the newly enacted Access to Business Finance Act in Fiji, which enables three alternative finance pathways: small-scale public offers, equity crowdfunding (ECF), and peer-to-peer (P2P) lending.","wom":"No","womt":"No<br>","Additional_information":"","Organizational_model_of_stock_exchange":"Not listed. Was incepted as a Private Company hence demutualization not applicable.Ownership and Group Structure<br>SPX is a private entity owned by eight shareholders, including licensed stock brokerage firms and institutional investors. It has two fully owned subsidiaries:<br>• Central Share Registry Pte Limited (CSRL): Fiji’s first central registry, offering registry and corporate action services to listed and unlisted companies.<br>• SPX Trustees Limited (SPXT): Licensed trustee for corporate bond issuances under the Companies (Wholesale Corporate Bonds) Regulations 2021.<br>","Regulatory_bodies":"Reserve Bank of Fiji<br>","Regulatory_model":"Limited exchange SRO","About_the_stock_exchange":"The South Pacific Stock Exchange (SPX) is Fiji’s sole licensed securities exchange,<br>operating under the Companies Act 2015 and regulated by the Reserve Bank of Fiji. SPX<br>Headquarters is located in Suva, Fiji.<br><br>As a key pillar of Fiji’s financial sector, SPX facilitates capital formation by providing a<br>transparent and efficient platform for primary market issuances and secondary market<br>trading of securities.<br><br>With its future in focus, SPX is strategically positioning itself as a dynamic, modern, and<br>inclusive exchange that enables businesses to raise long-term capital and investors to<br>access wealth-building opportunities. The Exchange also serves as a critical institution in<br>Fiji’s national development agenda, fostering financial inclusion and supporting private<br>sector growth.<br><br>SPX is guided by the vision \"To be the preferred securities exchange in the South Pacific,\"<br>with a mission focused on promoting the exchange as a credible platform for capital<br>raising and investment, adopting international best practices in market integrity and<br>investor protection, expanding product offerings and digital infrastructure, and<br>supporting financial inclusion and climate resilience. Its 2023–2025 Strategic Plan<br>outlines key priorities including increasing listings and product diversity, enhancing<br>investor and broker competencies, diversifying revenue and deepening market liquidity,<br>and driving regional integration and digital transformation.<br>","am":true,"os":false,"nz":false,"VCM":"","CCM":"","Notes":"","Source_lnk":""},{"id":185,"Country":"Cape Verde","cc":"CV","Name0":"Cabo Verde Stock Exchange","Link":"","Name":"<a href=\"https://www.blu-x.cv/bvcv/\">https://www.blu-x.cv/bvcv/</a><br>","nlc":4,"dmc":1213,"SSEPE":"Yes","SSEPEt":"","asr":"No","asrt":"It is essential to highlight that, in addition to adopting international guidelines,<br>internal regulations have been developed to reinforce Cabo Verde's commitment<br>to sustainability. Notably, the Blue Taxonomy—one of the first in the world—<br>was promoted in 2022 by the Cabo Verde Stock Exchange in partnership with<br>the Technical University of the Atlantic (UTA) and with strategic support from<br>the UNDP. Furthermore, three regulations were introduced for the issuance of<br>sustainable bonds: Blue Bonds, Green Bonds, and Social Bonds, strengthening<br>the country's position in promoting sustainable financing through the capital<br>market.<br>","ESGrr":"No","ESGrrt":"Meanwhile, companies with listed instruments are legally required to submit an<br>annual report on corporate governance.<br>Under our new Strategic Plan, which is scheduled to begin in 2026, we intend to<br>recommend the adoption of sustainability reports by listed companies. It is<br>important to note that national legislation does not require listed companies to<br>report on sustainability.<br>","hwg":"No","hwgt":"As part of the celebrations of the 25th anniversary of the Cabo Verde Stock<br>Exchange (BVC), we developed, in partnership with Alliance Consult, the<br><br>Corporate Sustainability Guide. This initiative aimed to gather and provide key<br>information on corporate sustainability, making it easier for BVC stakeholders<br>to identify, understand, and adopt sustainable practices, in line with major global<br>demands and trends.<br>","oert":"Yes","oertt":"With the support of Luxembourg Green Exchange, BVC has been promoting<br>training activities over the past recent years, with the aim of educating and<br>raising awareness among market participants on sustainable bonds (thematic<br>bonds), as well as strengthening our sustainable bond listing and trading<br>platform - Blu-X platform (www.blu-x.cv)<br>","mcbsri":"No","mcbsrit":"With the Blu-X platform and the development of the Cabo Verde Capital<br>Market, it’s expected that sustainability-related indices will be available in the<br>coming years.<br>","hsbls":"Yes","hsblst":"","HSMElp":"No","HSMElpt":"The inclusion of the SMEs is among the top priorities set up in the BVC<br>Strategic Plan 2026-2030. Also, both the Cabo Verde Capital Market Master<br>Plan, developed with the support of the African Development Bank, and the<br>review of the Capital Market Code currently underway establish the<br>development of an SME segment as a strategic objective.<br>","wom":"Yes","womt":"Since 2019, Cabo Verde has adopted a parity law that ensures effective equality<br>of rights and duties between men and women, aiming to eliminate all forms of<br>discrimination and creating equal opportunities, particularly regarding political<br>participation and the holding of decision-making positions, in order to achieve a<br>more just, democratic, and balanced society.<br><br>One of the objectives of this law is guarantee equal representation in decision-<br>making bodies, establishing that the collegiate management bodies of entities<br><br>within the State’s public administrative and business sector (including the Cabo<br>Verde Stock Exchange) and local authorities must have equal representation of<br>men and women.<br>Link to parity law: <a href=\"https://boe.incv.cv/Bulletins/Details/A2019/S1/BO118/3018\">https://boe.incv.cv/Bulletins/Details/A2019/S1/BO118/3018</a><br>","Additional_information":"","Organizational_model_of_stock_exchange":"Unlisted Company for Profit&#160;<br>","Regulatory_bodies":"<ul><li>Auditoria Geral do Mercado de Valores Mobiliários (General Audit&#160;Office of the Securities Market);<br></li><li>The Ministry of Finance of Cabo Verde;</li><li>Bank of Cabo Verde.</li></ul>","Regulatory_model":"• The organization and operations of the Cabo Verde Stock Exchange<br>(BVC) are subject to the direct regulation and supervision of the General<br>Audit of the Securities Market (AGMVM). BVC operates as the manager<br>of the securities market (both primary and secondary markets), the<br>clearing and custody central depository, and the national ISIN<br>codification authority;<br>• BVC maintains a close relationship with regulatory bodies, including by<br>proposing updates to capital market legislation in Cabo Verde. As part of<br>its reporting obligations, BVC periodically submits reports to the<br>AGMVM and the State-Owned Enterprise Monitoring Unit (UASE),<br>covering market developments, its financial position, and its operational<br>activities.<br>","About_the_stock_exchange":"The Cabo Verde Stock Exchange, S.A. (BVC) has been establishing itself as a<br>central platform of the Cabo Verdean financial system, offering financing and<br>investment alternatives to various economic agents, including the State, public<br>and private companies, municipalities, families, and individuals. Its contribution<br>to financing the country's socioeconomic development is increasingly relevant.<br>Upon completing its 25 years, it was established by government decision<br>through Law No. 51/V/98, of May 11. BVC continues to pursue its strategic aim<br>of promoting sustainable finance, following the international movement that<br>aims to reinforce the role of the financial sector in achieving the Sustainable<br>Development Goals (SDGs).<br>BVC is based in Praia, Cabo Verde.<br>","am":false,"os":true,"nz":false,"VCM":"","CCM":"","Notes":"","Source_lnk":""}]

Need help getting started?

'
Contact us