Nordigen SDKs & Libraries: Official and Community Integrations (2026)

SDKs overview

Nordigen provides Software Development Kits (SDKs) and client libraries designed to facilitate interaction with its Account Information API and Premium Data API. These SDKs abstract the underlying RESTful API endpoints, offering developers language-specific methods and data structures to streamline the integration of open banking functionalities. SDKs are typically utilized for tasks such as linking end-user bank accounts, retrieving transaction histories, and accessing financial insights in a programmatic manner.

The SDKs are developed to support various programming languages, enabling developers to integrate Nordigen services into diverse application environments. Key advantages of using an SDK over direct API calls include simplified authentication flows, automatic handling of request and response serialization, and comprehensive error handling. This approach aims to reduce development time and potential integration complexities, allowing developers to focus on application logic rather than low-level API communication. The availability of multiple language SDKs also addresses the needs of development teams working with different tech stacks, providing flexibility in adoption.

Official SDKs by language

Nordigen maintains official SDKs for several popular programming languages, ensuring direct support and continuous updates. These SDKs are typically available through standard package managers for each language, simplifying installation and dependency management. The following table provides an overview of the officially supported SDKs, including their respective package names and typical installation commands.

Each SDK is designed to encapsulate the Nordigen API structure, providing idiomatic access to features like institution selection, end-user agreement management, and data retrieval. Developers can find detailed API method documentation and usage examples within the Nordigen API documentation portal.

Installation

Installing Nordigen SDKs typically involves using the standard package manager for the chosen programming language. This process ensures that all necessary dependencies are resolved and the SDK can be easily imported into a project.

Python

To install the Python SDK, use pip:

pip install nordigen-python-client

Node.js

For Node.js projects, use npm:

npm install nordigen-node

Java

Java SDK integration typically involves adding a dependency to your project's build file. For Maven, add the following to your pom.xml:

<dependency>
    <groupId>com.nordigen</groupId>
    <artifactId>nordigen-java-client</artifactId>
    <version>YOUR_SDK_VERSION</version>
</dependency>

For Gradle, add it to your build.gradle:

implementation 'com.nordigen:nordigen-java-client:YOUR_SDK_VERSION'

Replace YOUR_SDK_VERSION with the latest available version, which can be found in the Nordigen Java Quickstart documentation.

PHP

PHP projects use Composer for dependency management:

composer require nordigen/nordigen-php

Ruby

For Ruby, use Bundler by adding to your Gemfile and then running bundle install:

gem 'nordigen-ruby'

Alternatively, install directly with gem:

gem install nordigen-ruby

Go

Go modules are used for dependency management:

go get github.com/nordigen/nordigen-go

After installation, the necessary packages or modules can be imported into your application code to begin interacting with the Nordigen API.

Quickstart example

This Python example demonstrates how to initialize the Nordigen client, obtain an access token, and list available institutions. This process is fundamental for any application integrating Nordigen's open banking services, as it sets up the authenticated connection to retrieve financial data.

from nordigen import NordigenClient
import os

# Initialize NordigenClient with credentials
client = NordigenClient(
    secret_id=os.environ.get("NORDIGEN_SECRET_ID"),
    secret_key=os.environ.get("NORDIGEN_SECRET_KEY")
)

try:
    # Generate an access token
    token_data = client.generate_token()
    access_token = token_data["access"]
    print(f"Access Token: {access_token}")

    # List institutions for a specific country (e.g., 'GB' for Great Britain)
    institutions = client.requisition.get_institutions(country="GB")
    print("Available Institutions (GB):")
    for inst in institutions:
        print(f"- {inst['name']} ({inst['id']})")

except Exception as e:
    print(f"An error occurred: {e}")

For this example to run, ensure you have set your Nordigen SECRET_ID and SECRET_KEY as environment variables. These credentials are required to authenticate with the Nordigen API and generate the access token. The process of obtaining these credentials is detailed in the Nordigen Python quickstart guide. After successfully listing institutions, the next steps typically involve creating an end-user agreement, generating a requisition link for account connection, and then fetching account and transaction data.

Community libraries

While Nordigen provides official SDKs for several key languages, the open-source community may also develop and maintain client libraries or wrappers for additional languages or specific frameworks. These community-driven projects can offer alternative integration paths, sometimes with features tailored to niche use cases or preferred programming paradigms. However, it is important to note that community libraries are not officially supported by Nordigen and may vary in terms of maintenance, feature completeness, and adherence to the latest API changes.

Developers considering community libraries should review the project's documentation, community activity, and contribution history to assess its reliability and suitability for their application. Checking the project's GitHub repository or other source code platforms for recent updates and issue resolution is a recommended practice. For example, developers focusing on web frameworks like Ruby on Rails or Django might find community wrappers that simplify integration into their existing application structures. While specific community libraries are not explicitly endorsed here, the existence of a robust developer community around an API can indicate its flexibility and broader adoption, as discussed in Google's developer community definitions.

For the most up-to-date and officially supported integration methods, developers are advised to primarily utilize the official Nordigen documentation and SDKs. If a community library is chosen, it is prudent to regularly cross-reference its functionalities and behavior with the official API specifications to ensure compatibility and prevent unexpected issues.