enable:Banking SDK

Welcome to Enable Banking SDK developer documentation! We are happy that you are interested our solution. In this documentation you have all information to start use our SDK.

Enable Banking SDK is for connecting your solution to Open Banking APIs without 3rd party solutions. With our solution you can build new business driven solutions and also connect your current solution to Open Banking APIs. We are believer for easy and fast development so we offer all needed documentation and code examples for you.

For starting you need to have developer license which you can order here. You will get your developer SDK, which is connected Open Banking API sandboxes.

Get started by cloning our sample repository

$ git clone https://github.com/enablebanking/OpenBankingJavaExamples

$ git clone https://github.com/enablebanking/OpenBankingJSExamples

$ git clone https://github.com/enablebanking/OpenBankingPythonExamples

In the easiest to get started with the SDK by using our code samples. The complete code samples for Java, Javascript and Python are available under our Github account: https://github.com/enablebanking.

For production usage please contact us or If you just need more info contact us at hello@enablebanking.com

Changelog

0.3.1

Added

• Base connector for banks implementing PolishAPI on KIR platform.

Changed

• [Python] Capitalization of request headers removed to be able to support API backend with case-sensitive handling of the headers.

0.3.0

Changed

• [Java] UnstructuredRemittanceInformation now uses ArrayList constructor.

• Parameter paymentRequestData of PISP API method makePaymentRequestConfirmation removed and the data is passed inside confirmation parameter (PaymentRequestConfirmation data structure now has an option attribute paymentRequest).

0.2.1

Added

• Added DataRetrievalException and InsufficientScopeException derived from HttpException to represent particular cases.

0.2.0

Added

• [Java] Improved connector settings interface. Added AbstractConnectorSettingsFactory class with a factory method createConnectorSettings to simplify creation of connector settings. ApiClient now has constructors taking ConnectorSettings instance instead of list of settings objects.
• [Java] AbstractPlatformExtension class consisting of signPKCS1v15usingSHA256 and makeRequest methods is added in order to simplify customisation of Java platform. Also added ApiClient constructor taking AbstractPlatformExtension as a parameter.
• Transaction data structure extended with fields bankTransactionCode, creditor and debtor and BankTransactionCode data structure added.
• Value refresh_token is supported for grant_type parameter of makeToken method.

Changed

• [Java] ApiClient constructors accepting settings as a list of objects and JavaPlatform class are changed to protected.
• Changed order of connector settings. Parameters consentId, accessToken and refreshToken are now always required (should be set to null if not present).
• [Java] Standard Java SE 8 date-time classes are used instead of ThreeTen-Backport classes, thus Java SE 6 and 7 support is dropped.
• Field remittanceInformation of Transaction changed to not required (mainly to support credit card transactions, for which remittance info is usually not provided).
• Access data structure changed: balances and transactions fields contain details for requested access and accounts field contains list of accessed account IDs.

Fixed

• Field mapping for Open Banking UK standard is improved.

0.1.x

This version was created before the changelog has been introduced.

SDK reference

Select a language for code samples from the tabs above or the mobile navigation menu.

Currently enable:Banking SDK consists of authorization, account information and payment initiation APIs. The same calls and data structures are used for interacting with different banks. In order to use each of the APIs corresponding API instance needs to be created with bank specific settings.

enable:Banking SDK API is based on STET PSD2 specification.

This API intends to provide an interface for Third Party Providers (TPP) for accessing Account Servicing Payment Service Providers (ASPSP, i.e. banks).

TPP may act as Account Information Service Provider (AISP), Payment Initiation Service Providers (PISP) or both.

The Payment Service User (PSU) is the owner of the accounts held by the ASPSP and gives accreditations to the TPP in order to access his accounts information or initiates payment from these accounts.

License: LicenseRef-LICENSE

Meta API

getConnectors

Code samples

const enablebanking = require('enablebanking');

const metaApi = new enablebanking.MetaApi(new enablebanking.ApiClient());

const connectors = await metaApi.getConnectors({
  country: 'FI' // requesting connectors for Finland
});

import enablebanking

meta_api = enablebanking.MetaApi(enablebanking.ApiClient())

connectors = meta_api.get_connectors(
    country='FI') # requesting connectors for Finland

import com.enablebanking.*;
import com.enablebanking.model.*;
import com.enablebanking.api.MetaApi;

MetaApi metaApi = new MetaApi(new ApiClient());

HalConnectors connectors = metaApi.getConnectors("FI"); // connectors for Finland

Retrieval of the available connectors

Parameters

Returned value

Data type: HalConnectors

List of connectors

Auth API

getAuth

Code samples

const enablebanking = require('enablebanking');

const authApi = new enablebanking.AuthApi(
  new enablebanking.ApiClient('Bank name', [ /* Bank settings */ ]));

const { url } = await authApi.getAuth(
  'code', // using authorization code grant
  'https://example.com/', // redirect URL
  ['aisp'], // API scope
  {
    state: 'test' // state to pass to redirect URL
  });

import enablebanking

auth_api = enablebanking.AuthApi(enablebanking.ApiClient(
    'Bank name',
    {
      # Bank settings
    })

url = auth_api.get_auth(
    'code', # using authorization code grant
    'https://example.com/', # redirect URL
    ['aisp'], # API scope
    state='test', # state to pass to redirect URL
).url

import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import com.enablebanking.ApiClient;
import com.enablebanking.model.*;
import com.enablebanking.api.AuthApi;

List bankSettings = new ArrayList();
// Filling in bank settings here...

AuthApi authApi = new AuthApi(new ApiClient("Bank name", bankSettings));

String url = authApi.getAuth(
    "code", // using authorization code grant
    "https://example.com/", // redirect URL
    new ArrayList(Arrays.asList("aisp")), // API scope
    "test", // state to pass to redirect URL
    null // not passing access request (bank's defaults will be used)
).url;

Request Authorization Data

Parameters

Detailed descriptions

access: Contains request for access to account information.

This parameter should be set to override defaults for the banks, which allow PSUs to give consent for account information sharing right after authentication.

Enumerated Values

response_type

scope

Returned value

Data type: Auth

Authorization Data

Exceptions

makeToken

Code samples

const enablebanking = require('enablebanking');

const authApi = new enablebanking.AuthApi(
  new enablebanking.ApiClient('Bank name', [ /* Bank settings */ ]));

const token = await authApi.makeToken(
  'authorization_code', // grant type, MUST be set to "authorization_code"
  'so43ls-3ldg03sd-hl4saa3l2sl5czfhl3'); // The code received in the query string when redirected from authorization

import enablebanking

auth_api = enablebanking.AuthApi(enablebanking.ApiClient(
    'Bank name',
    {
      # Bank settings
    })

token = auth_api.make_token(
    'authorization_code', # grant type, MUST be set to "authorization_code"
    'so43ls-3ldg03sd-hl4saa3l2sl5czfhl3') # The code received in the query string when redirected from authorization

import java.util.List;
import java.util.ArrayList;
import com.enablebanking.ApiClient;
import com.enablebanking.model.*;
import com.enablebanking.api.AuthApi;

List bankSettings = new ArrayList();
// Filling in bank settings here...

AuthApi authApi = new AuthApi(new ApiClient("Bank name", bankSettings));

Token token = authApi.makeToken(
    "authorization_code", // grant type, MUST be set to "authorization_code"
    "so43ls-3ldg03sd-hl4saa3l2sl5czfhl3" // The code received in the query string when redirected from authorization
);

Request Access Token

Parameters

Detailed descriptions

grant_type: Value should be set to authorization_code or refresh_token depending on what passed to code parameter.

code: Value of either the code received in the query string when redirected from authorization page or the refresh token used for renewing access token.

redirect_uri: Redirect URI supplied to getAuth function for retreival of the authorization URL. This parameter is only required for some connectors, but it is a good practice to pass it in order to unify usage for between different connectors.

Enumerated Values

grant_type

Returned value

Data type: Token

Authorisation token (Bearer)

Exceptions

getCurrentToken

Code samples

const enablebanking = require('enablebanking');

const authApi = new enablebanking.AuthApi(
  new enablebanking.ApiClient('Bank name', [ /* Bank settings */ ]));

const token = await authApi.getCurrentToken();

import enablebanking

auth_api = enablebanking.AuthApi(enablebanking.ApiClient(
    'Bank name',
    {
      # Bank settings
    })

token = auth_api.get_current_token()

import java.util.List;
import java.util.ArrayList;
import com.enablebanking.ApiClient;
import com.enablebanking.model.*;
import com.enablebanking.api.AuthApi;

List bankSettings = new ArrayList();
// Filling in bank settings here...

AuthApi authApi = new AuthApi(new ApiClient("Bank name", bankSettings));

Token token = authApi.getCurrentToken();

Get current token data

Returned value

Data type: Token

Current token. Values for some fields might be missing if not used.

AISP API

getAccounts

Code samples

const enablebanking = require('enablebanking');

const aispApi = new enablebanking.AISPApi(
  new enablebanking.ApiClient('Bank name', [ /* Bank settings */ ]));

const accounts = await aispApi.getAccounts();

import enablebanking

aisp_api = enablebanking.AISPApi(enablebanking.ApiClient(
    'Bank name',
    {
      # Bank settings
    }))

accounts = aisp_api.get_accounts()

import com.enablebanking.ApiClient;
import com.enablebanking.api.AispApi;
import com.enablebanking.model.*;

// To be replaced with real connector settings class and set properties
ConnectorSettings connectorSettings = new SomeBankConnectorSettings();

AispApi aispApi = new AispApi(new ApiClient(connectorSettings));

HalAccounts accounts = aispApi.getAccounts();

Retrieval of the PSU accounts (AISP)

Returned value

Data type: HalAccounts

Returned value consists of the list of the accounts that have been made available to the AISP by the PSU and HYPERMEDIA links to the related resources provided by ASPSP through the API.

Exceptions

getAccountBalances

Code samples

const enablebanking = require('enablebanking');

const aispApi = new enablebanking.AISPApi(
  new enablebanking.ApiClient('Bank name', [ /* Bank settings */ ]));

const balances = await aispApi.getAccountBalances('203059694928560295396833');

import enablebanking

aisp_api = enablebanking.AISPApi(enablebanking.ApiClient(
    'Bank name',
    {
      # Bank settings
    }))

balances = aisp_api.get_account_balances('203059694928560295396833')

import com.enablebanking.ApiClient;
import com.enablebanking.api.AispApi;
import com.enablebanking.model.*;

// To be replaced with real connector settings class and set properties
ConnectorSettings connectorSettings = new SomeBankConnectorSettings();

AispApi aispApi = new AispApi(new ApiClient(connectorSettings));

HalBalances balances = aispApi.getAccountBalances("203059694928560295396833")

Retrieval of an account balances report (AISP)

Parameters

Returned value

Data type: HalBalances

Returned value consists of the list of account balances and HYPERMEDIA links to the related resources provided by ASPSP through the API.

Exceptions

getAccountTransactions

Code samples

const enablebanking = require('enablebanking');

const aispApi = new enablebanking.AISPApi(
  new enablebanking.ApiClient('Bank name', [ /* Bank settings */ ]));

const transactions = await aispApi.getAccountTransactions('203059694928560295396833');

import enablebanking

aisp_api = enablebanking.AISPApi(enablebanking.ApiClient(
    'Bank name',
    {
      # Bank settings
    }))

transactions = aisp_api.get_account_transactions('203059694928560295396833')

import com.enablebanking.ApiClient;
import com.enablebanking.api.AispApi;
import com.enablebanking.model.*;

// To be replaced with real connector settings class and set properties
ConnectorSettings connectorSettings = new SomeBankConnectorSettings();

AispApi aispApi = new AispApi(new ApiClient(connectorSettings));

HalTransactions transactions = aispApi.getAccountTransactions("203059694928560295396833");

Retrieval of an account transaction set (AISP)

Parameters

Detailed descriptions

dateFrom: Inclusive minimal imputation date of the transactions.

Transactions having an imputation date equal to this parameter are included within the result.

dateTo: Exclusive maximal imputation date of the transactions.

Transactions having an imputation date equal to this parameter are not included within the result.

afterEntryReference: Specifies the value on which the result has to be computed.

Only the transaction having a technical identification greater than this value must be included within the result

Enumerated Values

transactionStatus

Returned value

Data type: HalTransactions

Complete transactions response

Exceptions

modifyConsents

Code samples

const enablebanking = require('enablebanking');

const aispApi = new enablebanking.AISPApi(
  new enablebanking.ApiClient('Bank name', [ /* Bank settings */ ]));

const consent = await aispApi.modifyConsents({
  access: {
    balances: ['203059694928560295396833'],
    transactions: [],
    trustedBeneficiaries: false,
    psuIdentity: true
  }
});

import enablebanking

aisp_api = enablebanking.AISPApi(enablebanking.ApiClient(
    'Bank name',
    {
      # Bank settings
    }))

consent = aisp_api.modify_consents(
    access=enablebanking.Access(
        # default access to balances
        balances=enablebanking.BalancesAccess(),
        # default access to transactions
        transactions=enablebanking.TransacrionsAccess(),
        trusted_beneficiaries=False,
        psu_identity=True,
    ),
)

import com.enablebanking.ApiClient;
import com.enablebanking.api.AispApi;
import com.enablebanking.model.*;

// To be replaced with real connector settings class and set properties
ConnectorSettings connectorSettings = new SomeBankConnectorSettings();

AispApi aispApi = new AispApi(new ApiClient(connectorSettings));

Consent consent = aispApi.modifyConsents(
  new Access()
    .balances(new BalancesAccess()) // default access to balances
    .transactions(new TransactionsAccess()) // default access to transactions
    .trustedBeneficiaries(false)
    .psuIdentity(true));

Forwarding the PSU consent (AISP)

Parameters

Returned value

Data type: Consent

Created or modified consent

Exceptions

getCurrentConsent

Code samples

const enablebanking = require('enablebanking');

const aispApi = new enablebanking.AISPApi(
  new enablebanking.ApiClient('Bank name', [ /* Bank settings */ ]));

const consent = await aispApi.getCurrentConsent();

import enablebanking

aisp_api = enablebanking.AISPApi(enablebanking.ApiClient(
    'Bank name',
    {
      # Bank settings
    }))

consent = aisp_api.get_current_consent()

import com.enablebanking.ApiClient;
import com.enablebanking.api.AispApi;
import com.enablebanking.model.*;

// To be replaced with real connector settings class and set properties
ConnectorSettings connectorSettings = new SomeBankConnectorSettings();

AispApi aispApi = new AispApi(new ApiClient(connectorSettings));

Consent consent = aispApi.getCurrentConsent();

Returns current consent (AISP)

Returned value

Data type: Consent

Current consent used for accessing AIS APIs.

PISP API

makePaymentRequest

Code samples

const enablebanking = require('enablebanking');

const pispApi = new enablebanking.PISPApi(
  new enablebanking.ApiClient('Bank name', [ /* Bank settings */ ]));

// Making payment request with credit transafer transaction of one element
const requestCreation = await pispApi.makePaymentRequest({
  creditTransferTransaction: [{
    instructedAmount: {
      amount: '12.25', // amount
      currency: 'EUR' // currency code
    },
    beneficiary: {
      creditor: {
        name: 'Creditor Name' // payee (merchant) name
      },
      creditorAccount: {
        iban: 'FI4966010005485495' // payee account number
      }
    }
  }],
  debtor: {
    name: 'Debtor Name' // payer (account holder) name
  },
  debtorAccount: {
    iban: 'FI3839390001384700' // payer account number
  }
});

import enablebanking

pisp_api = enablebanking.PISPApi(enablebanking.ApiClient(
    'Bank name',
    {
      # Bank settings
    }))

# Making payment request with credit transafer transaction of one element
request_creation = pisp_api.make_payment_request(
    enablebanking.PaymentRequestResource(
        credit_transfer_transaction=[
            enablebanking.CreditTransferTransaction(
                instructed_amount=enablebanking.AmountType(
                    amount='12.25', # amount
                    currency='EUR'), # currency code
                beneficiary=enablebanking.Beneficiary(
                    creditor=enablebanking.PartyIdentification(
                        name='Creditor Name'), # payee (merchant) name
                    creditor_account=enablebanking.AccountIdentification(
                        iban='FI4966010005485495'), # payee account number
                ),
            ),
        ],
        debtor=enablebanking.PartyIdentification(
            name='Debtor Name'), # payer (account holder) name
        debtor_account=enablebanking.AccountIdentification(
            iban='FI3839390001384700'), # payer account number
    ))

import java.math.BigDecimal;
import java.util.Arrays;

import com.enablebanking.ApiClient;
import com.enablebanking.api.PispApi;
import com.enablebanking.model.*;

// To be replaced with real connector settings class and set properties
ConnectorSettings connectorSettings = new SomeBankConnectorSettings();

PispApi pispApi = new PispApi(new ApiClient(connectorSettings));

// Making payment request with credit transafer transaction of one element
HalPaymentRequestCreation requestCreation = pispApi.makePaymentRequest(
  new PaymentRequestResource()
    .creditTransferTransaction(Arrays.asList(
      new CreditTransferTransaction()
        .instructedAmount(
          new AmountType()
            .currency("EUR")
            .amount(new BigDecimal("12.25")))
        .beneficiary(
          new Beneficiary()
            .creditor(
              new PartyIdentification()
                .name("Creditor Name"))
            .creditorAccount(
              new AccountIdentification()
                .iban("FI4966010005485495")))))
    .debtor(
      new PartyIdentification()
        .name("Debtor Name"))
    .debtorAccount(
      new AccountIdentification()
        .iban("FI3839390001384700")));

Payment request initiation (PISP)

Description

The following use cases can be applied:

• payment request on behalf of a merchant
• transfer request on behalf of the account's owner
• standing-order request on behalf of the account's owner

Data content

A payment request or a transfer request might embed several payment instructions having

• one single execution date or multiple execution dates
• case of one single execution date, this date must be set at the payment level
• case of multiple execution dates, those dates must be set at each payment instruction level
• one single beneficiary or multiple beneficiaries
• case of one single beneficiary, this beneficiary must be set at the payment level
• case of multiple beneficiaries, those beneficiaries must be set at each payment instruction level

A standing order request must embed one single payment instruction and must address one single beneficiary.

• The beneficiary must be set at the payment level
• The standing order specific characteristics (start date, periodicity...) must be set at the instruction level

Prerequisites for all use cases

• The TPP has been registered by the Registration Authority for the PISP role
• The TPP was provided with an OAUTH2 "Client Credential" access token by the ASPSP (cf. § 3.4.3).
• The TPP and the ASPSP have successfully processed a mutual check and authentication
• The TPP has presented its "OAUTH2 Client Credential" access token

Business flow

Payment Request use case

The PISP forwards a payment request on behalf of a merchant.
The PSU buys some goods or services on an e-commerce website held by a merchant. Among other payment method, the merchant suggests the use of a PISP service. As there is obviously a contract between the merchant and the PISP, there is no need of such a contract between the PSU and this PISP to initiate the process.
Case of the PSU that chooses to use the PISP service:

• The merchant forwards the requested payment characteristics to the PISP and redirects the PSU to the PISP portal.
• The PISP requests from the PSU which ASPSP will be used.
• The PISP prepares the Payment Request and sends this request to the ASPSP.
• The Request can embed several payment instructions having different requested execution date.
• The beneficiary, as being the merchant, is set at the payment level.

Transfer Request use case

The PISP forwards a transfer request on behalf of the owner of the account.

• The PSU provides the PISP with all information needed for the transfer.
• The PISP prepares the Transfer Request and sends this request to the relevant ASPSP that holds the debtor account.
• The Request can embed several payment instructions having different beneficiaries.
• The requested execution date, as being the same for all instructions, is set at the payment level.

Standing Order Request use case

The PISP forwards a Standing Order request on behalf of the owner of the account.

• The PSU provides the PISP with all information needed for the Standing Order.
• The PISP prepares the Standing Order Request and sends this request to the relevant ASPSP that holds the debtor account.
• The Request embeds one single payment instruction with
• The requested execution date of the first occurrence
• The requested execution frequency of the payment in order to compute further execution dates
• An execution rule to handle cases when the computed execution dates cannot be processed (e.g. bank holydays)
• An optional end date for closing the standing Order

Authentication flows for all use cases

As the request posted by the PISP to the ASPSP needs a PSU authentication before execution, this request will include:

• The specification of the authentication approaches that are supported by the PISP (any combination of "REDIRECT", "EMBEDDED" and "DECOUPLED" values).
• In case of possible REDIRECT or DECOUPLED authentication approach, one or two call-back URLs to be used by the ASPSP at the finalisation of the authentication and consent process :
• The first call-back URL will be called by the ASPSP if the Payment Request is processed without any error or rejection by the PSU
• The second call-back URL is to be used by the ASPSP in case of processing error or rejection by the PSU. Since this second URL is optional, the PISP might not provide it. In this case, the ASPSP will use the same URL for any processing result.
• Both call-back URLS must be used in a TLS-secured request.
• In case of possible "EMBEDDED" or "DECOUPLED" approaches, the PSU identifier that can be processed by the ASPSP for PSU recognition must have been set within the request body [debtor] structure.

The ASPSP saves the request and answers to the PISP. The answer embeds:

• A location link of the saved Request that will be further used to retrieve the Request and its status information.
• The specification of the chosen authentication approach taking into account both the PISP and the PSU capabilities.
• In case of chosen REDIRECT authentication approach, the URL to be used by the PISP for redirecting the PSU in order to perform a authentication.

Case of the PSU neither gives nor denies his/her consent, the Request shall expire and is then rejected to the PISP. The expiration delay is specified by each ASPSP.

Redirect authentication approach

When the chosen authentication approach within the ASPSP answers is set to "REDIRECT":

• The PISP redirects the PSU to the ASPSP which authenticates the PSU
• The ASPSP asks the PSU to give (or deny) his/her consent to the Payment Request
• The PSU chooses or confirms which of his/her accounts shall be used by the ASPSP for the future Credit Transfer.
• The ASPSP is then able to initiate the subsequent Credit Transfer
• The ASPSP redirects the PSU to the PISP using one of the call-back URLs provided within the posted Payment Request

Decoupled authentication approach

When the chosen authentication approach is "DECOUPLED":

• Based on the PSU identifier provided within the Payment Request by the PISP, the ASPSP gives the PSU with the Payment Request details and challenges the PSU for a Strong Customer Authentication on a decoupled device or application.
• The PSU chooses or confirms which of his/her accounts shall be used by the ASPSP for the future Credit Transfer.
• The ASPSP is then able to initiate the subsequent Credit Transfer
• The ASPSP notifies the PISP about the finalisation of the authentication and consent process by using one of the call-back URLs provided within the posted Payment Request

Embedded authentication approach

When the chosen authentication approach within the ASPSP answers is set to "EMBEDDED":

• The TPP informs the PSU that a challenge is needed for completing the Payment Request processing. This challenge will be one of the following:
• A One-Time-Password sent by the ASPSP to the PSU on a separate device or application.
• A response computed by a specific device on base of a challenge sent by the ASPSP to the PSU on a separate device or application.
• The PSU unlock the device or application through a "knowledge factor" and/or an "inherence factor" (biometric), retrieves the Payment Request details and processes the data sent by the ASPSP;
• The PSU might choose or confirm which of his/her accounts shall be used by the ASPSP for the future Credit Transfer when the device or application allows it.
• When agreeing the Payment Request, the PSU enters the resulting authentication factor through the PISP interface which will forward it to the ASPSP through a confirmation request (cf. § 4.7)

Parameters

Returned value

Data type: HalPaymentRequestCreation

The request has been created as a resource. The ASPSP must authenticate the PSU.

Exceptions

getPaymentRequest

Retrieval of a payment request (PISP)

Parameters

Returned value

Data type: HalPaymentRequest

Retrieval of the previously posted Payment Request

Exceptions

modifyPaymentRequest

Modification of a Payment/Transfer Request (PISP)

Parameters

Returned value

Data type: HalPaymentRequestCreation

The modification request has been saved. The ASPSP must authenticate the PSU before committing the update.

Exceptions

makePaymentRequestConfirmation

Confirmation of a payment request or a modification request (PISP)

Parameters

Detailed descriptions

confirmation: Data needed for confirmation of the Payment Request, especially in EMBEDDED approach

Returned value

Data type: HalPaymentRequest

retrieval of the Payment Request enriched with the status report

Exceptions

Data types

Auth

Fields

Token

Fields

Enumerated Values

token_type

HalConnectors

HYPERMEDIA structure used for returning the list of the connectors for given countries

Fields

ConnectorsLinks

links that can be used for further navigation when browsing connector information

Fields

Connector

Information about connector used for interaction with a bank

Fields

AuthenticationApproach

The ASPSP, based on the authentication approaches proposed by the PISP, choose the one that it can processed, in respect with the preferences and constraints of the PSU and indicates in this field which approach has been chosen

Base type

string

Enumerated Values

GenericIdentification

ISO20022: Unique identification of an account, a person or an organisation, as assigned by an issuer. API: The ASPSP will document which account reference type it will support.

Fields

Enumerated Values

schemeName

AccountIdentification

Unique and unambiguous identification for the account between the account owner and the account servicer.

Fields

AmountType

ISO20022: structure aiming to carry either an instructed amount or equivalent amount. Both structures embed the amount and the currency to be used.

API: only instructed amount can be used

Fields

BankTransactionCode

ISO20022: Allows the account servicer to correctly report a transaction, which in its turn will help account owners to perform their cash management and reconciliation operations.

Fields

ClearingSystemMemberIdentification

ISO20022: Information used to identify a member within a clearing system. API: to be used for some specific international credit transfers in order to identify the beneficiary bank

Fields

FinancialInstitutionIdentification

ISO20022: Unique and unambiguous identification of a financial institution, as assigned under an internationally recognised or proprietary identification scheme.

Fields

PostalAddress

ISO20022 : Information that locates and identifies a specific address, as defined by postal services.

Fields

PartyIdentification

API : Description of a Party which can be either a person or an organization.

Fields

ResourceId

Identifier assigned by the ASPSP for further use of the created resource through API calls

Base type

string

PaymentIdentification

ISO20022: Set of elements used to reference a payment instruction.

Fields

PriorityCode

ISO20022: Indicator of the urgency or order of importance that the instructing party would like the instructed party to apply to the processing of the instruction.

Base type

string

Enumerated Values

CategoryPurposeCode

ISO20022: Specifies the high level purpose of the instruction based on a set of pre-defined categories. This is used by the initiating party to provide information concerning the processing of the payment. It is likely to trigger special processing by any of the agents involved in the payment chain.

Base type

string

Enumerated Values

ServiceLevelCode

ISO20022: Agreement under which or rules under which the transaction should be processed. Specifies a pre-agreed service or level of service between the parties, as published in an external service level code list.

Base type

string

Enumerated Values

LocalInstrumentCode

ISO20022: User community specific instrument. Usage: This element is used to specify a local instrument, local clearing option and/or further qualify the service or service level.

Base type

string

PaymentTypeInformation

ISO20022: Set of elements used to further specify the type of transaction.

Fields

PurposeCode

ISO20022: Underlying reason for the payment transaction, as published in an external purpose code list.

Base type

string

Enumerated Values

ChargeBearerCode

ISO20022: Specifies which party/parties will bear the charges associated with the processing of the payment transaction.

Base type

string

Enumerated Values

UnstructuredRemittanceInformation

ISO20022: Information supplied to enable the matching of an entry with the items that the transfer is intended to settle, such as commercial invoices in an accounts' receivable system. API: Only one occurrence is allowed

Fields

PaymentInformationStatusCode

ISO20022: Specifies the status of the payment information.

Base type

string

Enumerated Values

TransactionIndividualStatusCode

ISO20022: Specifies the status of the payment information group.

Base type

string

Enumerated Values

StatusReasonInformation

ISO20022: Provides detailed information on the status reason. Can only be used in status equal to "RJCT".

Base type

string

Enumerated Values

RegulatoryReportingCode

Information needed due to regulatory and statutory requirements. Economical codes to be used are provided by the National Competent Authority

Base type

string

RegulatoryReportingCodes

List of needed regulatory reporting codes for international payments

Base type

[RegulatoryReportingCode]

RequestedExecutionDate

ISO20022: Date at which the initiating party requests the clearing agent to process the payment. API: This date can be used in the following cases:

• the single requested execution date for a payment having several instructions. In this case, this field must be set at the payment level.
• the requested execution date for a given instruction within a payment. In this case, this field must be set at each instruction level.
• The first date of execution for a standing order. When the payment cannot be processed at this date, the ASPSP is allowed to shift the applied execution date to the next possible execution date for non-standing orders. For standing orders, the [executionRule] parameter helps to compute the execution date to be applied.

Base type

string(date-time)

EndDate

The last applicable day of execution for a given standing order. If not given, the standing order is considered as endless.

Base type

string(date-time)

ExecutionRule

Execution date shifting rule for standing orders This data attribute defines the behaviour when recurring payment dates falls on a weekend or bank holiday. The payment is then executed either the "preceding" or "following" working day. ASPSP might reject the request due to the communicated value, if rules in Online-Banking are not supporting this execution rule.

Base type

string

Enumerated Values

FrequencyCode

Frequency rule for standing orders. The following codes from the "EventFrequency7Code" of ISO 20022 are supported. However, each ASPSP might restrict these values into a subset.

Base type

string

Enumerated Values

CreditTransferTransaction

ISO20022: Payment processes required to transfer cash from the debtor to the creditor. API:

Fields

BalanceStatus

Type of balance

Base type

string

Enumerated Values

TransactionStatus

Type of Transaction

Base type

string

Enumerated Values

Transaction

structure of a transaction

Fields

Enumerated Values

creditDebitIndicator

AccountResource

PSU account that is made available to the TPP

Fields

Enumerated Values

usage

cashAccountType

BalanceResource

Structure of an account balance

Fields

PaymentRequestConfirmation

Contains data for confirmation of payment request

Fields

Consent

User consent

Fields

PaymentInformationId

ISO20022 : Reference assigned by a sending party to unambiguously identify the payment information block within the message.

Base type

string

CreationDateTime

ISO20022: Date and time at which a (group of) payment instruction(s) was created by the instructing party.

Base type

string(date-time)

FundsAvailabilityInformation

indicator that the payment can be covered or not by the funds available on the relevant account

• true: payment is covered
• false: payment is not covered

Base type

boolean

BookingInformation

indicator that the payment can be immediately booked or not

• true: payment is booked
• false: payment is not booked

Base type

boolean

PaymentRequestResource

ISO20022: The PaymentRequestResource message is sent by the Creditor sending party to the Debtor receiving party, directly or through agents. It is used by a Creditor to request movement of funds from the debtor account to a creditor. API: Information about the creditor (Id, account and agent) might be placed either at payment level or at instruction level. Thus multi-beneficiary payments can be handled. The requested execution date can be placed either at payment level when all instructions are requested to be executed at the same date or at instruction level. The latest case includes:

• multiple instructions having different requested execution dates
• standing orders settings

Fields

PaymentCoverageRequestResource

Payment coverage request structure. The request must rely either on a cash account or a payment card.

Fields

HalAccounts

HYPERMEDIA structure used for returning the list of the available accounts to the AISP

Fields

HalBalances

HYPERMEDIA structure used for returning the list of the relevant balances for a given account to the AISP

Fields

HalTransactions

HYPERMEDIA structure used for returning the list of the transactions for a given account to the AISP

Fields

HalPaymentRequest

HYPERMEDIA structure used for returning the original Payment Request to the PISP

Fields

HalPaymentRequestCreation

data forwarded by the ASPSP to the PISP after creation of the Payment Request resource creation

Fields

HalPaymentCoverageReport

HYPERMEDIA structure used for returning the payment coverage report to the PIISP

Fields

Beneficiary

Specification of a beneficiary

Fields

HalBeneficiaries

HYPERMEDIA structure used for returning the list of the whitelisted beneficiaries

Fields

BalancesAccess

Defines what access to blanaces is requested

Fields

TransactionsAccess

Defines what access to transactions is requested

Fields

Access

Requested access services.

Fields

HAL

GenericLink

hypertext reference

Fields

AccountsLinks

Links that can be used for further navigation when browsing Account Information at top level

Fields

AccountLinks

links that can be used for further navigation when browsing Account Information at one account level

Fields

BalancesLinks

links that can be used for further navigation when browsing Account Information at one account level

Fields

TransactionsLinks

links that can be used for further navigation when browsing Account Information at one account level

Fields

BeneficiariesLinks

links that can be used for further navigation when browsing Account Information at one account level

Fields

PaymentRequestLinks

links that can be used for further navigation when having post a Payment Request in order to get the relevant status report.

Fields

PaymentCoverageReportLinks

links that can be used for further navigation to post another coverage request.

Fields

PaymentRequestResourceCreationLinks

Links that can be used for further navigation, especially in REDIRECT approach

Fields

ConsentLinks

Fields

Exceptions

HttpException

Code samples

{}

This exception is raised when ASPSP API responses with unspecified error.

Fields

DataRetrievalException

This exception is raised when unable to retrieve data requested from ASPSP API.

Base type

HttpException

InsufficientScopeException

This exception is raised when consent given by the PSU does not allow to retrieve
requested data.

Base type

DataRetrievalException

Connectors

ConnectorSettings

Base settings for all connectors

Fields

AktiaConnectorSettings

Settings for initializing ApiClient for Aktia

Base type

ConnectorSettings

Fields

AliorConnectorSettings

Base type

ConnectorSettings

Fields

BNPParibasPolandConnectorSettings

Base type

ConnectorSettings

Fields

INGPolandConnectorSettings

Base type

ConnectorSettings

Fields

LHVConnectorSettings

Base type

ConnectorSettings

Fields

NordeaConnectorSettings

Code samples

package com.eb.sample;

import com.enablebanking.ApiClient;
import com.enablebanking.model.NordeaConnectorSettings;

ApiClient apiClient = new ApiClient(
  new NordeaConnectorSettings()
    .clientId("put-your-client-id-here")
    .clientSecret("put-your-client-secret-here")
    .certPath("path/to/qwac-crt.pem")
    .keyPath("path/to/qwac-key.pem")
    .country("FI")
    .language("fi")
    .sandbox(true));

Settings for initializing ApiClient for Nordea (all countries).
Credentials can obtained at Nordea Developer Portal

Base type

ConnectorSettings

Fields

OPConnectorSettings

Base type

ConnectorSettings

Fields

PekaoConnectorSettings

Code samples

package com.eb.sample;

import com.enablebanking.ApiClient;
import com.enablebanking.model.PekaoConnectorSettings;

ApiClient apiClient = new ApiClient(
  new PekaoConnectorSettings()
    .clientId("put-your-client-id-here")
    .clientSecret("put-your-client-secret-here")
    .certPath("path/to/qwac-crt.pem")
    .keyPath("path/to/qwac-key.pem")
    .signKeyPath("path/to/qseal-key.pem")
    .signPubKeySerial("qseal-cert-serial")
    .signFingerprint("qseal-cert-fingerprint")
    .signCertUrl("qseal-cert-public-url")
    .sandbox(true));

Base type

ConnectorSettings

Fields

PKOConnectorSettings

Code samples

package com.eb.sample;

import com.enablebanking.ApiClient;
import com.enablebanking.model.PKOConnectorSettings;

ApiClient apiClient = new ApiClient(
  new PKOConnectorSettings()
    .clientId("put-your-client-id-here")
    .certPath("path/to/qwac-crt.pem")
    .keyPath("path/to/qwac-key.pem")
    .signKeyPath("path/to/qseal-key.pem")
    .signPubKeySerial("qseal-cert-serial")
    .signFingerprint("qseal-cert-fingerprint")
    .signCertUrl("qseal-cert-public-url")
    .tppId("your-tpp-id")
    .sandbox(true));

Base type

ConnectorSettings

Fields

KIRConnectorSettings

Setting for the connector to PolishAPI implementation provided by KIR.
Originally implemented for openbankinghackathon.pl
Sandbox only

Base type

ConnectorSettings

Fields

POPPankkiConnectorSettings

Base type

ConnectorSettings

Fields

SwedbankConnectorSettings

Code samples

package com.eb.sample;

import com.enablebanking.ApiClient;
import com.enablebanking.model.SwedbankConnectorSettings;

ApiClient apiClient = new ApiClient(
  new SwedbankConnectorSettings()
    .clientId("put-your-client-id-here")
    .clientSecret("put-your-client-secret-here")
    .country("SE")
    .tppRedirectUri("scheme://uri/to/redirect/after/payment")
    .psuIpAddress("end-user-ip-address")
    .psuUserAgent("end-user-ua-string")
    .sandbox(true));

Base type

ConnectorSettings

Fields

SPankkiConnectorSettings

Code samples

package com.eb.sample;

import com.enablebanking.ApiClient;
import com.enablebanking.model.SPankkiConnectorSettings;

ApiClient apiClient = new ApiClient(
  new SPankkiConnectorSettings()
    .clientId("put-your-client-id-here")
    .xApiKey("put-your-x-api-key-here")
    .certPath("path/to/qwac-crt.pem")
    .keyPath("path/to/qwac-key.pem")
    .signKeyPath("path/to/qseal-crt.pem")
    .signPubKeySerial("qseal-cert-public-serial-here")
    .paymentAuthRedirectUri("scheme://uri/to/redirect/after/payment")
    .paymentAuthState("payment-auth-state-value-here")
    .sandbox(true));

Settings for initializing ApiClient for S-Pankki (Finland).
Credentials can obtained at Open Banking Market
operated by Crosskey Banking Solutions.

Base type

ConnectorSettings

Fields

AlandsbankenConnectorSettings

Code samples

package com.eb.sample;

import com.enablebanking.ApiClient;
import com.enablebanking.model.AlandsbankenConnectorSettings;

ApiClient apiClient = new ApiClient(
  new AlandsbankenConnectorSettings()
    .clientId("put-your-client-id-here")
    .xApiKey("put-your-x-api-key-here")
    .certPath("path/to/qwac-crt.pem")
    .keyPath("path/to/qwac-key.pem")
    .signKeyPath("path/to/qseal-crt.pem")
    .signPubKeySerial("qseal-cert-public-serial-here")
    .paymentAuthRedirectUri("scheme://uri/to/redirect/after/payment")
    .paymentAuthState("payment-auth-state-value-here")
    .sandbox(true));

Settings for initializing ApiClient for Ålandsbanken (Finland).
Credentials can obtained at Open Banking Market
operated by Crosskey Banking Solutions.

Base type

ConnectorSettings

Fields

ResursConnectorSettings

Code samples

package com.eb.sample;

import com.enablebanking.ApiClient;
import com.enablebanking.model.ResursConnectorSettings;

ApiClient apiClient = new ApiClient(
  new ResursConnectorSettings()
    .clientId("put-your-client-id-here")
    .xApiKey("put-your-x-api-key-here")
    .certPath("path/to/qwac-crt.pem")
    .keyPath("path/to/qwac-key.pem")
    .signKeyPath("path/to/qseal-crt.pem")
    .signPubKeySerial("qseal-cert-public-serial-here")
    .paymentAuthRedirectUri("scheme://uri/to/redirect/after/payment")
    .paymentAuthState("payment-auth-state-value-here")
    .sandbox(true));

Base type

ConnectorSettings

Fields

KomplettConnectorSettings

Base type

ConnectorSettings

Fields

YaConnectorSettings

Base type

ConnectorSettings

Fields

SEBConnectorSettings

Code samples

package com.eb.sample;

import com.enablebanking.ApiClient;
import com.enablebanking.model.SEBConnectorSettings;

ApiClient apiClient = new ApiClient(
  new SPankkiConnectorSettings()
    .certPath("path/to/qwac-crt.pem")
    .keyPath("path/to/qwac-key.pem")
    .clientId("put-your-client-id-here")
    .country("EE")
    .psuIpAddress("end-user-IP-address")
    .tppRedirectUri("scheme://uri/to/redirect/after/payment")
    .sandbox(true));

Settings for initializing ApiClient for SEB Estonia, SEB Latvia and SEB Lithuania.
Credentials can obtained at SEB Developer Portal for Baltic countries.

Base type

ConnectorSettings

Fields

SEBSwedenConnectorSettings

Code samples

package com.eb.sample;

import com.enablebanking.ApiClient;
import com.enablebanking.model.SEBSwedenConnectorSettings;

ApiClient apiClient = new ApiClient(
  new SEBSwedenConnectorSettings()
    .clientId("put-your-client-id-here")
    .clientSecret("put-your-client-secret-here")
    .certPath("path/to/qwac-crt.pem")
    .keyPath("path/to/qwac-key.pem")
    .sandbox(true));

Settings for initializing ApiClient for SEB Sweden.
Credentials can obtained at SEB Developer Portal.

Base type

ConnectorSettings

Fields

Platform

Java

public abstract class AbstractConnectorSettingsFactory

Base class for connector settings factory, which can be used for creating instances of connector-specific settings classes (derived from ConnectorSettings class)

Code sample

public class SampleConnectorSettingsFactory {
    @Override
    public String getConnectorName() {
        // Returning connector identifier
        return "Nordea";
    }
    @Override
    public Boolean getSandbox() {
        // Returning value of `sandbox` parameter (common for all connectors)
        return true;
    }
    @Override
    public String getAccessToken() {
        // Returning "not set" for `accessToken` parameter (common for all connectors)
        return null;
    }
    @Override
    public String getRefreshToken() {
        // Returning "not set" for `refershToken` parameter (common for all connectors)
        return null;
    }
    @Override
    public String getConsentId() {
        // Returning "not set" for `consentId` parameter (common for all connectors)
        return null;
    }
    public String getClientId() {
        // Returning value of `clientId` parameter (Nordea specific)
        return "api-client-id";
    }
    public String getClientSecret() {
        // Returning value of `clientSecret` parameter (Nordea specific)
        return "api-client-secret";
    }
    public String getCertPath() {
        // Returning value of `certPath` parameter (Nordea specific)
        return "/path/to/qwac/cert";
    }
    public String getKeyPath() {
        // Returning value of `keyPath` parameter (Nordea specific)
        return "/path/to/qwac/key";
    }
}

abstract protected String getConnectorName()

• Returns: Connector identifier

abstract protected Boolean getSandbox()

• Returns: true - sandbox settings, false - production settings

abstract protected String getConsentId()

• Returns: Consent identifier (null if consent is not set)

abstract protected String getAccessToken()

• Returns: User access token (null if access token is not set)

abstract protected String getRefreshToken()

• Returns: User refresh token (null if refresh token is not set)

public ConnectorSettings createConnectorSettings()

Creates connector settings for a connector with identifier returned from getConnectorName method. The created connector settings instance will contain data returned by the corresponding methods of the factory. For example, if getConnectorName returns "Nordea" instance of NordeaConnectorSettings class will be created and data like client ID and client secret will be set (corresponding methods including getClientId and getClientSecret must be implemented in the factory, otherwise runtime exception will be thrown).

• Returns: Instance of a connector settings class

public abstract class AbstractPlatformExtension

Base class for customazing low-level functionality to the requirements of a target platform

• Package: com.enablebanking

abstract protected PlatformApiResponse makeRequest(PlatformApiRequest request)

Executes API request and returns an object containing response details.

• Parameters: request — Request details including parameters for establishing (M)TLS connection
• Returns: Object containing response details

abstract protected String signPKCS1v15usingSHA256(String value, String key, String keyPassword)

Generates PKCS #1 v1.5 RSA signature with SHA-256 mechanism.

• Parameters:
  • value — String to be signed
  • key — URI of the key used for signing {@code value} parameter
  • keyPassword — Password used to get access to the key (optional)
• Returns: String containing signature

public class PlatformApiRequest

Internal representation of API request

• Package: com.enablebanking

public PlatformApiRequest(String method, String origin, String path, List<Map.Entry<String, String>> headers, List<Map.Entry<String, String>> query, String body, TlsSettings tls)

Creates instance of the class with all necessary parameters.

• Parameters:
  • method — HTTP method: GET, POST, PUT, etc
  • origin — HTTP origin (i.e. <scheme> "://" <hostname> [ ":" <port> ])
  • path — Path part of a requested URL
  • headers — HTTP headers as a list of key-value pairs
  • query — Query part of a requested URL as a list of key-value pairs
  • body — HTTP body
  • tls — Parameters for establishing (M)TLS connection

public PlatformApiRequest(String method, String origin, String path, List<Map.Entry<String, String>> headers, List<Map.Entry<String, String>> query, String body)

Creates instance of the class with all parameters except (M)TLS settings.

• Parameters:
  • method — HTTP method: GET, POST, PUT, etc
  • origin — HTTP origin (i.e. <scheme> "://" <hostname> [ ":" <port> ])
  • path — Path part of an URL
  • headers — HTTP headers as a list of key-value pairs
  • query — Query part of an URL as a list of key-value pairs
  • body — HTTP body

public String getMethod()

• Returns: HTTP method of the request

public String getOrigin()

• Returns: HTTP origin of the request

public String getPath()

• Returns: Path part of the requested URL

public List<Map.Entry<String, String>> getHeaders()

• Returns: HTTP headers of the request

public List<Map.Entry<String, String>> getQuery()

• Returns: Query part of the requested URL

public String getBody()

• Returns: Body of the request

public TlsSettings getTls()

• Returns: Parameters for establishing (M)TLS connection for the request

public String findHeader(String header)

• Parameters: header — Name of an HTTP header
• Returns: First entry of the HTTP header with a given name or null if not found

public class TlsSettings

Internal representation of the parameters used to establish (M)TLS connection

• Package: com.enablebanking

public TlsSettings(String certPath, String keyPath, String caCertPath, String keyPassword)

Creates instance of the class with all necessary parameters.

• Parameters:
  • certPath — URI for identifying client certificate for MTLS connection
  • keyPath — URI for identifying private key for MTLS client certificate
  • caCertPath — URI for identifying server certificate
  • keyPassword — Password used to get access to the private key (optional)

public TlsSettings(String certPath, String keyPath, String caCertPath)

Creates instance of the class with all parameters except key password (set to null).

• Parameters:
  • certPath — URI for identifying client certificate for MTLS connection
  • keyPath — URI for identifying private key for MTLS client certificate
  • caCertPath — URI for identifying server certificate

public TlsSettings(String certPath, String keyPath)

Creates instance of the class with all parameters except key password and server certificate (set to null).

• Parameters:
  • certPath — URI for identifying client certificate for MTLS connection
  • keyPath — URI for identifying private key for MTLS client certificate

public String getCertPath()

• Returns: URI for identifying client certificate for MTLS connection

public String getKeyPath()

• Returns: URI for identifying private key for MTLS client certificate

public String getCaCertPath()

• Returns: URI for identifying server certificate (null if not set)

public String getKeyPassword()

• Returns: Password used to get access to the private key (null if not set)

@Override public boolean equals(Object obj)

Checks if this object equals to another.

• Parameters: obj — Object to compare with
• Returns: true when {@code obj} is considered equal to {@code this}, otherwise false

public class PlatformApiResponse

Internal representation of API response

• Package: com.enablebanking

public PlatformApiResponse(int statusCode, List<Map.Entry<String, String>> headers, String body)

Creates instance of the class with all necessary parameters.

• Parameters:
  • statusCode — HTTP response code
  • headers — HTTP response headers as list of key-value pairs
  • body — Body of HTTP response

public int getStatusCode()

• Returns: HTTP code of the response

public List<Map.Entry<String, String>> getHeaders()

• Returns: HTTP headers of the response

public String getBody()

• Returns: Body of the response

public String findHeader(String header)

• Parameters: header — Name of an HTTP header
• Returns: First entry of the HTTP header with a given name or null if not found