---
title: "Instant card payouts"
description: "Learn how to make payouts to cards."
url: "https://docs.adyen.com/online-payments/online-payouts/instant-payouts"
source_url: "https://docs.adyen.com/online-payments/online-payouts/instant-payouts.md"
canonical: "https://docs.adyen.com/online-payments/online-payouts/instant-payouts"
last_modified: "2021-12-10T18:44:00+01:00"
language: "en"
---

# Instant card payouts

Learn how to make payouts to cards.

We are no longer accepting new integrations with the [Payout API](https://docs.adyen.com/api-explorer/Payout/latest/overview); use the [Transfers API](https://docs.adyen.com/api-explorer/transfers/latest/overview) instead. With the Transfers API, you can:

* Handle multiple payout use cases with a single API.
* Use new payout functionalities, such as instant payouts.
* Receive webhooks with more details and defined transfer states.

If you are:

* Building a new integration, refer to [Pay out to third-party cards](/payouts/payout-service/pay-out-to-cards/) to integrate with the Transfers API.
* Already integrated with the Payout API, reach out to your Adyen contact for information on how to migrate to the Transfers API.

Adyen supports paying out to Mastercard and Visa cards instantly, immediately returning the result of the payout attempt.

With one [/payout](https://docs.adyen.com/api-explorer/Payout/latest/post/payout) call, you can pay out to your customers for a variety of money transfer and funds disbursement use cases.

The funds will be made available within 30 minutes, but are typically available within 2 minutes. How long it takes depends on the issuer. And, the payout will immediately be reflected on the cardholder's debit card balance or open-to-buy credit limit.

There are two main use cases for instant card payouts:

* **Funds disbursements**: you pay out to your sellers, customers, freelancers, and so on. The purpose is typically crediting someone for delivering goods or services.
* **Money transfers**: you facilitate the transfer of money between two individuals, virtual wallets, or accounts. The purpose is typically moving funds.

These two use cases require different fields to be submitted in the payout request, as you can see in the examples.

## How it works

1. Contact your Adyen account manager or our [Support Team](https://ca-test.adyen.com/ca/ca/contactUs/support.shtml?form=other) to enable instant card payouts.\
   Using instant card payouts often requires a [local entity](#supported-countries), and requires compliance approval and additional configuration on our end.

2. Configure your account to receive [additional details](#additional-data-payout) in the API response.\
   You need these details to determine if the card is eligible for payouts. You also need additional details if you plan to make recurring payouts.

3. Make a [zero-auth payment](#payout-zero-auth) to check if the card is eligible for payouts.\
   If you plan to make recurring payouts, tokenize the card details by adding some parameters to the zero-auth payment request. You can then use the token to make future recurring payouts.

4. Make a payout. See [money transfers](#peer-to-peer-payouts) or [funds disbursements](#business-to-consumer-payout).

## Enable additional details in the API response

1. In your [Customer Area](https://ca-test.adyen.com/), go to **Developers** > **Additional data**.

2. Select the fields that you want to include.

   * To get the card eligibility details, under **Card**, select **Card bin payout details**.
   * To get the card BIN details, under **Card**, select **Card bin details**. Among other things, this will return the `fundingSource` and the `cardBin`.
   * To get the recurring details in the response so you can make more payments to the same card, under **Payment**, select **Recurring details**.

3. Select **Save configuration**.

## Check if the card is eligible for payouts

1. Submit a POST [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) request with:

   * [merchantAccount](https://docs.adyen.com/api-explorer/#/CheckoutService/latest/post/payments__reqParam_merchantAccount): your merchant account.
   * [paymentMethod](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments#request-paymentMethod): an object containing your customer's card details.

   You can only pass raw card data if you are [fully PCI compliant](/get-started-with-adyen/adyen-glossary/#pci-compliance). Otherwise, use our [Card Component](/payment-methods/cards/custom-card-integration) to securely collect and encrypt card details.

   * [amount](https://docs.adyen.com/api-explorer/#/CheckoutService/latest/post/payments__reqParam_amount): set the `amount.value` to zero, and the `amount.currency` to the currency that is applicable to the card.

   **Submit a zero-value payment request**

   ```bash
   curl https://checkout-test.adyen.com/v68/payments \
   -H 'x-api-key: ADYEN_API_KEY' \
   -H 'content-type: application/json' \
   -d '{
      "amount":{
         "value":0,
         "currency":"USD"
      },
      "paymentMethod":{
         "type":"scheme",
         "number": "4111111111111111",
         "expiryMonth": "03",
         "expiryYear": "2030",
         "cvc": "737",
         "holderName": "John Smith"
      },
      "reference":"YOUR_ORDER_NUMBER",
      "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
      "shopperReference":"YOUR_UNIQUE_SHOPPER_ID",
   }'
   ```

   **Example zero-value payment response**

   ```json
   {
    "additionalData":{
       "payoutEligible":"Y",
       "fundsAvailability":"I",
       "cardSchemeCommercial": "true",
       "cardPaymentMethod": "visa",
       "cardIssuingBank": "Bank of America",
       "cardIssuingCountry": "US",
       "cardIssuingCurrency": "USD",
       "cardBin": "411111",
       "fundingSource": "DEBIT"
    },
    "pspReference":"MLSPNCQ8HXSKGK82",
    "resultCode":"Authorised"
   }
   ```

[]()

2. Check the [payoutEligible](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments#responses-200-additionalData-ResponseAdditionalDataCommon-payoutEligible) parameter in the response. If the card is eligible for payouts, the possible values are:

   * **Y**: eligible for payout. For Mastercard, this means that the card is eligible for both domestic and cross-border payouts.
   * **D**: applies only to Mastercard. This means that the card is eligible only for domestic payouts.

   If you receive an **N** or **U**, the card cannot be used for payouts.

[]()

3. Check the [fundsAvailability](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments#responses-200-additionalData-ResponseAdditionalDataCommon-fundsAvailability) parameter in the response. The possible values are:

   * **I**: The card supports instant funds.
   * **N**: The card does not support instant funds.

   For Mastercard, the field is only returned if `payoutEligible` is **Y** or **D**.

### Tokenize the card details

For recurring payouts, you have to [tokenize](/online-payments/tokenization) the card details. You can do this by creating a recurring contract through a [/payments](https://docs.adyen.com/api-explorer/Checkout/latest/post/payments) request.

The example below combines the zero-auth call with creating a token that represents the card details.

**Save the card details**

#### curl

```bash
curl https://checkout-test.adyen.com/v68/payments \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
  "amount": {
      "value": 0,
      "currency": "USD"
  },
  "paymentMethod": {
      "type": "scheme",
      "number":"4111111111111111",
      "expiryMonth":"03",
      "expiryYear":"2030",
      "cvc":"737",
      "holderName":"John Smith"
  },
  "billingAddress":{
     "houseNumberOrName":"1",
     "street":"Infinite Loop",
     "city":"Cupertino",
     "stateOrProvince":"CA",
     "country":"US",
     "postalCode":"95014"
  },
  "storePaymentMethod": true,
  "reference": "YOUR_ORDER_NUMBER",
  "shopperInteraction": "Ecommerce",
  "recurringProcessingModel": "CardOnFile",
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID",
  "enablePayOut": "True",
  "dateOfBirth":"1990-01-01",
  "nationality":"US",
  "entityType":"Individual"
}'
```

#### Java

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

// For the live environment, additionally include your liveEndpointUrlPrefix.
Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
Amount amount = new Amount()
  .currency("USD")
  .value(0L);

CardDetails cardDetails = new CardDetails()
  .number("4111111111111111")
  .cvc("737")
  .holderName("John Smith")
  .expiryMonth("03")
  .expiryYear("2030")
  .type(CardDetails.TypeEnum.SCHEME);

BillingAddress billingAddress = new BillingAddress()
  .country("US")
  .stateOrProvince("CA")
  .city("Cupertino")
  .houseNumberOrName("1")
  .street("Infinite Loop")
  .postalCode("95014");

PaymentRequest paymentRequest = new PaymentRequest()
  .enablePayOut(True)
  .amount(amount)
  .entityType(PaymentRequest.EntityTypeEnum.INDIVIDUAL)
  .dateOfBirth(OffsetDateTime.parse("1990-01-01"))
  .reference("YOUR_ORDER_NUMBER")
  .storePaymentMethod(true)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .recurringProcessingModel(PaymentRequest.RecurringProcessingModelEnum.CARDONFILE)
  .paymentMethod(new CheckoutPaymentMethod(cardDetails))
  .shopperInteraction(PaymentRequest.ShopperInteractionEnum.ECOMMERCE)
  .billingAddress(billingAddress)
  .shopperReference("YOUR_UNIQUE_SHOPPER_ID");

// Send the request
PaymentsApi service = new PaymentsApi(client);
PaymentResponse response = service.payments(paymentRequest, new RequestOptions().idempotencyKey("UUID"));
```

#### PHP

```php
// Adyen PHP API Library v18.2.1
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Checkout\Amount;
use Adyen\Model\Checkout\CheckoutPaymentMethod;
use Adyen\Model\Checkout\BillingAddress;
use Adyen\Model\Checkout\PaymentRequest;
use Adyen\Service\Checkout\PaymentsApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
// For the live environment, additionally include your liveEndpointUrlPrefix.
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$amount = new Amount();
$amount
  ->setCurrency("USD")
  ->setValue(0);

$checkoutPaymentMethod = new CheckoutPaymentMethod();
$checkoutPaymentMethod
  ->setNumber("4111111111111111")
  ->setCvc("737")
  ->setHolderName("John Smith")
  ->setExpiryMonth("03")
  ->setExpiryYear("2030")
  ->setType("scheme");

$billingAddress = new BillingAddress();
$billingAddress
  ->setCountry("US")
  ->setStateOrProvince("CA")
  ->setCity("Cupertino")
  ->setHouseNumberOrName("1")
  ->setStreet("Infinite Loop")
  ->setPostalCode("95014");

$paymentRequest = new PaymentRequest();
$paymentRequest
  ->setEnablePayOut(True)
  ->setAmount($amount)
  ->setEntityType("Individual")
  ->setDateOfBirth("1990-01-01")
  ->setReference("YOUR_ORDER_NUMBER")
  ->setStorePaymentMethod(true)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setRecurringProcessingModel("CardOnFile")
  ->setPaymentMethod($checkoutPaymentMethod)
  ->setShopperInteraction("Ecommerce")
  ->setBillingAddress($billingAddress)
  ->setShopperReference("YOUR_UNIQUE_SHOPPER_ID");

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

// Send the request
$service = new PaymentsApi($client);
$response = $service->payments($paymentRequest, $requestOptions);
```

#### C\#

```cs
// Adyen .net API Library v17.0.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Checkout;
using Adyen.Service.Checkout;

// For the live environment, additionally include your liveEndpointUrlPrefix.
var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
Amount amount = new Amount
{
  Currency = "USD",
  Value = 0
};

CardDetails cardDetails = new CardDetails
{
  Number = "4111111111111111",
  Cvc = "737",
  HolderName = "John Smith",
  ExpiryMonth = "03",
  ExpiryYear = "2030",
  Type = CardDetails.TypeEnum.Scheme
};

BillingAddress billingAddress = new BillingAddress
{
  Country = "US",
  StateOrProvince = "CA",
  City = "Cupertino",
  HouseNumberOrName = "1",
  Street = "Infinite Loop",
  PostalCode = "95014"
};

PaymentRequest paymentRequest = new PaymentRequest
{
  EnablePayOut = True,
  Amount = amount,
  EntityType = PaymentRequest.EntityTypeEnum.Individual,
  DateOfBirth = DateTime.Parse("1990-01-01"),
  Reference = "YOUR_ORDER_NUMBER",
  StorePaymentMethod = true,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel = PaymentRequest.RecurringProcessingModelEnum.CardOnFile,
  PaymentMethod = new CheckoutPaymentMethod(cardDetails),
  ShopperInteraction = PaymentRequest.ShopperInteractionEnum.Ecommerce,
  BillingAddress = billingAddress,
  ShopperReference = "YOUR_UNIQUE_SHOPPER_ID"
};

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

#### NodeJS (JavaScript)

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

// Create the request object(s)
const paymentRequest = {
  amount: {
    value: 0,
    currency: "USD"
  },
  paymentMethod: {
    type: "scheme",
    number: "4111111111111111",
    expiryMonth: "03",
    expiryYear: "2030",
    cvc: "737",
    holderName: "John Smith"
  },
  billingAddress: {
    houseNumberOrName: "1",
    street: "Infinite Loop",
    city: "Cupertino",
    stateOrProvince: "CA",
    country: "US",
    postalCode: "95014"
  },
  storePaymentMethod: true,
  reference: "YOUR_ORDER_NUMBER",
  shopperInteraction: "Ecommerce",
  recurringProcessingModel: "CardOnFile",
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID",
  enablePayOut: "True",
  dateOfBirth: new Date("1990-01-01"),
  nationality: "US",
  entityType: "Individual"
}

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
```

#### Go

```go
// Adyen Go API Library v10.4.0
import (
  "context"
  "time"
  "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/checkout"
)
// For the live environment, additionally include your liveEndpointUrlPrefix.
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
amount := checkout.Amount{
  Currency: "USD",
  Value: 0,
}

cardDetails := checkout.CardDetails{
  Number: common.PtrString("4111111111111111"),
  Cvc: common.PtrString("737"),
  HolderName: common.PtrString("John Smith"),
  ExpiryMonth: common.PtrString("03"),
  ExpiryYear: common.PtrString("2030"),
  Type: common.PtrString("scheme"),
}

billingAddress := checkout.BillingAddress{
  Country: "US",
  StateOrProvince: common.PtrString("CA"),
  City: "Cupertino",
  HouseNumberOrName: "1",
  Street: "Infinite Loop",
  PostalCode: "95014",
}

paymentRequest := checkout.PaymentRequest{
  EnablePayOut: common.PtrBool(True),
  Amount: amount,
  EntityType: common.PtrString("Individual"),
  DateOfBirth:  func() *time.Time { t, _ := time.Parse(time.RFC3339, "1990-01-01"); return &t }(),
  Reference: "YOUR_ORDER_NUMBER",
  StorePaymentMethod: common.PtrBool(true),
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  RecurringProcessingModel: common.PtrString("CardOnFile"),
  PaymentMethod: checkout.CardDetailsAsCheckoutPaymentMethod(&cardDetails),
  ShopperInteraction: common.PtrString("Ecommerce"),
  BillingAddress: &billingAddress,
  ShopperReference: common.PtrString("YOUR_UNIQUE_SHOPPER_ID"),
}

// Send the request
service := client.Checkout()
req := service.PaymentsApi.PaymentsInput().IdempotencyKey("UUID").PaymentRequest(paymentRequest)
res, httpRes, err := service.PaymentsApi.Payments(context.Background(), req)
```

#### Python

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

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
# For the live environment, additionally include your liveEndpointUrlPrefix.
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "amount": {
    "value": 0,
    "currency": "USD"
  },
  "paymentMethod": {
    "type": "scheme",
    "number": "4111111111111111",
    "expiryMonth": "03",
    "expiryYear": "2030",
    "cvc": "737",
    "holderName": "John Smith"
  },
  "billingAddress": {
    "houseNumberOrName": "1",
    "street": "Infinite Loop",
    "city": "Cupertino",
    "stateOrProvince": "CA",
    "country": "US",
    "postalCode": "95014"
  },
  "storePaymentMethod": True,
  "reference": "YOUR_ORDER_NUMBER",
  "shopperInteraction": "Ecommerce",
  "recurringProcessingModel": "CardOnFile",
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID",
  "enablePayOut": "True",
  "dateOfBirth": "1990-01-01",
  "nationality": "US",
  "entityType": "Individual"
}

# Send the request
result = adyen.checkout.payments_api.payments(request=json_request, idempotency_key="UUID")
```

#### Ruby

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

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
# For the live environment, additionally include your liveEndpointUrlPrefix.
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :amount => {
    :value => 0,
    :currency => 'USD'
  },
  :paymentMethod => {
    :type => 'scheme',
    :number => '4111111111111111',
    :expiryMonth => '03',
    :expiryYear => '2030',
    :cvc => '737',
    :holderName => 'John Smith'
  },
  :billingAddress => {
    :houseNumberOrName => '1',
    :street => 'Infinite Loop',
    :city => 'Cupertino',
    :stateOrProvince => 'CA',
    :country => 'US',
    :postalCode => '95014'
  },
  :storePaymentMethod => true,
  :reference => 'YOUR_ORDER_NUMBER',
  :shopperInteraction => 'Ecommerce',
  :recurringProcessingModel => 'CardOnFile',
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :shopperReference => 'YOUR_UNIQUE_SHOPPER_ID',
  :enablePayOut => 'True',
  :dateOfBirth => '1990-01-01',
  :nationality => 'US',
  :entityType => 'Individual'
}

# Send the request
result = adyen.checkout.payments_api.payments(request_body, headers: { 'Idempotency-Key' => 'UUID' })
```

#### NodeJS (TypeScript)

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

// Create the request object(s)
const amount: Types.checkout.Amount = {
  currency: "USD",
  value: 0
};

const cardDetails: Types.checkout.CardDetails = {
  number: "4111111111111111",
  cvc: "737",
  holderName: "John Smith",
  expiryMonth: "03",
  expiryYear: "2030",
  type: Types.checkout.CardDetails.TypeEnum.Scheme
};

const billingAddress: Types.checkout.BillingAddress = {
  country: "US",
  stateOrProvince: "CA",
  city: "Cupertino",
  houseNumberOrName: "1",
  street: "Infinite Loop",
  postalCode: "95014"
};

const paymentRequest: Types.checkout.PaymentRequest = {
  enablePayOut: True,
  amount: amount,
  entityType: Types.checkout.PaymentRequest.EntityTypeEnum.Individual,
  dateOfBirth: new Date("1990-01-01"),
  reference: "YOUR_ORDER_NUMBER",
  storePaymentMethod: true,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  recurringProcessingModel: Types.checkout.PaymentRequest.RecurringProcessingModelEnum.CardOnFile,
  paymentMethod: cardDetails,
  shopperInteraction: Types.checkout.PaymentRequest.ShopperInteractionEnum.Ecommerce,
  billingAddress: billingAddress,
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID"
};

// Send the request
const checkoutAPI = new CheckoutAPI(client);
const response = checkoutAPI.PaymentsApi.payments(paymentRequest, { idempotencyKey: "UUID" });
```

**Example response**

```json
{
 "additionalData": {
   "recurringProcessingModel": "CardOnFile",
   "recurring.shopperReference": "YOUR_UNIQUE_SHOPPER_ID",
   "recurring.recurringDetailReference": "8315659584588245",
   "payoutEligible":"Y",
   "fundsAvailability":"I"
 },
 "pspReference": "ZC4R4RBFJGXXGN82",
 "resultCode": "Authorised",
 "amount": {
   "currency": "USD",
   "value": 0
 },
 "merchantReference": "Your order number"
}
```

## Funds disbursements

The examples below demonstrate how to send a one-off or recurring funds disbursement payout. Submit this request to the [/payout](https://docs.adyen.com/api-explorer/Payout/latest/post/payout) endpoint.

The data you submit in your requests must meet our requirements to pass our [data validation](#data-validation) checks.

### Tab: One-off funds disbursements

### Request

#### curl

```bash
curl https://pal-test.adyen.com/pal/servlet/Payout/v68/payout \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
     "amount":{
        "value":2500,
        "currency":"USD"
     },
     "card":{
        "number":"4111111111111111",
        "expiryMonth":"03",
        "expiryYear":"2030",
        "holderName":"John Smith"
     },
     "billingAddress":{
        "houseNumberOrName":"1",
        "street":"Infinite Loop",
        "city":"Cupertino",
        "postalCode":"95014",
        "stateOrProvince":"CA",
        "country":"US"
     },
     "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
     "reference":"YOUR_REFERENCE_FOR_THE_PAYOUT",
     "{hint:The name of the shopper receiving the funds.}shopperName{/hint}":{
        "firstName":"John",
        "lastName":"Smith"
     },
     "dateOfBirth":"1990-01-01",
     "nationality":"US",
	 "entityType":"Individual"
}'
```

#### Java

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

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

// Create the request object(s)
Amount amount = new Amount()
  .currency("USD")
  .value(2500L);

Name name = new Name()
  .firstName("John")
  .lastName("Smith");

Address address = new Address()
  .country("US")
  .stateOrProvince("CA")
  .city("Cupertino")
  .houseNumberOrName("1")
  .street("Infinite Loop")
  .postalCode("95014");

Card card = new Card()
  .number("4111111111111111")
  .holderName("John Smith")
  .expiryMonth("03")
  .expiryYear("2030");

PayoutRequest payoutRequest = new PayoutRequest()
  .reference("YOUR_REFERENCE_FOR_THE_PAYOUT")
  .amount(amount)
  .shopperName(name)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .billingAddress(address)
  .card(card);

// Send the request
InstantPayoutsApi service = new InstantPayoutsApi(client);
PayoutResponse response = service.payout(payoutRequest, null);
```

#### PHP

```php
// Adyen PHP API Library v18.2.1
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Payout\Amount;
use Adyen\Model\Payout\Name;
use Adyen\Model\Payout\Address;
use Adyen\Model\Payout\Card;
use Adyen\Model\Payout\PayoutRequest;
use Adyen\Service\Payout\InstantPayoutsApi;

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


// Create the request object(s)
$amount = new Amount();
$amount
  ->setCurrency("USD")
  ->setValue(2500);

$name = new Name();
$name
  ->setFirstName("John")
  ->setLastName("Smith");

$address = new Address();
$address
  ->setCountry("US")
  ->setStateOrProvince("CA")
  ->setCity("Cupertino")
  ->setHouseNumberOrName("1")
  ->setStreet("Infinite Loop")
  ->setPostalCode("95014");

$card = new Card();
$card
  ->setNumber("4111111111111111")
  ->setHolderName("John Smith")
  ->setExpiryMonth("03")
  ->setExpiryYear("2030");

$payoutRequest = new PayoutRequest();
$payoutRequest
  ->setReference("YOUR_REFERENCE_FOR_THE_PAYOUT")
  ->setAmount($amount)
  ->setShopperName($name)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setBillingAddress($address)
  ->setCard($card);

// Send the request
$service = new InstantPayoutsApi($client);
$response = $service->payout($payoutRequest);
```

#### C\#

```cs
// Adyen .net API Library v17.0.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Payout;
using Adyen.Service.Payout;

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

// Create the request object(s)
Amount amount = new Amount
{
  Currency = "USD",
  Value = 2500
};

Name name = new Name
{
  FirstName = "John",
  LastName = "Smith"
};

Address address = new Address
{
  Country = "US",
  StateOrProvince = "CA",
  City = "Cupertino",
  HouseNumberOrName = "1",
  Street = "Infinite Loop",
  PostalCode = "95014"
};

Card card = new Card
{
  Number = "4111111111111111",
  HolderName = "John Smith",
  ExpiryMonth = "03",
  ExpiryYear = "2030"
};

PayoutRequest payoutRequest = new PayoutRequest
{
  Reference = "YOUR_REFERENCE_FOR_THE_PAYOUT",
  Amount = amount,
  ShopperName = name,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  BillingAddress = address,
  Card = card
};

// Send the request
var service = new InstantPayoutsService(client);
var response = service.Payout(payoutRequest);
```

#### NodeJS (JavaScript)

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

// Create the request object(s)
const payoutRequest = {
  amount: {
    value: 2500,
    currency: "USD"
  },
  card: {
    number: "4111111111111111",
    expiryMonth: "03",
    expiryYear: "2030",
    holderName: "John Smith"
  },
  billingAddress: {
    houseNumberOrName: "1",
    street: "Infinite Loop",
    city: "Cupertino",
    postalCode: "95014",
    stateOrProvince: "CA",
    country: "US"
  },
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  reference: "YOUR_REFERENCE_FOR_THE_PAYOUT",
  shopperName: {
    firstName: "John",
    lastName: "Smith"
  },
  dateOfBirth: new Date("1990-01-01"),
  nationality: "US",
  entityType: "Individual"
}

// Send the request
const payoutAPI = new PayoutAPI(client);
const response = payoutAPI.InstantPayoutsApi.payout(payoutRequest);
```

#### Go

```go
// Adyen Go API Library v10.4.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/payout"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
amount := payout.Amount{
  Currency: "USD",
  Value: 2500,
}

name := payout.Name{
  FirstName: "John",
  LastName: "Smith",
}

address := payout.Address{
  Country: "US",
  StateOrProvince: common.PtrString("CA"),
  City: "Cupertino",
  HouseNumberOrName: "1",
  Street: "Infinite Loop",
  PostalCode: "95014",
}

card := payout.Card{
  Number: common.PtrString("4111111111111111"),
  HolderName: common.PtrString("John Smith"),
  ExpiryMonth: common.PtrString("03"),
  ExpiryYear: common.PtrString("2030"),
}

payoutRequest := payout.PayoutRequest{
  Reference: "YOUR_REFERENCE_FOR_THE_PAYOUT",
  Amount: amount,
  ShopperName: &name,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  BillingAddress: &address,
  Card: &card,
}

// Send the request
service := client.Payout()
req := service.InstantPayoutsApi.PayoutInput().PayoutRequest(payoutRequest)
res, httpRes, err := service.InstantPayoutsApi.Payout(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.5.1
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": 2500,
    "currency": "USD"
  },
  "card": {
    "number": "4111111111111111",
    "expiryMonth": "03",
    "expiryYear": "2030",
    "holderName": "John Smith"
  },
  "billingAddress": {
    "houseNumberOrName": "1",
    "street": "Infinite Loop",
    "city": "Cupertino",
    "postalCode": "95014",
    "stateOrProvince": "CA",
    "country": "US"
  },
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "reference": "YOUR_REFERENCE_FOR_THE_PAYOUT",
  "shopperName": {
    "firstName": "John",
    "lastName": "Smith"
  },
  "dateOfBirth": "1990-01-01",
  "nationality": "US",
  "entityType": "Individual"
}

# Send the request
result = adyen.payout.instant_payouts_api.payout(request=json_request)
```

#### Ruby

```rb
# Adyen Ruby API Library v9.5.1
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 => 2500,
    :currency => 'USD'
  },
  :card => {
    :number => '4111111111111111',
    :expiryMonth => '03',
    :expiryYear => '2030',
    :holderName => 'John Smith'
  },
  :billingAddress => {
    :houseNumberOrName => '1',
    :street => 'Infinite Loop',
    :city => 'Cupertino',
    :postalCode => '95014',
    :stateOrProvince => 'CA',
    :country => 'US'
  },
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :reference => 'YOUR_REFERENCE_FOR_THE_PAYOUT',
  :shopperName => {
    :firstName => 'John',
    :lastName => 'Smith'
  },
  :dateOfBirth => '1990-01-01',
  :nationality => 'US',
  :entityType => 'Individual'
}

# Send the request
result = adyen.payout.instant_payouts_api.payout(request_body)
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v17.3.0
// Require the parts of the module you want to use
import { Client, PayoutAPI, 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 amount: Types.payout.Amount = {
  currency: "USD",
  value: 2500
};

const name: Types.payout.Name = {
  firstName: "John",
  lastName: "Smith"
};

const address: Types.payout.Address = {
  country: "US",
  stateOrProvince: "CA",
  city: "Cupertino",
  houseNumberOrName: "1",
  street: "Infinite Loop",
  postalCode: "95014"
};

const card: Types.payout.Card = {
  number: "4111111111111111",
  holderName: "John Smith",
  expiryMonth: "03",
  expiryYear: "2030"
};

const payoutRequest: Types.payout.PayoutRequest = {
  reference: "YOUR_REFERENCE_FOR_THE_PAYOUT",
  amount: amount,
  shopperName: name,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  billingAddress: address,
  card: card
};

// Send the request
const payoutAPI = new PayoutAPI(client);
const response = payoutAPI.InstantPayoutsApi.payout(payoutRequest);
```

### Response

**Example funds disbursements response**

```json
{
   "pspReference":"R5CZ2NWPJTGV9D82",
   "resultCode":"Authorised",
   "additionalData":{
      "authCode":"83152"
   }
} 
```

### Tab: Recurring funds disbursements

### Request

#### curl

```bash
curl https://pal-test.adyen.com/pal/servlet/Payout/v68/payout \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
  "amount":{
      "value":2500,
      "currency":"USD"
  },
  "selectedRecurringDetailReference": "8315535507322518",
  "recurring": {
    "contract": "PAYOUT"
  },
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID",
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "reference": "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  "shopperInteraction": "ContAuth"
}'
```

#### Java

```java
// Adyen Java API Library v25.0.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.payout.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.payout.*;

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

// Create the request object(s)
Amount amount = new Amount()
  .currency("USD")
  .value(2500L);

Recurring recurring = new Recurring()
  .contract(Recurring.ContractEnum.PAYOUT);

PayoutRequest payoutRequest = new PayoutRequest()
  .reference("YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT")
  .amount(amount)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .recurring(recurring)
  .selectedRecurringDetailReference("8315535507322518")
  .shopperInteraction(PayoutRequest.ShopperInteractionEnum.CONTAUTH)
  .shopperReference("YOUR_UNIQUE_SHOPPER_ID");

// Make the API call
InstantPayoutsApi service = new InstantPayoutsApi(client);
PayoutResponse response = service.payout(payoutRequest, null);
```

#### PHP

```php
// Adyen PHP API Library v17.4.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Payout\Amount;
use Adyen\Model\Payout\Recurring;
use Adyen\Model\Payout\PayoutRequest;
use Adyen\Service\Payout\InstantPayoutsApi;

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


// Create the request object(s)
$amount = new Amount();
$amount
  ->setCurrency("USD")
  ->setValue(2500);

$recurring = new Recurring();
$recurring
  ->setContract("PAYOUT");

$payoutRequest = new PayoutRequest();
$payoutRequest
  ->setReference("YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT")
  ->setAmount($amount)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setRecurring($recurring)
  ->setSelectedRecurringDetailReference("8315535507322518")
  ->setShopperInteraction("ContAuth")
  ->setShopperReference("YOUR_UNIQUE_SHOPPER_ID");

// Make the API call
$service = new InstantPayoutsApi($client);
$response = $service->payout($payoutRequest);
```

#### C\#

```cs
// Adyen .net API Library v14.4.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Payout;
using Adyen.Service.Payout;

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

// Create the request object(s)
Amount amount = new Amount
{
  Currency = "USD",
  Value = 2500
};

Recurring recurring = new Recurring
{
  Contract = Recurring.ContractEnum.PAYOUT
};

PayoutRequest payoutRequest = new PayoutRequest
{
  Reference = "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  Amount = amount,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  Recurring = recurring,
  SelectedRecurringDetailReference = "8315535507322518",
  ShopperInteraction = PayoutRequest.ShopperInteractionEnum.ContAuth,
  ShopperReference = "YOUR_UNIQUE_SHOPPER_ID"
};

// Make the API call
var service = new InstantPayoutsService(client);
var response = service.Payout(payoutRequest);
```

#### NodeJS (JavaScript)

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

// Create the request object(s)
const payoutRequest = {
  amount: {
    value: 2500,
    currency: "USD"
  },
  selectedRecurringDetailReference: "8315535507322518",
  recurring: {
    contract: "PAYOUT"
  },
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID",
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  reference: "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  shopperInteraction: "ContAuth"
}

// Make the API call
const payoutAPI = new PayoutAPI(client);
const response = payoutAPI.InstantPayoutsApi.payout(payoutRequest);
```

#### Go

```go
// Adyen Go API Library v9.3.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/payout"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
amount := payout.Amount{
  Currency: "USD",
  Value: 2500,
}

recurring := payout.Recurring{
  Contract: common.PtrString("PAYOUT"),
}

payoutRequest := payout.PayoutRequest{
  Reference: "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  Amount: amount,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  Recurring: &recurring,
  SelectedRecurringDetailReference: common.PtrString("8315535507322518"),
  ShopperInteraction: common.PtrString("ContAuth"),
  ShopperReference: common.PtrString("YOUR_UNIQUE_SHOPPER_ID"),
}

// Make the API call
service := client.Payout()
req := service.InstantPayoutsApi.PayoutInput().PayoutRequest(payoutRequest)
res, httpRes, err := service.InstantPayoutsApi.Payout(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.2.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": 2500,
    "currency": "USD"
  },
  "selectedRecurringDetailReference": "8315535507322518",
  "recurring": {
    "contract": "PAYOUT"
  },
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID",
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "reference": "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  "shopperInteraction": "ContAuth"
}

# Make the API call
result = adyen.payout.instant_payouts_api.payout(request=json_request)
```

#### Ruby

```rb
# Adyen Ruby API Library v9.3.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 => 2500,
    :currency => 'USD'
  },
  :selectedRecurringDetailReference => '8315535507322518',
  :recurring => {
    :contract => 'PAYOUT'
  },
  :shopperReference => 'YOUR_UNIQUE_SHOPPER_ID',
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :reference => 'YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT',
  :shopperInteraction => 'ContAuth'
}

# Make the API call
result = adyen.payout.instant_payouts_api.payout(request_body)
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
import { Client, PayoutAPI, 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 amount: Types.payout.Amount = {
  currency: "USD",
  value: 2500
};

const recurring: Types.payout.Recurring = {
  contract: Types.payout.Recurring.ContractEnum.PAYOUT
};

const payoutRequest: Types.payout.PayoutRequest = {
  reference: "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  amount: amount,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  recurring: recurring,
  selectedRecurringDetailReference: "8315535507322518",
  shopperInteraction: Types.payout.PayoutRequest.ShopperInteractionEnum.ContAuth,
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID"
};

// Make the API call
const payoutAPI = new PayoutAPI(client);
const response = payoutAPI.InstantPayoutsApi.payout(payoutRequest);
```

### Response

**Example recurring funds disbursements response**

```json
{
   "pspReference":"R5CZ2NWPJTGV9D82",
   "resultCode":"Authorised",
   "additionalData":{
      "authCode":"83152"
   }
} 
```

## Money transfers

The examples below demonstrate how to send a one-off or recurring payout to transfer money from one individual to another, and how to transfer money from a virtual wallet or account onto a card.

The difference between these scenarios is the funding source, and what you send in the `fundSource` object.

For **individuals**:

* Funds are transferred from one card to another.
* Provide the details of the sender in the `fundSource` object.
* The `additionalData.fundingSource` is usually `DEBIT`.

For **virtual wallets or accounts**:

* Funds are cashed out from the wallet or account onto a card.
* Provide the details of the virtual wallet or account that the funds are moved out of in the `fundSource` object.
* The `additionalData.fundingSource` is `DEPOSIT_ACCOUNT`. The source is a deposit account because the virtual wallet or account is provided by a separate company. The person who opened the virtual wallet or account owns the funds deposited in it. The funds can be transferred to their own card, or to a different person's card.

In addition, for **Visa transactions**:

* Include a `networkTxReference`. With money transfers, the payout is preceded by a 'pay-in' transaction where funds go from the shopper to the merchant. In the case of Visa transactions, you can connect the two transactions by including the `networkTxReference` from the pay-in response in your payout request.

Submit your payout request to the  [/payout](https://docs.adyen.com/api-explorer/Payout/latest/post/payout) endpoint. The data you submit in your requests must meet our requirements to pass our [data validation](#data-validation) checks.

### Tab: Transfer between individuals

### Request

#### curl

```bash
curl https://pal-test.adyen.com/pal/servlet/Payout/v68/payout \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
  "amount":{
     "value":2500,
     "currency":"USD"
  },
  "{hint:The card details of the shopper receiving the funds.}card{/hint}":{
     "number":"4111111111111111",
     "expiryMonth":"03",
     "expiryYear":"2030",
     "holderName":"John Smith"
  },
  "billingAddress":{
     "houseNumberOrName":"1",
     "street":"Test Street",
     "country":"US",
     "postalCode":"20500",
     "city":"Washington",
     "{hint:Value cannot be null. Specify NA if the field is not applicable.}stateOrProvince{/hint}":"DC"
  },
  "fundSource":{
     "additionalData":{
        "fundingSource":"DEBIT",
        "{hint:Only for Visa payouts. Specify the networkTxReference from the pay-in transaction.}networkTxReference{/hint}":"412345678912345"
     },
     "billingAddress":{
        "houseNumberOrName":"1",
        "street":"Infinite Loop",
        "country":"US",
        "postalCode":"95014",
        "city":"Cupertino",
        "{hint:Value cannot be null. Specify NA or echo the country if the field is not applicable.}stateOrProvince{/hint}":"CA"
     },
     "{hint:The card details of the shopper sending the funds.}card{/hint}":{
        "expiryMonth":"03",
        "expiryYear":"2030",
        "holderName":"Simon Hopper",
        "number":"4400000000000008"
     },
     "{hint:The name of the shopper sending the funds.}shopperName{/hint}":{
        "firstName":"Simon",
        "lastName":"Hopper"
     }
  },
  "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
  "reference":"YOUR_REFERENCE_FOR_THE_PAYOUT",
  "{hint:The name of the shopper receiving the funds.}shopperName{/hint}":{
     "firstName":"John",
     "lastName":"Smith"
  },
  "shopperStatement":"SHOPPER_STATEMENT",
  "dateOfBirth":"1990-01-01",
  "nationality":"US",
  "entityType":"Individual"
}'
```

#### Java

```java
// Adyen Java API Library v32.0.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.payout.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.payout.*;

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

// Create the request object(s)
Name fundSourceName = new Name()
  .firstName("Simon")
  .lastName("Hopper");

Address fundSourceAddress = new Address()
  .country("US")
  .stateOrProvince("CA")
  .city("Cupertino")
  .houseNumberOrName("1")
  .street("Infinite Loop")
  .postalCode("95014");

Card fundSourceCard = new Card()
  .number("4400000000000008")
  .holderName("Simon Hopper")
  .expiryMonth("03")
  .expiryYear("2030");

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

Name name = new Name()
  .firstName("John")
  .lastName("Smith");

Address address = new Address()
  .country("US")
  .stateOrProvince("DC")
  .city("Washington")
  .houseNumberOrName("1")
  .street("Test Street")
  .postalCode("20500");

Card card = new Card()
  .number("4111111111111111")
  .holderName("John Smith")
  .expiryMonth("03")
  .expiryYear("2030");

FundSource fundSource = new FundSource()
  .shopperName(fundSourceName)
  .additionalData(new HashMap<String, String>(Map.of(
    "networkTxReference", "412345678912345",
    "fundingSource", "DEBIT"
  )))
  .billingAddress(fundSourceAddress)
  .card(fundSourceCard);

PayoutRequest payoutRequest = new PayoutRequest()
  .reference("YOUR_REFERENCE_FOR_THE_PAYOUT")
  .amount(amount)
  .shopperName(name)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .billingAddress(address)
  .card(card)
  .fundSource(fundSource);

// Send the request
InstantPayoutsApi service = new InstantPayoutsApi(client);
PayoutResponse response = service.payout(payoutRequest, null);
```

#### PHP

```php
<?php
// Adyen PHP API Library v23.0.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Payout\Amount;
use Adyen\Model\Payout\Name;
use Adyen\Model\Payout\Address;
use Adyen\Model\Payout\Card;
use Adyen\Model\Payout\FundSource;
use Adyen\Model\Payout\PayoutRequest;
use Adyen\Service\Payout\InstantPayoutsApi;

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


// Create the request object(s)
$fundSourceName = new Name();
$fundSourceName
  ->setFirstName("Simon")
  ->setLastName("Hopper");

$fundSourceAddress = new Address();
$fundSourceAddress
  ->setCountry("US")
  ->setStateOrProvince("CA")
  ->setCity("Cupertino")
  ->setHouseNumberOrName("1")
  ->setStreet("Infinite Loop")
  ->setPostalCode("95014");

$fundSourceCard = new Card();
$fundSourceCard
  ->setNumber("4400000000000008")
  ->setHolderName("Simon Hopper")
  ->setExpiryMonth("03")
  ->setExpiryYear("2030");

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

$name = new Name();
$name
  ->setFirstName("John")
  ->setLastName("Smith");

$address = new Address();
$address
  ->setCountry("US")
  ->setStateOrProvince("DC")
  ->setCity("Washington")
  ->setHouseNumberOrName("1")
  ->setStreet("Test Street")
  ->setPostalCode("20500");

$card = new Card();
$card
  ->setNumber("4111111111111111")
  ->setHolderName("John Smith")
  ->setExpiryMonth("03")
  ->setExpiryYear("2030");

$fundSource = new FundSource();
$fundSource
  ->setShopperName($fundSourceName)
  ->setAdditionalData(
    array(
      "networkTxReference" => "412345678912345",
      "fundingSource" => "DEBIT"
    )
  )
  ->setBillingAddress($fundSourceAddress)
  ->setCard($fundSourceCard);

$payoutRequest = new PayoutRequest();
$payoutRequest
  ->setReference("YOUR_REFERENCE_FOR_THE_PAYOUT")
  ->setAmount($amount)
  ->setShopperName($name)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setBillingAddress($address)
  ->setCard($card)
  ->setFundSource($fundSource);

// Send the request
$service = new InstantPayoutsApi($client);
$response = $service->payout($payoutRequest);
```

#### C\#

```cs
// Adyen .net API Library v26.0.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Payout;
using Adyen.Service.Payout;

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

// Create the request object(s)
Name fundSourceName = new Name
{
  FirstName = "Simon",
  LastName = "Hopper"
};

Address fundSourceAddress = new Address
{
  Country = "US",
  StateOrProvince = "CA",
  City = "Cupertino",
  HouseNumberOrName = "1",
  Street = "Infinite Loop",
  PostalCode = "95014"
};

Card fundSourceCard = new Card
{
  Number = "4400000000000008",
  HolderName = "Simon Hopper",
  ExpiryMonth = "03",
  ExpiryYear = "2030"
};

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

Name name = new Name
{
  FirstName = "John",
  LastName = "Smith"
};

Address address = new Address
{
  Country = "US",
  StateOrProvince = "DC",
  City = "Washington",
  HouseNumberOrName = "1",
  Street = "Test Street",
  PostalCode = "20500"
};

Card card = new Card
{
  Number = "4111111111111111",
  HolderName = "John Smith",
  ExpiryMonth = "03",
  ExpiryYear = "2030"
};

FundSource fundSource = new FundSource
{
  ShopperName = fundSourceName,
  AdditionalData = new Dictionary<string, string>
  {

    { "networkTxReference", "412345678912345" },
    { "fundingSource", "DEBIT" }
  },
  BillingAddress = fundSourceAddress,
  Card = fundSourceCard
};

PayoutRequest payoutRequest = new PayoutRequest
{
  Reference = "YOUR_REFERENCE_FOR_THE_PAYOUT",
  Amount = amount,
  ShopperName = name,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  BillingAddress = address,
  Card = card,
  FundSource = fundSource
};

// Send the request
var service = new InstantPayoutsService(client);
var response = service.Payout(payoutRequest);
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v22.1.0
// Require the parts of the module you want to use
const { Client, PayoutAPI } = require('@adyen/api-library');

const client = new Client({ apiKey: "ADYEN_API_KEY", environment: "TEST" });

// Create the request object(s)
const payoutRequest = {
  amount: {
    value: 2500,
    currency: "USD"
  },
  card: {
    number: "4111111111111111",
    expiryMonth: "03",
    expiryYear: "2030",
    holderName: "John Smith"
  },
  billingAddress: {
    houseNumberOrName: "1",
    street: "Test Street",
    country: "US",
    postalCode: "20500",
    city: "Washington",
    stateOrProvince: "DC"
  },
  fundSource: {
    additionalData: {
      fundingSource: "DEBIT",
      networkTxReference: "412345678912345"
    },
    billingAddress: {
      houseNumberOrName: "1",
      street: "Infinite Loop",
      country: "US",
      postalCode: "95014",
      city: "Cupertino",
      stateOrProvince: "CA"
    },
    card: {
      expiryMonth: "03",
      expiryYear: "2030",
      holderName: "Simon Hopper",
      number: "4400000000000008"
    },
    shopperName: {
      firstName: "Simon",
      lastName: "Hopper"
    }
  },
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  reference: "YOUR_REFERENCE_FOR_THE_PAYOUT",
  shopperName: {
    firstName: "John",
    lastName: "Smith"
  },
  shopperStatement: "SHOPPER_STATEMENT",
  dateOfBirth: new Date("1990-01-01"),
  nationality: "US",
  entityType: "Individual"
}

// Send the request
const payoutAPI = new PayoutAPI(client);
const response = payoutAPI.InstantPayoutsApi.payout(payoutRequest);
```

#### Go

```go
// Adyen Go API Library v16.1.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/payout"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
fundSourceName := payout.Name{
  FirstName: "Simon",
  LastName: "Hopper",
}

fundSourceAddress := payout.Address{
  Country: "US",
  StateOrProvince: common.PtrString("CA"),
  City: "Cupertino",
  HouseNumberOrName: "1",
  Street: "Infinite Loop",
  PostalCode: "95014",
}

fundSourceCard := payout.Card{
  Number: common.PtrString("4400000000000008"),
  HolderName: common.PtrString("Simon Hopper"),
  ExpiryMonth: common.PtrString("03"),
  ExpiryYear: common.PtrString("2030"),
}

amount := payout.Amount{
  Currency: "USD",
  Value: 2500,
}

name := payout.Name{
  FirstName: "John",
  LastName: "Smith",
}

address := payout.Address{
  Country: "US",
  StateOrProvince: common.PtrString("DC"),
  City: "Washington",
  HouseNumberOrName: "1",
  Street: "Test Street",
  PostalCode: "20500",
}

card := payout.Card{
  Number: common.PtrString("4111111111111111"),
  HolderName: common.PtrString("John Smith"),
  ExpiryMonth: common.PtrString("03"),
  ExpiryYear: common.PtrString("2030"),
}

fundSource := payout.FundSource{
  ShopperName: &fundSourceName,
  AdditionalData: &map[string]string{
    "networkTxReference": "412345678912345",
    "fundingSource": "DEBIT",
  },
  BillingAddress: &fundSourceAddress,
  Card: &fundSourceCard,
}

payoutRequest := payout.PayoutRequest{
  Reference: "YOUR_REFERENCE_FOR_THE_PAYOUT",
  Amount: amount,
  ShopperName: &name,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  BillingAddress: &address,
  Card: &card,
  FundSource: &fundSource,
}

// Send the request
service := client.Payout()
req := service.InstantPayoutsApi.PayoutInput().PayoutRequest(payoutRequest)
res, httpRes, err := service.InstantPayoutsApi.Payout(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v13.2.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": 2500,
    "currency": "USD"
  },
  "card": {
    "number": "4111111111111111",
    "expiryMonth": "03",
    "expiryYear": "2030",
    "holderName": "John Smith"
  },
  "billingAddress": {
    "houseNumberOrName": "1",
    "street": "Test Street",
    "country": "US",
    "postalCode": "20500",
    "city": "Washington",
    "stateOrProvince": "DC"
  },
  "fundSource": {
    "additionalData": {
      "fundingSource": "DEBIT",
      "networkTxReference": "412345678912345"
    },
    "billingAddress": {
      "houseNumberOrName": "1",
      "street": "Infinite Loop",
      "country": "US",
      "postalCode": "95014",
      "city": "Cupertino",
      "stateOrProvince": "CA"
    },
    "card": {
      "expiryMonth": "03",
      "expiryYear": "2030",
      "holderName": "Simon Hopper",
      "number": "4400000000000008"
    },
    "shopperName": {
      "firstName": "Simon",
      "lastName": "Hopper"
    }
  },
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "reference": "YOUR_REFERENCE_FOR_THE_PAYOUT",
  "shopperName": {
    "firstName": "John",
    "lastName": "Smith"
  },
  "shopperStatement": "SHOPPER_STATEMENT",
  "dateOfBirth": "1990-01-01",
  "nationality": "US",
  "entityType": "Individual"
}

# Send the request
result = adyen.payout.instant_payouts_api.payout(request=json_request)
```

#### Ruby

```rb
# Adyen Ruby API Library v10.1.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 => 2500,
    :currency => 'USD'
  },
  :card => {
    :number => '4111111111111111',
    :expiryMonth => '03',
    :expiryYear => '2030',
    :holderName => 'John Smith'
  },
  :billingAddress => {
    :houseNumberOrName => '1',
    :street => 'Test Street',
    :country => 'US',
    :postalCode => '20500',
    :city => 'Washington',
    :stateOrProvince => 'DC'
  },
  :fundSource => {
    :additionalData => {
      :fundingSource => 'DEBIT',
      :networkTxReference => '412345678912345'
    },
    :billingAddress => {
      :houseNumberOrName => '1',
      :street => 'Infinite Loop',
      :country => 'US',
      :postalCode => '95014',
      :city => 'Cupertino',
      :stateOrProvince => 'CA'
    },
    :card => {
      :expiryMonth => '03',
      :expiryYear => '2030',
      :holderName => 'Simon Hopper',
      :number => '4400000000000008'
    },
    :shopperName => {
      :firstName => 'Simon',
      :lastName => 'Hopper'
    }
  },
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :reference => 'YOUR_REFERENCE_FOR_THE_PAYOUT',
  :shopperName => {
    :firstName => 'John',
    :lastName => 'Smith'
  },
  :shopperStatement => 'SHOPPER_STATEMENT',
  :dateOfBirth => '1990-01-01',
  :nationality => 'US',
  :entityType => 'Individual'
}

# Send the request
result = adyen.payout.instant_payouts_api.payout(request_body)
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v22.1.0
// Require the parts of the module you want to use
import { Client, PayoutAPI, Types } from "@adyen/api-library";

const client = new Client({ apiKey: "ADYEN_API_KEY", environment: "TEST" });

// Create the request object(s)
const fundSourceName: Types.payout.Name = {
  firstName: "Simon",
  lastName: "Hopper"
};

const fundSourceAddress: Types.payout.Address = {
  country: "US",
  stateOrProvince: "CA",
  city: "Cupertino",
  houseNumberOrName: "1",
  street: "Infinite Loop",
  postalCode: "95014"
};

const fundSourceCard: Types.payout.Card = {
  number: "4400000000000008",
  holderName: "Simon Hopper",
  expiryMonth: "03",
  expiryYear: "2030"
};

const amount: Types.payout.Amount = {
  currency: "USD",
  value: 2500
};

const name: Types.payout.Name = {
  firstName: "John",
  lastName: "Smith"
};

const address: Types.payout.Address = {
  country: "US",
  stateOrProvince: "DC",
  city: "Washington",
  houseNumberOrName: "1",
  street: "Test Street",
  postalCode: "20500"
};

const card: Types.payout.Card = {
  number: "4111111111111111",
  holderName: "John Smith",
  expiryMonth: "03",
  expiryYear: "2030"
};

const fundSource: Types.payout.FundSource = {
  shopperName: fundSourceName,
  additionalData: {
    "networkTxReference": "412345678912345",
    "fundingSource": "DEBIT"
  },
  billingAddress: fundSourceAddress,
  card: fundSourceCard
};

const payoutRequest: Types.payout.PayoutRequest = {
  reference: "YOUR_REFERENCE_FOR_THE_PAYOUT",
  amount: amount,
  shopperName: name,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  billingAddress: address,
  card: card,
  fundSource: fundSource
};

// Send the request
const payoutAPI = new PayoutAPI(client);
const response = payoutAPI.InstantPayoutsApi.payout(payoutRequest);
```

### Response

**Example money transfer response**

```json
{
   "pspReference":"GH4R4RBFJGXXGN82",
   "resultCode":"Authorised",
   "additionalData":{
      "authCode":"83152"
   }
} 
```

### Tab: Transfer from a virtual wallet or account to a card

### Request

#### curl

```bash
curl https://pal-test.adyen.com/pal/servlet/Payout/v68/payout \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
  "amount":{
     "value":2500,
     "currency":"USD"
  },
  "card":{
     "number":"4111111111111111",
     "expiryMonth":"03",
     "expiryYear":"2030",
     "{hint:The holder name on the card connected to the wallet or account.}holderName{/hint}":"John Smith"
  },
  "billingAddress":{
     "houseNumberOrName":"1",
     "street":"Test Street",
     "country":"US",
     "postalCode":"20500",
     "city":"Washington",
     "{hint:Value cannot be null. Specify NA if the field is not applicable.}stateOrProvince{/hint}":"DC"
  },
  "{hint:The details of the wallet or account.}fundSource{/hint}":{
     "additionalData":{
        "fundingSource":"DEPOSIT_ACCOUNT",
        "{hint:The identifier that uniquely identifies the wallet or account. Not required when the fundingSource is DEBIT.}walletIdentifier{/hint}" : "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
        "{hint:Only for Visa payouts. Specify the networkTxReference from the pay-in transaction.}networkTxReference{/hint}":"412345678912345"
     },
     "billingAddress":{
        "houseNumberOrName":"1",
        "street":"Infinite Loop",
        "country":"US",
        "postalCode":"95014",
        "city":"Cupertino",
        "{hint:Value cannot be null. Specify NA if the field is not applicable.}stateOrProvince{/hint}":"CA"
     },
     "{hint:The name of the shopper moving the funds out of the wallet or account.}shopperName{/hint}":{
        "firstName":"Simon",
        "lastName":"Hopper"
     }
  },
  "merchantAccount":"YOUR_MERCHANT_ACCOUNT",
  "reference":"YOUR_REFERENCE_FOR_THE_PAYOUT",
  "{hint:The name of the shopper receiving the funds.}shopperName{/hint}":{
     "firstName":"Simon",
     "lastName":"Hopper"
  },
  "dateOfBirth":"1990-01-01",
  "nationality":"US",
  "entityType":"Individual"
}'
```

#### Java

```java
// Adyen Java API Library v25.0.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.payout.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.payout.*;

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

// Create the request object(s)
Name fundSourceName = new Name()
  .firstName("Simon")
  .lastName("Hopper");

Address fundSourceAddress = new Address()
  .country("US")
  .stateOrProvince("CA")
  .city("Cupertino")
  .houseNumberOrName("1")
  .street("Infinite Loop")
  .postalCode("95014");

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

Name name = new Name()
  .firstName("Simon")
  .lastName("Hopper");

Address address = new Address()
  .country("US")
  .stateOrProvince("DC")
  .city("Washington")
  .houseNumberOrName("1")
  .street("Test Street")
  .postalCode("20500");

Card card = new Card()
  .number("4111111111111111")
  .holderName("John Smith")
  .expiryMonth("03")
  .expiryYear("2030");

FundSource fundSource = new FundSource()
  .shopperName(fundSourceName)
  .additionalData(new HashMap<String, String>(Map.of(
    "walletIdentifier", "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
    "networkTxReference", "412345678912345",
    "fundingSource", "DEPOSIT_ACCOUNT"
  )))
  .billingAddress(fundSourceAddress);

PayoutRequest payoutRequest = new PayoutRequest()
  .reference("YOUR_REFERENCE_FOR_THE_PAYOUT")
  .amount(amount)
  .shopperName(name)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .billingAddress(address)
  .card(card)
  .fundSource(fundSource);

// Make the API call
InstantPayoutsApi service = new InstantPayoutsApi(client);
PayoutResponse response = service.payout(payoutRequest, null);
```

#### PHP

```php
// Adyen PHP API Library v17.4.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Payout\Amount;
use Adyen\Model\Payout\Name;
use Adyen\Model\Payout\Address;
use Adyen\Model\Payout\Card;
use Adyen\Model\Payout\FundSource;
use Adyen\Model\Payout\PayoutRequest;
use Adyen\Service\Payout\InstantPayoutsApi;

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


// Create the request object(s)
$fundSourceName = new Name();
$fundSourceName
  ->setFirstName("Simon")
  ->setLastName("Hopper");

$fundSourceAddress = new Address();
$fundSourceAddress
  ->setCountry("US")
  ->setStateOrProvince("CA")
  ->setCity("Cupertino")
  ->setHouseNumberOrName("1")
  ->setStreet("Infinite Loop")
  ->setPostalCode("95014");

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

$name = new Name();
$name
  ->setFirstName("Simon")
  ->setLastName("Hopper");

$address = new Address();
$address
  ->setCountry("US")
  ->setStateOrProvince("DC")
  ->setCity("Washington")
  ->setHouseNumberOrName("1")
  ->setStreet("Test Street")
  ->setPostalCode("20500");

$card = new Card();
$card
  ->setNumber("4111111111111111")
  ->setHolderName("John Smith")
  ->setExpiryMonth("03")
  ->setExpiryYear("2030");

$fundSource = new FundSource();
$fundSource
  ->setShopperName($fundSourceName)
  ->setAdditionalData(
    array(
      "walletIdentifier" => "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
      "networkTxReference" => "412345678912345",
      "fundingSource" => "DEPOSIT_ACCOUNT"
    )
  )
  ->setBillingAddress($fundSourceAddress);

$payoutRequest = new PayoutRequest();
$payoutRequest
  ->setReference("YOUR_REFERENCE_FOR_THE_PAYOUT")
  ->setAmount($amount)
  ->setShopperName($name)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setBillingAddress($address)
  ->setCard($card)
  ->setFundSource($fundSource);

// Make the API call
$service = new InstantPayoutsApi($client);
$response = $service->payout($payoutRequest);
```

#### C\#

```cs
// Adyen .net API Library v14.4.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Payout;
using Adyen.Service.Payout;

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

// Create the request object(s)
Name fundSourceName = new Name
{
  FirstName = "Simon",
  LastName = "Hopper"
};

Address fundSourceAddress = new Address
{
  Country = "US",
  StateOrProvince = "CA",
  City = "Cupertino",
  HouseNumberOrName = "1",
  Street = "Infinite Loop",
  PostalCode = "95014"
};

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

Name name = new Name
{
  FirstName = "Simon",
  LastName = "Hopper"
};

Address address = new Address
{
  Country = "US",
  StateOrProvince = "DC",
  City = "Washington",
  HouseNumberOrName = "1",
  Street = "Test Street",
  PostalCode = "20500"
};

Card card = new Card
{
  Number = "4111111111111111",
  HolderName = "John Smith",
  ExpiryMonth = "03",
  ExpiryYear = "2030"
};

FundSource fundSource = new FundSource
{
  ShopperName = fundSourceName,
  AdditionalData = new Dictionary<string, string>
  {

    { "walletIdentifier", "UNIQUE_FUNDING_SOURCE_IDENTIFIER" },
    { "networkTxReference", "412345678912345" },
    { "fundingSource", "DEPOSIT_ACCOUNT" }
  },
  BillingAddress = fundSourceAddress
};

PayoutRequest payoutRequest = new PayoutRequest
{
  Reference = "YOUR_REFERENCE_FOR_THE_PAYOUT",
  Amount = amount,
  ShopperName = name,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  BillingAddress = address,
  Card = card,
  FundSource = fundSource
};

// Make the API call
var service = new InstantPayoutsService(client);
var response = service.Payout(payoutRequest);
```

#### NodeJS (JavaScript)

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

// Create the request object(s)
const payoutRequest = {
  amount: {
    value: 2500,
    currency: "USD"
  },
  card: {
    number: "4111111111111111",
    expiryMonth: "03",
    expiryYear: "2030",
    holderName: "John Smith"
  },
  billingAddress: {
    houseNumberOrName: "1",
    street: "Test Street",
    country: "US",
    postalCode: "20500",
    city: "Washington",
    stateOrProvince: "DC"
  },
  fundSource: {
    additionalData: {
      fundingSource: "DEPOSIT_ACCOUNT",
      walletIdentifier: "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
      networkTxReference: "412345678912345"
    },
    billingAddress: {
      houseNumberOrName: "1",
      street: "Infinite Loop",
      country: "US",
      postalCode: "95014",
      city: "Cupertino",
      stateOrProvince: "CA"
    },
    shopperName: {
      firstName: "Simon",
      lastName: "Hopper"
    }
  },
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  reference: "YOUR_REFERENCE_FOR_THE_PAYOUT",
  shopperName: {
    firstName: "Simon",
    lastName: "Hopper"
  },
  dateOfBirth: new Date("1990-01-01"),
  nationality: "US",
  entityType: "Individual"
}

// Make the API call
const payoutAPI = new PayoutAPI(client);
const response = payoutAPI.InstantPayoutsApi.payout(payoutRequest);
```

#### Go

```go
// Adyen Go API Library v9.3.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/payout"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
fundSourceName := payout.Name{
  FirstName: "Simon",
  LastName: "Hopper",
}

fundSourceAddress := payout.Address{
  Country: "US",
  StateOrProvince: common.PtrString("CA"),
  City: "Cupertino",
  HouseNumberOrName: "1",
  Street: "Infinite Loop",
  PostalCode: "95014",
}

amount := payout.Amount{
  Currency: "USD",
  Value: 2500,
}

name := payout.Name{
  FirstName: "Simon",
  LastName: "Hopper",
}

address := payout.Address{
  Country: "US",
  StateOrProvince: common.PtrString("DC"),
  City: "Washington",
  HouseNumberOrName: "1",
  Street: "Test Street",
  PostalCode: "20500",
}

card := payout.Card{
  Number: common.PtrString("4111111111111111"),
  HolderName: common.PtrString("John Smith"),
  ExpiryMonth: common.PtrString("03"),
  ExpiryYear: common.PtrString("2030"),
}

fundSource := payout.FundSource{
  ShopperName: &fundSourceName,
  AdditionalData: &map[string]string{
    "walletIdentifier": "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
    "networkTxReference": "412345678912345",
    "fundingSource": "DEPOSIT_ACCOUNT",
  },
  BillingAddress: &fundSourceAddress,
}

payoutRequest := payout.PayoutRequest{
  Reference: "YOUR_REFERENCE_FOR_THE_PAYOUT",
  Amount: amount,
  ShopperName: &name,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  BillingAddress: &address,
  Card: &card,
  FundSource: &fundSource,
}

// Make the API call
service := client.Payout()
req := service.InstantPayoutsApi.PayoutInput().PayoutRequest(payoutRequest)
res, httpRes, err := service.InstantPayoutsApi.Payout(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.2.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": 2500,
    "currency": "USD"
  },
  "card": {
    "number": "4111111111111111",
    "expiryMonth": "03",
    "expiryYear": "2030",
    "holderName": "John Smith"
  },
  "billingAddress": {
    "houseNumberOrName": "1",
    "street": "Test Street",
    "country": "US",
    "postalCode": "20500",
    "city": "Washington",
    "stateOrProvince": "DC"
  },
  "fundSource": {
    "additionalData": {
      "fundingSource": "DEPOSIT_ACCOUNT",
      "walletIdentifier": "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
      "networkTxReference": "412345678912345"
    },
    "billingAddress": {
      "houseNumberOrName": "1",
      "street": "Infinite Loop",
      "country": "US",
      "postalCode": "95014",
      "city": "Cupertino",
      "stateOrProvince": "CA"
    },
    "shopperName": {
      "firstName": "Simon",
      "lastName": "Hopper"
    }
  },
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "reference": "YOUR_REFERENCE_FOR_THE_PAYOUT",
  "shopperName": {
    "firstName": "Simon",
    "lastName": "Hopper"
  },
  "dateOfBirth": "1990-01-01",
  "nationality": "US",
  "entityType": "Individual"
}

# Make the API call
result = adyen.payout.instant_payouts_api.payout(request=json_request)
```

#### Ruby

```rb
# Adyen Ruby API Library v9.3.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 => 2500,
    :currency => 'USD'
  },
  :card => {
    :number => '4111111111111111',
    :expiryMonth => '03',
    :expiryYear => '2030',
    :holderName => 'John Smith'
  },
  :billingAddress => {
    :houseNumberOrName => '1',
    :street => 'Test Street',
    :country => 'US',
    :postalCode => '20500',
    :city => 'Washington',
    :stateOrProvince => 'DC'
  },
  :fundSource => {
    :additionalData => {
      :fundingSource => 'DEPOSIT_ACCOUNT',
      :walletIdentifier => 'UNIQUE_FUNDING_SOURCE_IDENTIFIER',
      :networkTxReference => '412345678912345'
    },
    :billingAddress => {
      :houseNumberOrName => '1',
      :street => 'Infinite Loop',
      :country => 'US',
      :postalCode => '95014',
      :city => 'Cupertino',
      :stateOrProvince => 'CA'
    },
    :shopperName => {
      :firstName => 'Simon',
      :lastName => 'Hopper'
    }
  },
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :reference => 'YOUR_REFERENCE_FOR_THE_PAYOUT',
  :shopperName => {
    :firstName => 'Simon',
    :lastName => 'Hopper'
  },
  :dateOfBirth => '1990-01-01',
  :nationality => 'US',
  :entityType => 'Individual'
}

# Make the API call
result = adyen.payout.instant_payouts_api.payout(request_body)
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
import { Client, PayoutAPI, 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 fundSourceName: Types.payout.Name = {
  firstName: "Simon",
  lastName: "Hopper"
};

const fundSourceAddress: Types.payout.Address = {
  country: "US",
  stateOrProvince: "CA",
  city: "Cupertino",
  houseNumberOrName: "1",
  street: "Infinite Loop",
  postalCode: "95014"
};

const amount: Types.payout.Amount = {
  currency: "USD",
  value: 2500
};

const name: Types.payout.Name = {
  firstName: "Simon",
  lastName: "Hopper"
};

const address: Types.payout.Address = {
  country: "US",
  stateOrProvince: "DC",
  city: "Washington",
  houseNumberOrName: "1",
  street: "Test Street",
  postalCode: "20500"
};

const card: Types.payout.Card = {
  number: "4111111111111111",
  holderName: "John Smith",
  expiryMonth: "03",
  expiryYear: "2030"
};

const fundSource: Types.payout.FundSource = {
  shopperName: fundSourceName,
  additionalData: {
    "walletIdentifier": "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
    "networkTxReference": "412345678912345",
    "fundingSource": "DEPOSIT_ACCOUNT"
  },
  billingAddress: fundSourceAddress
};

const payoutRequest: Types.payout.PayoutRequest = {
  reference: "YOUR_REFERENCE_FOR_THE_PAYOUT",
  amount: amount,
  shopperName: name,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  billingAddress: address,
  card: card,
  fundSource: fundSource
};

// Make the API call
const payoutAPI = new PayoutAPI(client);
const response = payoutAPI.InstantPayoutsApi.payout(payoutRequest);
```

### Response

**Example money transfer wallet or account response**

```json
{
   "pspReference":"GH4R4RBFJGXXGN82",
   "resultCode":"Authorised",
   "additionalData":{
      "authCode":"83152"
   }
} 
```

### Tab: Recurring money transfers

### Request

#### curl

```bash
curl https://pal-test.adyen.com/pal/servlet/Payout/v68/payout \
-H 'x-api-key: ADYEN_API_KEY' \
-H 'content-type: application/json' \
-d '{
  "amount":{
     "value":2500,
     "currency":"USD"
  },
  "selectedRecurringDetailReference": "LATEST",
  "recurring": {
    "contract": "PAYOUT"
  },
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID",
  "shopperName": {
    "lastName": "Smith",
    "firstName": "John"
  },
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "reference": "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  "shopperInteraction": "ContAuth",
  "fundSource": {
    "shopperName": {
        "lastName": "Hopper",
        "firstName": "Simon"
    },
    "billingAddress":{
        "houseNumberOrName":"1",
        "street":"Infinite Loop",
        "country":"US",
        "postalCode":"95014",
        "city":"Cupertino",
        "{hint:Value cannot be null. Specify NA if the field is not applicable.}stateOrProvince{/hint}":"CA"
    },
    "additionalData": {
        "fundingSource": "DEPOSIT_ACCOUNT",
        "walletIdentifier": "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
        "{hint:Only for Visa payouts. Specify the networkTxReference from the pay-in transaction.}networkTxReference{/hint}":"412345678912345"
    }
  }
}'
```

#### Java

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

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

// Create the request object(s)
Name fundSourceName = new Name()
  .lastName("Hopper")
  .firstName("Simon");

Address address = new Address()
  .country("US")
  .stateOrProvince("CA")
  .city("Cupertino")
  .houseNumberOrName("1")
  .street("Infinite Loop")
  .postalCode("95014");

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

Name name = new Name()
  .lastName("Smith")
  .firstName("John");

Recurring recurring = new Recurring()
  .contract(Recurring.ContractEnum.PAYOUT);

FundSource fundSource = new FundSource()
  .shopperName(fundSourceName)
  .billingAddress(address)
  .additionalData(new HashMap<String, String>(Map.of(
    "walletIdentifier", "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
    "networkTxReference", "412345678912345",
    "fundingSource", "DEPOSIT_ACCOUNT"
  )));

PayoutRequest payoutRequest = new PayoutRequest()
  .reference("YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT")
  .amount(amount)
  .shopperName(name)
  .merchantAccount("YOUR_MERCHANT_ACCOUNT")
  .recurring(recurring)
  .selectedRecurringDetailReference("LATEST")
  .shopperInteraction(PayoutRequest.ShopperInteractionEnum.CONTAUTH)
  .shopperReference("YOUR_UNIQUE_SHOPPER_ID")
  .fundSource(fundSource);

// Send the request
InstantPayoutsApi service = new InstantPayoutsApi(client);
PayoutResponse response = service.payout(payoutRequest, null);
```

#### PHP

```php
// Adyen PHP API Library v18.2.1
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\Payout\Amount;
use Adyen\Model\Payout\Name;
use Adyen\Model\Payout\Recurring;
use Adyen\Model\Payout\FundSource;
use Adyen\Model\Payout\Address;
use Adyen\Model\Payout\PayoutRequest;
use Adyen\Service\Payout\InstantPayoutsApi;

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


// Create the request object(s)
$fundSourceName = new Name();
$fundSourceName
  ->setLastName("Hopper")
  ->setFirstName("Simon");

$address = new Address();
$address
  ->setCountry("US")
  ->setStateOrProvince("CA")
  ->setCity("Cupertino")
  ->setHouseNumberOrName("1")
  ->setStreet("Infinite Loop")
  ->setPostalCode("95014");

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

$name = new Name();
$name
  ->setLastName("Smith")
  ->setFirstName("John");

$recurring = new Recurring();
$recurring
  ->setContract("PAYOUT");

$fundSource = new FundSource();
$fundSource
  ->setShopperName($fundSourceName)
  ->setBillingAddress($address)
  ->setAdditionalData(
    array(
      "walletIdentifier" => "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
      "networkTxReference" => "412345678912345",
      "fundingSource" => "DEPOSIT_ACCOUNT"
    )
  );

$payoutRequest = new PayoutRequest();
$payoutRequest
  ->setReference("YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT")
  ->setAmount($amount)
  ->setShopperName($name)
  ->setMerchantAccount("YOUR_MERCHANT_ACCOUNT")
  ->setRecurring($recurring)
  ->setSelectedRecurringDetailReference("LATEST")
  ->setShopperInteraction("ContAuth")
  ->setShopperReference("YOUR_UNIQUE_SHOPPER_ID")
  ->setFundSource($fundSource);

// Send the request
$service = new InstantPayoutsApi($client);
$response = $service->payout($payoutRequest);
```

#### C\#

```cs
// Adyen .net API Library v17.0.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.Payout;
using Adyen.Service.Payout;

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

// Create the request object(s)
Name fundSourceName = new Name
{
  LastName = "Hopper",
  FirstName = "Simon"
};

Address address = new Address
{
  Country = "US",
  StateOrProvince = "CA",
  City = "Cupertino",
  HouseNumberOrName = "1",
  Street = "Infinite Loop",
  PostalCode = "95014"
};

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

Name name = new Name
{
  LastName = "Smith",
  FirstName = "John"
};

Recurring recurring = new Recurring
{
  Contract = Recurring.ContractEnum.PAYOUT
};

FundSource fundSource = new FundSource
{
  ShopperName = fundSourceName,
  BillingAddress = address,
  AdditionalData = new Dictionary<string, string>
  {

    { "walletIdentifier", "UNIQUE_FUNDING_SOURCE_IDENTIFIER" },
    { "networkTxReference", "412345678912345" },
    { "fundingSource", "DEPOSIT_ACCOUNT" }
  }
};

PayoutRequest payoutRequest = new PayoutRequest
{
  Reference = "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  Amount = amount,
  ShopperName = name,
  MerchantAccount = "YOUR_MERCHANT_ACCOUNT",
  Recurring = recurring,
  SelectedRecurringDetailReference = "LATEST",
  ShopperInteraction = PayoutRequest.ShopperInteractionEnum.ContAuth,
  ShopperReference = "YOUR_UNIQUE_SHOPPER_ID",
  FundSource = fundSource
};

// Send the request
var service = new InstantPayoutsService(client);
var response = service.Payout(payoutRequest);
```

#### NodeJS (JavaScript)

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

// Create the request object(s)
const payoutRequest = {
  amount: {
    value: 2500,
    currency: "USD"
  },
  selectedRecurringDetailReference: "LATEST",
  recurring: {
    contract: "PAYOUT"
  },
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID",
  shopperName: {
    lastName: "Smith",
    firstName: "John"
  },
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  reference: "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  shopperInteraction: "ContAuth",
  fundSource: {
    shopperName: {
      lastName: "Hopper",
      firstName: "Simon"
    },
    billingAddress: {
      houseNumberOrName: "1",
      street: "Infinite Loop",
      country: "US",
      postalCode: "95014",
      city: "Cupertino",
      stateOrProvince: "CA"
    },
    additionalData: {
      fundingSource: "DEPOSIT_ACCOUNT",
      walletIdentifier: "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
      networkTxReference: "412345678912345"
    }
  }
}

// Send the request
const payoutAPI = new PayoutAPI(client);
const response = payoutAPI.InstantPayoutsApi.payout(payoutRequest);
```

#### Go

```go
// Adyen Go API Library v10.4.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/payout"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
fundSourceName := payout.Name{
  LastName: "Hopper",
  FirstName: "Simon",
}

address := payout.Address{
  Country: "US",
  StateOrProvince: common.PtrString("CA"),
  City: "Cupertino",
  HouseNumberOrName: "1",
  Street: "Infinite Loop",
  PostalCode: "95014",
}

amount := payout.Amount{
  Currency: "USD",
  Value: 2500,
}

name := payout.Name{
  LastName: "Smith",
  FirstName: "John",
}

recurring := payout.Recurring{
  Contract: common.PtrString("PAYOUT"),
}

fundSource := payout.FundSource{
  ShopperName: &fundSourceName,
  BillingAddress: &address,
  AdditionalData: &map[string]string{
    "walletIdentifier": "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
    "networkTxReference": "412345678912345",
    "fundingSource": "DEPOSIT_ACCOUNT",
  },
}

payoutRequest := payout.PayoutRequest{
  Reference: "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  Amount: amount,
  ShopperName: &name,
  MerchantAccount: "YOUR_MERCHANT_ACCOUNT",
  Recurring: &recurring,
  SelectedRecurringDetailReference: common.PtrString("LATEST"),
  ShopperInteraction: common.PtrString("ContAuth"),
  ShopperReference: common.PtrString("YOUR_UNIQUE_SHOPPER_ID"),
  FundSource: &fundSource,
}

// Send the request
service := client.Payout()
req := service.InstantPayoutsApi.PayoutInput().PayoutRequest(payoutRequest)
res, httpRes, err := service.InstantPayoutsApi.Payout(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.5.1
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": 2500,
    "currency": "USD"
  },
  "selectedRecurringDetailReference": "LATEST",
  "recurring": {
    "contract": "PAYOUT"
  },
  "shopperReference": "YOUR_UNIQUE_SHOPPER_ID",
  "shopperName": {
    "lastName": "Smith",
    "firstName": "John"
  },
  "merchantAccount": "YOUR_MERCHANT_ACCOUNT",
  "reference": "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  "shopperInteraction": "ContAuth",
  "fundSource": {
    "shopperName": {
      "lastName": "Hopper",
      "firstName": "Simon"
    },
    "billingAddress": {
      "houseNumberOrName": "1",
      "street": "Infinite Loop",
      "country": "US",
      "postalCode": "95014",
      "city": "Cupertino",
      "stateOrProvince": "CA"
    },
    "additionalData": {
      "fundingSource": "DEPOSIT_ACCOUNT",
      "walletIdentifier": "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
      "networkTxReference": "412345678912345"
    }
  }
}

# Send the request
result = adyen.payout.instant_payouts_api.payout(request=json_request)
```

#### Ruby

```rb
# Adyen Ruby API Library v9.5.1
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 => 2500,
    :currency => 'USD'
  },
  :selectedRecurringDetailReference => 'LATEST',
  :recurring => {
    :contract => 'PAYOUT'
  },
  :shopperReference => 'YOUR_UNIQUE_SHOPPER_ID',
  :shopperName => {
    :lastName => 'Smith',
    :firstName => 'John'
  },
  :merchantAccount => 'YOUR_MERCHANT_ACCOUNT',
  :reference => 'YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT',
  :shopperInteraction => 'ContAuth',
  :fundSource => {
    :shopperName => {
      :lastName => 'Hopper',
      :firstName => 'Simon'
    },
    :billingAddress => {
      :houseNumberOrName => '1',
      :street => 'Infinite Loop',
      :country => 'US',
      :postalCode => '95014',
      :city => 'Cupertino',
      :stateOrProvince => 'CA'
    },
    :additionalData => {
      :fundingSource => 'DEPOSIT_ACCOUNT',
      :walletIdentifier => 'UNIQUE_FUNDING_SOURCE_IDENTIFIER',
      :networkTxReference => '412345678912345'
    }
  }
}

# Send the request
result = adyen.payout.instant_payouts_api.payout(request_body)
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v17.3.0
// Require the parts of the module you want to use
import { Client, PayoutAPI, 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 fundSourceName: Types.payout.Name = {
  lastName: "Hopper",
  firstName: "Simon"
};

const address: Types.payout.Address = {
  country: "US",
  stateOrProvince: "CA",
  city: "Cupertino",
  houseNumberOrName: "1",
  street: "Infinite Loop",
  postalCode: "95014"
};

const amount: Types.payout.Amount = {
  currency: "USD",
  value: 2500
};

const name: Types.payout.Name = {
  lastName: "Smith",
  firstName: "John"
};

const recurring: Types.payout.Recurring = {
  contract: Types.payout.Recurring.ContractEnum.PAYOUT
};

const fundSource: Types.payout.FundSource = {
  shopperName: fundSourceName,
  billingAddress: address,
  additionalData: {
    "walletIdentifier": "UNIQUE_FUNDING_SOURCE_IDENTIFIER",
    "networkTxReference": "412345678912345",
    "fundingSource": "DEPOSIT_ACCOUNT"
  }
};

const payoutRequest: Types.payout.PayoutRequest = {
  reference: "YOUR_REFERENCE_FOR_THE_RECURRING_PAYOUT",
  amount: amount,
  shopperName: name,
  merchantAccount: "YOUR_MERCHANT_ACCOUNT",
  recurring: recurring,
  selectedRecurringDetailReference: "LATEST",
  shopperInteraction: Types.payout.PayoutRequest.ShopperInteractionEnum.ContAuth,
  shopperReference: "YOUR_UNIQUE_SHOPPER_ID",
  fundSource: fundSource
};

// Send the request
const payoutAPI = new PayoutAPI(client);
const response = payoutAPI.InstantPayoutsApi.payout(payoutRequest);
```

### Response

**Example recurring money transfer response**

```json
{
   "pspReference":"GH4R4RBFJGXXGN82",
   "resultCode":"Authorised"
} 
```

## Data validation

We perform additional validations when facilitating money transfers between different entities, and decline transactions where the data provided does not meet our requirements.

* Only ASCII characters are supported.

* The `shopperName`, and `billingAddress` fields values can not:

  * Consist only of spaces, symbols, numbers.
  * Include emojis.
  * Be **N/A**, or **null**.

* The `shopperName`, and `billingAddress` fields can only contain the following special characters: `,`, `.`, `;`, `:`, `-`, `—`, `/`, `\`, `+`, `&`, `!`, `?`, `@`, `(`, `)`, `"`, `'`.

* The `shopperName` can not be a common placeholder name, like **John Doe**.

* The combined number of characters for the `firstName` and `lastName` fields in the `shopperName` can not be less than 3.

* The `billingAddress.street` field can not consist of less than 3 characters.

* The different fields in the `billingAddress` can not have the same value.

* The `dateOfBirth` can not be earlier than **1900**.

## Supported countries/regions and currencies

You can only make domestic payouts. This means that you can only pay out to a card when it is used in the country/region of its issue, and in the currency of that country/region. For cards issued in the European Economic Area (EEA), payouts inside the EEA are considered domestic.\
In other cases, for cross-border payouts, contact your account manager or our [Support Team](https://ca-test.adyen.com/ca/ca/contactUs/support.shtml?form=other). In most cases, a local entity is required.

Below is the list of countries/regions where instant card payouts are allowed:

| Recipient country/region | Card payouts                                                                                |
| ------------------------ | ------------------------------------------------------------------------------------------- |
| **Australia**            | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Austria**              | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Belgium**              | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Bulgaria**             | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Canada**               | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Croatia**              | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Cyprus**               | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Czech Republic**       | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Denmark**              | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Estonia**              | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Finland**              | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **France**               | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Germany**              | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Greece**               | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Hungary**              | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Iceland**              | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Ireland**              | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Italy**                | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Latvia**               | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Liechtenstein**        | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Lithuania**            | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Luxembourg**           | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Netherlands**          | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Norway**               | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Poland**               | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Portugal**             | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Romania**              | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Slovakia**             | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Slovenia**             | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Spain**                | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Sweden**               | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **Switzerland**          | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **United Kingdom**       | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |
| **United States**        | ![-white\_check\_mark-](/user/data/smileys/emoji/white_check_mark.png "-white_check_mark-") |