---
title: "Make a transfer request"
description: "Learn how to send funds to third parties using an Adyen business account."
url: "https://docs.adyen.com/business-accounts/send-funds/make-transfer-request"
source_url: "https://docs.adyen.com/business-accounts/send-funds/make-transfer-request.md"
canonical: "https://docs.adyen.com/business-accounts/send-funds/make-transfer-request"
last_modified: "2026-05-27T12:56:26+02:00"
language: "en"
---

# Make a transfer request

Learn how to send funds to third parties using an Adyen business account.

[View source](/business-accounts/send-funds/make-transfer-request.md)

When sending funds to third-party bank accounts, the required bank account details depend on the [bank identification type](/business-accounts/send-funds#bank-account-identification-types). There are also additional required fields if you are doing a [cross-border transfer](/business-accounts/send-funds#cross-border). Additionally, you can [validate the third-party bank account](#validate-a-third-party-bank-account) before sending funds to avoid failed transfers due to incorrect details.

## Requirements

| Requirement                                                                                              | Description                                                                                                                                                                                                                                                                                                                                     |
| -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Integration type**                                                                                     | Adyen business accounts                                                                                                                                                                                                                                                                                                                         |
| **API credential roles**                                                                                 | Make sure that your API credential has the [roles](/business-accounts/manage-access#manage-api-credentials) to use the [Transfers API](https://docs.adyen.com/api-explorer/transfers/latest/overview).                                                                                                                                          |
| **[Webhooks](/development-resources/webhooks)**                                                          | Subscribe to the following webhook(s):- **[Transfer webhooks](https://docs.adyen.com/api-explorer/transfer-webhooks/latest/overview)**
- **[Transaction webhooks](https://docs.adyen.com/api-explorer/transaction-webhooks/latest/overview)**                                                                                                   |
| **[Capabilities](/business-accounts/verification-overview/capabilities/#business-account-capabilities)** | Make sure that the user has the following capability allowed and enabled:- **sendToThirdParty**                                                                                                                                                                                                                                                 |
| **Limitations**                                                                                          | Currently, Adyen only supports sending funds to third-party bank accounts. In the future, you will be able to send to third-party wallets and cards.                                                                                                                                                                                            |
| **Setup steps**                                                                                          | * Reach out to your Adyen contact to:

  * Make sure you have the roles and capabilities necessary to send funds to a third-party bank account.
  * Enable transfers for the source balance account.

* (Recommended) Get transfer routes before transferring to a new counterparty.

* (Recommended) Validate the counterparty's bank account. |

## Get transfer routes

Prior to submitting a transfer request, we recommend that you [calculate the available transfer routes](/business-accounts/send-funds/transfer-routes). This will enable you to design a configuration that optimally aligns with your use case. Furthermore, it minimizes the risk of transfer failures by proactively identifying supported routes and highlighting any necessary parameters.

## Validate a third-party bank account

Before sending funds to a third-party bank account, you can validate this bank account to avoid failed transfers due to incorrect details.

To validate a third-party bank account, make a POST `/validateBankAccountIdentification` request specifying the following information, depending on the [bank account identification type](/business-accounts/send-funds#bank-account-identification-types):

| Parameter               | Description                                                        |
| ----------------------- | ------------------------------------------------------------------ |
| `accountIdentification` | Object containing the details of the bank account to be validated. |

### Tab: IBAN

**Validate a third-party IBAN**

```json
{
  "accountIdentification": {
    "type": "iban",
    "iban": "1001001234"
  }
}
```

### Tab: US bank account

**Validate a US third-party bank account**

```json
{
  "accountIdentification": {
    "type": "usLocal",
    "accountNumber": "12345JHDhjkf67890",
    "routingNumber": "121000cxhgjhzxg248"
  }
}
```

### Tab: AU bank account

**Validate an AU third-party bank account**

```json
{
  "accountIdentification": {
    "type": "auLocal",
    "accountNumber": "17520016",
    "bsbCode": "237001"
  }
}
```

If the bank account details are valid, you'll get an **HTTP 200 OK** response. You can proceed with transferring funds to this account.

In case the bank account validation fails, you'll get the details in the response. Use this information to build your own logic for handling invalid bank account details.

### Tab: IBAN

**Invalid IBAN details**

```json
{
    "type": "https://docs.adyen.com/errors/validation",
    "title": "Invalid bank account identification details provided",
    "status": 422,
    "invalidFields": [
        {
            "name": "iban",
            "message": "Invalid IBAN."
        }
    ],
    "errorCode": "33_01"
}
```

### Tab: US bank account

**Invalid US bank account details**

```json
{
    "type": "https://docs.adyen.com/errors/validation",
    "title": "Invalid bank account identification details provided",
    "status": 422,
    "invalidFields": [
        {
            "name": "accountNumber",
            "message": "Invalid account number."
        },
        {
            "name": "routingNumber",
            "message": "Invalid routing number."
        }
    ],
    "errorCode": "33_01"
}
```

### Tab: AU bank account

**Invalid AU bank account details**

```json
{
  "type": "https://docs.adyen.com/errors/validation",
  "title": "Invalid bank account identification details provided",
  "status": 422,
  "invalidFields": [
      {
          "name": "bsbCode",
          "message": "Invalid BSB code."
      }
  ],
  "errorCode": "33_01"
}
```

## Make a transfer

To start a transfer to a third party bank account, make a POST [/transfers](https://docs.adyen.com/api-explorer/#/transfers/latest/post/transfers) request specifying:

| Parameter name                                                                                                                 | Required                                                                                    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [amount](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers#request-amount)                                   | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") | The amount and the currency of the transfer.                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [balanceAccountId](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers#request-balanceAccountId)               | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") | The ID of the [balance account](https://docs.adyen.com/api-explorer/balanceplatform/latest/post/balanceAccounts) from which funds are deducted.                                                                                                                                                                                                                                                                                                                                                  |
| [category](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers#request-category)                               | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") | Set to **bank**.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [bankAccount](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers#request-counterparty-bankAccount)            | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") | Contains details about the bank account and its owner.- The `accountHolder.fullName` is always required. For [cross-border transfers](/business-accounts/send-funds#cross-border), the `accountHolder.address` object is also required.
- The `accountIdentification` is required. The fields that you need to send in this object are determined by the `accountIdentification.type`. See [bank account identification types](/business-accounts/send-funds#bank-account-identification-types). |
| [priority](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers#request-priority)                               | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") | The [priority](/business-accounts/send-funds#supported-currencies-locations-and-priorities) of the bank transfer, which affects the speed of the transfer and the fees you have to pay.                                                                                                                                                                                                                                                                                                          |
| [description](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers#request-description)                         |                                                                                             | Your description for the transfer. See [Bank account identification types](/business-accounts/send-funds#bank-account-identification-types) for allowed characters.                                                                                                                                                                                                                                                                                                                              |
| [reference](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers#request-reference)                             |                                                                                             | Your reference for the transfer. This is only used within your balance platform and not sent to the recipient. If you do not provide this in the request, Adyen generates a unique reference.                                                                                                                                                                                                                                                                                                    |
| [referenceForBeneficiary](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers#request-referenceForBeneficiary) |                                                                                             | Your reference for the transfer that Adyen sends to the recipient.                                                                                                                                                                                                                                                                                                                                                                                                                               |

Select a tab below for examples.

### Tab: Local funds transfer to IBAN bank account

Here is an example of a local funds transfer of EUR funds to an IBAN bank account. When providing the details of the bank account, set the `accountIdentification.type` to **iban**.

For possible values for local transfers, see [Bank account identification types](/business-accounts/send-funds#bank-account-identification-types).

**Local funds transfer to an IBAN bank account**

#### curl

```bash
curl https://balanceplatform-api-test.adyen.com/btl/v4/transfers \
-H 'x-api-key: ADYEN_BALANCE_PLATFORM_API_KEY' \
-H 'content-type: application/json' \
-X POST \
-d '{
    "amount": {
      "currency": "EUR",
      "value": 150000
    },
    "category": "bank",
    "priority": "regular",
    "balanceAccountId": "BA00000000000000000000001",
    "counterparty": {
      "bankAccount": {
        "accountHolder": {
          "fullName": "A. Klaassen"
        },
        "accountIdentification": {
          "type": "iban",
          "iban": "NL91ABNA0417164300"
        }
      }
    },
    "referenceForBeneficiary": "YOUR_REFERENCE_SENT_TO_THE_BENEFICIARY",
    "reference": "YOUR_INTERNAL_REFERENCE",
    "description": "YOUR_DESCRIPTION"
}'
```

#### Java

```java
// Adyen Java API Library v26.2.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.transfers.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.transfers.*;

Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
PartyIdentification partyIdentification3 = new PartyIdentification()
  .fullName("A. Klaassen");

IbanAccountIdentification ibanAccountIdentification = new IbanAccountIdentification()
  .iban("NL91ABNA0417164300")
  .type(IbanAccountIdentification.TypeEnum.IBAN);

BankAccountV3 bankAccountV33 = new BankAccountV3()
  .accountHolder(partyIdentification3)
  .accountIdentification(new TransferInfoAccountIdentification(ibanAccountIdentification));

Amount amount = new Amount()
  .currency("EUR")
  .value(150000L);

CounterpartyInfoV3 counterpartyInfoV3 = new CounterpartyInfoV3()
  .bankAccount(bankAccountV33);

TransferInfo transferInfo = new TransferInfo()
  .balanceAccountId("BA00000000000000000000001")
  .reference("YOUR_INTERNAL_REFERENCE")
  .amount(amount)
  .referenceForBeneficiary("YOUR_REFERENCE_SENT_TO_THE_BENEFICIARY")
  .counterparty(counterpartyInfoV3)
  .description("YOUR_DESCRIPTION")
  .category(TransferInfo.CategoryEnum.BANK)
  .priority(TransferInfo.PriorityEnum.REGULAR);

// Send the request
TransfersApi service = new TransfersApi(client);
Transfer response = service.transferFunds(transferInfo, null);
```

#### PHP

```php
// Adyen PHP API Library v18.2.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Transfers\Amount;
use Adyen\Model\Transfers\CounterpartyInfoV3;
use Adyen\Model\Transfers\PartyIdentification;
use Adyen\Model\Transfers\TransferInfoAccountIdentification;
use Adyen\Model\Transfers\BankAccountV3;
use Adyen\Service\Transfers\TransfersApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$partyIdentification3 = new PartyIdentification();
$partyIdentification3
  ->setFullName("A. Klaassen");

$transferInfoAccountIdentification = new TransferInfoAccountIdentification();
$transferInfoAccountIdentification
  ->setIban("NL91ABNA0417164300")
  ->setType("iban");

$bankAccountV33 = new BankAccountV3();
$bankAccountV33
  ->setAccountHolder($partyIdentification3)
  ->setAccountIdentification($transferInfoAccountIdentification);

$amount = new Amount();
$amount
  ->setCurrency("EUR")
  ->setValue(150000);

$counterpartyInfoV3 = new CounterpartyInfoV3();
$counterpartyInfoV3
  ->setBankAccount($bankAccountV33);

$transferInfo = new TransferInfo();
$transferInfo
  ->setBalanceAccountId("BA00000000000000000000001")
  ->setReference("YOUR_INTERNAL_REFERENCE")
  ->setAmount($amount)
  ->setReferenceForBeneficiary("YOUR_REFERENCE_SENT_TO_THE_BENEFICIARY")
  ->setCounterparty($counterpartyInfoV3)
  ->setDescription("YOUR_DESCRIPTION")
  ->setCategory("bank")
  ->setPriority("regular");

// Send the request
$service = new TransfersApi($client);
$response = $service->transferFunds($transferInfo);
```

#### C\#

```cs
// Adyen .net API Library v16.1.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Transfers;
using Adyen.Service.Transfers;

var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
PartyIdentification partyIdentification3 = new PartyIdentification
{
  FullName = "A. Klaassen"
};

IbanAccountIdentification ibanAccountIdentification = new IbanAccountIdentification
{
  Iban = "NL91ABNA0417164300",
  Type = IbanAccountIdentification.TypeEnum.Iban
};

BankAccountV3 bankAccountV33 = new BankAccountV3
{
  AccountHolder = partyIdentification3,
  AccountIdentification = new TransferInfoAccountIdentification(ibanAccountIdentification)
};

Amount amount = new Amount
{
  Currency = "EUR",
  Value = 150000
};

CounterpartyInfoV3 counterpartyInfoV3 = new CounterpartyInfoV3
{
  BankAccount = bankAccountV33
};

TransferInfo transferInfo = new TransferInfo
{
  BalanceAccountId = "BA00000000000000000000001",
  Reference = "YOUR_INTERNAL_REFERENCE",
  Amount = amount,
  ReferenceForBeneficiary = "YOUR_REFERENCE_SENT_TO_THE_BENEFICIARY",
  Counterparty = counterpartyInfoV3,
  Description = "YOUR_DESCRIPTION",
  Category = TransferInfo.CategoryEnum.Bank,
  Priority = TransferInfo.PriorityEnum.Regular
};

// Send the request
var service = new TransfersService(client);
var response = service.TransferFunds(transferInfo);
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v17.2.0
// Require the parts of the module you want to use
const { Client, TransfersAPI } = require('@adyen/api-library');
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const transferInfo = {
  amount: {
    currency: "EUR",
    value: 150000
  },
  category: "bank",
  priority: "regular",
  balanceAccountId: "BA00000000000000000000001",
  counterparty: {
    bankAccount: {
      accountHolder: {
        fullName: "A. Klaassen"
      },
      accountIdentification: {
        type: "iban",
        iban: "NL91ABNA0417164300"
      }
    }
  },
  referenceForBeneficiary: "YOUR_REFERENCE_SENT_TO_THE_BENEFICIARY",
  reference: "YOUR_INTERNAL_REFERENCE",
  description: "YOUR_DESCRIPTION"
}

// Send the request
const transfersAPI = new TransfersAPI(client);
const response = transfersAPI.TransfersApi.transferFunds(transferInfo);
```

#### Go

```go
// Adyen Go API Library v10.2.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v9/src/common"
  "github.com/adyen/adyen-go-api-library/v9/src/adyen"
  "github.com/adyen/adyen-go-api-library/v9/src/transfers"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
partyIdentification3 := transfers.PartyIdentification{
  FullName: "A. Klaassen",
}

ibanAccountIdentification := transfers.IbanAccountIdentification{
  Iban: "NL91ABNA0417164300",
  Type: "iban",
}

bankAccountV33 := transfers.BankAccountV3{
  AccountHolder: partyIdentification3,
  AccountIdentification: transfers.IbanAccountIdentificationAsTransferInfoAccountIdentification(&ibanAccountIdentification),
}

amount := transfers.Amount{
  Currency: "EUR",
  Value: 150000,
}

counterpartyInfoV3 := transfers.CounterpartyInfoV3{
  BankAccount: &bankAccountV33,
}

transferInfo := transfers.TransferInfo{
  BalanceAccountId: common.PtrString("BA00000000000000000000001"),
  Reference: common.PtrString("YOUR_INTERNAL_REFERENCE"),
  Amount: amount,
  ReferenceForBeneficiary: common.PtrString("YOUR_REFERENCE_SENT_TO_THE_BENEFICIARY"),
  Counterparty: counterpartyInfoV3,
  Description: common.PtrString("YOUR_DESCRIPTION"),
  Category: "bank",
  Priority: common.PtrString("regular"),
}

// Send the request
service := client.Transfers()
req := service.TransfersApi.TransferFundsInput().TransferInfo(transferInfo)
res, httpRes, err := service.TransfersApi.TransferFunds(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.5.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "amount": {
    "currency": "EUR",
    "value": 150000
  },
  "category": "bank",
  "priority": "regular",
  "balanceAccountId": "BA00000000000000000000001",
  "counterparty": {
    "bankAccount": {
      "accountHolder": {
        "fullName": "A. Klaassen"
      },
      "accountIdentification": {
        "type": "iban",
        "iban": "NL91ABNA0417164300"
      }
    }
  },
  "referenceForBeneficiary": "YOUR_REFERENCE_SENT_TO_THE_BENEFICIARY",
  "reference": "YOUR_INTERNAL_REFERENCE",
  "description": "YOUR_DESCRIPTION"
}

# Send the request
result = adyen.transfers.transfers_api.transfer_funds(request=json_request)
```

#### Ruby

```rb
# Adyen Ruby API Library v9.5.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :amount => {
    :currency => 'EUR',
    :value => 150000
  },
  :category => 'bank',
  :priority => 'regular',
  :balanceAccountId => 'BA00000000000000000000001',
  :counterparty => {
    :bankAccount => {
      :accountHolder => {
        :fullName => 'A. Klaassen'
      },
      :accountIdentification => {
        :type => 'iban',
        :iban => 'NL91ABNA0417164300'
      }
    }
  },
  :referenceForBeneficiary => 'YOUR_REFERENCE_SENT_TO_THE_BENEFICIARY',
  :reference => 'YOUR_INTERNAL_REFERENCE',
  :description => 'YOUR_DESCRIPTION'
}

# Send the request
result = adyen.transfers.transfers_api.transfer_funds(request_body)
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v17.2.0
// Require the parts of the module you want to use
import { Client, TransfersAPI, Types } from "@adyen/api-library";
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const partyIdentification3: Types.transfers.PartyIdentification = {
  fullName: "A. Klaassen"
};

const ibanAccountIdentification: Types.transfers.IbanAccountIdentification = {
  iban: "NL91ABNA0417164300",
  type: Types.transfers.IbanAccountIdentification.TypeEnum.Iban
};

const bankAccountV33: Types.transfers.BankAccountV3 = {
  accountHolder: partyIdentification3,
  accountIdentification: ibanAccountIdentification
};

const amount: Types.transfers.Amount = {
  currency: "EUR",
  value: 150000
};

const counterpartyInfoV3: Types.transfers.CounterpartyInfoV3 = {
  bankAccount: bankAccountV33
};

const transferInfo: Types.transfers.TransferInfo = {
  balanceAccountId: "BA00000000000000000000001",
  reference: "YOUR_INTERNAL_REFERENCE",
  amount: amount,
  referenceForBeneficiary: "YOUR_REFERENCE_SENT_TO_THE_BENEFICIARY",
  counterparty: counterpartyInfoV3,
  description: "YOUR_DESCRIPTION",
  category: Types.transfers.TransferInfo.CategoryEnum.Bank,
  priority: Types.transfers.TransferInfo.PriorityEnum.Regular
};

// Send the request
const transfersAPI = new TransfersAPI(client);
const response = transfersAPI.TransfersApi.transferFunds(transferInfo);
```

### Tab: Local funds transfer to a US bank account

Here is an example of a local funds transfer of USD funds to a US bank account. To provide the details of the bank account, the `accountIdentification.type` is set to **usLocal**.

For possible values for local transfers, see [Bank account identification types](/business-accounts/send-funds#bank-account-identification-types).

**Local funds transfer to a US bank account**

#### curl

```bash
curl https://balanceplatform-api-test.adyen.com/btl/v4/transfers \
-H 'x-api-key: ADYEN_BALANCE_PLATFORM_API_KEY' \
-H 'content-type: application/json' \
-X POST \
-d '{
    "amount": {
      "value": 10000,
      "currency": "USD"
    },
    "balanceAccountId": "BA00000000000000000000001",
    "category": "bank",
    "counterparty": {
      "bankAccount": {
        "accountHolder": {
          "fullName": "A. Klaassen"
        },
        "accountIdentification": {
          "type": "usLocal",
          "accountNumber": "123456789",
          "routingNumber": "011000138"
        }
      }
    },
    "priority": "regular",
    "referenceForBeneficiary": "Your-reference-sent-to-the-beneficiary",
    "reference": "YOUR_INTERNAL_REFERENCE",
    "description": "YOUR_DESCRIPTION_FOR_THE_TRANSFER"
}'
```

#### Java

```java
// Adyen Java API Library v26.2.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.transfers.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.transfers.*;

Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
PartyIdentification partyIdentification3 = new PartyIdentification()
  .fullName("A. Klaassen");

USLocalAccountIdentification uSLocalAccountIdentification = new USLocalAccountIdentification()
  .routingNumber("011000138")
  .type(USLocalAccountIdentification.TypeEnum.USLOCAL)
  .accountNumber("123456789");

BankAccountV3 bankAccountV33 = new BankAccountV3()
  .accountHolder(partyIdentification3)
  .accountIdentification(new TransferInfoAccountIdentification(uSLocalAccountIdentification));

Amount amount = new Amount()
  .currency("USD")
  .value(10000L);

CounterpartyInfoV3 counterpartyInfoV3 = new CounterpartyInfoV3()
  .bankAccount(bankAccountV33);

TransferInfo transferInfo = new TransferInfo()
  .balanceAccountId("BA00000000000000000000001")
  .reference("YOUR_INTERNAL_REFERENCE")
  .amount(amount)
  .referenceForBeneficiary("Your-reference-sent-to-the-beneficiary")
  .counterparty(counterpartyInfoV3)
  .description("YOUR_DESCRIPTION_FOR_THE_TRANSFER")
  .category(TransferInfo.CategoryEnum.BANK)
  .priority(TransferInfo.PriorityEnum.REGULAR);

// Send the request
TransfersApi service = new TransfersApi(client);
Transfer response = service.transferFunds(transferInfo, null);
```

#### PHP

```php
// Adyen PHP API Library v18.2.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Transfers\Amount;
use Adyen\Model\Transfers\CounterpartyInfoV3;
use Adyen\Model\Transfers\PartyIdentification;
use Adyen\Model\Transfers\TransferInfoAccountIdentification;
use Adyen\Model\Transfers\BankAccountV3;
use Adyen\Service\Transfers\TransfersApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$partyIdentification3 = new PartyIdentification();
$partyIdentification3
  ->setFullName("A. Klaassen");

$transferInfoAccountIdentification = new TransferInfoAccountIdentification();
$transferInfoAccountIdentification
  ->setRoutingNumber("011000138")
  ->setType("usLocal")
  ->setAccountNumber("123456789");

$bankAccountV33 = new BankAccountV3();
$bankAccountV33
  ->setAccountHolder($partyIdentification3)
  ->setAccountIdentification($transferInfoAccountIdentification);

$amount = new Amount();
$amount
  ->setCurrency("USD")
  ->setValue(10000);

$counterpartyInfoV3 = new CounterpartyInfoV3();
$counterpartyInfoV3
  ->setBankAccount($bankAccountV33);

$transferInfo = new TransferInfo();
$transferInfo
  ->setBalanceAccountId("BA00000000000000000000001")
  ->setReference("YOUR_INTERNAL_REFERENCE")
  ->setAmount($amount)
  ->setReferenceForBeneficiary("Your-reference-sent-to-the-beneficiary")
  ->setCounterparty($counterpartyInfoV3)
  ->setDescription("YOUR_DESCRIPTION_FOR_THE_TRANSFER")
  ->setCategory("bank")
  ->setPriority("regular");

// Send the request
$service = new TransfersApi($client);
$response = $service->transferFunds($transferInfo);
```

#### C\#

```cs
// Adyen .net API Library v16.1.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Transfers;
using Adyen.Service.Transfers;

var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
PartyIdentification partyIdentification3 = new PartyIdentification
{
  FullName = "A. Klaassen"
};

USLocalAccountIdentification uSLocalAccountIdentification = new USLocalAccountIdentification
{
  RoutingNumber = "011000138",
  Type = USLocalAccountIdentification.TypeEnum.UsLocal,
  AccountNumber = "123456789"
};

BankAccountV3 bankAccountV33 = new BankAccountV3
{
  AccountHolder = partyIdentification3,
  AccountIdentification = new TransferInfoAccountIdentification(uSLocalAccountIdentification)
};

Amount amount = new Amount
{
  Currency = "USD",
  Value = 10000
};

CounterpartyInfoV3 counterpartyInfoV3 = new CounterpartyInfoV3
{
  BankAccount = bankAccountV33
};

TransferInfo transferInfo = new TransferInfo
{
  BalanceAccountId = "BA00000000000000000000001",
  Reference = "YOUR_INTERNAL_REFERENCE",
  Amount = amount,
  ReferenceForBeneficiary = "Your-reference-sent-to-the-beneficiary",
  Counterparty = counterpartyInfoV3,
  Description = "YOUR_DESCRIPTION_FOR_THE_TRANSFER",
  Category = TransferInfo.CategoryEnum.Bank,
  Priority = TransferInfo.PriorityEnum.Regular
};

// Send the request
var service = new TransfersService(client);
var response = service.TransferFunds(transferInfo);
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v17.2.0
// Require the parts of the module you want to use
const { Client, TransfersAPI } = require('@adyen/api-library');
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const transferInfo = {
  amount: {
    value: 10000,
    currency: "USD"
  },
  balanceAccountId: "BA00000000000000000000001",
  category: "bank",
  counterparty: {
    bankAccount: {
      accountHolder: {
        fullName: "A. Klaassen"
      },
      accountIdentification: {
        type: "usLocal",
        accountNumber: "123456789",
        routingNumber: "011000138"
      }
    }
  },
  priority: "regular",
  referenceForBeneficiary: "Your-reference-sent-to-the-beneficiary",
  reference: "YOUR_INTERNAL_REFERENCE",
  description: "YOUR_DESCRIPTION_FOR_THE_TRANSFER"
}

// Send the request
const transfersAPI = new TransfersAPI(client);
const response = transfersAPI.TransfersApi.transferFunds(transferInfo);
```

#### Go

```go
// Adyen Go API Library v10.2.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v9/src/common"
  "github.com/adyen/adyen-go-api-library/v9/src/adyen"
  "github.com/adyen/adyen-go-api-library/v9/src/transfers"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
partyIdentification3 := transfers.PartyIdentification{
  FullName: "A. Klaassen",
}

uSLocalAccountIdentification := transfers.USLocalAccountIdentification{
  RoutingNumber: "011000138",
  Type: "usLocal",
  AccountNumber: "123456789",
}

bankAccountV33 := transfers.BankAccountV3{
  AccountHolder: partyIdentification3,
  AccountIdentification: transfers.USLocalAccountIdentificationAsTransferInfoAccountIdentification(&uSLocalAccountIdentification),
}

amount := transfers.Amount{
  Currency: "USD",
  Value: 10000,
}

counterpartyInfoV3 := transfers.CounterpartyInfoV3{
  BankAccount: &bankAccountV33,
}

transferInfo := transfers.TransferInfo{
  BalanceAccountId: common.PtrString("BA00000000000000000000001"),
  Reference: common.PtrString("YOUR_INTERNAL_REFERENCE"),
  Amount: amount,
  ReferenceForBeneficiary: common.PtrString("Your-reference-sent-to-the-beneficiary"),
  Counterparty: counterpartyInfoV3,
  Description: common.PtrString("YOUR_DESCRIPTION_FOR_THE_TRANSFER"),
  Category: "bank",
  Priority: common.PtrString("regular"),
}

// Send the request
service := client.Transfers()
req := service.TransfersApi.TransferFundsInput().TransferInfo(transferInfo)
res, httpRes, err := service.TransfersApi.TransferFunds(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.5.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "amount": {
    "value": 10000,
    "currency": "USD"
  },
  "balanceAccountId": "BA00000000000000000000001",
  "category": "bank",
  "counterparty": {
    "bankAccount": {
      "accountHolder": {
        "fullName": "A. Klaassen"
      },
      "accountIdentification": {
        "type": "usLocal",
        "accountNumber": "123456789",
        "routingNumber": "011000138"
      }
    }
  },
  "priority": "regular",
  "referenceForBeneficiary": "Your-reference-sent-to-the-beneficiary",
  "reference": "YOUR_INTERNAL_REFERENCE",
  "description": "YOUR_DESCRIPTION_FOR_THE_TRANSFER"
}

# Send the request
result = adyen.transfers.transfers_api.transfer_funds(request=json_request)
```

#### Ruby

```rb
# Adyen Ruby API Library v9.5.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :amount => {
    :value => 10000,
    :currency => 'USD'
  },
  :balanceAccountId => 'BA00000000000000000000001',
  :category => 'bank',
  :counterparty => {
    :bankAccount => {
      :accountHolder => {
        :fullName => 'A. Klaassen'
      },
      :accountIdentification => {
        :type => 'usLocal',
        :accountNumber => '123456789',
        :routingNumber => '011000138'
      }
    }
  },
  :priority => 'regular',
  :referenceForBeneficiary => 'Your-reference-sent-to-the-beneficiary',
  :reference => 'YOUR_INTERNAL_REFERENCE',
  :description => 'YOUR_DESCRIPTION_FOR_THE_TRANSFER'
}

# Send the request
result = adyen.transfers.transfers_api.transfer_funds(request_body)
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v17.2.0
// Require the parts of the module you want to use
import { Client, TransfersAPI, Types } from "@adyen/api-library";
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const partyIdentification3: Types.transfers.PartyIdentification = {
  fullName: "A. Klaassen"
};

const uSLocalAccountIdentification: Types.transfers.USLocalAccountIdentification = {
  routingNumber: "011000138",
  type: Types.transfers.USLocalAccountIdentification.TypeEnum.UsLocal,
  accountNumber: "123456789"
};

const bankAccountV33: Types.transfers.BankAccountV3 = {
  accountHolder: partyIdentification3,
  accountIdentification: uSLocalAccountIdentification
};

const amount: Types.transfers.Amount = {
  currency: "USD",
  value: 10000
};

const counterpartyInfoV3: Types.transfers.CounterpartyInfoV3 = {
  bankAccount: bankAccountV33
};

const transferInfo: Types.transfers.TransferInfo = {
  balanceAccountId: "BA00000000000000000000001",
  reference: "YOUR_INTERNAL_REFERENCE",
  amount: amount,
  referenceForBeneficiary: "Your-reference-sent-to-the-beneficiary",
  counterparty: counterpartyInfoV3,
  description: "YOUR_DESCRIPTION_FOR_THE_TRANSFER",
  category: Types.transfers.TransferInfo.CategoryEnum.Bank,
  priority: Types.transfers.TransferInfo.PriorityEnum.Regular
};

// Send the request
const transfersAPI = new TransfersAPI(client);
const response = transfersAPI.TransfersApi.transferFunds(transferInfo);
```

### Tab: Cross-border transfer

Here is an example of a cross-border wire transfer of EUR funds to a bank account in the US. To provide the details of the bank account, the `accountIdentification.type` is set to **numberAndBic**.

For possible values for cross-border transfers, see [Bank account identification types](/business-accounts/send-funds#bank-account-identification-types).

**Cross-border wire transfer to a US bank account**

#### curl

```bash
curl https://balanceplatform-api-test.adyen.com/btl/v4/transfers \
-H 'x-api-key: ADYEN_BALANCE_PLATFORM_API_KEY' \
-H 'content-type: application/json' \
-X POST \
-d '{
    "amount": {
      "value": 150000,
      "currency": "EUR"
    },
    "balanceAccountId": "BA00000000000000000000002",
    "category": "bank",
    "counterparty": {
      "bankAccount": {
        "accountHolder": {
          "fullName": "A. Klaassen",
          "address": {
            "city": "San Francisco",
            "country": "US",
            "postalCode": "94678",
            "stateOrProvince": "CA",
            "street": "Brannan Street",
            "street2": "274"
          }
        },
        "accountIdentification": {
	      "type": "numberAndBic",
	      "accountNumber": "123456789",
          "bic": "BOFAUS3NXXX"
        }
      }
    },
    "priority": "wire",
    "referenceForBeneficiary": "Your-reference-sent-to-the-beneficiary",
    "reference": "YOUR_INTERNAL_REFERENCE",
    "description": "YOUR_DESCRIPTION_FOR_THE_TRANSFER"
}'
```

#### Java

```java
// Adyen Java API Library v26.2.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.transfers.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.transfers.*;

Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
Address address3 = new Address()
  .country("US")
  .stateOrProvince("CA")
  .city("San Francisco")
  .postalCode("94678");

PartyIdentification partyIdentification3 = new PartyIdentification()
  .address(address3)
  .fullName("A. Klaassen");

NumberAndBicAccountIdentification numberAndBicAccountIdentification = new NumberAndBicAccountIdentification()
  .type(NumberAndBicAccountIdentification.TypeEnum.NUMBERANDBIC)
  .accountNumber("123456789")
  .bic("BOFAUS3NXXX");

BankAccountV3 bankAccountV33 = new BankAccountV3()
  .accountHolder(partyIdentification3)
  .accountIdentification(new TransferInfoAccountIdentification(numberAndBicAccountIdentification));

Amount amount = new Amount()
  .currency("EUR")
  .value(150000L);

CounterpartyInfoV3 counterpartyInfoV3 = new CounterpartyInfoV3()
  .bankAccount(bankAccountV33);

TransferInfo transferInfo = new TransferInfo()
  .balanceAccountId("BA00000000000000000000002")
  .reference("YOUR_INTERNAL_REFERENCE")
  .amount(amount)
  .referenceForBeneficiary("Your-reference-sent-to-the-beneficiary")
  .counterparty(counterpartyInfoV3)
  .description("YOUR_DESCRIPTION_FOR_THE_TRANSFER")
  .category(TransferInfo.CategoryEnum.BANK)
  .priority(TransferInfo.PriorityEnum.WIRE);

// Send the request
TransfersApi service = new TransfersApi(client);
Transfer response = service.transferFunds(transferInfo, null);
```

#### PHP

```php
// Adyen PHP API Library v18.2.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Transfers\Amount;
use Adyen\Model\Transfers\CounterpartyInfoV3;
use Adyen\Model\Transfers\Address;
use Adyen\Model\Transfers\PartyIdentification;
use Adyen\Model\Transfers\TransferInfoAccountIdentification;
use Adyen\Model\Transfers\BankAccountV3;
use Adyen\Service\Transfers\TransfersApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$address3 = new Address();
$address3
  ->setCountry("US")
  ->setStateOrProvince("CA")
  ->setCity("San Francisco")
  ->setPostalCode("94678");

$partyIdentification3 = new PartyIdentification();
$partyIdentification3
  ->setAddress($address3)
  ->setFullName("A. Klaassen");

$transferInfoAccountIdentification = new TransferInfoAccountIdentification();
$transferInfoAccountIdentification
  ->setType("numberAndBic")
  ->setAccountNumber("123456789")
  ->setBic("BOFAUS3NXXX");

$bankAccountV33 = new BankAccountV3();
$bankAccountV33
  ->setAccountHolder($partyIdentification3)
  ->setAccountIdentification($transferInfoAccountIdentification);

$amount = new Amount();
$amount
  ->setCurrency("EUR")
  ->setValue(150000);

$counterpartyInfoV3 = new CounterpartyInfoV3();
$counterpartyInfoV3
  ->setBankAccount($bankAccountV33);

$transferInfo = new TransferInfo();
$transferInfo
  ->setBalanceAccountId("BA00000000000000000000002")
  ->setReference("YOUR_INTERNAL_REFERENCE")
  ->setAmount($amount)
  ->setReferenceForBeneficiary("Your-reference-sent-to-the-beneficiary")
  ->setCounterparty($counterpartyInfoV3)
  ->setDescription("YOUR_DESCRIPTION_FOR_THE_TRANSFER")
  ->setCategory("bank")
  ->setPriority("wire");

// Send the request
$service = new TransfersApi($client);
$response = $service->transferFunds($transferInfo);
```

#### C\#

```cs
// Adyen .net API Library v16.1.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Transfers;
using Adyen.Service.Transfers;

var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
Address address3 = new Address
{
  Country = "US",
  StateOrProvince = "CA",
  City = "San Francisco",
  PostalCode = "94678"
};

PartyIdentification partyIdentification3 = new PartyIdentification
{
  Address = address3,
  FullName = "A. Klaassen"
};

NumberAndBicAccountIdentification numberAndBicAccountIdentification = new NumberAndBicAccountIdentification
{
  Type = NumberAndBicAccountIdentification.TypeEnum.NumberAndBic,
  AccountNumber = "123456789",
  Bic = "BOFAUS3NXXX"
};

BankAccountV3 bankAccountV33 = new BankAccountV3
{
  AccountHolder = partyIdentification3,
  AccountIdentification = new TransferInfoAccountIdentification(numberAndBicAccountIdentification)
};

Amount amount = new Amount
{
  Currency = "EUR",
  Value = 150000
};

CounterpartyInfoV3 counterpartyInfoV3 = new CounterpartyInfoV3
{
  BankAccount = bankAccountV33
};

TransferInfo transferInfo = new TransferInfo
{
  BalanceAccountId = "BA00000000000000000000002",
  Reference = "YOUR_INTERNAL_REFERENCE",
  Amount = amount,
  ReferenceForBeneficiary = "Your-reference-sent-to-the-beneficiary",
  Counterparty = counterpartyInfoV3,
  Description = "YOUR_DESCRIPTION_FOR_THE_TRANSFER",
  Category = TransferInfo.CategoryEnum.Bank,
  Priority = TransferInfo.PriorityEnum.Wire
};

// Send the request
var service = new TransfersService(client);
var response = service.TransferFunds(transferInfo);
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v17.2.0
// Require the parts of the module you want to use
const { Client, TransfersAPI } = require('@adyen/api-library');
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const transferInfo = {
  amount: {
    value: 150000,
    currency: "EUR"
  },
  balanceAccountId: "BA00000000000000000000002",
  category: "bank",
  counterparty: {
    bankAccount: {
      accountHolder: {
        fullName: "A. Klaassen",
        address: {
          city: "San Francisco",
          country: "US",
          postalCode: "94678",
          stateOrProvince: "CA",
          street: "Brannan Street",
          street2: "274"
        }
      },
      accountIdentification: {
        type: "numberAndBic",
        accountNumber: "123456789",
        bic: "BOFAUS3NXXX"
      }
    }
  },
  priority: "wire",
  referenceForBeneficiary: "Your-reference-sent-to-the-beneficiary",
  reference: "YOUR_INTERNAL_REFERENCE",
  description: "YOUR_DESCRIPTION_FOR_THE_TRANSFER"
}

// Send the request
const transfersAPI = new TransfersAPI(client);
const response = transfersAPI.TransfersApi.transferFunds(transferInfo);
```

#### Go

```go
// Adyen Go API Library v10.2.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v9/src/common"
  "github.com/adyen/adyen-go-api-library/v9/src/adyen"
  "github.com/adyen/adyen-go-api-library/v9/src/transfers"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
address3 := transfers.Address{
  Country: "US",
  StateOrProvince: common.PtrString("CA"),
  City: common.PtrString("San Francisco"),
  PostalCode: common.PtrString("94678"),
}

partyIdentification3 := transfers.PartyIdentification{
  Address: &address3,
  FullName: "A. Klaassen",
}

numberAndBicAccountIdentification := transfers.NumberAndBicAccountIdentification{
  Type: "numberAndBic",
  AccountNumber: "123456789",
  Bic: "BOFAUS3NXXX",
}

bankAccountV33 := transfers.BankAccountV3{
  AccountHolder: partyIdentification3,
  AccountIdentification: transfers.NumberAndBicAccountIdentificationAsTransferInfoAccountIdentification(&numberAndBicAccountIdentification),
}

amount := transfers.Amount{
  Currency: "EUR",
  Value: 150000,
}

counterpartyInfoV3 := transfers.CounterpartyInfoV3{
  BankAccount: &bankAccountV33,
}

transferInfo := transfers.TransferInfo{
  BalanceAccountId: common.PtrString("BA00000000000000000000002"),
  Reference: common.PtrString("YOUR_INTERNAL_REFERENCE"),
  Amount: amount,
  ReferenceForBeneficiary: common.PtrString("Your-reference-sent-to-the-beneficiary"),
  Counterparty: counterpartyInfoV3,
  Description: common.PtrString("YOUR_DESCRIPTION_FOR_THE_TRANSFER"),
  Category: "bank",
  Priority: common.PtrString("wire"),
}

// Send the request
service := client.Transfers()
req := service.TransfersApi.TransferFundsInput().TransferInfo(transferInfo)
res, httpRes, err := service.TransfersApi.TransferFunds(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.5.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "amount": {
    "value": 150000,
    "currency": "EUR"
  },
  "balanceAccountId": "BA00000000000000000000002",
  "category": "bank",
  "counterparty": {
    "bankAccount": {
      "accountHolder": {
        "fullName": "A. Klaassen",
        "address": {
          "city": "San Francisco",
          "country": "US",
          "postalCode": "94678",
          "stateOrProvince": "CA",
          "street": "Brannan Street",
          "street2": "274"
        }
      },
      "accountIdentification": {
        "type": "numberAndBic",
        "accountNumber": "123456789",
        "bic": "BOFAUS3NXXX"
      }
    }
  },
  "priority": "wire",
  "referenceForBeneficiary": "Your-reference-sent-to-the-beneficiary",
  "reference": "YOUR_INTERNAL_REFERENCE",
  "description": "YOUR_DESCRIPTION_FOR_THE_TRANSFER"
}

# Send the request
result = adyen.transfers.transfers_api.transfer_funds(request=json_request)
```

#### Ruby

```rb
# Adyen Ruby API Library v9.5.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :amount => {
    :value => 150000,
    :currency => 'EUR'
  },
  :balanceAccountId => 'BA00000000000000000000002',
  :category => 'bank',
  :counterparty => {
    :bankAccount => {
      :accountHolder => {
        :fullName => 'A. Klaassen',
        :address => {
          :city => 'San Francisco',
          :country => 'US',
          :postalCode => '94678',
          :stateOrProvince => 'CA',
          :street => 'Brannan Street',
          :street2 => '274'
        }
      },
      :accountIdentification => {
        :type => 'numberAndBic',
        :accountNumber => '123456789',
        :bic => 'BOFAUS3NXXX'
      }
    }
  },
  :priority => 'wire',
  :referenceForBeneficiary => 'Your-reference-sent-to-the-beneficiary',
  :reference => 'YOUR_INTERNAL_REFERENCE',
  :description => 'YOUR_DESCRIPTION_FOR_THE_TRANSFER'
}

# Send the request
result = adyen.transfers.transfers_api.transfer_funds(request_body)
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v17.2.0
// Require the parts of the module you want to use
import { Client, TransfersAPI, Types } from "@adyen/api-library";
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const address3: Types.transfers.Address = {
  country: "US",
  stateOrProvince: "CA",
  city: "San Francisco",
  postalCode: "94678"
};

const partyIdentification3: Types.transfers.PartyIdentification = {
  address: address3,
  fullName: "A. Klaassen"
};

const numberAndBicAccountIdentification: Types.transfers.NumberAndBicAccountIdentification = {
  type: Types.transfers.NumberAndBicAccountIdentification.TypeEnum.NumberAndBic,
  accountNumber: "123456789",
  bic: "BOFAUS3NXXX"
};

const bankAccountV33: Types.transfers.BankAccountV3 = {
  accountHolder: partyIdentification3,
  accountIdentification: numberAndBicAccountIdentification
};

const amount: Types.transfers.Amount = {
  currency: "EUR",
  value: 150000
};

const counterpartyInfoV3: Types.transfers.CounterpartyInfoV3 = {
  bankAccount: bankAccountV33
};

const transferInfo: Types.transfers.TransferInfo = {
  balanceAccountId: "BA00000000000000000000002",
  reference: "YOUR_INTERNAL_REFERENCE",
  amount: amount,
  referenceForBeneficiary: "Your-reference-sent-to-the-beneficiary",
  counterparty: counterpartyInfoV3,
  description: "YOUR_DESCRIPTION_FOR_THE_TRANSFER",
  category: Types.transfers.TransferInfo.CategoryEnum.Bank,
  priority: Types.transfers.TransferInfo.PriorityEnum.Wire
};

// Send the request
const transfersAPI = new TransfersAPI(client);
const response = transfersAPI.TransfersApi.transferFunds(transferInfo);
```

If the transfer request is successful, you receive an **HTTP 200 OK** response containing an `id` of the transfer request. Adyen informs your server of the status of the transfer through [outgoing bank transfer webhooks](/business-accounts/third-party-transfer-webhooks/#sending-funds).

**

### Trigger additional reviews

To better control money movement in your balance platform, you can trigger additional reviews for s. Additional reviews require a member of your team to verify a before Adyen processes it.

1. You can trigger an additional review by including the [review](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers#request-review) object in the POST [/transfers](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers) request. In the object, specify the following parameter:

   | Parameter name                                                                                                                                   | Required                                                                                    | Description                                                                                                                                               |   |
   | ------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
   | [review.numberOfApprovalsRequired](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers#request-review-numberOfApprovalsRequired) | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") | Specifies the number of approvals required to process the . Possible values: **1**. Currently, it is possible to request only one additional review per . |   |

   The following code sample shows how to include the `review` object.

   **Trigger an additional review**

   #### curl

   ```bash
   curl https://balanceplatform-api-test.adyen.com/btl/v4/transfers \
   -H 'x-api-key: YOUR_BALANCE_PLATFORM_API_KEY' \
   -H 'content-type: application/json' \
   -X POST \
   -d '{
       "amount": {
           "value": 60000,
           "currency": "EUR"
       },
       "balanceAccountId": "BA00000000000000000000001",
       "category": "bank",
       "counterparty": {
          "bankAccount": {
              "accountHolder": {
                  "fullName": "Adyen N.V.",
                  "address": {
                      "city": "Amsterdam",
                      "country": "NL",
                      "postalCode": "1011DJ",
                      "stateOrProvince": "NH",
                      "line1": "Simon Carmiggeltstraat 6-50"
                  }
              },
              "accountIdentification": {
                  "type": "iban",
                  "iban": "NL33ADYX1000001544"
              }
          }
       },
       "description": "Your-description-for-the-transfer",
       "priority": "fast",
       "reference": "YOUR_INTERNAL_REFERENCE",
       "referenceForBeneficiary": "Your-reference-for-the-beneficiary",
       "review": {
           "numberOfApprovalsRequired": 1
       }
   }'
   ```

   #### Java

   ```java
   // Adyen Java API Library v29.1.0
   import com.adyen.Client;
   import com.adyen.enums.Environment;
   import com.adyen.model.transfers.*;
   import java.time.OffsetDateTime;
   import java.util.*;
   import com.adyen.model.RequestOptions;
   import com.adyen.service.transfers.*;

   Client client = new Client("YOUR_BALANCE_PLATFORM_API_KEY", Environment.TEST);

   // Create the request object(s)
   Address address3 = new Address()
     .country("NL")
     .stateOrProvince("NH")
     .city("Amsterdam")
     .postalCode("1011DJ")
     .line1("Simon Carmiggeltstraat 6-50");

   PartyIdentification partyIdentification3 = new PartyIdentification()
     .address(address3)
     .fullName("Adyen N.V.");

   IbanAccountIdentification ibanAccountIdentification = new IbanAccountIdentification()
     .iban("NL33ADYX1000001544")
     .type(IbanAccountIdentification.TypeEnum.IBAN);

   BankAccountV3 bankAccountV33 = new BankAccountV3()
     .accountHolder(partyIdentification3)
     .accountIdentification(new TransferInfoAccountIdentification(ibanAccountIdentification));

   Amount amount = new Amount()
     .currency("EUR")
     .value(60000L);

   TransferRequestReview transferRequestReview = new TransferRequestReview()
     .numberOfApprovalsRequired(1);

   CounterpartyInfoV3 counterpartyInfoV3 = new CounterpartyInfoV3()
     .bankAccount(bankAccountV33);

   TransferInfo transferInfo = new TransferInfo()
     .balanceAccountId("BA00000000000000000000001")
     .reference("YOUR_INTERNAL_REFERENCE")
     .amount(amount)
     .referenceForBeneficiary("Your-reference-for-the-beneficiary")
     .review(transferRequestReview)
     .counterparty(counterpartyInfoV3)
     .description("Your-description-for-the-transfer")
     .category(TransferInfo.CategoryEnum.BANK)
     .priority(TransferInfo.PriorityEnum.FAST);

   // Send the request
   TransfersApi service = new TransfersApi(client);
   Transfer response = service.transferFunds(transferInfo, new RequestOptions().idempotencyKey("UUID"));
   ```

   #### PHP

   ```php
   <?php
   // Adyen PHP API Library v28.3.0
   use Adyen\Client;
   use Adyen\Environment;
   use Adyen\Model\Transfers\Amount;
   use Adyen\Model\Transfers\TransferRequestReview;
   use Adyen\Model\Transfers\CounterpartyInfoV3;
   use Adyen\Model\Transfers\Address;
   use Adyen\Model\Transfers\PartyIdentification;
   use Adyen\Model\Transfers\TransferInfoAccountIdentification;
   use Adyen\Model\Transfers\BankAccountV3;
   use Adyen\Service\Transfers\TransfersApi;

   $client = new Client();
   $client->setXApiKey("YOUR_BALANCE_PLATFORM_API_KEY");
   $client->setEnvironment(Environment::TEST);


   // Create the request object(s)
   $address3 = new Address();
   $address3
     ->setCountry("NL")
     ->setStateOrProvince("NH")
     ->setCity("Amsterdam")
     ->setPostalCode("1011DJ")
     ->setLine1("Simon Carmiggeltstraat 6-50");

   $partyIdentification3 = new PartyIdentification();
   $partyIdentification3
     ->setAddress($address3)
     ->setFullName("Adyen N.V.");

   $transferInfoAccountIdentification = new TransferInfoAccountIdentification();
   $transferInfoAccountIdentification
     ->setIban("NL33ADYX1000001544")
     ->setType("iban");

   $bankAccountV33 = new BankAccountV3();
   $bankAccountV33
     ->setAccountHolder($partyIdentification3)
     ->setAccountIdentification($transferInfoAccountIdentification);

   $amount = new Amount();
   $amount
     ->setCurrency("EUR")
     ->setValue(60000);

   $transferRequestReview = new TransferRequestReview();
   $transferRequestReview
     ->setNumberOfApprovalsRequired(1);

   $counterpartyInfoV3 = new CounterpartyInfoV3();
   $counterpartyInfoV3
     ->setBankAccount($bankAccountV33);

   $transferInfo = new TransferInfo();
   $transferInfo
     ->setBalanceAccountId("BA00000000000000000000001")
     ->setReference("YOUR_INTERNAL_REFERENCE")
     ->setAmount($amount)
     ->setReferenceForBeneficiary("Your-reference-for-the-beneficiary")
     ->setReview($transferRequestReview)
     ->setCounterparty($counterpartyInfoV3)
     ->setDescription("Your-description-for-the-transfer")
     ->setCategory("bank")
     ->setPriority("fast");

   $requestOptions['idempotencyKey'] = 'UUID';

   // Send the request
   $service = new TransfersApi($client);
   $response = $service->transferFunds($transferInfo, $requestOptions);
   ```

   #### C\#

   ```cs
   // Adyen .NET API Library v32.2.1
   using Adyen;
   using Environment = Adyen.Model.Environment;
   using Adyen.Model;
   using Adyen.Model.Transfers;
   using Adyen.Service.Transfers;

   var config = new Config()
   {
       XApiKey = "YOUR_BALANCE_PLATFORM_API_KEY",
       Environment = Environment.Test
   };
   var client = new Client(config);

   // Create the request object(s)
   Address address3 = new Address
   {
     Country = "NL",
     StateOrProvince = "NH",
     City = "Amsterdam",
     PostalCode = "1011DJ",
     Line1 = "Simon Carmiggeltstraat 6-50"
   };

   PartyIdentification partyIdentification3 = new PartyIdentification
   {
     Address = address3,
     FullName = "Adyen N.V."
   };

   IbanAccountIdentification ibanAccountIdentification = new IbanAccountIdentification
   {
     Iban = "NL33ADYX1000001544",
     Type = IbanAccountIdentification.TypeEnum.Iban
   };

   BankAccountV3 bankAccountV33 = new BankAccountV3
   {
     AccountHolder = partyIdentification3,
     AccountIdentification = new TransferInfoAccountIdentification(ibanAccountIdentification)
   };

   Amount amount = new Amount
   {
     Currency = "EUR",
     Value = 60000
   };

   TransferRequestReview transferRequestReview = new TransferRequestReview
   {
     NumberOfApprovalsRequired = 1
   };

   CounterpartyInfoV3 counterpartyInfoV3 = new CounterpartyInfoV3
   {
     BankAccount = bankAccountV33
   };

   TransferInfo transferInfo = new TransferInfo
   {
     BalanceAccountId = "BA00000000000000000000001",
     Reference = "YOUR_INTERNAL_REFERENCE",
     Amount = amount,
     ReferenceForBeneficiary = "Your-reference-for-the-beneficiary",
     Review = transferRequestReview,
     Counterparty = counterpartyInfoV3,
     Description = "Your-description-for-the-transfer",
     Category = TransferInfo.CategoryEnum.Bank,
     Priority = TransferInfo.PriorityEnum.Fast
   };

   // Send the request
   var service = new TransfersService(client);
   var response = service.TransferFunds(transferInfo, requestOptions: new RequestOptions { IdempotencyKey = "UUID"});
   ```

   #### NodeJS (JavaScript)

   ```js
   // Adyen Node API Library v21.0.0
   // Require the parts of the module you want to use
   const { Client, TransfersAPI } = require('@adyen/api-library');
   // Initialize the client object
   const client = new Client({apiKey: "YOUR_BALANCE_PLATFORM_API_KEY", environment: "TEST"});

   // Create the request object(s)
   const transferInfo = {
     amount: {
       value: 60000,
       currency: "EUR"
     },
     balanceAccountId: "BA00000000000000000000001",
     category: "bank",
     counterparty: {
       bankAccount: {
         accountHolder: {
           fullName: "Adyen N.V.",
           address: {
             city: "Amsterdam",
             country: "NL",
             postalCode: "1011DJ",
             stateOrProvince: "NH",
             line1: "Simon Carmiggeltstraat 6-50"
           }
         },
         accountIdentification: {
           type: "iban",
           iban: "NL33ADYX1000001544"
         }
       }
     },
     description: "Your-description-for-the-transfer",
     priority: "fast",
     reference: "YOUR_INTERNAL_REFERENCE",
     referenceForBeneficiary: "Your-reference-for-the-beneficiary",
     review: {
       numberOfApprovalsRequired: 1
     }
   }

   // Send the request
   const transfersAPI = new TransfersAPI(client);
   const response = transfersAPI.TransfersApi.transferFunds(transferInfo, { idempotencyKey: "UUID" });
   ```

   #### Go

   ```go
   // Adyen Go API Library v14.0.0
   import (
     "context"
     "github.com/adyen/adyen-go-api-library/v9/src/common"
     "github.com/adyen/adyen-go-api-library/v9/src/adyen"
     "github.com/adyen/adyen-go-api-library/v9/src/transfers"
   )
   client := adyen.NewClient(&common.Config{
     ApiKey:      "YOUR_BALANCE_PLATFORM_API_KEY",
     Environment: common.TestEnv,
   })

   // Create the request object(s)
   address3 := transfers.Address{
     Country: "NL",
     StateOrProvince: common.PtrString("NH"),
     City: common.PtrString("Amsterdam"),
     PostalCode: common.PtrString("1011DJ"),
     Line1: common.PtrString("Simon Carmiggeltstraat 6-50"),
   }

   partyIdentification3 := transfers.PartyIdentification{
     Address: &address3,
     FullName: common.PtrString("Adyen N.V."),
   }

   ibanAccountIdentification := transfers.IbanAccountIdentification{
     Iban: "NL33ADYX1000001544",
     Type: "iban",
   }

   bankAccountV33 := transfers.BankAccountV3{
     AccountHolder: partyIdentification3,
     AccountIdentification: transfers.IbanAccountIdentificationAsTransferInfoAccountIdentification(&ibanAccountIdentification),
   }

   amount := transfers.Amount{
     Currency: "EUR",
     Value: 60000,
   }

   transferRequestReview := transfers.TransferRequestReview{
     NumberOfApprovalsRequired: common.PtrInt32(1),
   }

   counterpartyInfoV3 := transfers.CounterpartyInfoV3{
     BankAccount: &bankAccountV33,
   }

   transferInfo := transfers.TransferInfo{
     BalanceAccountId: common.PtrString("BA00000000000000000000001"),
     Reference: common.PtrString("YOUR_INTERNAL_REFERENCE"),
     Amount: amount,
     ReferenceForBeneficiary: common.PtrString("Your-reference-for-the-beneficiary"),
     Review: &transferRequestReview,
     Counterparty: counterpartyInfoV3,
     Description: common.PtrString("Your-description-for-the-transfer"),
     Category: "bank",
     Priority: common.PtrString("fast"),
   }

   // Send the request
   service := client.Transfers()
   req := service.TransfersApi.TransferFundsInput().IdempotencyKey("UUID").TransferInfo(transferInfo)
   res, httpRes, err := service.TransfersApi.TransferFunds(context.Background(), req)
   ```

   #### Python

   ```py
   # Adyen Python API Library v12.8.0
   import Adyen

   adyen = Adyen.Adyen()
   adyen.client.xapikey = "YOUR_BALANCE_PLATFORM_API_KEY"
   adyen.client.platform = "test" # The environment to use library in.

   # Create the request object(s)
   json_request = {
     "amount": {
       "value": 60000,
       "currency": "EUR"
     },
     "balanceAccountId": "BA00000000000000000000001",
     "category": "bank",
     "counterparty": {
       "bankAccount": {
         "accountHolder": {
           "fullName": "Adyen N.V.",
           "address": {
             "city": "Amsterdam",
             "country": "NL",
             "postalCode": "1011DJ",
             "stateOrProvince": "NH",
             "line1": "Simon Carmiggeltstraat 6-50"
           }
         },
         "accountIdentification": {
           "type": "iban",
           "iban": "NL33ADYX1000001544"
         }
       }
     },
     "description": "Your-description-for-the-transfer",
     "priority": "fast",
     "reference": "YOUR_INTERNAL_REFERENCE",
     "referenceForBeneficiary": "Your-reference-for-the-beneficiary",
     "review": {
       "numberOfApprovalsRequired": 1
     }
   }

   # Send the request
   result = adyen.transfers.transfers_api.transfer_funds(request=json_request, idempotency_key="UUID")
   ```

   #### Ruby

   ```rb
   # Adyen Ruby API Library v9.9.0
   require "adyen-ruby-api-library"

   adyen = Adyen::Client.new
   adyen.api_key = 'YOUR_BALANCE_PLATFORM_API_KEY'
   adyen.env = :test # Set to "live" for live environment

   # Create the request object(s)
   request_body = {
     :amount => {
       :value => 60000,
       :currency => 'EUR'
     },
     :balanceAccountId => 'BA00000000000000000000001',
     :category => 'bank',
     :counterparty => {
       :bankAccount => {
         :accountHolder => {
           :fullName => 'Adyen N.V.',
           :address => {
             :city => 'Amsterdam',
             :country => 'NL',
             :postalCode => '1011DJ',
             :stateOrProvince => 'NH',
             :line1 => 'Simon Carmiggeltstraat 6-50'
           }
         },
         :accountIdentification => {
           :type => 'iban',
           :iban => 'NL33ADYX1000001544'
         }
       }
     },
     :description => 'Your-description-for-the-transfer',
     :priority => 'fast',
     :reference => 'YOUR_INTERNAL_REFERENCE',
     :referenceForBeneficiary => 'Your-reference-for-the-beneficiary',
     :review => {
       :numberOfApprovalsRequired => 1
     }
   }

   # Send the request
   result = adyen.transfers.transfers_api.transfer_funds(request_body, headers: { 'Idempotency-Key' => 'UUID' })
   ```

   #### NodeJS (TypeScript)

   ```ts
   // Adyen Node API Library v21.0.0
   // Require the parts of the module you want to use
   import { Client, TransfersAPI, Types } from "@adyen/api-library";
   // Initialize the client object
   const client = new Client({apiKey: "YOUR_BALANCE_PLATFORM_API_KEY", environment: "TEST"});

   // Create the request object(s)
   const address3: Types.transfers.Address = {
     country: "NL",
     stateOrProvince: "NH",
     city: "Amsterdam",
     postalCode: "1011DJ",
     line1: "Simon Carmiggeltstraat 6-50"
   };

   const partyIdentification3: Types.transfers.PartyIdentification = {
     address: address3,
     fullName: "Adyen N.V."
   };

   const ibanAccountIdentification: Types.transfers.IbanAccountIdentification = {
     iban: "NL33ADYX1000001544",
     type: Types.transfers.IbanAccountIdentification.TypeEnum.Iban
   };

   const bankAccountV33: Types.transfers.BankAccountV3 = {
     accountHolder: partyIdentification3,
     accountIdentification: ibanAccountIdentification
   };

   const amount: Types.transfers.Amount = {
     currency: "EUR",
     value: 60000
   };

   const transferRequestReview: Types.transfers.TransferRequestReview = {
     numberOfApprovalsRequired: 1
   };

   const counterpartyInfoV3: Types.transfers.CounterpartyInfoV3 = {
     bankAccount: bankAccountV33
   };

   const transferInfo: Types.transfers.TransferInfo = {
     balanceAccountId: "BA00000000000000000000001",
     reference: "YOUR_INTERNAL_REFERENCE",
     amount: amount,
     referenceForBeneficiary: "Your-reference-for-the-beneficiary",
     review: transferRequestReview,
     counterparty: counterpartyInfoV3,
     description: "Your-description-for-the-transfer",
     category: Types.transfers.TransferInfo.CategoryEnum.Bank,
     priority: Types.transfers.TransferInfo.PriorityEnum.Fast
   };

   // Send the request
   const transfersAPI = new TransfersAPI(client);
   const response = transfersAPI.TransfersApi.transferFunds(transferInfo, { idempotencyKey: "UUID" });
   ```

2. If the request is successful, you receive an **HTTP 2XX** response containing details, including the following parameters:

   | Parameter name                                                                                                                                         | Description                                             |
   | ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------- |
   | [review.numberOfApprovalsRequired](https://docs.adyen.com/api-explorer/transfers/latest/post/transfers#responses-202-review-numberOfApprovalsRequired) | Shows the number of approvals required to process the . |

   After triggering the review, a member of your team must [approve](/business-accounts/send-funds/approve-cancel-transfers) the before Adyen continues processing it.