Skip to main content
Premium

Account Transaction & Balance API

Version

Introduction

The Account Transaction & Balance API gives businesses direct access to transactions and balances on their Danske Bank accounts in real time through a single integration.

Whether you're automating reconciliation, building cash forecasting models, embedding live bank feeds into an ERP, or automating workflows, the API delivers the data your financial tool needs without delays, batch jobs, or fragmented connections.

It's designed to slot into existing systems, treasury platforms, accounting software, Excel/PowerBI, or AI tools.

Use Cases and Features

Real-time insights: See account activity and balance changes the moment they happen.

Automated reconciliation: Match incoming payments to invoices automatically and trigger downstream workflows like order fulfilment, settlement, or reporting.

Embedded bank feeds: Push transactions and balances directly into ERP, accounting, or treasury platforms, so end users see live Danske Bank data inside the tools they already work in.

Features

  • Real-time transaction retrieval for a specified account
  • Transaction history with date-range and ULID-based filtering
  • Rich transaction detail: counterparty, reference, booking date, value date, amount, and more
  • Detailed retrieval of a specific transaction, including entryDetails for underlying transactions when available
  • Current and historical balances (booked, interest, available, intra-group)
  • End-of-day balanace lookup
  • Multi-language transaction texts (DA, EN, SV, NO, FI, DE, PL, FR)

Markets

The API is available across all of Danske Bank's markets.

It's been built and validated with a disparate range of customers. The API covers the core jobs that finance teams and platforms rely on every day. Equally, we continuously expand its capabilities and add more data points.

For specific requirements or integration questions, please reach out to us.

Getting Started

External API Platform

To get started with the Account Transaction & Balance API, it is necessary to onboard via External API Platform first. After onboarding the platform, you will have access to all the Premium APIs that Danske Bank offers.

Link to External API Platform onboarding guidelines: Danske Bank Open Banking Developer Portal

Certificate

Production acccess requires a valid certificate registered. See the Premium APIs FAQ for supported certificate types and the registration steps: Danske Bank Open Banking Developer Portal

Environment Description

As described in the External API Platform onboarding guidelines, the Account Transaction & Balance API will be available in two environments:

  • Sandbox: This environment will be used for initial integration tests and will provide mocked data. The mocked data includes three accounts. Each account will have transactions with either NOK, SEK or DKK currencies.

  • Production will provide you access to your real data. What accounts you have access to depends on your technical user setup.

Sandbox URLs

Token Endpoint: https://sandbox-api.danskebank.com/sandbox-corporate/api/dk/business/oauth2/token

Account Transaction & Balance API: https://sandbox-api.danskebank.com/sandbox-corporate/api/v1/account-transaction-service

Production URLs

Token Endpoint: https://api.danskebank.com/corporate/api/dk/business/oauth2/token

Account Transaction & Balance API: https://api.danskebank.com/corporate/api/v1/account-transaction-service

Authentication

To access a resource, the client must first request a Client Credentials Grant token by calling the token endpoint specified in the OpenId configuration (token_endpoint). The request should be an x-www-form-urlencoded POST with the following parameters:

  • grant_type - client_credentials (read more).

  • scope - should include a scope the client has access to; for the Account Transaction & Balance API, it MUST contain the “accounts” keyword (read more).

  • client_id - the ID received after onboarding (read more).

Example Request:

curl --location --request POST 'https://example.com/oauth2/token' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode 'grant_type=client_credentials' \
--data-urlencode 'client_id=1233456' \
--data-urlencode 'scope=accounts'

Example Response:

{
  "token_type": "Bearer",
  "access_token": "A****",
  "metadata": "m:",
  "expires_in": 3600,
  "consented_on": 1588933990,
  "scope": "accounts"
}

Using the Access Token:

The access_token received is valid for 1 hour and must be included in the request header on all subsequent API requests:

Authorization: Bearer <access_token>

Supported Endpoints

Account Transaction & Balance API includes the following key endpoints to interact with:

EndpointMethodDescriptionLimitPagination
/accounts/listGETRetrieves a list of accounts associated with the authenticated user.100 accounts per pageYes
/accounts/{accountId}/transactionsGETRetrieves a list of transactions for a specific account identified by {accountId}. Requires date range filtering.1000 transactionsSee “Transactions Pagination”: follow next.href as-is until it is no longer returned
/accounts/{accountId}/transactions/{transactionId}GETRetrieves details for a specific transaction on a given account, including entryDetails when available.1 transaction detail response; up to 1000 entryDetails items per pageYes
/accounts/{accountId}/balancesGETRetrieves the available balance types for a given account1 account per requestNo

Implementation Details

Accounts

Retrieve account information for the accounts available through your technical user. This endpoint provides the foundation for building account overviews, dashboards, and financial workflows on top of Danske Bank account data.

Accounts mockup

The /accounts/list endpoint is a prerequisite to fetch your transactions by fetching account ids first. The accounts you have access to will be defined by how your technical user is set up. You can only see accounts where that user has enquiry permissions.

The endpoint will provide you with UUIDs (technical ids) of your accounts within the field called "other" (see example response below). This is the {accountId} to use in both the /accounts/{accountId}/transactions and the /accounts/{accountId}/balances endpoint. These UUIDs will remain the same, so it is suggested that you store them to avoid having to call the endpoint every time you want to fetch transactions. See suggested flow below.

Accounts Pagination

Pagination can be implemented by utilizing the “offset” parameter together with the value in “href” in the response. To get next page, extract the number value after “offset=” and use it in the offset request parameter. An example of a href value:

"href": "/v1/account-transaction-service/accounts/list?offset=1314351&limit=10"

Here you would extract the value 1314351 and use it in the offset request parameter for your next request to get “page 2”.

Sorting uuids

Example Request and Response for Accounts

Accounts cURL Request
curl -X GET https://api.danskebank.com/corporate/api/v1/account-transaction-service/accounts/list?offset=0&limit=10 \ 
-H "Authorization: Bearer {accessToken}" 
Accounts Response
{
  "accounts": [
    {
      "iban": "DK3030000011223388",
      "bban": "11223388",
      "other": "b03bb874-b6c5-5bbf-bb63-bbb96984bb23",
      "country": "DK",
      "currency": "DKK"
    },
    {
      "iban": "NO511112233333",
      "bban": "11112233333",
      "other": "7bb255b2-7352-50bb-b278-0b19b02db829",
      "country": "NO",
      "currency": "NOK"
    },
    {
      "iban": "SE7212000000011223344556",
      "bban": "11223344556",
      "other": "bbb2bb25-5a20-5463-b676-5b088cb7b1b9",
      "country": "SE",
      "currency": "SEK"
    }
  ],
  "next": {
    "href": "/v1/account-transaction-service/accounts/list?offset=4121389&limit=3"
  }
}

Transactions

Retrieve real-time transaction data for a specific account. This endpoint provides enriched transaction information such as counterparty details, references, booking and value dates, amounts, and other data points that support reconciliation, reporting, and financial automation.

Transaction list

This section covers the request parameters to the /accounts/{accountId}/transactions endpoint, the response structure, pagination, and the recommended polling pattern for staying in sync with an account without missing or duplicating transactions.

Query Parameters

ParameterInRequiredType / FormatDescription
accountIdpathYesUUIDThe technical account id from /accounts/list (the value of the other field).
bookingDateFromqueryYesDate YYYY-MM-DD, inclusiveStart of the booking-date range. The earliest accepted value is 2025-03-01.
bookingDateToqueryNoDate YYYY-MM-DD, inclusiveEnd of the booking-date range. When omitted, defaults to the moment the request is processed.
aspspParametersqueryNoULIDPolling filter: returns only transactions whose ULID is strictly greater than this value. It is not the paging mechanism; to page, follow next.href (see Transactions Pagination). See Field Details: aspspParameters and Recommended Query Pattern below.
limitqueryNoInteger, maximum 1000Maximum number of transactions per response. We recommend setting this explicitly to 1000 for predictable pagination behaviour.
bankTransactionCodequeryNoString abcd-efgh-ijkl, case-insensitiveFilters by bank transaction code. Partial substrings are supported.
languageCodequeryNoISO 639-1 code (e.g. DA, EN)Language for bank-generated transaction texts. Defaults to EN. See supported languages below.

Field Details: aspspParameters

Each transaction is assigned a ULID (Universally Unique Lexicographically Sortable Identifier). The ULID for a given transaction is exposed in the response at links.aspspParameters.href. aspspParameters is the polling filter used for incremental fetching (see Recommended Query Pattern). It is not the paging mechanism: paging is done by following next.href (see Transactions Pagination).

A ULID is assigned at the moment a transaction is processed by our system, not at the moment it is booked. ULIDs therefore follow processing time, across days as well as within a day. The bookingDate does not follow processing time. This distinction matters because:

  • A transaction can have a bookingDate in the future (a future-booked transaction). It receives its ULID today, when it is processed, but only becomes visible in responses once its booking date arrives. On its booking date, its ULID will already be lower than transactions both booked and processed that day.
  • A transaction can have a bookingDate in the past (a backdated transaction). It also receives its ULID at the moment of processing, so its ULID will sit alongside other transactions processed at the same time, even though its bookingDate is older.

Booking dates are [Danish calendar dates / UTC dates — to be confirmed], and a future-booked transaction becomes visible [from the start of its booking date — to be confirmed]. These properties are what drive the Recommended Query Pattern further down.

Disclaimers on aspspParameters
  • The value will not be available for transactions created before 2025-03-01.

Date Filters

Both bookingDateFrom and bookingDateTo use the format YYYY-MM-DD and are inclusive at both ends. If you do not provide a bookingDateTo, the endpoint returns transactions from bookingDateFrom up to "now" (the moment the request is processed).

When combined with aspspParameters, the server applies both filters: it returns transactions whose bookingDate is within the date range and whose ULID is strictly greater thanaspspParameters.

Disclaimer on date filters
  • Historical data is only available back until 2025-03-01.

Bank Transaction Code Filters

The endpoint allows transactions to be filtered by their bank transaction code. When a bank transaction code is provided, the endpoint returns transactions that match the specified value.

The supported format for bank transaction codes is abcd-efgh-ijkl, and the search is not case sensitive.

Disclaimer on Bank Transaction Code filters
  • Partial bank transaction codes can also be used as search terms, though the position of the substring cannot be specified.

Language Code Selection

The endpoint accepts a languageCode parameter to specify the language for bank-generated transaction texts. For example, setting languageCode to FI displays transaction texts in Finnish. The language code must conform to the ISO 639-1 standard. If no languageCode is provided, the API defaults to English. Include the languageCode parameter in your API request to receive transaction texts in the specified language, where available.

The following languages are currently supported:

CodeLanguage
DADanish
ENEnglish
SVSwedish
NONorwegian
FIFinnish
DEGerman
PLPolish
FRFrench

Please note that not all texts are translated into every supported language. If a specific translation is missing, the original untranslated text will be returned.

Transactions Pagination

When a response contains a top-level next.href, there may be more transactions to retrieve. To page through the remainder:

  1. Call the URL provided in the response's top-level next.href as-is.
  2. Repeat until a response no longer contains next.href.

A short or empty page does not mean you are done: keep following next.href for as long as it is returned. Do not stop on "fewer than limit transactions".

next.href carries an opaque pageToken query parameter. pageToken is internal: do not build, parse or change it. You also do not need to work out the highest ULID yourself for paging.

aspspParameters is the polling filter only (see Recommended Query Pattern); it is not used for paging.

This pagination pattern applies to every call described in the Recommended Query Pattern below.

Recommended Query Pattern

This section describes how to call the endpoint so that you receive every transaction, however often you poll. Run the bootstrap (A) once per account at onboarding. After that, every poll uses flow B, except the first poll of each new UTC day, which uses the rollover flow C.

Every call in this pattern fetches all its pages: follow next.href exactly as returned until a response no longer contains it. A short or empty page does not mean you are done. See Transactions Pagination.

Why a pattern is needed: every transaction gets a ULID when it is processed, but it only appears on its booking date. A future-booked transaction, such as an FX deal, appears days after its ULID was set. A backdated transaction appears with a booking date in the past. The flows below catch both.

State to persist (per account)

You need to persist two values per account:

  • lastSeenUlid: the highest ULID you have received for the account. Each transaction's ULID is in links.aspspParameters.href. Transactions are not sorted by ULID, so take the highest value across all pages, not the value of the last transaction. Do not read it from next.href.
  • lastRollover: the UTC date of your last completed rollover (flow C). Flow C1 uses it as bookingDateFrom.

Constants used below

  • LOOKBACK_DAYS = 30: how far back to re-check for backdated transactions. Increase it if your business accepts backdating beyond 30 days.
  • "Day" means UTC day, since the API operates in UTC.
  • Use limit=1000 on every call.

A. First-ever poll (bootstrap)

Run once per account when you first integrate.

ParameterValue
bookingDateFromThe earliest date you need (for example your onboarding date), no earlier than 2025-03-01
bookingDateToomit
aspspParametersomit
limit1000

Follow next.href until it is no longer returned. Then save:

  • the highest ULID received as lastSeenUlid
  • the UTC date the bootstrap started as lastRollover

Example: ?bookingDateFrom=2025-03-01&limit=1000

B. Subsequent poll within the same UTC day

A single call per account.

ParameterValue
bookingDateFromtoday - LOOKBACK_DAYS
bookingDateToomit
aspspParameterslastSeenUlid
limit1000

Follow next.href until it is no longer returned. Then update lastSeenUlid to the highest ULID received.

Example: ?bookingDateFrom=2026-04-04&aspspParameters=01JP1XJV95P02XBDAVVSF6E2QB&limit=1000

C. First poll of a new UTC day (rollover)

This requires two calls per account, in either order. Both calls use lastSeenUlid as it was before the rollover. Do not update lastSeenUlid until both calls have finished. If you update it between the two calls, C2 will skip backdated transactions.

C1: future-booked sweep

Picks up transactions whose booking date falls on any day from lastRollover up to and including today, but which were processed earlier.

  • There is no ULID filter, because these transactions have older ULIDs.
  • C1 starts on lastRollover, not the day after. This also catches transactions that became visible after the last rollover ran.
  • If you miss a day of polling, C1 still covers it, so no future-booked transaction is lost.
ParameterValue
bookingDateFromlastRollover
bookingDateToomit
aspspParametersomit
limit1000

Example (last rollover 2026-05-02, today 2026-05-04): ?bookingDateFrom=2026-05-02&limit=1000

C2: backdated sweep

Picks up transactions backdated into the lookback window that have been processed since your last poll.

ParameterValue
bookingDateFromtoday - LOOKBACK_DAYS
bookingDateTotoday - 1 (yesterday)
aspspParameterslastSeenUlid (the value from before the rollover)
limit1000

Example: ?bookingDateFrom=2026-04-04&bookingDateTo=2026-05-03&aspspParameters=01JP1XJV95P02XBDAVVSF6E2QB&limit=1000

After both calls have finished:

  1. Set lastSeenUlid to the highest ULID received across both calls.
  2. Set lastRollover to today.
  3. Remove duplicates by transactionId. C1 and C2 can return the same transaction.

For any further polls during the same UTC day, use flow B.

Why this works

TransactionCaught by
Booked and processed on the same dayFlow B: its ULID is higher than lastSeenUlid, and its booking date is inside the lookback window.
Future-booked, booking date has now arrivedFlow C1: its booking date is on or after lastRollover, and C1 has no ULID filter, so its older ULID does not exclude it.
Future-booked, became visible after the last rollover ranFlow C1 at the next rollover, because C1 starts on lastRollover.
Backdated, processed since your last pollFlow C2 (across UTC days) or flow B (within the same UTC day): its booking date is inside the lookback window, and its ULID is higher than lastSeenUlid.

Notes and edge cases

  • Duplicates. Always remove duplicates by transactionId. C1 re-reads the day of the last rollover, C1 and C2 can overlap, and a retried call can return the same page twice. Do not use lastSeenUlid for this, because C1 has no ULID filter.
  • Balance check. Regularly compare the sum of your transactions with the /balances endpoint. It confirms that nothing is missing.
  • Historical limit. Transaction history and ULIDs are available from 2025-03-01.
  • Lookback window. The 30-day default covers the great majority of backdated transactions. If you increase LOOKBACK_DAYS, the date range of flow B and flow C2 widens too.
  • Polling frequency. The pattern works for any frequency, from once a day to continuous polling. To choose between B and C, compare today's UTC date with lastRollover. If you poll once a day, you only need A once and then C every day.

If you used the previous version of this pattern

  • Stop on next.href, not on page size. Keep following next.href until it is no longer returned, even if a page has fewer than limit transactions.
  • Read lastSeenUlid from the transactions. next.href no longer carries the highest ULID.
  • Start storing lastRollover. For your first rollover under the new pattern, set it to the UTC date of your last poll.

Example Request and Response for Transactions

Transactions cURL request
curl -X GET "https://api.danskebank.com/corporate/api/v1/account-transaction-service/accounts/63bd9d0c-67ba-4be6-bccb-f4c20190aa7d/transactions?bookingDateFrom=2025-06-01&limit=1000&aspspParameters=01JP1XJV95P02XBDAVVSF6E2QB" \
-H "Authorization: Bearer {accessToken}"
Transactions Response
{
  "transactions": [
    {
      "transactionId": "CE42C787E4EBB35119A5A4854D90CE9A26C2F492112D4E6B7C2742DE97936F24",
      "entryReference": "2025-03-10T19:52:13.952918Z",
      "batchIndicator": false,
      "references": {
        "accountServicerReference": "8101579783",
        "instructionId": "TEST-65980824",
        "endToEndId": "700179278"
      },
      "bookingDate": "2025-03-10",
      "valueDate": "2025-03-10",
      "transactionAmount": {
        "currency": "DKK",
        "amount": "-472.05"
      },
      "amountDetails": {
        "instructedAmount": {
          "currency": "DKK",
          "amount": "-472.05"
        }
      },
      "creditorAccount": {
        "bban": "81015797830824"
      },
      "debtor": {
        "name": "Test Solutions Ltd"
      },
      "remittanceInformationUnstructured": [
        "Money to XXX"
      ],
      "additionalTransactionInformation": "ABC.TEST-65980824",
      "bankTransactionCode": "PMNT-ICDT-DMCT",
      "balanceAfterTransaction": {
        "balanceAmount": {
          "currency": "DKK",
          "amount": "4360368.23"
        },
        "balanceType": "interimBooked"
      },
      "links": {
        "aspspParameters": {
          "href": "01JP1XJV95P02XBDAZVQF6D8QB"
        }
      }
    },
    {
      "transactionId": "69CA5B4E7D873BFAF40B13AB68C92BF8758ADF60E23436BC128566CC89367D64",
      "entryReference": "2025-03-10T19:41:13.485129Z",
      "batchIndicator": false,
      "references": {
        "accountServicerReference": "8101579784",
        "instructionId": "TEST-44480824"
      },
      "bookingDate": "2025-03-10",
      "valueDate": "2025-03-10",
      "transactionAmount": {
        "currency": "DKK",
        "amount": "-553.65"
      },
      "amountDetails": {
        "instructedAmount": {
          "currency": "DKK",
          "amount": "-553.65"
        }
      },
      "creditorAccount": {
        "bban": "81111797830824"
      },
      "debtor": {
        "name": "Test Trading Co"
      },
      "remittanceInformationUnstructured": [
        "Money to XXX"
      ],
      "additionalTransactionInformation": "ABC.TEST-44480824",
      "bankTransactionCode": "PMNT-ICDT-DMCT",
      "balanceAfterTransaction": {
        "balanceAmount": {
          "currency": "DKK",
          "amount": "4360840.28"
        },
        "balanceType": "interimBooked"
      },
      "links": {
        "aspspParameters": {
          "href": "01JP1XJPXGN64SB5HQFJ7F3G6K"
        }
      }
    }
  ],
  "next": {
    "href": "/v1/account-transaction-service/accounts/63bd9d0c-67ba-4be6-bccb-f4c20190aa7d/transactions?bookingDateFrom=2025-06-01&limit=1000&aspspParameters=01JP1XJV95P02XBDAZVQF6D8QB"
  }
}

Transaction Details

Retrieve the full details of a specific transaction on an account. This endpoint can provide underlying entry details for supported bulked transactions, helping you gain deeper insight into payment activity and reconciliation processes.

Transaction details

The /accounts/{accountId}/transactions/{transactionId} endpoint returns entryDetails when available. This is useful for transactions that represent multiple underlying entries, such as bulked transactions.

Data on bulked transactions are subject to availability and are currently limited to FIK and certain CREMUL (KID) payments.

Path and Query Parameters

ParameterInRequiredType / FormatDescription
accountIdpathYesUUIDIdentifier of the account. This is the technical account id retrieved from /accounts/list.
transactionIdpathYesStringIdentifier of the transaction. This value is provided in the transactionId field of the corresponding transaction returned by /accounts/{accountId}/transactions.
languageCodequeryNoISO 639-1 code (e.g. DA, EN)Language for bank-generated transaction texts.
limitqueryNoInteger, min 10, max 1000Maximum number of entryDetails items returned in a single response page.
offsetqueryNoIntegerOffset value for pagination of entryDetails.

What the endpoint returns

The response contains a transactionDetail object with detailed information about the requested transaction. This includes fields such as transactionId, entryReference, references, bookingDate, valueDate, transactionAmount, amountDetails, creditor, debtor, remittanceInformation, bankTransactionCode, and additionalTransactionInformation.

When available, the response also includes entryDetails. The entryDetails array contains additional details related to the transaction entry and may be useful when a single booked transaction represents multiple underlying entries.

If the number of entryDetails exceeds the requested page size, pagination is supported through the limit, offset, and next fields.

Entry Details

Each item in entryDetails can include:

  • debtor
  • transactionAmount
  • debtorAccount
  • remittanceInformationStructured

If entryDetails is present, it provides a more granular breakdown of the transaction.

For transactions that represent multiple underlying entries, such as bulked transactions, the entryDetails array may contain many items and can be paginated.

Language Code Selection

The endpoint accepts an optional languageCode parameter to specify the language for bank-generated transaction texts.

For supported language codes and fallback behavior, see the Language Code Selection section under Transactions.

Transaction Details Pagination

The response may include a next object with an href value for retrieving the next page of entryDetails.

Use the limit parameter to control page size and the offset parameter to request subsequent pages.

Pagination is relevant when the transaction contains more entryDetails items than can be returned in a single response.

Example Request and Response for Transaction Details

Transaction Details cURL request
curl -X GET "https://api.danskebank.com/corporate/api/v1/account-transaction-service/accounts/{accountId}/transactions/{transactionId}?languageCode=EN&limit=100&offset=0" \
-H "Authorization: Bearer {accessToken}"
Transaction Details Response
{
  "transactionDetails": {
    "transactionId": "3B8063BEC1E5856E0S36AFF4B382EDCB108CE952886DE8545E590D9AD2FE16BA",
    "entryReference": "2026-05-18T23:49:15.199160Z",
    "batchIndicator": false,
    "references": {
      "accountServicerReference": "FISAM.POST"
    },
    "bookingDate": "2026-05-19",
    "valueDate": "2026-05-19",
    "transactionAmount": {
      "currency": "DKK",
      "amount": "18718.75"
    },
    "entryDetails": [
      {
        "remittanceInformationStructured": {
          "creditorReferenceInformation": {
            "reference": "0000000000080341602",
            "referenceTypeCode": "SCOR"
          }
        },
        "transactionAmount": {
          "currency": "DKK",
          "amount": "3406.25"
        }
      },
      {
        "remittanceInformationStructured": {
          "creditorReferenceInformation": {
            "reference": "0000000000080543106",
            "referenceTypeCode": "SCOR"
          }
        },
        "transactionAmount": {
          "currency": "DKK",
          "amount": "15312.50"
        }
      }
    ],
    "additionalTransactionInformation": "Paying-in forms 89124128 / 71",
    "bankTransactionCode": "PMNT-RCDT-VCOM"
  },
  "next": {
    "href": "/v1/account-transaction-service/accounts/63bd9d0c-67ba-4be6-bccb-f4c20190aa7d/transactions/3B8063BEC1E5856E0S36AFF4B382EDCB108CE952886DE8545E590D9AD2FE16BA?limit=10020&offset=0&languageCode=EN"
  }
}

Balances

The balance endpoint allows you to retrieve both current and historical balances for a specified account. It provides up-to-date information on booked, interest and intra-group balances, ensuring transparency and ease of financial tracking.

Balances

With a single request to the /accounts/{accountId}/balances endpoint, all supported balance types are returned. Depending on the account type, different balance types are available.

Multi-Currency Cash Pool (MCCP) balances

The balance endpoint also supports Multi-Currency Cash Pool (MCCP) structures.

To retrieve balances for currency folders, submit the request using the MCCP account's accountId. The API automatically returns swept balances for the associated currency folders, including the balance currency for each folder.

The dateTime parameter is not supported for Multi-Currency Cash Pool (MCCP) accounts. Historical balances are only available for standard account types. Submitting a dateTime value on a request for an MCCP account will result in a validation error.

Please refer to the API specification for the detailed response structure and available balance fields.

Balance Types

ParameterBalance TypeDescription
interimBookedBooked BalanceThe total sum of all transactions that have been fully processed on an account. It includes all credited and debited entries that the bank has officially posted.
valueBalanceInterest BalanceThe account balance calculated based on the value dates of the transactions, rather than when they are booked. It reflects the balance used by the bank to calculate interest on the account.
intraGroupBookedIntra-Group Booked BalanceThe intra-group balance resulting from the operation of the cash pool. The intra-group balance does not reflect an outstanding balance with Danske Bank.
intraGroupInterestIntra-Group Interest BalanceThe intra-group interest balance resulting from the operation of the cash pool. The intra-group interest balance does not reflect an outstanding balance with Danske Bank.

Historical Balances

The endpoint supports retrieving historical balances using the dateTime parameter. Only dateTime returns a historical balance. Five different input formats are supported with strict validation and future timestamp prevention:

  • YYYY-MM-DD - Date only (e.g., 2026-02-10)
  • HH:mm - Time only (e.g., 14:30)
  • HH:mm:ss - Time with seconds (e.g., 14:30:45)
  • HH:mm:ss.SSSSSSZ - Time with microseconds (e.g., 14:30:45.123456Z)
  • YYYY-MM-DD'T'HH:mm:ss.SSSSSSZ - Full datetime (e.g., 2026-02-10T14:30:45.123456Z)

To retrieve the end-of-day (EOD) balance, provide only the date in YYYY-MM-DD format. The application will automatically return the EOD balance for that date.

All valid inputs are converted to the standard format: YYYY-MM-DD'T'HH:mm:ss.SSSSSS'Z'.

Example Request and Response for Balances

Balances cURL Request
curl -X GET https://api.danskebank.com/corporate/api/v1/account-transaction-service/accounts/63bd9d0c-67ba-4be6-bccb-f4c20190aa7d/balances?dateTime=2026-02-10T14:30:45.123456Z \ 
-H "Authorization: Bearer {accessToken}"
Balances Response
{
  "account": {
    "iban": "DK0830003100285690",
    "bban": "3100285690",
    "other": "00b23b5a-a7aa-4289-b84b-257ade5b9cc7",
    "country": "DK",
    "currency": "DKK",
    "name": "Multicurrency Cash Pool Account"
  },
  "balances": [
    {
      "balanceAmount": {
        "currency": "DKK",
        "amount": "586017777.30"
      },
      "balanceType": "interimBooked",
      "referenceDate": "2026-09-11T09:57:57.937064Z"
    }
  ],
  "currencyFolders": [
    {
      "account": {
        "currency": "DKK",
        "name": "MCCP Currency Folder"
      },
      "balances": [
        {
          "balanceAmount": {
            "currency": "DKK",
            "amount": "567971464.58"
          },
          "balanceType": "interimBooked",
          "referenceDate": "2026-09-11T09:57:57.937064Z"
        }
      ]
    },
    {
      "account": {
        "currency": "EUR",
        "name": "MCCP Currency Folder"
      },
      "balances": [
        {
          "balanceAmount": {
            "currency": "EUR",
            "amount": "16463644.99"
          },
          "balanceType": "interimBooked",
          "referenceDate": "2026-09-11T09:57:57.937064Z"
        }
      ]
    },
    {
      "account": {
        "currency": "SEK",
        "name": "MCCP Currency Folder"
      },
      "balances": [
        {
          "balanceAmount": {
            "currency": "SEK",
            "amount": "1549135610.70"
          },
          "balanceType": "interimBooked",
          "referenceDate": "2026-09-11T09:57:57.937064Z"
        }
      ]
    },
    {
      "account": {
        "currency": "GBP",
        "name": "MCCP Currency Folder"
      },
      "balances": [
        {
          "balanceAmount": {
            "currency": "GBP",
            "amount": "10305.32"
          },
          "balanceType": "interimBooked",
          "referenceDate": "2026-09-11T09:57:57.937064Z"
        }
      ]
    },
    {
      "account": {
        "currency": "NOK",
        "name": "MCCP Currency Folder"
      },
      "balances": [
        {
          "balanceAmount": {
            "currency": "NOK",
            "amount": "26239.49"
          },
          "balanceType": "interimBooked",
          "referenceDate": "2026-09-11T09:57:57.937064Z"
        }
      ]
    }
  ]
}

Error Codes

Our API uses standardized HTTP status codes to indicate the success or failure of API requests. Below is a summary of the error codes you may encounter:

Error CodeDescriptionResolution Steps
200 OKThe request was successful.No action needed.
400 Bad RequestThe request could not be understood or was missing required parameters.Check the request syntax and ensure all required parameters are included.
401 UnauthorizedAuthentication credentials were missing or incorrect.Verify that authentication credentials are correct and included in the request.
403 ForbiddenThe request was understood, but it has been refused or access is not allowed.Ensure that you have the necessary permissions to access the requested resource.
404 Not FoundThe requested resource could not be found.Verify the resource URL and ensure that the resource exists.
500 Internal Server ErrorAn error occurred on the server.Try the request again later and contact support if the issue persists.

A more exhaustive list of HTTP errors can be found within our API specification. Please refer to this documentation for comprehensive information on all possible error responses you may encounter.

The Account Transaction & Balance API will return errors in the following structure:

{
  "exceptionType": "accounts.api.security.exceptions.AuthenticationException",
  "status": "UNAUTHORIZED",
  "details": "Access unauthorized: Access token is not provided."
}

Architectural constraints

State
Active

Technical constraints

Static URL
/premium-apis/account-transaction--and--balance-api
Environment(s)
PROD, SANDBOX