@lap v0.3
# Machine-readable API spec. Each @endpoint block is one API call.
@api Configuration API
@base https://balanceplatform-api-test.adyen.com/bcl/v2
@version 2
@auth ApiKey X-API-Key in header | Bearer basic | ApiKey clientKey in query
@endpoints 83
@hint download_for_search
@toc accountHolders(7), balanceAccounts(16), balancePlatforms(12), cardorders(2), grantAccounts(1), grantOffers(2), networkTokens(2), paymentInstrumentGroups(3), paymentInstruments(13), pins(2), publicKey(1), registeredDevices(6), transactionRules(4), transferRoutes(1), validateBankAccountIdentification(1), mandates(4), scaAssociations(3), scaDevices(3)

@group accountHolders
@endpoint POST /accountHolders
@desc Create an account holder
@required {legalEntityId: str # The unique identifier of the [legal entity](https://docs.adyen.com/api-explorer/legalentity/latest/post/legalEntities#responses-200-id) associated with the account holder. Adyen performs a verification process against the legal entity of the account holder.}
@optional {balancePlatform: str # The unique identifier of the [balance platform](https://docs.adyen.com/api-explorer/#/balanceplatform/latest/get/balancePlatforms/{id}__queryParam_id) to which the account holder belongs. Required in the request if your API credentials can be used for multiple balance platforms., capabilities: map # Contains key-value pairs that specify the actions that an account holder can do in your platform. The key is a capability required for your integration. For example, **issueCard** for Issuing. The value is an object containing the settings for the capability., contactDetails: map{address!: map, email!: str, phone!: map, webAddress: str}, description: str # Your description for the account holder., metadata: map # A set of key and value pairs for general use. The keys do not have specific names and may be used for storing miscellaneous data as desired. > Note that during an update of metadata, the omission of existing key-value pairs will result in the deletion of those key-value pairs., migratedAccountHolderCode: str # The unique identifier of the migrated account holder in the classic integration., reference: str # Your reference for the account holder., timeZone: str # The time zone of the account holder. For example, **Europe/Amsterdam**. Defaults to the time zone of the balance platform if no time zone is set. For possible values, see the [list of time zone codes](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).}
@returns(200) {balancePlatform: str, capabilities: map, contactDetails: map{address: map{city: str, country: str, houseNumberOrName: str, postalCode: str, stateOrProvince: str, street: str}, email: str, phone: map{number: str, type: str}, webAddress: str}, description: str, id: str, legalEntityId: str, metadata: map, migratedAccountHolderCode: str, primaryBalanceAccount: str, reference: str, status: str, timeZone: str, verificationDeadlines: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"description":"Account holder used for international payments and payouts","reference":"S.Eller-001","legalEntityId":"LE322JV223222D5GG42KN6869"}

@endpoint GET /accountHolders/{id}
@desc Get an account holder
@required {id: str # The unique identifier of the account holder.}
@returns(200) {balancePlatform: str, capabilities: map, contactDetails: map{address: map{city: str, country: str, houseNumberOrName: str, postalCode: str, stateOrProvince: str, street: str}, email: str, phone: map{number: str, type: str}, webAddress: str}, description: str, id: str, legalEntityId: str, metadata: map, migratedAccountHolderCode: str, primaryBalanceAccount: str, reference: str, status: str, timeZone: str, verificationDeadlines: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint PATCH /accountHolders/{id}
@desc Update an account holder
@required {id: str # The unique identifier of the account holder.}
@optional {balancePlatform: str # The unique identifier of the [balance platform](https://docs.adyen.com/api-explorer/#/balanceplatform/latest/get/balancePlatforms/{id}__queryParam_id) to which the account holder belongs. Required in the request if your API credentials can be used for multiple balance platforms., capabilities: map # Contains key-value pairs that specify the actions that an account holder can do in your platform. The key is a capability required for your integration. For example, **issueCard** for Issuing. The value is an object containing the settings for the capability., contactDetails: map{address!: map, email!: str, phone!: map, webAddress: str}, description: str # Your description for the account holder., metadata: map # A set of key and value pairs for general use. The keys do not have specific names and may be used for storing miscellaneous data as desired. > Note that during an update of metadata, the omission of existing key-value pairs will result in the deletion of those key-value pairs., migratedAccountHolderCode: str # The unique identifier of the migrated account holder in the classic integration., primaryBalanceAccount: str # The ID of the account holder's primary balance account. By default, this is set to the first balance account that you create for the account holder. To assign a different balance account, send a PATCH request., reference: str # Your reference for the account holder., status: str(active/closed/suspended) # The status of the account holder.  Possible values:    * **active**: The account holder is active and allowed to use its capabilities. This is the initial status for account holders and balance accounts. You can change this status to **suspended** or **closed**.    * **suspended**: The account holder is temporarily disabled and payouts are blocked. You can change this status to **active** or **closed**.   * **closed**: The account holder and all of its capabilities are permanently disabled. This is a final status and cannot be changed., timeZone: str # The time zone of the account holder. For example, **Europe/Amsterdam**. Defaults to the time zone of the balance platform if no time zone is set. For possible values, see the [list of time zone codes](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)., verificationDeadlines: [map{capabilities!: [str], entityIds: [str], expiresAt!: str(date-time)}] # List of verification deadlines and the capabilities that will be disallowed if verification errors are not resolved.}
@returns(200) {balancePlatform: str, capabilities: map, contactDetails: map{address: map{city: str, country: str, houseNumberOrName: str, postalCode: str, stateOrProvince: str, street: str}, email: str, phone: map{number: str, type: str}, webAddress: str}, description: str, id: str, legalEntityId: str, metadata: map, migratedAccountHolderCode: str, primaryBalanceAccount: str, reference: str, status: str, timeZone: str, verificationDeadlines: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"description":"Account holder used for international payments and payouts","reference":"S.Eller-001","capabilities":{"receivePayments":{"requested":true}}}

@endpoint GET /accountHolders/{id}/balanceAccounts
@desc Get all balance accounts of an account holder
@required {id: str # The unique identifier of the account holder.}
@optional {offset: int(int32) # The number of items that you want to skip., limit: int(int32) # The number of items returned per page, maximum 100 items. By default, the response returns 10 items per page.}
@returns(200) {balanceAccounts: [map], hasNext: bool, hasPrevious: bool} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /accountHolders/{id}/taxForms
@desc Get a tax form
@required {id: str # The unique identifier of the account holder., formType: str(US1099k/US1099nec) # The type of tax form you want to retrieve. Accepted values are **US1099k** and **US1099nec**., year: int(int32) # The tax year in **YYYY** format for the tax form you want to retrieve.}
@optional {legalEntityId: str # The legal entity reference whose tax form you want to retrieve.}
@returns(200) {content: str(byte), contentType: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 404: The requested tax form was not available., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /accountHolders/{id}/transactionRules
@desc Get all transaction rules for an account holder
@required {id: str # The unique identifier of the account holder.}
@returns(200) {transactionRules: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group balanceAccounts
@endpoint POST /balanceAccounts
@desc Create a balance account
@required {accountHolderId: str # The unique identifier of the [account holder](https://docs.adyen.com/api-explorer/balanceplatform/latest/post/accountHolders#responses-200-id) associated with the balance account.}
@optional {defaultCurrencyCode: str # The default three-character [ISO currency code](https://docs.adyen.com/development-resources/currency-codes) of the balance account. This is the currency displayed on the Balance Account overview page in your Customer Area. The default value is **EUR**. > After a balance account is created, you cannot change its default currency., description: str # A human-readable description of the balance account, maximum 300 characters. You can use this parameter to distinguish between multiple balance accounts under an account holder., metadata: map # A set of key and value pairs for general use. The keys do not have specific names and may be used for storing miscellaneous data as desired. > Note that during an update of metadata, the omission of existing key-value pairs will result in the deletion of those key-value pairs., migratedAccountCode: str # The unique identifier of the account of the migrated account holder in the classic integration., platformPaymentConfiguration: map{salesDayClosingTime: str(time), settlementDelayDays: int(int32)}, reference: str # Your reference for the balance account, maximum 150 characters., timeZone: str # The time zone of the balance account. For example, **Europe/Amsterdam**. Defaults to the time zone of the account holder if no time zone is set. For possible values, see the [list of time zone codes](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).}
@returns(200) {accountHolderId: str, balances: [map], defaultCurrencyCode: str, description: str, id: str, metadata: map, migratedAccountCode: str, platformPaymentConfiguration: map{salesDayClosingTime: str(time), settlementDelayDays: int(int32)}, reference: str, status: str, timeZone: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"accountHolderId":"AH32272223222C5GXTD343TKP","description":"S.Hopper - Main balance account"}

@endpoint GET /balanceAccounts/{balanceAccountId}/sweeps
@desc Get all sweeps for a balance account
@required {balanceAccountId: str # The unique identifier of the balance account.}
@optional {offset: int(int32) # The number of items that you want to skip., limit: int(int32) # The number of items returned per page, maximum 100 items. By default, the response returns 10 items per page.}
@returns(200) {hasNext: bool, hasPrevious: bool, sweeps: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint POST /balanceAccounts/{balanceAccountId}/sweeps
@desc Create a sweep
@required {balanceAccountId: str # The unique identifier of the balance account., counterparty: map{balanceAccountId: str, merchantAccount: str, transferInstrumentId: str}, currency: str # The three-character [ISO currency code](https://docs.adyen.com/development-resources/currency-codes) in uppercase. For example, **EUR**.  The sweep currency must match any of the [balances currencies](https://docs.adyen.com/api-explorer/#/balanceplatform/latest/get/balanceAccounts/{id}__resParam_balances)., schedule: map{cronExpression: str, type!: str}}
@optional {category: str(bank/internal/platformPayment) # The type of transfer that results from the sweep.  Possible values:   - **bank**: Sweep to a [transfer instrument](https://docs.adyen.com/api-explorer/#/legalentity/latest/post/transferInstruments__resParam_id).  - **internal**: Transfer to another [balance account](https://docs.adyen.com/api-explorer/#/balanceplatform/latest/post/balanceAccounts__resParam_id) within your platform.  Required when setting `priorities`., description: str # The message that will be used in the sweep transfer's description body with a maximum length of 140 characters.  If the message is longer after replacing placeholders, the message will be cut off at 140 characters., priorities: [str] # The list of priorities for the bank transfer. This sets the speed at which the transfer is sent and the fees that you have to pay. You can provide multiple priorities, ordered by your preference. Adyen will try to pay out using the priorities in the given order. If the first priority is not currently supported or enabled for your platform, the system will try the next one, and so on.  The request will be accepted as long as **at least one** of the provided priorities is valid (i.e., supported by Adyen and activated for your platform). For example, if you provide `["wire","regular"]`, and `wire` is not supported but `regular` is, the request will still be accepted and processed.  Possible values:  * **regular**: For normal, low-value transactions.  * **fast**: A faster way to transfer funds, but the fees are higher. Recommended for high-priority, low-value transactions.  * **wire**: The fastest way to transfer funds, but this has the highest fees. Recommended for high-priority, high-value transactions.  * **instant**: For instant funds transfers within the United States and in [SEPA locations](https://www.ecb.europa.eu/paym/integration/retail/sepa/html/index.en.html).  * **crossBorder**: For high-value transfers to a recipient in a different country.  * **internal**: For transfers to an Adyen-issued business bank account (by bank account number/IBAN).  Set `category` to **bank**. For more details, see optional priorities setup for [marketplaces](https://docs.adyen.com/marketplaces/payout-to-users/scheduled-payouts#optional-priorities-setup) or [platforms](https://docs.adyen.com/platforms/payout-to-users/scheduled-payouts#optional-priorities-setup)., reason: str(accountHierarchyNotActive/amountLimitExceeded/approved/counterpartyAccountBlocked/counterpartyAccountClosed/counterpartyAccountNotFound/counterpartyAddressRequired/counterpartyBankTimedOut/counterpartyBankUnavailable/directDebitNotSupported/error/notEnoughBalance/refusedByCounterpartyBank/routeNotFound/transferInstrumentDoesNotExist/unknown) # The reason for disabling the sweep., reasonDetail: str # The human readable reason for disabling the sweep., reference: str # Your reference for the sweep configuration., referenceForBeneficiary: str # The reference sent to or received from the counterparty. Only alphanumeric characters are allowed., status: str(active/inactive) # The status of the sweep. If not provided, by default, this is set to **active**.  Possible values:    * **active**:  the sweep is enabled and funds will be pulled in or pushed out based on the defined configuration.    * **inactive**: the sweep is disabled and cannot be triggered., sweepAmount: map{currency!: str, value!: int(int64)}, targetAmount: map{currency!: str, value!: int(int64)}, triggerAmount: map{currency!: str, value!: int(int64)}, type: str(pull/push)=push # The direction of sweep, whether pushing out or pulling in funds to the balance account. If not provided, by default, this is set to **push**.  Possible values:   * **push**: _push out funds_ to a destination balance account or transfer instrument.   * **pull**: _pull in funds_ from a source merchant account, transfer instrument, or balance account.}
@returns(200) {category: str, counterparty: map{balanceAccountId: str, merchantAccount: str, transferInstrumentId: str}, currency: str, description: str, id: str, priorities: [str], reason: str, reasonDetail: str, reference: str, referenceForBeneficiary: str, schedule: map{cronExpression: str, type: str}, status: str, sweepAmount: map{currency: str, value: int(int64)}, targetAmount: map{currency: str, value: int(int64)}, triggerAmount: map{currency: str, value: int(int64)}, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"counterparty":{"merchantAccount":"YOUR_MERCHANT_ACCOUNT"},"triggerAmount":{"currency":"EUR","value":50000},"currency":"EUR","schedule":{"type":"balance"},"type":"pull","status":"active"}

@endpoint GET /balanceAccounts/{balanceAccountId}/sweeps/{sweepId}
@desc Get a sweep
@required {balanceAccountId: str # The unique identifier of the balance account., sweepId: str # The unique identifier of the sweep.}
@returns(200) {category: str, counterparty: map{balanceAccountId: str, merchantAccount: str, transferInstrumentId: str}, currency: str, description: str, id: str, priorities: [str], reason: str, reasonDetail: str, reference: str, referenceForBeneficiary: str, schedule: map{cronExpression: str, type: str}, status: str, sweepAmount: map{currency: str, value: int(int64)}, targetAmount: map{currency: str, value: int(int64)}, triggerAmount: map{currency: str, value: int(int64)}, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint DELETE /balanceAccounts/{balanceAccountId}/sweeps/{sweepId}
@desc Delete a sweep
@required {balanceAccountId: str # The unique identifier of the balance account., sweepId: str # The unique identifier of the sweep.}
@returns(204) No Content - look at the actual response code for the status of the request.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint PATCH /balanceAccounts/{balanceAccountId}/sweeps/{sweepId}
@desc Update a sweep
@required {balanceAccountId: str # The unique identifier of the balance account., sweepId: str # The unique identifier of the sweep.}
@optional {category: str(bank/internal/platformPayment) # The type of transfer that results from the sweep.  Possible values:   - **bank**: Sweep to a [transfer instrument](https://docs.adyen.com/api-explorer/#/legalentity/latest/post/transferInstruments__resParam_id).  - **internal**: Transfer to another [balance account](https://docs.adyen.com/api-explorer/#/balanceplatform/latest/post/balanceAccounts__resParam_id) within your platform.  Required when setting `priorities`., counterparty: map{balanceAccountId: str, merchantAccount: str, transferInstrumentId: str}, currency: str # The three-character [ISO currency code](https://docs.adyen.com/development-resources/currency-codes) in uppercase. For example, **EUR**.  The sweep currency must match any of the [balances currencies](https://docs.adyen.com/api-explorer/#/balanceplatform/latest/get/balanceAccounts/{id}__resParam_balances)., description: str # The message that will be used in the sweep transfer's description body with a maximum length of 140 characters.  If the message is longer after replacing placeholders, the message will be cut off at 140 characters., id: str # The unique identifier of the sweep., priorities: [str] # The list of priorities for the bank transfer. This sets the speed at which the transfer is sent and the fees that you have to pay. You can provide multiple priorities, ordered by your preference. Adyen will try to pay out using the priorities in the given order. If the first priority is not currently supported or enabled for your platform, the system will try the next one, and so on.  The request will be accepted as long as **at least one** of the provided priorities is valid (i.e., supported by Adyen and activated for your platform). For example, if you provide `["wire","regular"]`, and `wire` is not supported but `regular` is, the request will still be accepted and processed.  Possible values:  * **regular**: For normal, low-value transactions.  * **fast**: A faster way to transfer funds, but the fees are higher. Recommended for high-priority, low-value transactions.  * **wire**: The fastest way to transfer funds, but this has the highest fees. Recommended for high-priority, high-value transactions.  * **instant**: For instant funds transfers within the United States and in [SEPA locations](https://www.ecb.europa.eu/paym/integration/retail/sepa/html/index.en.html).  * **crossBorder**: For high-value transfers to a recipient in a different country.  * **internal**: For transfers to an Adyen-issued business bank account (by bank account number/IBAN).  Set `category` to **bank**. For more details, see optional priorities setup for [marketplaces](https://docs.adyen.com/marketplaces/payout-to-users/scheduled-payouts#optional-priorities-setup) or [platforms](https://docs.adyen.com/platforms/payout-to-users/scheduled-payouts#optional-priorities-setup)., reason: str(accountHierarchyNotActive/amountLimitExceeded/approved/counterpartyAccountBlocked/counterpartyAccountClosed/counterpartyAccountNotFound/counterpartyAddressRequired/counterpartyBankTimedOut/counterpartyBankUnavailable/directDebitNotSupported/error/notEnoughBalance/refusedByCounterpartyBank/routeNotFound/transferInstrumentDoesNotExist/unknown) # The reason for disabling the sweep., reasonDetail: str # The human readable reason for disabling the sweep., reference: str # Your reference for the sweep configuration., referenceForBeneficiary: str # The reference sent to or received from the counterparty. Only alphanumeric characters are allowed., schedule: map{cronExpression: str, type!: str}, status: str(active/inactive) # The status of the sweep. If not provided, by default, this is set to **active**.  Possible values:    * **active**:  the sweep is enabled and funds will be pulled in or pushed out based on the defined configuration.    * **inactive**: the sweep is disabled and cannot be triggered., sweepAmount: map{currency!: str, value!: int(int64)}, targetAmount: map{currency!: str, value!: int(int64)}, triggerAmount: map{currency!: str, value!: int(int64)}, type: str(pull/push)=push # The direction of sweep, whether pushing out or pulling in funds to the balance account. If not provided, by default, this is set to **push**.  Possible values:   * **push**: _push out funds_ to a destination balance account or transfer instrument.   * **pull**: _pull in funds_ from a source merchant account, transfer instrument, or balance account.}
@returns(200) {category: str, counterparty: map{balanceAccountId: str, merchantAccount: str, transferInstrumentId: str}, currency: str, description: str, id: str, priorities: [str], reason: str, reasonDetail: str, reference: str, referenceForBeneficiary: str, schedule: map{cronExpression: str, type: str}, status: str, sweepAmount: map{currency: str, value: int(int64)}, targetAmount: map{currency: str, value: int(int64)}, triggerAmount: map{currency: str, value: int(int64)}, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"status":"inactive"}

@endpoint GET /balanceAccounts/{id}
@desc Get a balance account
@required {id: str # The unique identifier of the balance account.}
@returns(200) {accountHolderId: str, balances: [map], defaultCurrencyCode: str, description: str, id: str, metadata: map, migratedAccountCode: str, platformPaymentConfiguration: map{salesDayClosingTime: str(time), settlementDelayDays: int(int32)}, reference: str, status: str, timeZone: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint PATCH /balanceAccounts/{id}
@desc Update a balance account
@required {id: str # The unique identifier of the balance account.}
@optional {accountHolderId: str # The unique identifier of the [account holder](https://docs.adyen.com/api-explorer/balanceplatform/latest/post/accountHolders#responses-200-id) associated with the balance account., description: str # A human-readable description of the balance account. You can use this parameter to distinguish between multiple balance accounts under an account holder., metadata: map # A set of key and value pairs for general use. The keys do not have specific names and may be used for storing miscellaneous data as desired. > Note that during an update of metadata, the omission of existing key-value pairs will result in the deletion of those key-value pairs., platformPaymentConfiguration: map{salesDayClosingTime: str(time), settlementDelayDays: int(int32)}, reference: str # Your reference to the balance account., status: str(active/closed/inactive/suspended) # The status of the balance account. Payment instruments linked to the balance account can only be used if the balance account status is **active**.  Possible values: **active**, **closed**, **suspended**., timeZone: str # The time zone of the balance account. For example, **Europe/Amsterdam**. Defaults to the time zone of the account holder if no time zone is set. For possible values, see the [list of time zone codes](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).}
@returns(200) {accountHolderId: str, balances: [map], defaultCurrencyCode: str, description: str, id: str, metadata: map, migratedAccountCode: str, platformPaymentConfiguration: map{salesDayClosingTime: str(time), settlementDelayDays: int(int32)}, reference: str, status: str, timeZone: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"timeZone":"Europe/Amsterdam"}

@endpoint GET /balanceAccounts/{id}/paymentInstruments
@desc Get payment instruments linked to a balance account
@required {id: str # The unique identifier of the balance account.}
@optional {offset: int(int32) # The number of items that you want to skip., limit: int(int32) # The number of items returned per page, maximum 100 items. By default, the response returns 10 items per page., status: str # The status of the payment instruments that you want to get. By default, the response includes payment instruments with any status.}
@returns(200) {hasNext: bool, hasPrevious: bool, paymentInstruments: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /balanceAccounts/{id}/transactionRules
@desc Get all transaction rules for a balance account
@required {id: str # The unique identifier of the balance account.}
@returns(200) {transactionRules: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group balancePlatforms
@endpoint GET /balancePlatforms/{id}
@desc Get a balance platform
@required {id: str # The unique identifier of the balance platform.}
@returns(200) {description: str, id: str, status: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /balancePlatforms/{id}/accountHolders
@desc Get all account holders under a balance platform
@required {id: str # The unique identifier of the balance platform.}
@optional {offset: int(int32) # The number of items that you want to skip., limit: int(int32) # The number of items returned per page, maximum 100 items. By default, the response returns 10 items per page.}
@returns(200) {accountHolders: [map], hasNext: bool, hasPrevious: bool} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /balancePlatforms/{id}/transactionRules
@desc Get all transaction rules for a balance platform
@required {id: str # The unique identifier of the balance platform.}
@returns(200) {transactionRules: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group cardorders
@endpoint GET /cardorders
@desc Get a list of card orders
@optional {id: str # The unique identifier of the card order., cardManufacturingProfileId: str # The unique identifier of the card manufacturer profile., status: str # The status of the card order., txVariantCode: str # The unique code of the card manufacturer profile.  Possible values: **mcmaestro**, **mc**, **visa**, **mcdebit**., createdSince: str(date-time) # Only include card orders that have been created on or after this point in time. The value must be in ISO 8601 format. For example, **2021-05-30T15:07:40Z**., createdUntil: str(date-time) # Only include card orders that have been created on or before this point in time. The value must be in ISO 8601 format. For example, **2021-05-30T15:07:40Z**., lockedSince: str(date-time) # Only include card orders that have been locked on or after this point in time. The value must be in ISO 8601 format. For example, **2021-05-30T15:07:40Z**., lockedUntil: str(date-time) # Only include card orders that have been locked on or before this point in time. The value must be in ISO 8601 format. For example, **2021-05-30T15:07:40Z**., serviceCenter: str # The service center at which the card is issued. The value is case-sensitive., offset: int(int32) # Specifies the position of an element in a list of card orders. The response includes a list of card orders that starts at the specified offset.  **Default:** 0, which means that the response contains all the elements in the list of card orders., limit: int(int32) # The number of card orders returned per page. **Default:** 10.}
@returns(200) {cardOrders: [map], hasNext: bool, hasPrevious: bool} # OK - the request has succeeded.
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /cardorders/{id}/items
@desc Get card order items
@required {id: str # The unique identifier of the card order.}
@optional {offset: int(int32) # Specifies the position of an element in a list of card orders. The response includes a list of card order items that starts at the specified offset.  **Default:** 0, which means that the response contains all the elements in the list of card order items., limit: int(int32) # The number of card order items returned per page. **Default:** 10.}
@returns(200) {data: [map], hasNext: bool, hasPrevious: bool} # OK - the request has succeeded.
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group grantAccounts
@endpoint GET /grantAccounts/{id}
@desc Get a grant account
@required {id: str # The unique identifier of the grant account.}
@returns(200) {balances: [map], fundingBalanceAccountId: str, id: str, limits: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group grantOffers
@endpoint GET /grantOffers
@desc Get all available grant offers
@required {accountHolderId: str # The unique identifier of the grant account.}
@returns(200) {grantOffers: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /grantOffers/{grantOfferId}
@desc Get a grant offer
@required {grantOfferId: str # The unique identifier of the grant offer.}
@returns(200) {accountHolderId: str, amount: map{currency: str, value: int(int64)}, contractType: str, expiresAt: str(date-time), fee: map{amount: map{currency: str, value: int(int64)}}, id: str, repayment: map{basisPoints: int(int32), term: map{estimatedDays: int(int32), maximumDays: int(int32)}, threshold: map{amount: map{currency: str, value: int(int64)}}}, startsAt: str(date-time)} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group networkTokens
@endpoint GET /networkTokens/{networkTokenId}
@desc Get a network token
@required {networkTokenId: str # The unique identifier of the network token.}
@returns(200) {token: map{brandVariant: str, creationDate: str(date-time), device: map{formFactor: str, osName: str, phone: map{hashedNumber: str, lastFourDigits: str, number: str}}, id: str, paymentInstrumentId: str, status: str, tokenLastFour: str, tokenRequestor: map{id: str, name: str}, type: str}} # OK - the request has succeeded.
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint PATCH /networkTokens/{networkTokenId}
@desc Update a network token
@required {networkTokenId: str # The unique identifier of the network token.}
@optional {status: str(active/suspended/closed) # The new status of the network token. Possible values: **active**, **suspended**, **closed**. The **closed** status is final and cannot be changed.}
@returns(202) No Content - look at the actual response code for the status of the request.
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group paymentInstrumentGroups
@endpoint POST /paymentInstrumentGroups
@desc Create a payment instrument group
@required {balancePlatform: str # The unique identifier of the [balance platform](https://docs.adyen.com/api-explorer/#/balanceplatform/latest/get/balancePlatforms/{id}__queryParam_id) to which the payment instrument group belongs., txVariant: str # The tx variant of the payment instrument group.}
@optional {description: str # Your description for the payment instrument group., properties: map # Properties of the payment instrument group., reference: str # Your reference for the payment instrument group.}
@returns(200) {balancePlatform: str, description: str, id: str, properties: map, reference: str, txVariant: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"balancePlatform":"YOUR_BALANCE_PLATFORM","txVariant":"mc"}

@endpoint GET /paymentInstrumentGroups/{id}
@desc Get a payment instrument group
@required {id: str # The unique identifier of the payment instrument group.}
@returns(200) {balancePlatform: str, description: str, id: str, properties: map, reference: str, txVariant: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /paymentInstrumentGroups/{id}/transactionRules
@desc Get all transaction rules for a payment instrument group
@required {id: str # The unique identifier of the payment instrument group.}
@returns(200) {transactionRules: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group paymentInstruments
@endpoint POST /paymentInstruments
@desc Create a payment instrument
@required {balanceAccountId: str # The unique identifier of the [balance account](https://docs.adyen.com/api-explorer/#/balanceplatform/v1/post/balanceAccounts__resParam_id) associated with the payment instrument., issuingCountryCode: str # The two-character [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) country code where the payment instrument is issued. For example, **NL** or **US**., type: str(bankAccount/card) # The type of payment instrument.  Possible values: **card**, **bankAccount**.}
@optional {bankAccount: map{formFactor: str}, card: map{authentication: map, brand!: str, brandVariant!: str, cardholderName!: str, configuration: map, deliveryContact: map, formFactor!: str, threeDSecure: str, usage: str}, description: str # Your description for the payment instrument, maximum 300 characters., paymentInstrumentGroupId: str # The unique identifier of the [payment instrument group](https://docs.adyen.com/api-explorer/#/balanceplatform/v1/post/paymentInstrumentGroups__resParam_id) to which the payment instrument belongs., reference: str # Your reference for the payment instrument, maximum 150 characters., status: str(active/closed/inactive/suspended) # The status of the payment instrument. If a status is not specified when creating a payment instrument, it is set to **active** by default. However, there can be exceptions for cards based on the `card.formFactor` and the `issuingCountryCode`. For example, when issuing physical cards in the US, the default status is **inactive**.  Possible values:    * **active**:  The payment instrument is active and can be used to make payments.    * **inactive**: The payment instrument is inactive and cannot be used to make payments.    * **suspended**: The payment instrument is suspended, either because it was stolen or lost.    * **closed**: The payment instrument is permanently closed. This action cannot be undone., statusComment: str # The status comment provides additional information for the statusReason of the payment instrument., statusReason: str(accountClosure/damaged/endOfLife/expired/lost/other/stolen/suspectedFraud/transactionRule) # The reason for the status of the payment instrument.  Possible values: **accountClosure**, **damaged**, **endOfLife**, **expired**, **lost**, **stolen**, **suspectedFraud**, **transactionRule**, **other**. If the reason is **other**, you must also send the `statusComment` parameter describing the status change.}
@returns(200) {additionalBankAccountIdentifications: [any], balanceAccountId: str, bankAccount: map{accountNumber: str, accountType: str, branchNumber: str, formFactor: str, iban: str, routingNumber: str, sortCode: str, type: str}, card: map{authentication: map{email: str, password: str, phone: map{number: str, type: str}}, bin: str, brand: str, brandVariant: str, cardholderName: str, configuration: map{activation: str, activationUrl: str, bulkAddress: map{city: str, company: str, country: str, email: str, houseNumberOrName: str, line1: str, line2: str, line3: str, mobile: str, name: str, postalCode: str, stateOrProvince: str, street: str}, cardImageId: str, carrier: str, carrierImageId: str, configurationProfileId: str, currency: str, envelope: str, insert: str, language: str, logoImageId: str, pinMailer: str, shipmentMethod: str}, cvc: str, deliveryContact: map{address: map{city: str, country: str, line1: str, line2: str, line3: str, postalCode: str, stateOrProvince: str}, company: str, email: str, fullPhoneNumber: str, name: map{firstName: str, lastName: str}, phoneNumber: map{phoneCountryCode: str, phoneNumber: str, phoneType: str}, webAddress: str}, expiration: map{month: str, year: str}, formFactor: str, lastFour: str, number: str, threeDSecure: str, usage: str}, description: str, id: str, issuingCountryCode: str, paymentInstrumentGroupId: str, reference: str, replacedById: str, replacementOfId: str, status: str, statusComment: str, statusReason: str, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"type":"bankAccount","description":"YOUR_DESCRIPTION","balanceAccountId":"BA3227C223222B5CTBLR8BWJB","issuingCountryCode":"NL"}

@endpoint POST /paymentInstruments/reveal
@desc Reveal the data of a payment instrument
@required {encryptedKey: str # The symmetric session key that you encrypted with the [public key](https://docs.adyen.com/api-explorer/balanceplatform/2/get/publicKey) that you received from Adyen., paymentInstrumentId: str # The unique identifier of the payment instrument, which is the card for which you are managing the PIN.}
@returns(200) {encryptedData: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /paymentInstruments/{id}
@desc Get a payment instrument
@required {id: str # The unique identifier of the payment instrument.}
@returns(200) {additionalBankAccountIdentifications: [any], balanceAccountId: str, bankAccount: map{accountNumber: str, accountType: str, branchNumber: str, formFactor: str, iban: str, routingNumber: str, sortCode: str, type: str}, card: map{authentication: map{email: str, password: str, phone: map{number: str, type: str}}, bin: str, brand: str, brandVariant: str, cardholderName: str, configuration: map{activation: str, activationUrl: str, bulkAddress: map{city: str, company: str, country: str, email: str, houseNumberOrName: str, line1: str, line2: str, line3: str, mobile: str, name: str, postalCode: str, stateOrProvince: str, street: str}, cardImageId: str, carrier: str, carrierImageId: str, configurationProfileId: str, currency: str, envelope: str, insert: str, language: str, logoImageId: str, pinMailer: str, shipmentMethod: str}, cvc: str, deliveryContact: map{address: map{city: str, country: str, line1: str, line2: str, line3: str, postalCode: str, stateOrProvince: str}, company: str, email: str, fullPhoneNumber: str, name: map{firstName: str, lastName: str}, phoneNumber: map{phoneCountryCode: str, phoneNumber: str, phoneType: str}, webAddress: str}, expiration: map{month: str, year: str}, formFactor: str, lastFour: str, number: str, threeDSecure: str, usage: str}, description: str, id: str, issuingCountryCode: str, paymentInstrumentGroupId: str, reference: str, replacedById: str, replacementOfId: str, status: str, statusComment: str, statusReason: str, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint PATCH /paymentInstruments/{id}
@desc Update a payment instrument
@required {id: str # The unique identifier of the payment instrument.}
@optional {balanceAccountId: str # The unique identifier of the balance account associated with this payment instrument. >You can only change the balance account ID if the payment instrument has **inactive** status., card: map{authentication: map, brand!: str, brandVariant!: str, cardholderName!: str, configuration: map, deliveryContact: map, formFactor!: str, threeDSecure: str, usage: str}, status: str(active/closed/inactive/suspended) # The status of the payment instrument. If a status is not specified when creating a payment instrument, it is set to **active** by default. However, there can be exceptions for cards based on the `card.formFactor` and the `issuingCountryCode`. For example, when issuing physical cards in the US, the default status is **inactive**.  Possible values:    * **active**:  The payment instrument is active and can be used to make payments.    * **inactive**: The payment instrument is inactive and cannot be used to make payments.    * **suspended**: The payment instrument is suspended, either because it was stolen or lost.    * **closed**: The payment instrument is permanently closed. This action cannot be undone., statusComment: str # Comment for the status of the payment instrument.  Required if `statusReason` is **other**., statusReason: str(accountClosure/damaged/endOfLife/expired/lost/other/stolen/suspectedFraud/transactionRule) # The reason for updating the status of the payment instrument.  Possible values: **lost**, **stolen**, **damaged**, **suspectedFraud**, **expired**, **endOfLife**, **accountClosure**, **other**. If the reason is **other**, you must also send the `statusComment` parameter describing the status change.}
@returns(200) {additionalBankAccountIdentifications: [any], balanceAccountId: str, bankAccount: map{accountNumber: str, accountType: str, branchNumber: str, formFactor: str, iban: str, routingNumber: str, sortCode: str, type: str}, card: map{authentication: map{email: str, password: str, phone: map{number: str, type: str}}, bin: str, brand: str, brandVariant: str, cardholderName: str, configuration: map{activation: str, activationUrl: str, bulkAddress: map{city: str, company: str, country: str, email: str, houseNumberOrName: str, line1: str, line2: str, line3: str, mobile: str, name: str, postalCode: str, stateOrProvince: str, street: str}, cardImageId: str, carrier: str, carrierImageId: str, configurationProfileId: str, currency: str, envelope: str, insert: str, language: str, logoImageId: str, pinMailer: str, shipmentMethod: str}, cvc: str, deliveryContact: map{address: map{city: str, country: str, line1: str, line2: str, line3: str, postalCode: str, stateOrProvince: str}, company: str, email: str, fullPhoneNumber: str, name: map{firstName: str, lastName: str}, phoneNumber: map{phoneCountryCode: str, phoneNumber: str, phoneType: str}, webAddress: str}, expiration: map{month: str, year: str}, formFactor: str, lastFour: str, number: str, threeDSecure: str, usage: str}, description: str, id: str, issuingCountryCode: str, paymentInstrumentGroupId: str, reference: str, replacedById: str, replacementOfId: str, status: str, statusComment: str, statusReason: str, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"balanceAccountId":"BA32272223222B5CM82WL892M"}

@endpoint GET /paymentInstruments/{id}/networkTokenActivationData
@desc Get network token activation data
@required {id: str # The unique identifier of the payment instrument.}
@returns(200) {sdkInput: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint POST /paymentInstruments/{id}/networkTokenActivationData
@desc Create network token provisioning data
@required {id: str # The unique identifier of the payment instrument.}
@optional {sdkOutput: str # A block of data automatically generated by Adyen's SDK for network token provisioning. This `sdkOutput` is required to create provisioning data for the network token.  For more information, see the repositories for Adyen's SDKs for network token provisioning: * [Adyen Apple Pay Provisioning SDK](https://github.com/Adyen/adyen-apple-pay-provisioning-ios). * [Adyen Google Wallet Provisioning SDK](https://github.com/Adyen/adyen-issuing-android)}
@returns(200) {sdkInput: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /paymentInstruments/{id}/networkTokens
@desc List network tokens
@required {id: str # The unique identifier of the payment instrument.}
@returns(200) {networkTokens: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /paymentInstruments/{id}/reveal
@desc Get the PAN of a payment instrument
@required {id: str # The unique identifier of the payment instrument.}
@returns(200) {cvc: str, expiration: map{month: str, year: str}, pan: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /paymentInstruments/{id}/transactionRules
@desc Get all transaction rules for a payment instrument
@required {id: str # The unique identifier of the payment instrument.}
@returns(200) {transactionRules: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group pins
@endpoint POST /pins/change
@desc Change a card PIN
@required {encryptedKey: str # The symmetric session key that you encrypted with the [public key](https://docs.adyen.com/api-explorer/balanceplatform/2/get/publicKey) that you received from Adyen., encryptedPinBlock: str # The encrypted [PIN block](https://www.pcisecuritystandards.org/glossary/pin-block)., paymentInstrumentId: str # The unique identifier of the payment instrument, which is the card for which you are managing the PIN., token: str # The 16-digit token that you used to generate the `encryptedPinBlock`.}
@returns(200) {status: str} # OK - the request has succeeded.
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"paymentInstrumentId":"PI6789678967896789","encryptedKey":"75989E8881284D10153ABACF022EEA09F5...","encryptedPinBlock":"63E5060591EF65F48DD1D4FECD0FECD5","token":"5555341244441115"}

@endpoint POST /pins/reveal
@desc Reveal a card PIN
@required {encryptedKey: str # The symmetric session key that you encrypted with the [public key](https://docs.adyen.com/api-explorer/balanceplatform/2/get/publicKey) that you received from Adyen., paymentInstrumentId: str # The unique identifier of the payment instrument, which is the card for which you are managing the PIN.}
@returns(200) {encryptedPinBlock: str, token: str} # OK - the request has succeeded.
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"paymentInstrumentId":"PI3227C223222B5BPCMFXD2XG","encryptedKey":"75989E8881284D10153ABACF022EEA09F5..."}

@endgroup

@group publicKey
@endpoint GET /publicKey
@desc Get an RSA public key
@optional {purpose: str # The purpose of the public key.  Possible values: **pinChange**, **pinReveal**, **panReveal**.  Default value: **pinReveal**., format: str # The encoding format of public key.  Possible values: **jwk**, **pem**.  Default value: **pem**.}
@returns(200) {publicKey: str, publicKeyExpiryDate: str} # OK - the request has succeeded.
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group registeredDevices
@endpoint GET /registeredDevices
@desc Get a list of registered SCA devices
@required {paymentInstrumentId: str # The unique identifier of a payment instrument. It limits the returned list to SCA devices associated to this payment instrument.}
@optional {pageNumber: int(int32) # The index of the page to retrieve. The index of the first page is 0 (zero).  Default: 0., pageSize: int(int32) # The number of items to have on a page.  Default: 20. Maximum: 100.}
@returns(200) {data: [map], itemsTotal: int(int32), link: map{first: map{href: str}, last: map{href: str}, next: map{href: str}, previous: map{href: str}, self: map{href: str}}, pagesTotal: int(int32)} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint POST /registeredDevices
@desc Initiate the registration of an SCA device
@required {paymentInstrumentId: str # The unique identifier of the payment instrument for which you are registering the SCA device., strongCustomerAuthentication: map{sdkOutput!: str}}
@optional {name: str # The name of the SCA device that you are registering. You can use it to help your users identify the device.  If you do not specify a `name`, Adyen automatically generates one.}
@returns(200) {id: str, paymentInstrumentId: str, sdkInput: str, success: bool} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint POST /registeredDevices/{deviceId}/associations
@desc Initiate an association between an SCA device and a resource
@required {deviceId: str # The unique identifier of the SCA device that you are associating with a resource., ids: [str] # The list of unique identifiers of the resources that you are associating with the SCA device.  Maximum: 5 strings., type: str # The type of resource that you are associating with the SCA device.  Possible value: **PaymentInstrument**}
@returns(200) {sdkInput: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint PATCH /registeredDevices/{deviceId}/associations
@desc Complete an association between an SCA device and a resource
@required {deviceId: str # The unique identifier of the SCA device that you are associating with a resource., ids: [str] # The list of unique identifiers of the resources that you are associating with the SCA device.  Maximum: 5 strings., strongCustomerAuthentication: map{sdkOutput!: str}, type: str # The type of resource that you are associating with the SCA device.  Possible value: **PaymentInstrument**}
@returns(200) {deviceId: str, ids: [str], type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint DELETE /registeredDevices/{id}
@desc Delete a registration of an SCA device
@required {id: str # The unique identifier of the SCA device., paymentInstrumentId: str # The unique identifier of the payment instrument linked to the SCA device.}
@returns(204) No Content - look at the actual response code for the status of the request.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint PATCH /registeredDevices/{id}
@desc Complete the registration of an SCA device
@required {id: str # The unique identifier of the SCA device. You obtain this `id` in the response of a POST [/registeredDevices](https://docs.adyen.com/api-explorer/balanceplatform/2/post/registeredDevices#responses-200-id) request., paymentInstrumentId: str # The unique identifier of the payment instrument for which you are registering the SCA device., strongCustomerAuthentication: map{sdkOutput!: str}}
@optional {name: str # The name of the SCA device that you are registering. You can use it to help your users identify the device.  If you do not specify a `name`, Adyen automatically generates one.}
@returns(200) {success: bool} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group transactionRules
@endpoint POST /transactionRules
@desc Create a transaction rule
@required {description: str # Your description for the transaction rule., entityKey: map{entityReference: str, entityType: str}, interval: map{dayOfMonth: int(int32), dayOfWeek: str, duration: map, timeOfDay: str, timeZone: str, type!: str}, reference: str # Your reference for the transaction rule., ruleRestrictions: map{activeNetworkTokens: map, brandVariants: map, counterpartyBank: map, counterpartyTypes: map, countries: map, dayOfWeek: map, differentCurrencies: map, entryModes: map, internationalTransaction: map, matchingTransactions: map, matchingValues: map, mccs: map, merchantNames: map, merchants: map, processingTypes: map, riskScores: map, sameAmountRestriction: map, sameCounterpartyRestriction: map, sourceAccountTypes: map, timeOfDay: map, tokenRequestors: map, totalAmount: map, walletProviderAccountScore: map, walletProviderDeviceScore: map, walletProviderDeviceType: map}, type: str(allowList/blockList/maxUsage/velocity) # The [type of rule](https://docs.adyen.com/issuing/transaction-rules#rule-types), which defines if a rule blocks transactions based on individual characteristics or accumulates data.  Possible values:  * **blockList**: decline a transaction when the conditions are met.  * **maxUsage**: add the amount or number of transactions for the lifetime of a payment instrument, and then decline a transaction when the specified limits are met.  * **velocity**: add the amount or number of transactions based on a specified time interval, and then decline a transaction when the specified limits are met.}
@optional {aggregationLevel: str # The level at which data must be accumulated, used in rules with `type` **velocity** or **maxUsage**. The level must be the [same or lower in hierarchy](https://docs.adyen.com/issuing/transaction-rules#accumulate-data) than the `entityKey`.  If not provided, by default, the rule will accumulate data at the **paymentInstrument** level.  Possible values: **paymentInstrument**, **paymentInstrumentGroup**, **balanceAccount**, **accountHolder**, **balancePlatform**., endDate: str # The date when the rule will stop being evaluated, in ISO 8601 extended offset date-time format. For example, **2025-03-19T10:15:30+01:00**.  If not provided, the rule will be evaluated until the rule status is set to **inactive**., outcomeType: str(enforceSCA/hardBlock/scoreBased/timedBlock) # The [outcome](https://docs.adyen.com/issuing/transaction-rules#outcome) that will be applied when a transaction meets the conditions of the rule.  Possible values: * **hardBlock** (default): the transaction is declined. * **scoreBased**: the transaction is assigned the `score` you specified. Adyen calculates the total score and if it exceeds 100, the transaction is declined. This value is not allowed when `requestType` is **bankTransfer**.  * **enforceSCA**: your user is prompted to verify their identity using [3D Secure authentication](https://docs.adyen.com/issuing/3d-secure/). If the authentication fails or times out, the transaction is declined. This value is only allowed when `requestType` is **authentication**., purpose: str(compliance/fraud/internalPolicy/policy/system) # Specifies the reason for creating the rule.  Possible values: * **fraud**: the rule is created to regulate fraudulent activity. * **policy**: the rule is created to ensure that the transaction adheres to your business' policies. For example, if your business has policies about the Merchant Category Codes (MCCs) allowed on a transaction, you can create a rule to block transactions that have specific MCCs., requestType: str(authentication/authorization/bankTransfer/tokenization) # Indicates the type of request to which the rule applies. If not provided, by default, this is set to **authorization**.  Possible values: **authorization**, **authentication**, **tokenization**, **bankTransfer**., score: int(int32) # A positive or negative score applied to the transaction if it meets the conditions of the rule. Required when `outcomeType` is **scoreBased**.  The value must be between **-100** and **100**., startDate: str # The date when the rule will start to be evaluated, in ISO 8601 extended offset date-time format. For example, **2025-03-19T10:15:30+01:00**.  If not provided when creating a transaction rule, the `startDate` is set to the date when the rule status is set to **active**., status: str(active/inactive) # The status of the transaction rule. If you provide a `startDate` in the request, the rule is automatically created  with an **active** status.   Possible values: **active**, **inactive**.}
@returns(200) {aggregationLevel: str, description: str, endDate: str, entityKey: map{entityReference: str, entityType: str}, id: str, interval: map{dayOfMonth: int(int32), dayOfWeek: str, duration: map{unit: str, value: int(int32)}, timeOfDay: str, timeZone: str, type: str}, outcomeType: str, purpose: str, reference: str, requestType: str, ruleRestrictions: map{activeNetworkTokens: map{operation: str, value: int(int32)}, brandVariants: map{operation: str, value: [str]}, counterpartyBank: map{operation: str, value: [map]}, counterpartyTypes: map{operation: str, value: [str]}, countries: map{operation: str, value: [str]}, dayOfWeek: map{operation: str, value: [str]}, differentCurrencies: map{operation: str, value: bool}, entryModes: map{operation: str, value: [str]}, internationalTransaction: map{operation: str, value: bool}, matchingTransactions: map{operation: str, value: int(int32)}, matchingValues: map{operation: str, value: [str]}, mccs: map{operation: str, value: [str]}, merchantNames: map{operation: str, value: [map]}, merchants: map{operation: str, value: [map]}, processingTypes: map{operation: str, value: [str]}, riskScores: map{operation: str, value: map{mastercard: int(int32), visa: int(int32)}}, sameAmountRestriction: map{operation: str, value: bool}, sameCounterpartyRestriction: map{operation: str, value: bool}, sourceAccountTypes: map{operation: str, value: [str]}, timeOfDay: map{operation: str, value: map{endTime: str, startTime: str}}, tokenRequestors: map{operation: str, value: [str]}, totalAmount: map{operation: str, value: map{currency: str, value: int(int64)}}, walletProviderAccountScore: map{operation: str, value: int(int32)}, walletProviderDeviceScore: map{operation: str, value: int(int32)}, walletProviderDeviceType: map{operation: str, value: [str]}}, score: int(int32), startDate: str, status: str, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"description":"Allow only point-of-sale transactions","reference":"YOUR_REFERENCE_4F7346","entityKey":{"entityType":"paymentInstrument","entityReference":"PI3227C223222B5FG88SB8BHR"},"status":"active","interval":{"type":"perTransaction"},"ruleRestrictions":{"processingTypes":{"operation":"noneMatch","value":["pos"]}},"type":"blockList"}

@endpoint GET /transactionRules/{transactionRuleId}
@desc Get a transaction rule
@required {transactionRuleId: str # The unique identifier of the transaction rule.}
@returns(200) {transactionRule: map{aggregationLevel: str, description: str, endDate: str, entityKey: map{entityReference: str, entityType: str}, id: str, interval: map{dayOfMonth: int(int32), dayOfWeek: str, duration: map{unit: str, value: int(int32)}, timeOfDay: str, timeZone: str, type: str}, outcomeType: str, purpose: str, reference: str, requestType: str, ruleRestrictions: map{activeNetworkTokens: map{operation: str, value: int(int32)}, brandVariants: map{operation: str, value: [str]}, counterpartyBank: map{operation: str, value: [map]}, counterpartyTypes: map{operation: str, value: [str]}, countries: map{operation: str, value: [str]}, dayOfWeek: map{operation: str, value: [str]}, differentCurrencies: map{operation: str, value: bool}, entryModes: map{operation: str, value: [str]}, internationalTransaction: map{operation: str, value: bool}, matchingTransactions: map{operation: str, value: int(int32)}, matchingValues: map{operation: str, value: [str]}, mccs: map{operation: str, value: [str]}, merchantNames: map{operation: str, value: [map]}, merchants: map{operation: str, value: [map]}, processingTypes: map{operation: str, value: [str]}, riskScores: map{operation: str, value: map}, sameAmountRestriction: map{operation: str, value: bool}, sameCounterpartyRestriction: map{operation: str, value: bool}, sourceAccountTypes: map{operation: str, value: [str]}, timeOfDay: map{operation: str, value: map}, tokenRequestors: map{operation: str, value: [str]}, totalAmount: map{operation: str, value: map}, walletProviderAccountScore: map{operation: str, value: int(int32)}, walletProviderDeviceScore: map{operation: str, value: int(int32)}, walletProviderDeviceType: map{operation: str, value: [str]}}, score: int(int32), startDate: str, status: str, type: str}} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint DELETE /transactionRules/{transactionRuleId}
@desc Delete a transaction rule
@required {transactionRuleId: str # The unique identifier of the transaction rule.}
@returns(200) {aggregationLevel: str, description: str, endDate: str, entityKey: map{entityReference: str, entityType: str}, id: str, interval: map{dayOfMonth: int(int32), dayOfWeek: str, duration: map{unit: str, value: int(int32)}, timeOfDay: str, timeZone: str, type: str}, outcomeType: str, purpose: str, reference: str, requestType: str, ruleRestrictions: map{activeNetworkTokens: map{operation: str, value: int(int32)}, brandVariants: map{operation: str, value: [str]}, counterpartyBank: map{operation: str, value: [map]}, counterpartyTypes: map{operation: str, value: [str]}, countries: map{operation: str, value: [str]}, dayOfWeek: map{operation: str, value: [str]}, differentCurrencies: map{operation: str, value: bool}, entryModes: map{operation: str, value: [str]}, internationalTransaction: map{operation: str, value: bool}, matchingTransactions: map{operation: str, value: int(int32)}, matchingValues: map{operation: str, value: [str]}, mccs: map{operation: str, value: [str]}, merchantNames: map{operation: str, value: [map]}, merchants: map{operation: str, value: [map]}, processingTypes: map{operation: str, value: [str]}, riskScores: map{operation: str, value: map{mastercard: int(int32), visa: int(int32)}}, sameAmountRestriction: map{operation: str, value: bool}, sameCounterpartyRestriction: map{operation: str, value: bool}, sourceAccountTypes: map{operation: str, value: [str]}, timeOfDay: map{operation: str, value: map{endTime: str, startTime: str}}, tokenRequestors: map{operation: str, value: [str]}, totalAmount: map{operation: str, value: map{currency: str, value: int(int64)}}, walletProviderAccountScore: map{operation: str, value: int(int32)}, walletProviderDeviceScore: map{operation: str, value: int(int32)}, walletProviderDeviceType: map{operation: str, value: [str]}}, score: int(int32), startDate: str, status: str, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint PATCH /transactionRules/{transactionRuleId}
@desc Update a transaction rule
@required {transactionRuleId: str # The unique identifier of the transaction rule., description: str # Your description for the transaction rule., entityKey: map{entityReference: str, entityType: str}, interval: map{dayOfMonth: int(int32), dayOfWeek: str, duration: map, timeOfDay: str, timeZone: str, type!: str}, reference: str # Your reference for the transaction rule., ruleRestrictions: map{activeNetworkTokens: map, brandVariants: map, counterpartyBank: map, counterpartyTypes: map, countries: map, dayOfWeek: map, differentCurrencies: map, entryModes: map, internationalTransaction: map, matchingTransactions: map, matchingValues: map, mccs: map, merchantNames: map, merchants: map, processingTypes: map, riskScores: map, sameAmountRestriction: map, sameCounterpartyRestriction: map, sourceAccountTypes: map, timeOfDay: map, tokenRequestors: map, totalAmount: map, walletProviderAccountScore: map, walletProviderDeviceScore: map, walletProviderDeviceType: map}, type: str(allowList/blockList/maxUsage/velocity) # The [type of rule](https://docs.adyen.com/issuing/transaction-rules#rule-types), which defines if a rule blocks transactions based on individual characteristics or accumulates data.  Possible values:  * **blockList**: decline a transaction when the conditions are met.  * **maxUsage**: add the amount or number of transactions for the lifetime of a payment instrument, and then decline a transaction when the specified limits are met.  * **velocity**: add the amount or number of transactions based on a specified time interval, and then decline a transaction when the specified limits are met.}
@optional {aggregationLevel: str # The level at which data must be accumulated, used in rules with `type` **velocity** or **maxUsage**. The level must be the [same or lower in hierarchy](https://docs.adyen.com/issuing/transaction-rules#accumulate-data) than the `entityKey`.  If not provided, by default, the rule will accumulate data at the **paymentInstrument** level.  Possible values: **paymentInstrument**, **paymentInstrumentGroup**, **balanceAccount**, **accountHolder**, **balancePlatform**., endDate: str # The date when the rule will stop being evaluated, in ISO 8601 extended offset date-time format. For example, **2025-03-19T10:15:30+01:00**.  If not provided, the rule will be evaluated until the rule status is set to **inactive**., outcomeType: str(enforceSCA/hardBlock/scoreBased/timedBlock) # The [outcome](https://docs.adyen.com/issuing/transaction-rules#outcome) that will be applied when a transaction meets the conditions of the rule.  Possible values: * **hardBlock** (default): the transaction is declined. * **scoreBased**: the transaction is assigned the `score` you specified. Adyen calculates the total score and if it exceeds 100, the transaction is declined. This value is not allowed when `requestType` is **bankTransfer**.  * **enforceSCA**: your user is prompted to verify their identity using [3D Secure authentication](https://docs.adyen.com/issuing/3d-secure/). If the authentication fails or times out, the transaction is declined. This value is only allowed when `requestType` is **authentication**., purpose: str(compliance/fraud/internalPolicy/policy/system) # Specifies the reason for creating the rule.  Possible values: * **fraud**: the rule is created to regulate fraudulent activity. * **policy**: the rule is created to ensure that the transaction adheres to your business' policies. For example, if your business has policies about the Merchant Category Codes (MCCs) allowed on a transaction, you can create a rule to block transactions that have specific MCCs., requestType: str(authentication/authorization/bankTransfer/tokenization) # Indicates the type of request to which the rule applies. If not provided, by default, this is set to **authorization**.  Possible values: **authorization**, **authentication**, **tokenization**, **bankTransfer**., score: int(int32) # A positive or negative score applied to the transaction if it meets the conditions of the rule. Required when `outcomeType` is **scoreBased**.  The value must be between **-100** and **100**., startDate: str # The date when the rule will start to be evaluated, in ISO 8601 extended offset date-time format. For example, **2025-03-19T10:15:30+01:00**.  If not provided when creating a transaction rule, the `startDate` is set to the date when the rule status is set to **active**., status: str(active/inactive) # The status of the transaction rule. If you provide a `startDate` in the request, the rule is automatically created  with an **active** status.   Possible values: **active**, **inactive**.}
@returns(200) {aggregationLevel: str, description: str, endDate: str, entityKey: map{entityReference: str, entityType: str}, id: str, interval: map{dayOfMonth: int(int32), dayOfWeek: str, duration: map{unit: str, value: int(int32)}, timeOfDay: str, timeZone: str, type: str}, outcomeType: str, purpose: str, reference: str, requestType: str, ruleRestrictions: map{activeNetworkTokens: map{operation: str, value: int(int32)}, brandVariants: map{operation: str, value: [str]}, counterpartyBank: map{operation: str, value: [map]}, counterpartyTypes: map{operation: str, value: [str]}, countries: map{operation: str, value: [str]}, dayOfWeek: map{operation: str, value: [str]}, differentCurrencies: map{operation: str, value: bool}, entryModes: map{operation: str, value: [str]}, internationalTransaction: map{operation: str, value: bool}, matchingTransactions: map{operation: str, value: int(int32)}, matchingValues: map{operation: str, value: [str]}, mccs: map{operation: str, value: [str]}, merchantNames: map{operation: str, value: [map]}, merchants: map{operation: str, value: [map]}, processingTypes: map{operation: str, value: [str]}, riskScores: map{operation: str, value: map{mastercard: int(int32), visa: int(int32)}}, sameAmountRestriction: map{operation: str, value: bool}, sameCounterpartyRestriction: map{operation: str, value: bool}, sourceAccountTypes: map{operation: str, value: [str]}, timeOfDay: map{operation: str, value: map{endTime: str, startTime: str}}, tokenRequestors: map{operation: str, value: [str]}, totalAmount: map{operation: str, value: map{currency: str, value: int(int64)}}, walletProviderAccountScore: map{operation: str, value: int(int32)}, walletProviderDeviceScore: map{operation: str, value: int(int32)}, walletProviderDeviceType: map{operation: str, value: [str]}}, score: int(int32), startDate: str, status: str, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"description":"Allow only point-of-sale transactions","reference":"YOUR_REFERENCE_4F7346","entityKey":{"entityType":"paymentInstrument","entityReference":"PI3227C223222B5FG88SB8BHR"},"status":"inactive","interval":{"type":"weekly"},"ruleRestrictions":{"processingTypes":{"operation":"noneMatch","value":["pos"]}},"type":"blockList"}

@endgroup

@group transferRoutes
@endpoint POST /transferRoutes/calculate
@desc Calculate transfer routes
@required {balancePlatform: str # The unique identifier assigned to the balance platform associated with the account holder., category: str # The type of transfer. Possible values:    - **bank**: Transfer to a [transfer instrument](https://docs.adyen.com/api-explorer/#/legalentity/latest/post/transferInstruments__resParam_id) or a bank account., currency: str # The three-character ISO currency code of transfer. For example, **USD** or **EUR**.}
@optional {balanceAccountId: str # The unique identifier of the source [balance account](https://docs.adyen.com/api-explorer/#/balanceplatform/latest/post/balanceAccounts__resParam_id). Required if `counterparty` is **transferInstrumentId**., counterparty: map{bankAccount: map, transferInstrumentId: str}, country: str # The two-character ISO-3166-1 alpha-2 country code of the counterparty. For example, **US** or **NL**.  > Either `counterparty` or `country` field must be provided in a transfer route request., priorities: [str] # The list of priorities for the bank transfer. Priorities set the speed at which the transfer is sent and the fees that you have to pay. Multiple values can be provided. Possible values:  * **regular**: For normal, low-value transactions.  * **fast**: A faster way to transfer funds, but the fees are higher. Recommended for high-priority, low-value transactions.  * **wire**: The fastest way to transfer funds, but this has the highest fees. Recommended for high-priority, high-value transactions.  * **instant**: For instant funds transfers within the United States and in [SEPA locations](https://www.ecb.europa.eu/paym/integration/retail/sepa/html/index.en.html).  * **crossBorder**: For high-value transfers to a recipient in a different country.  * **internal**: For transfers to an Adyen-issued business bank account (by bank account number/IBAN).}
@returns(200) {transferRoutes: [map]} # OK - the request has succeeded.
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"balancePlatform":"YOUR_BALANCE_PLATFORM","currency":"USD","category":"bank","counterparty":{"bankAccount":{"accountIdentification":{"type":"iban","iban":"NL91ABNA0417164300"}}}}

@endgroup

@group validateBankAccountIdentification
@endpoint POST /validateBankAccountIdentification
@desc Validate a bank account
@required {accountIdentification: any # Bank account identification.}
@returns(200) No Content - look at the actual response code for the status of the request.
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"accountIdentification":{"type":"iban","iban":"1001001234"}}

@endgroup

@group accountHolders
@endpoint GET /accountHolders/{id}/taxFormSummary
@desc Get summary of tax forms for an account holder
@required {id: str # The unique identifier of the account holder., formType: str # The type of tax form you want a summary for. Accepted values are **US1099k** and **US1099nec**.}
@returns(200) {data: [map]} # OK - the request has succeeded.

@endgroup

@group balanceAccounts
@endpoint GET /balanceAccounts/{id}/transferLimits
@desc Filter and view the transfer limits
@required {id: str # The unique identifier of the balance account.}
@optional {scope: str # The scope to which the transfer limit applies. Possible values: * **perTransaction**: you set a maximum amount for each transfer made from the balance account or balance platform. * **perDay**: you set a maximum total amount for all transfers made from the balance account or balance platform in a day., transferType: str # The type of transfer to which the limit applies. Possible values: * **instant**: the limit applies to transfers with an **instant** priority. * **all**: the limit applies to all transfers, regardless of priority., status: str # The status of the transfer limit. Possible values:    * **active**: the limit is currently active. * **inactive**: the limit is currently inactive. * **pendingSCA**: the limit is pending until your user performs SCA. * **scheduled**: the limit is scheduled to become active at a future date.}
@returns(200) {transferLimits: [map]} # OK - The request has succeeded.
@errors {404: Not found - One of the transfer limits could not be found., 422: Unprocessable Content - A request validation error.}

@endpoint POST /balanceAccounts/{id}/transferLimits
@desc Create a transfer limit
@required {id: str # The unique identifier of the balance account., amount: map{currency!: str, value!: int(int64)}, scope: str(perDay/perTransaction) # The scope to which the transfer limit applies. Possible values: * **perTransaction**: you set a maximum amount for each transfer made from the balance account or balance platform. * **perDay**: you set a maximum total amount for all transfers made from the balance account or balance platform in a day., transferType: str(instant/all) # The type of transfer to which the limit applies. Possible values: * **instant**: the limit applies to transfers with an **instant** priority. * **all**: the limit applies to all transfers, regardless of priority.}
@optional {WWW-Authenticate: str # Header for authenticating through SCA, endsAt: str(date-time) # The date and time when the transfer limit becomes inactive. If you do not specify an end date, the limit stays active until you override it with a new limit.  Format [ISO 8601](https://www.w3.org/TR/NOTE-datetime): **YYYY-MM-DDThh:mm:ss.sssTZD**, reference: str # Your reference for the transfer limit., scaInformation: map{exemption: str, scaOnApproval: bool}, startsAt: str(date-time) # The date and time when the transfer limit becomes active. If you specify a date in the future, we will schedule a transfer limit.  Format [ISO 8601](https://www.w3.org/TR/NOTE-datetime): **YYYY-MM-DDThh:mm:ss.sssTZD**}
@returns(200) {amount: map{currency: str, value: int(int64)}, endsAt: str(date-time), id: str, limitStatus: str, reference: str, scaInformation: map{exemption: str, status: str}, scope: str, startsAt: str(date-time), transferType: str} # OK - The request has succeeded.
@errors {400: Bad Request - The input is invalid, or no registered device for SCA was found., 401: Unauthorized - Authentication required via Strong Customer Authentication (SCA). The client must resolve the provided challenge., 422: Unprocessable Content - A request validation error.}
@example_request {"amount":{"currency":"EUR","value":10000},"reference":"Your reference for the transfer limit","scaInformation":{"scaOnApproval":true},"scope":"perTransaction","startsAt":"2025-08-15T06:36:20+01:00","endsAt":"2026-08-14T00:00:00+01:00","transferType":"all"}

@endpoint POST /balanceAccounts/{id}/transferLimits/approve
@desc Approve pending transfer limits
@required {id: str # The unique identifier of the balance account., transferLimitIds: [str] # A list that includes the `transferLimitId` of all the pending transfer limits you want to approve.}
@optional {WWW-Authenticate: str # Header for authenticating using SCA.}
@returns(204) No Content - The request has succeeded.
@errors {401: Unauthorized - Authentication required via Strong Customer Authentication (SCA). The client must resolve the provided challenge., 404: Not found - One of the transfer limits could not be found., 422: Unprocessable Content - A request validation error.}
@example_request {"transferLimitIds":["TRLI00000000000000000000000001","TRLI00000000000000000000000002"]}

@endpoint GET /balanceAccounts/{id}/transferLimits/current
@desc Get all current transfer limits
@required {id: str # The unique identifier of the balance account.}
@optional {scope: str # The scope to which the transfer limit applies. Possible values: * **perTransaction**: you set a maximum amount for each transfer made from the balance account or balance platform. * **perDay**: you set a maximum total amount for all transfers made from the balance account or balance platform in a day., transferType: str # The type of transfer to which the limit applies. Possible values: * **instant**: the limit applies to transfers with an **instant** priority. * **all**: the limit applies to all transfers, regardless of priority.}
@returns(200) {transferLimits: [map]} # OK - The request has succeeded.
@errors {404: Not found - One of the transfer limits could not be found., 422: Unprocessable Content - A request validation error.}

@endpoint GET /balanceAccounts/{id}/transferLimits/{transferLimitId}
@desc Get the details of a transfer limit
@required {id: str # The unique identifier of the balance account., transferLimitId: str # The unique identifier of the transfer limit.}
@returns(200) {amount: map{currency: str, value: int(int64)}, endsAt: str(date-time), id: str, limitStatus: str, reference: str, scaInformation: map{exemption: str, status: str}, scope: str, startsAt: str(date-time), transferType: str} # OK - The request has succeeded.
@errors {404: Not found - One of the transfer limits could not be found., 422: Unprocessable Content - A request validation error.}

@endpoint DELETE /balanceAccounts/{id}/transferLimits/{transferLimitId}
@desc Delete a scheduled or pending transfer limit
@required {id: str # The unique identifier of the balance account., transferLimitId: str # The unique identifier of the transfer limit.}
@returns(204) No Content - The request has succeeded.
@errors {404: Not found - One of the transfer limits could not be found., 422: Unprocessable Content - A request validation error.}

@endgroup

@group balancePlatforms
@endpoint GET /balancePlatforms/{balancePlatformId}/webhooks/{webhookId}/settings
@desc Get all balance webhook settings
@required {balancePlatformId: str # The unique identifier of the balance platform., webhookId: str # The unique identifier of the balance webhook.}
@returns(200) {webhookSettings: [map]} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 404: Not Found - the payment was not found, 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint POST /balancePlatforms/{balancePlatformId}/webhooks/{webhookId}/settings
@desc Create a balance webhook setting
@required {balancePlatformId: str # The unique identifier of the balance platform., webhookId: str # The unique identifier of the balance webhook., currency: str # The three-character [ISO currency code](https://docs.adyen.com/development-resources/currency-codes) of the balance., status: str(active/inactive) # The status of the webhook setting. Possible values:  * **active**: You receive a balance webhook if any of the conditions in this setting are met. * **inactive**: You do not receive a balance webhook even if the conditions in this settings are met., target: map{id!: str, type!: str}, type: str # The type of the webhook you are configuring. Set to **balance**.}
@optional {conditions: [map{balanceType!: str, conditionType!: str, value!: int(int64)}] # The array of conditions a balance change must meet for Adyen to send the webhook.}
@returns(200) {currency: str, id: str, status: str, target: map{id: str, type: str}, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 404: Not Found - the payment was not found, 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"type":"balance","target":{"type":"balanceAccount","id":"BA00000000000000000LIABLE"},"currency":"USD","status":"active","conditions":[{"balanceType":"available","conditionType":"lessThan","value":500000}]}

@endpoint GET /balancePlatforms/{balancePlatformId}/webhooks/{webhookId}/settings/{settingId}
@desc Get a balance webhook setting by id
@required {balancePlatformId: str # The unique identifier of the balance platform., webhookId: str # The unique identifier of the balance webhook., settingId: str # The unique identifier of the balance webhook setting.}
@returns(200) {currency: str, id: str, status: str, target: map{id: str, type: str}, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 404: Not Found - the payment was not found, 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint DELETE /balancePlatforms/{balancePlatformId}/webhooks/{webhookId}/settings/{settingId}
@desc Delete a balance webhook setting by id
@required {balancePlatformId: str # The unique identifier of the balance platform., webhookId: str # The unique identifier of the balance webhook., settingId: str # The unique identifier of the balance webhook setting.}
@returns(204) No Content - the request has been successfully processed, but there is no additional content.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 404: Not Found - the payment was not found, 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint PATCH /balancePlatforms/{balancePlatformId}/webhooks/{webhookId}/settings/{settingId}
@desc Update a balance webhook setting by id
@required {balancePlatformId: str # The unique identifier of the balance platform., webhookId: str # The unique identifier of the balance webhook., settingId: str # The unique identifier of the balance webhook setting.}
@optional {conditions: [map{balanceType!: str, conditionType!: str, value!: int(int64)}] # The array of conditions a balance change must meet for Adyen to send the webhook., currency: str # The three-character [ISO currency code](https://docs.adyen.com/development-resources/currency-codes) of the balance., status: str(active/inactive) # The status of the webhook setting. Possible values:  * **active**: You receive a balance webhook if any of the conditions in this setting are met. * **inactive**: You do not receive a balance webhook even if the conditions in this settings are met., target: map{id: str, type: str}, type: str # The type of the webhook you are configuring. Set to **balance**.}
@returns(200) {currency: str, id: str, status: str, target: map{id: str, type: str}, type: str} # OK - the request has succeeded.
@errors {400: Bad Request - a problem reading or understanding the request., 401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 404: Not Found - the payment was not found, 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}
@example_request {"type":"balance","status":"inactive"}

@endpoint GET /balancePlatforms/{id}/transferLimits
@desc Filter and view the transfer limits
@required {id: str # The unique identifier of the balance platform.}
@optional {scope: str # The scope to which the transfer limit applies. Possible values: * **perTransaction**: you set a maximum amount for each transfer made from the balance account or balance platform. * **perDay**: you set a maximum total amount for all transfers made from the balance account or balance platform in a day., transferType: str # The type of transfer to which the limit applies. Possible values: * **instant**: the limit applies to transfers with an **instant** priority. * **all**: the limit applies to all transfers, regardless of priority., status: str # The status of the transfer limit. Possible values:    * **active**: the limit is currently active. * **inactive**: the limit is currently inactive. * **pendingSCA**: the limit is pending until your user performs SCA. * **scheduled**: the limit is scheduled to become active at a future date.}
@returns(200) {transferLimits: [map]} # OK - The request has succeeded.
@errors {404: Not found - One of the transfer limits could not be found., 422: Unprocessable Content - A request validation error.}

@endpoint POST /balancePlatforms/{id}/transferLimits
@desc Create a transfer limit
@required {id: str # The unique identifier of the balance platform., amount: map{currency!: str, value!: int(int64)}, scope: str(perDay/perTransaction) # The scope to which the transfer limit applies. Possible values: * **perTransaction**: you set a maximum amount for each transfer made from the balance account or balance platform. * **perDay**: you set a maximum total amount for all transfers made from the balance account or balance platform in a day., transferType: str(instant/all) # The type of transfer to which the limit applies. Possible values: * **instant**: the limit applies to transfers with an **instant** priority. * **all**: the limit applies to all transfers, regardless of priority.}
@optional {endsAt: str(date-time) # The date and time when the transfer limit becomes inactive. If you do not specify an end date, the limit stays active until you override it with a new limit.  Format [ISO 8601](https://www.w3.org/TR/NOTE-datetime): **YYYY-MM-DDThh:mm:ss.sssTZD**, reference: str # Your reference for the transfer limit., scaInformation: map{exemption: str, scaOnApproval: bool}, startsAt: str(date-time) # The date and time when the transfer limit becomes active. If you specify a date in the future, we will schedule a transfer limit.  Format [ISO 8601](https://www.w3.org/TR/NOTE-datetime): **YYYY-MM-DDThh:mm:ss.sssTZD**}
@returns(200) {amount: map{currency: str, value: int(int64)}, endsAt: str(date-time), id: str, limitStatus: str, reference: str, scaInformation: map{exemption: str, status: str}, scope: str, startsAt: str(date-time), transferType: str} # OK - The request has succeeded.
@errors {404: Not found - One of the transfer limits could not be found., 422: Unprocessable Content - A request validation error.}
@example_request {"amount":{"currency":"EUR","value":10000},"reference":"Your reference for the transfer limit","scaInformation":{"scaOnApproval":true},"scope":"perTransaction","startsAt":"2025-08-15T06:36:20+01:00","endsAt":"2026-08-14T00:00:00+01:00","transferType":"all"}

@endpoint GET /balancePlatforms/{id}/transferLimits/{transferLimitId}
@desc Get the details of a transfer limit
@required {id: str # The unique identifier of the balance platform., transferLimitId: str # The unique identifier of the transfer limit.}
@returns(200) {amount: map{currency: str, value: int(int64)}, endsAt: str(date-time), id: str, limitStatus: str, reference: str, scaInformation: map{exemption: str, status: str}, scope: str, startsAt: str(date-time), transferType: str} # OK - The request has succeeded.
@errors {404: Not found - One of the transfer limits could not be found., 422: Unprocessable Content - A request validation error.}

@endpoint DELETE /balancePlatforms/{id}/transferLimits/{transferLimitId}
@desc Delete a scheduled or pending transfer limit
@required {id: str # The unique identifier of the balance platform., transferLimitId: str # The unique identifier of the transfer limit.}
@returns(204) No Content - The request has succeeded.
@errors {404: Not found - One of the transfer limits could not be found., 422: Unprocessable Content - A request validation error.}

@endgroup

@group mandates
@endpoint GET /mandates
@desc Get a list of mandates
@optional {balanceAccountId: str # The unique identifier of the balance account linked to the payment instrument., paymentInstrumentId: str # The unique identifier of the payment instrument linked to the mandate., cursor: str # The pagination cursor returned in a previous GET `/mandates` request.}
@returns(200) {link: map{first: map{href: str}, last: map{href: str}, next: map{href: str}, previous: map{href: str}, self: map{href: str}}, mandates: [map]} # OK - The request has succeeded
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint GET /mandates/{mandateId}
@desc Get a specific mandate
@required {mandateId: str # The unique identifier of the mandate.}
@returns(200) {balanceAccountId: str, counterparty: map{accountHolder: map{fullName: str}, accountIdentification: map{type: str}}, createdAt: str(date-time), id: str, paymentInstrumentId: str, status: str, type: str, updatedAt: str(date-time)} # OK - The request has succeeded
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 404: The mandate was not found., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint PATCH /mandates/{mandateId}
@desc Amend a mandate
@required {mandateId: str # The unique identifier of the mandate.}
@optional {paymentInstrumentId: str # The unique identifier of the payment instrument linked to the mandate.}
@returns(202) Accepted - The request has been accepted
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 404: The mandate was not found, 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endpoint POST /mandates/{mandateId}/cancel
@desc Cancel a mandate
@required {mandateId: str # The unique identifier of the mandate.}
@returns(202) Accepted - The request has been accepted
@errors {401: Unauthorized - authentication required., 403: Forbidden - insufficient permissions to process the request., 404: The mandate was not found., 422: Unprocessable Entity - a request validation error., 500: Internal Server Error - the server could not process the request.}

@endgroup

@group paymentInstruments
@endpoint GET /paymentInstruments/{paymentInstrumentId}/authorisedCardUsers
@desc Get authorized users for a card.
@required {paymentInstrumentId: str}
@returns(200) {legalEntityIds: [str]} # Successful operation
@errors {401: Unauthorized, 403: Forbidden, 404: Not Found, 422: Unprocessable Entity - a request validation error.}

@endpoint POST /paymentInstruments/{paymentInstrumentId}/authorisedCardUsers
@desc Create authorized users for a card.
@required {paymentInstrumentId: str}
@optional {legalEntityIds: [str] # The legal entity IDs of the authorized card users linked to the specified payment instrument.}
@returns(204) Successful operation
@errors {400: Bad request, 401: Unauthorized, 403: Forbidden, 422: Unprocessable Entity - a request validation error.}
@example_request {"legalEntityIds":["LE328V522322685LV3KTNF35M","LE328SW223226B5LWVWNQ8THN"]}

@endpoint DELETE /paymentInstruments/{paymentInstrumentId}/authorisedCardUsers
@desc Delete the authorized users for a card.
@required {paymentInstrumentId: str}
@returns(204) Successful operation
@errors {401: Unauthorized, 403: Forbidden}

@endpoint PATCH /paymentInstruments/{paymentInstrumentId}/authorisedCardUsers
@desc Update the authorized users for a card.
@required {paymentInstrumentId: str}
@optional {legalEntityIds: [str] # The legal entity IDs of the authorized card users linked to the specified payment instrument.}
@returns(204) Successful operation
@errors {400: Bad request, 401: Unauthorized, 403: Forbidden, 422: Unprocessable Entity - a request validation error.}
@example_request {"legalEntityIds":["LE328V522322685LV3KTNF35M","LE328SW223226B5LWVWNQ8THN"]}

@endgroup

@group scaAssociations
@endpoint GET /scaAssociations
@desc Get a list of devices associated with an entity
@required {entityType: str # The type of entity you want to retrieve a list of associations for.   Possible values: **accountHolder** or **paymentInstrument**., entityId: str # The unique identifier of the entity., pageSize: int(int32) # The number of items to have on a page.   Default: **5**., pageNumber: int(int32) # The index of the page to retrieve. The index of the first page is **0** (zero).   Default:  **0**.}
@returns(200) {_links: map{first: map{href: str}, last: map{href: str}, next: map{href: str}, previous: map{href: str}, self: map{href: str}}, data: [map], itemsTotal: int(int32), pagesTotal: int(int32)} # OK - The request has succeeded.
@errors {400: Bad request - The request contains invalid input and fails validation., 401: Unauthorized - Authentication required., 403: Forbidden - Insufficient permissions to process the request., 500: Internal Server Error - The server could not process the request.}

@endpoint DELETE /scaAssociations
@desc Delete association to devices
@required {WWW-Authenticate: str # The header for authenticating through SCA., entityId: str # The unique identifier of the entity., entityType: str(accountHolder/paymentInstrument), scaDeviceIds: [str] # A list of device ids associated with the entity that should be removed.}
@returns(204) No Content - Successful association deletion.
@errors {401: Unauthorized - Authentication required., 403: Forbidden - Insufficient permissions to process the request., 500: Internal Server Error - The server could not process the request.}
@example_request {"entityType":"accountHolder","entityId":"AH00000000000000000000001","scaDeviceIds":["BSDR42XV3223223S5N6CDQDGH53M8H"]}

@endpoint PATCH /scaAssociations
@desc Approve a pending approval association
@required {WWW-Authenticate: str # The header for authenticating through SCA., entityId: str # The unique identifier of the entity., entityType: str(accountHolder/paymentInstrument), scaDeviceIds: [str] # List of device ids associated to the entity that will be approved., status: str(pendingApproval/active)}
@returns(200) {scaAssociations: [map]} # OK - Successful approval
@errors {401: Unauthorized - Authentication required., 403: Forbidden - Insufficient permissions to process the request., 500: Internal Server Error - The server could not process the request.}
@example_request {"status":"active","entityType":"accountHolder","entityId":"AH00000000000000000000001","scaDeviceIds":["BSDR42XV3223223S5N6CDQDGH53M8H"]}

@endgroup

@group scaDevices
@endpoint POST /scaDevices
@desc Begin SCA device registration
@required {name: str # The name of the SCA device that you are registering. You can use it to help your users identify the device., sdkOutput: str # A base64-encoded block with the data required to register the SCA device. You obtain this information by using Adyen's authentication SDK.}
@returns(201) {scaDevice: map{id: str, name: str, type: str}, sdkInput: str} # Created - A device resource is created. The initial step of registration is complete, but the device isn't ready for use.
@errors {400: Bad Request - The request contains invalid input and fails validation., 401: Unauthorized - Authentication required., 403: Forbidden - Insufficient permissions to process the request., 422: Unprocessable entity - A request validation error., 500: Internal Server Error - The server could not process the request.}
@example_request {"name":"My Device","sdkOutput":"eyJjaGFsbGVuZ2UiOiJVWEZaTURONGNXWjZUVFExUlhWV2JuaEJPVzVzTm05cVVEUktUbFZtZGtrPSJ9"}

@endpoint PATCH /scaDevices/{deviceId}
@desc Finish registration process for a SCA device
@required {deviceId: str # The unique identifier of the SCA device that you are associating with a resource., sdkOutput: str # A base64-encoded block with the data required to register the SCA device. You obtain this information by using Adyen's authentication SDK.}
@returns(200) {scaDevice: map{id: str, name: str, type: str}} # OK - Device registration was completed successfully.
@errors {400: Bad Request - The request contains invalid input and fails validation., 401: Unauthorized - Authentication required., 403: Forbidden - Insufficient permissions to process the request., 404: Not Found - Device not found., 422: Unprocessable entity - A request validation error., 500: Internal Server Error - The server could not process the request.}
@example_request {"sdkOutput":"eyJjaGFsbGVuZ2UiOiJVWEZaTURONGNXWjZUVFExUlhWV2JuaEJPVzVzTm05cVVEUktUbFZtZGtrPSJ9"}

@endpoint POST /scaDevices/{deviceId}/scaAssociations
@desc Create a new SCA association for a device
@required {deviceId: str # The unique identifier of the SCA device that you are associating with a resource., entities: [map{id!: str, type!: str}] # The list of entities to be associated.}
@returns(201) {scaAssociations: [map]} # Created - Association created.
@errors {400: Bad Request - The request contains invalid input and fails validation., 401: Unauthorized - Authentication required., 403: Forbidden - Insufficient permissions to process the request., 404: Not Found - Device not found., 422: Unprocessable Entity - A request validation error., 500: Internal Server Error - The server could not process the request.}
@example_request {"entities":[{"type":"accountHolder","id":"AH00000000000000000000001"}]}

@endgroup

@end