BNM Open Data SDKs & Libraries: Python & R for Financial Data (2026)

SDKs overview

Bank Negara Malaysia (BNM) Open Data offers public access to a range of economic and financial statistics through its official portal. While BNM itself does not provide official software development kits (SDKs), the data is made available via direct API endpoints and downloadable CSV files. This approach allows developers flexibility in choosing their preferred programming languages and tools for integration. The API documentation, embedded within individual dataset pages on the BNM Open Data portal, details the specific parameters and expected response formats for each endpoint.

Developers commonly interact with the BNM Open Data APIs using standard HTTP client libraries available in various programming languages. These client libraries enable sending HTTP requests to the specified API endpoints and processing the JSON or CSV responses. The absence of official SDKs means that developers often create custom functions or community-contributed wrappers to streamline data access and manipulation. This section focuses on demonstrating how to interact with the BNM Open Data API using common programming paradigms, particularly in Python and R, which are widely used in data analysis and financial modeling.

The Open Data initiative aligns with broader trends in government data accessibility, where public institutions provide raw data via APIs to foster innovation and transparency. For instance, similar approaches are observed in other financial data providers, which often detail their API reference documentation for direct HTTP interactions. This method requires developers to have a foundational understanding of HTTP requests and JSON/CSV parsing.

Official SDKs by language

Bank Negara Malaysia does not currently offer official SDKs for interacting with its Open Data API. The primary method for accessing data programmatically is through direct HTTP requests to the provided RESTful endpoints. This means developers use general-purpose HTTP client libraries rather than specialized BNM-branded SDKs.

The API endpoints are designed to be straightforward, typically requiring parameters such as dataset ID, date ranges, and specific filters. Responses are generally in JSON format, making them compatible with standard data parsing libraries in most programming languages. Although no official SDKs exist, the direct API access model is common among government open data initiatives, empowering developers to build custom solutions tailored to their specific needs without being constrained by predefined SDK structures.

Installation

Since there are no official SDKs provided by Bank Negara Malaysia, installation typically involves setting up standard HTTP client libraries for your chosen programming language. The following instructions cover common languages used for data analysis.

Python

For Python, the requests library is widely used for making HTTP requests, and pandas is essential for data manipulation once the data is retrieved. To install these:

pip install requests pandas

This command installs both the requests library, which simplifies sending HTTP requests, and the pandas library, which provides powerful data structures like DataFrames for handling tabular data, making it easier to process the CSV or JSON responses from the BNM API. For more details on the requests library, refer to its official Python Requests documentation.

R

In R, the httr package is a popular choice for interacting with web APIs, and jsonlite or readr can be used for parsing JSON or CSV data, respectively. To install these:

install.packages("httr")
install.packages("jsonlite") # For JSON responses
install.packages("readr")   # For CSV responses

These commands will download and install the specified packages from CRAN, the Comprehensive R Archive Network. The httr package streamlines the process of constructing and sending HTTP requests, while jsonlite and readr provide efficient functions for converting API responses into R data structures.

JavaScript (Node.js)

For server-side JavaScript environments like Node.js, the node-fetch library provides a familiar API for making HTTP requests, similar to the browser's native fetch API. To install:

npm install node-fetch

This command adds node-fetch to your project's dependencies, allowing you to make asynchronous HTTP requests to the BNM Open Data API within your Node.js applications.

Quickstart example

This example demonstrates how to fetch a dataset, specifically the Exchange Rates for Selected Currencies, using Python. The process involves identifying the API endpoint, making an HTTP GET request, and parsing the JSON response into a pandas DataFrame.

Python Quickstart: Fetching Exchange Rates

First, identify the API endpoint for the desired dataset. For the Exchange Rates, the API endpoint can be found on its respective dataset page. The example below uses a hypothetical endpoint structure, as specific API URLs can vary based on the dataset and its version within the BNM portal.

import requests
import pandas as pd

# Define the API endpoint for Exchange Rates (example URL, confirm actual URL on BNM Open Data portal)
# Always refer to the specific dataset page on BNM Open Data for the correct API URL and parameters.
api_url = "https://api.bnm.gov.my/public/exchange-rate/MYR/latest?currency=USD,EUR,SGD"

# Define headers if required (BNM Open Data typically does not require specific headers for public access)
headers = {
    'Accept': 'application/json'
}

try:
    # Make the GET request to the API
    response = requests.get(api_url, headers=headers)
    response.raise_for_status()  # Raise an HTTPError for bad responses (4xx or 5xx)

    # Parse the JSON response
    data = response.json()

    # The structure of the JSON response will vary by dataset. 
    # Inspect the 'data' variable to understand its keys and values.
    # For this example, let's assume the data is under a 'data' key and is a list of dictionaries.
    # You might need to adjust 'data["data"]' based on the actual API response structure.
    df = pd.DataFrame(data['data'])

    # Print the first few rows of the DataFrame
    print("Successfully fetched data:")
    print(df.head())

    # Further processing, e.g., saving to CSV or performing analysis
    # df.to_csv("exchange_rates.csv", index=False)

except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error occurred: {http_err}")
except requests.exceptions.ConnectionError as conn_err:
    print(f"Connection error occurred: {conn_err}")
except requests.exceptions.Timeout as timeout_err:
    print(f"Timeout error occurred: {timeout_err}")
except requests.exceptions.RequestException as req_err:
    print(f"An error occurred: {req_err}")
except KeyError as key_err:
    print(f"Key error: {key_err}. Check the JSON structure. Response: {data}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

This Python snippet first defines the target API URL and sets an Accept header to request JSON data. It then uses requests.get() to send the request. Upon receiving a successful response, response.json() parses the JSON content, which is then converted into a pandas DataFrame. Error handling is included to catch common issues like network problems or HTTP errors, ensuring the script is robust. Remember to always consult the specific BNM Open Data dataset page for the exact API endpoint, required parameters, and response structure, as these can vary significantly between datasets.

Community libraries

Given the absence of official SDKs, the Bank Negara Malaysia Open Data ecosystem relies heavily on community-contributed code and general-purpose data science libraries. Developers often build their own wrappers or utility functions to simplify interaction with the BNM APIs, sharing these within their organizations or open-source communities.

Python Community Contributions

In the Python ecosystem, while there isn't a single widely adopted, dedicated BNM Open Data library, developers frequently use combinations of:

• requests: For handling HTTP requests, as shown in the quickstart example. It provides a user-friendly interface for web interactions.
• pandas: For data manipulation and analysis. After fetching data, converting it into a pandas DataFrame simplifies operations like filtering, aggregation, and merging with other datasets.
• json: Python's built-in library for parsing JSON responses.

Many data scientists and financial analysts create custom Python scripts that encapsulate the logic for specific BNM datasets. These scripts often involve functions to construct API URLs, make requests, handle pagination (if applicable), and clean the resulting data. These are typically shared as Gist snippets on GitHub or within internal project repositories.

R Community Contributions

The R community also leverages general-purpose packages for API interaction and data handling:

• httr: For making HTTP requests, similar to Python's requests. It supports various HTTP methods and authentication schemes, though BNM Open Data typically requires none for public access.
• jsonlite: For efficient parsing of JSON data into R data frames or lists.
• dplyr / tidyr: From the tidyverse collection, these packages are used for data cleaning, transformation, and manipulation once the data is loaded into R.

R users often develop custom functions or small packages that abstract away the API calling details, providing simpler interfaces for specific BNM datasets. These can be found in academic projects or financial modeling scripts shared in R communities.

General Approach to Community Libraries

The pattern across different languages is to combine robust, general-purpose HTTP client libraries with powerful data processing frameworks. This allows developers to:

• Flexibility: Adapt to changes in API endpoints or data structures without waiting for an official SDK update.
• Control: Have granular control over the request and response handling, including custom error logging and retry mechanisms.
• Integration: Seamlessly integrate BNM data with other data sources and analytical workflows that already use these standard libraries.

When searching for community-contributed code, developers typically look on platforms like GitHub, Stack Overflow, or academic repositories for examples related to "Bank Negara Malaysia API" or "Malaysia financial data Python/R". While not officially supported, these community efforts demonstrate practical approaches to consuming the BNM Open Data.