RobinTTY.NordigenApiClient 2.0.0

NordigenApiClient

This project provides a C# client for the Nordigen API. The project targets .Net 6 and supports the following endpoints of the API:

• Token
• Institutions
• Agreements
• Requisitions
• Accounts

Getting started

1. To get started install the package via the package manager:

   Install-Package RobinTTY.NordigenApiClient
   

2. Next you need to create a new instance of the client:

   using var httpClient = new HttpClient();
   var credentials = new NordigenClientCredentials("my-secret-id", "my-secret-key");
   var client = new NordigenClient(httpClient, credentials);
   

   Note: The client will obtain the required JWT access/refresh token itself and manage it accordingly, for access/refresh token reuse see the advanced section.

3. You can now use the different endpoints through the client:

   var response = await client.InstitutionsEndpoint.GetInstitutions(country: "GB");
   

   The responses that are returned always have the same structure:

   // If the response is successful the Result will not be null (the Error will be null)
   if(response.IsSuccess){
      var institutions = response.Result!;
      institutions.ForEach(institution => Console.WriteLine(institution.Name));
   }
   // If the response is not successful the Error will not be null (the Result will be null)
   else
      Console.WriteLine(response.Error!.Summary);
   

Getting balances and transactions for a bank account

Here is how you would go about retrieving the balances and transactions for a bank account:

1. Get a list of institutions in your country (e.g. Great Britain):

   var institutionsResponse = await client.InstitutionsEndpoint.GetInstitutions(country: "GB");
   if(institutionsResponse.IsSuccess)
      institutionsResponse.Result!.ForEach(institution =>
      {
          Console.WriteLine($"Institution: {institution.Name}, Id: {institution.Id}");
      });
   else
      Console.WriteLine($"Couldn't retrieve institutions, error: {institutionsResponse.Error!.Summary}");
   

2. Choose the institution your bank account is registered with and create a requisition for it:

   var institution = "BANK_OF_SCOTLAND_BOFSGBS1";
   var userLanguage = "EN";
   var reference = "your-internal-reference";
   var redirect = new Uri("https://where-nordigen-will-redirect-after-authentication.com");
   var requisitionRequest = new CreateRequisitionRequest(redirect, institution, reference, userLanguage);
   var requisitionResponse = await client.RequisitionsEndpoint.CreateRequisition(requisitionRequest);
   
    if (requisitionResponse.IsSuccess)
    {
        Console.WriteLine($"Requisition id: {requisitionResponse.Result!.Id}");
        Console.WriteLine($"Start authentication: {requisitionResponse.Result!.AuthenticationLink}");
    }
   
    else
        Console.WriteLine($"Requisition couldn't be created: {requisitionResponse.Error!.Summary}");
   

3. You will now need to accept the end user agreement by following the authentication link. After that you will be able to retrieve the accounts linked to your bank account:

   var requisitionId = "your-requisition-id";
   var accountsResponse = await client.RequisitionsEndpoint.GetRequisition(requisitionId);
   if(accountsResponse.IsSuccess)
       accountsResponse.Result!.Accounts.ForEach(accountId =>
       {
            Console.WriteLine($"Account id: {accountId}");
       });
   else
       Console.WriteLine($"Accounts couldn't be retrieved: {accountsResponse.Error!.Summary}");
   

4. Now you can retrieve details about the bank account and the balances/transactions:

   var accountId = "your-account-id";
   var bankAccountDetailsResponse = await client.AccountsEndpoint.GetAccountDetails(accountId);
   if(bankAccountDetailsResponse.IsSuccess)
   {
        Console.WriteLine($"IBAN: {bankAccountDetailsResponse.Result!.Iban}");
        Console.WriteLine($"Account name: {bankAccountDetailsResponse.Result!.Name}");
   }
   
   var balancesResponse = await client.AccountsEndpoint.GetBalances(accountId);
   if(balancesResponse.IsSuccess)
       balancesResponse.Result!.ForEach(balance =>
       {
           var balanceAmount = balance.BalanceAmount;
           Console.WriteLine($"Type: {balance.BalanceType}");
           Console.WriteLine($"Balance: {balanceAmount.AmountParsed} {balanceAmount.Currency}");
       });
   
   var transactionsResponse = await client.AccountsEndpoint.GetTransactions(accountId);
   if (transactionsResponse.IsSuccess)
       transactionsResponse.Result!.BookedTransactions.ForEach(transaction =>
       {
           var transactionAmount = transaction.TransactionAmount;
           Console.WriteLine($"Remittance: {transaction.RemittanceInformationUnstructured}");
           Console.WriteLine($"Booking date:{transaction.ValueDate}");
           Console.WriteLine($"Amount: {transactionAmount.AmountParsed} {transactionAmount.Currency}");
       });
   

Advanced Usage

Acess/Refresh Token reuse

If you wan't to persist the access/refresh token used by the client you can do so by accessing the JwtTokenPair property of the client. After the first request that requires authentication this property will be populated with the access/refresh token that was automatically aquired.

Console.WriteLine(client.JwtTokenPair.AccessToken.EncodedToken);
Console.WriteLine(client.JwtTokenPair.RefreshToken.EncodedToken);

The next time you instantiate the client you can pass the access/refresh token to the client constructor:

using var httpClient = new HttpClient();
var credentials = new NordigenClientCredentials("my-secret-id", "my-secret-key");
var tokenPair = new JsonWebTokenPair("encoded-access-token", "encoded-refresh-token");
var client = new NordigenClient(httpClient, credentials, tokenPair);

The client will now use the given token pair and refresh it automatically if it is expired.

Alternatively you can also use the tokens endpoint directly:

var response = await client.TokenEndpoint.GetTokenPair();
if (response.IsSuccess)
{
    Console.WriteLine($"Access token: {response.Result!.AccessToken.EncodedToken}");
    Console.WriteLine($"Refresh token: {response.Result!.RefreshToken.EncodedToken}");
}

// Set the token pair on the client
client.JwtTokenPair = response.Result;