> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://apidoc-v1.maniscloud.com/llms.txt.
> For full documentation content, see https://apidoc-v1.maniscloud.com/llms-full.txt.

# Create payout

POST https://api/v1/payouts
Content-Type: application/json

## Payouts API

This endpoint allows you to create a new payout by submitting the necessary details regarding the transaction.

### HTTP Method

`POST`

### Endpoint

`{{url}}/api/v1/payouts`

### Request Body

| Field | Type | **Required** | **Description** |
| --- | --- | --- | --- |
| requestId | string | Yes | A unique request ID is specified by the client in the request. |
| pspId | string | No, if not provided will use pspSelection logic to choose PSP based on routing rule | The ID of the Payment Service Provider |
| manisPaymentMethodName | string | Yes | a payment method name of Manis definition |
| amount | decimal | Yes | Sender amount |
| `fundingCurrency` | string | Yes | The currency in which the payout is funded (e.g., "SGD"). |
| `customerId` | string | Yes | The unique identifier for the customer making the payout |
| `beneficiaryId` | string | Yes | The unique identifier for the beneficiary receiving the payout |
| `paymentType` | string | Yes | The type of payment used for the payout  <br>Enum: WALLET  <br>CARD  <br>CASH  <br>GLOBAL_TRANSFER  <br>LOCAL_TRANSFER  <br>GLOBAL_TRANSFER_FAST  <br>LOCAL_TRANSFER_FAST  <br>SWIFT  <br>PROXY |
| `walletType` | string | Conditional(Nium only) | Specifies the type of wallet supported for the payment method. It depends on the country and currency, with different wallets available for each country.  <br>Possible Values:  <br>  <br>China: Alipay  <br>  <br>Indonesia: OVO, GOPAY, DANA, LINKAJA, SHOPEEPAY  <br>  <br>Philippines: GCASH, PAYMAYA, SHOPEEPAY, STARPAY, TAYOCASH, PALAWANPAY, LULU, USSC, GRABPAY, MAYA, BAYAD, COINSPH, JUANCASH, IREMIT |
| `purposeCode` | string | Conditional | The purpose for the payment, i.e. SELF |
| `description` | string | Yes(Nium Only) | Payment Narration. |
| `beneficiaryAmount` | string | No | The amount of money that the beneficiary will receive |
| `sourceOfFunds` | string | Conditional(Nium Only) | source of funds |
| `webhookUrl` | string | No | HTTPS endpoint to receive async payout status updates via POST |

#### **Response Body**

200 OK

| Field | Type | **Description** |
| --- | --- | --- |
| `manisTransactionId` | string | ID of payout request in manis |
| `pspPayoutId` | string | Payout request id in PSP |
| `beneficiaryId` | string | Beneficiary id |
| `paymentType` | string | The method used for the payout  <br>Enum: WALLET  <br>CARD  <br>CASH  <br>GLOBAL_TRANSFER  <br>LOCAL_TRANSFER  <br>GLOBAL_TRANSFER_FAST  <br>LOCAL_TRANSFER_FAST  <br>SWIFT  <br>PROXY |
| `walletType` | string | Specifies the type of wallet supported for the payment method. It depends on the country and currency, with different wallets available for each country |
| `transaction` | object |  |
| └─`id` | string | ID of transaction in Manis |
| └─`requestId` | string | The client specifies a unique request ID in the request. |
| └─`customerId` | string | ID of the customer |
| └─`merchantId` | string | ID of the merchant |
| └─`pspId` | string | ID of the PSP |
| └─`paymentType` | string | The type of payment used for the payout  <br>Enum: WALLET  <br>CARD  <br>CASH  <br>GLOBAL_TRANSFER  <br>LOCAL_TRANSFER  <br>GLOBAL_TRANSFER_FAST  <br>LOCAL_TRANSFER_FAST  <br>SWIFT  <br>PROXY |
| └─`status` | string | Status of payout  <br>PENDING  <br>COMPLETED  <br>FAILED  <br>EXPIRED  <br>REFUNDED  <br>CANCELLED |
| └─`currency` | string | Currency |
| └─`amount` | decimal | Amount of transaction |
| └─`description` | string | Description |
| └─`lastStatusUpdatedAt` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') | Last time update status |
| └─`createdBy` | string |  |
| └─`createdAt` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') |  |
| └─`updatedBy` | string |  |
| └─`updatedAt` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') |  |
| `createdBy` | string |  |
| `createdAt` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') |  |
| `updatedBy` | string |  |
| `updatedAt` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') |  |

400 BAD REQUEST

| **Field** | **Type** |
| --- | --- |
| `type` | string |
| `status` | number |
| `timestamp` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') |
| `title` | string |
| `soaCode` | string |
| `fieldErrors` | array |
| └─ `object` | string |
| └─ `field` | string |
| └─ `rejectedValue` | string |
| └─ `message` | string |

401 UNAUTHORIZED

Reference: https://apidoc-v1.maniscloud.com/manis-unified-api-v-1-0/payout/create-payout

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: collection
  version: 1.0.0
paths:
  /api/v1/payouts:
    post:
      operationId: create-payout
      summary: Create payout
      description: >-
        ## Payouts API


        This endpoint allows you to create a new payout by submitting the
        necessary details regarding the transaction.


        ### HTTP Method


        `POST`


        ### Endpoint


        `{{url}}/api/v1/payouts`


        ### Request Body


        | Field | Type | **Required** | **Description** |

        | --- | --- | --- | --- |

        | requestId | string | Yes | A unique request ID is specified by the
        client in the request. |

        | pspId | string | No, if not provided will use pspSelection logic to
        choose PSP based on routing rule | The ID of the Payment Service
        Provider |

        | manisPaymentMethodName | string | Yes | a payment method name of Manis
        definition |

        | amount | decimal | Yes | Sender amount |

        | `fundingCurrency` | string | Yes | The currency in which the payout is
        funded (e.g., "SGD"). |

        | `customerId` | string | Yes | The unique identifier for the customer
        making the payout |

        | `beneficiaryId` | string | Yes | The unique identifier for the
        beneficiary receiving the payout |

        | `paymentType` | string | Yes | The type of payment used for the
        payout  <br>Enum: WALLET  <br>CARD  <br>CASH  <br>GLOBAL_TRANSFER 
        <br>LOCAL_TRANSFER  <br>GLOBAL_TRANSFER_FAST  <br>LOCAL_TRANSFER_FAST 
        <br>SWIFT  <br>PROXY |

        | `walletType` | string | Conditional(Nium only) | Specifies the type of
        wallet supported for the payment method. It depends on the country and
        currency, with different wallets available for each country. 
        <br>Possible Values:  <br>  <br>China: Alipay  <br>  <br>Indonesia: OVO,
        GOPAY, DANA, LINKAJA, SHOPEEPAY  <br>  <br>Philippines: GCASH, PAYMAYA,
        SHOPEEPAY, STARPAY, TAYOCASH, PALAWANPAY, LULU, USSC, GRABPAY, MAYA,
        BAYAD, COINSPH, JUANCASH, IREMIT |

        | `purposeCode` | string | Conditional | The purpose for the payment,
        i.e. SELF |

        | `description` | string | Yes(Nium Only) | Payment Narration. |

        | `beneficiaryAmount` | string | No | The amount of money that the
        beneficiary will receive |

        | `sourceOfFunds` | string | Conditional(Nium Only) | source of funds |

        | `webhookUrl` | string | No | HTTPS endpoint to receive async payout
        status updates via POST |


        #### **Response Body**


        200 OK


        | Field | Type | **Description** |

        | --- | --- | --- |

        | `manisTransactionId` | string | ID of payout request in manis |

        | `pspPayoutId` | string | Payout request id in PSP |

        | `beneficiaryId` | string | Beneficiary id |

        | `paymentType` | string | The method used for the payout  <br>Enum:
        WALLET  <br>CARD  <br>CASH  <br>GLOBAL_TRANSFER  <br>LOCAL_TRANSFER 
        <br>GLOBAL_TRANSFER_FAST  <br>LOCAL_TRANSFER_FAST  <br>SWIFT  <br>PROXY
        |

        | `walletType` | string | Specifies the type of wallet supported for the
        payment method. It depends on the country and currency, with different
        wallets available for each country |

        | `transaction` | object |  |

        | └─`id` | string | ID of transaction in Manis |

        | └─`requestId` | string | The client specifies a unique request ID in
        the request. |

        | └─`customerId` | string | ID of the customer |

        | └─`merchantId` | string | ID of the merchant |

        | └─`pspId` | string | ID of the PSP |

        | └─`paymentType` | string | The type of payment used for the payout 
        <br>Enum: WALLET  <br>CARD  <br>CASH  <br>GLOBAL_TRANSFER 
        <br>LOCAL_TRANSFER  <br>GLOBAL_TRANSFER_FAST  <br>LOCAL_TRANSFER_FAST 
        <br>SWIFT  <br>PROXY |

        | └─`status` | string | Status of payout  <br>PENDING  <br>COMPLETED 
        <br>FAILED  <br>EXPIRED  <br>REFUNDED  <br>CANCELLED |

        | └─`currency` | string | Currency |

        | └─`amount` | decimal | Amount of transaction |

        | └─`description` | string | Description |

        | └─`lastStatusUpdatedAt` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') | Last
        time update status |

        | └─`createdBy` | string |  |

        | └─`createdAt` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') |  |

        | └─`updatedBy` | string |  |

        | └─`updatedAt` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') |  |

        | `createdBy` | string |  |

        | `createdAt` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') |  |

        | `updatedBy` | string |  |

        | `updatedAt` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') |  |


        400 BAD REQUEST


        | **Field** | **Type** |

        | --- | --- |

        | `type` | string |

        | `status` | number |

        | `timestamp` | date(yyyy-MM-dd'T'HH:mm:ss.SSS'Z') |

        | `title` | string |

        | `soaCode` | string |

        | `fieldErrors` | array |

        | └─ `object` | string |

        | └─ `field` | string |

        | └─ `rejectedValue` | string |

        | └─ `message` | string |


        401 UNAUTHORIZED
      tags:
        - subpackage_payout
      parameters:
        - name: X-Mock-Scenario
          in: header
          description: >-
            see supported scenarios
            https://dev.azure.com/eastgate-software/Manis-PaymentCenter/_wiki/wikis/Manis-PaymentCenter.wiki/8348/PSP-mock-module-guidance
          required: false
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Payout_Create payout_Response_200'
      requestBody:
        content:
          application/json:
            schema:
              type: string
servers:
  - url: https:/
components:
  schemas:
    ApiV1PayoutsPostResponsesContentApplicationJsonSchemaTransaction:
      type: object
      properties:
        pspId:
          type: string
        amount:
          type: integer
        currency:
          type: string
        createdAt:
          type: string
          format: date-time
        createdBy:
          type: string
        requestId:
          type: string
          format: uuid
        updatedAt:
          type: string
          format: date-time
        updatedBy:
          type: string
        customerId:
          type: string
        merchantId:
          type: string
        description:
          type: string
        paymentType:
          type: string
        manisTransactionId:
          type: string
        manisTransactionStatus:
          type: string
      required:
        - pspId
        - amount
        - currency
        - createdAt
        - createdBy
        - requestId
        - updatedAt
        - updatedBy
        - customerId
        - merchantId
        - description
        - paymentType
        - manisTransactionId
        - manisTransactionStatus
      title: ApiV1PayoutsPostResponsesContentApplicationJsonSchemaTransaction
    Payout_Create payout_Response_200:
      type: object
      properties:
        createdAt:
          type: string
          format: date-time
        createdBy:
          type: string
        updatedAt:
          type: string
          format: date-time
        updatedBy:
          type: string
        pspPayoutId:
          type: string
        transaction:
          $ref: >-
            #/components/schemas/ApiV1PayoutsPostResponsesContentApplicationJsonSchemaTransaction
        beneficiaryId:
          type: string
        pspPayoutMethod:
          type: string
        manisTransactionId:
          type: string
      required:
        - createdAt
        - createdBy
        - updatedAt
        - updatedBy
        - pspPayoutId
        - transaction
        - beneficiaryId
        - pspPayoutMethod
        - manisTransactionId
      title: Payout_Create payout_Response_200

```

## SDK Code Examples

```python 400: Bad request
import requests

url = "https://https/api/v1/payouts"

headers = {
    "X-Mock-Scenario": "finmo/retry-2fail-1success",
    "Content-Type": "application/json"
}

response = requests.post(url, headers=headers)

print(response.json())
```

```javascript 400: Bad request
const url = 'https://https/api/v1/payouts';
const options = {
  method: 'POST',
  headers: {
    'X-Mock-Scenario': 'finmo/retry-2fail-1success',
    'Content-Type': 'application/json'
  },
  body: undefined
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go 400: Bad request
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://https/api/v1/payouts"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("X-Mock-Scenario", "finmo/retry-2fail-1success")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby 400: Bad request
require 'uri'
require 'net/http'

url = URI("https://https/api/v1/payouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-Mock-Scenario"] = 'finmo/retry-2fail-1success'
request["Content-Type"] = 'application/json'

response = http.request(request)
puts response.read_body
```

```java 400: Bad request
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/api/v1/payouts")
  .header("X-Mock-Scenario", "finmo/retry-2fail-1success")
  .header("Content-Type", "application/json")
  .asString();
```

```php 400: Bad request
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/api/v1/payouts', [
  'headers' => [
    'Content-Type' => 'application/json',
    'X-Mock-Scenario' => 'finmo/retry-2fail-1success',
  ],
]);

echo $response->getBody();
```

```csharp 400: Bad request
using RestSharp;

var client = new RestClient("https://https/api/v1/payouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-Mock-Scenario", "finmo/retry-2fail-1success");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift 400: Bad request
import Foundation

let headers = [
  "X-Mock-Scenario": "finmo/retry-2fail-1success",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/api/v1/payouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

```python 200: create with SGD and PROXY payment method for Finmo
import requests

url = "https://https/api/v1/payouts"

headers = {
    "X-Mock-Scenario": "finmo/retry-2fail-1success",
    "Content-Type": "application/json"
}

response = requests.post(url, headers=headers)

print(response.json())
```

```javascript 200: create with SGD and PROXY payment method for Finmo
const url = 'https://https/api/v1/payouts';
const options = {
  method: 'POST',
  headers: {
    'X-Mock-Scenario': 'finmo/retry-2fail-1success',
    'Content-Type': 'application/json'
  },
  body: undefined
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go 200: create with SGD and PROXY payment method for Finmo
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://https/api/v1/payouts"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("X-Mock-Scenario", "finmo/retry-2fail-1success")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby 200: create with SGD and PROXY payment method for Finmo
require 'uri'
require 'net/http'

url = URI("https://https/api/v1/payouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-Mock-Scenario"] = 'finmo/retry-2fail-1success'
request["Content-Type"] = 'application/json'

response = http.request(request)
puts response.read_body
```

```java 200: create with SGD and PROXY payment method for Finmo
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/api/v1/payouts")
  .header("X-Mock-Scenario", "finmo/retry-2fail-1success")
  .header("Content-Type", "application/json")
  .asString();
```

```php 200: create with SGD and PROXY payment method for Finmo
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/api/v1/payouts', [
  'headers' => [
    'Content-Type' => 'application/json',
    'X-Mock-Scenario' => 'finmo/retry-2fail-1success',
  ],
]);

echo $response->getBody();
```

```csharp 200: create with SGD and PROXY payment method for Finmo
using RestSharp;

var client = new RestClient("https://https/api/v1/payouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-Mock-Scenario", "finmo/retry-2fail-1success");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift 200: create with SGD and PROXY payment method for Finmo
import Foundation

let headers = [
  "X-Mock-Scenario": "finmo/retry-2fail-1success",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/api/v1/payouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

```python 200: create with currency is SGD and SWIFT transfer for Nium
import requests

url = "https://https/api/v1/payouts"

headers = {
    "X-Mock-Scenario": "finmo/retry-2fail-1success",
    "Content-Type": "application/json"
}

response = requests.post(url, headers=headers)

print(response.json())
```

```javascript 200: create with currency is SGD and SWIFT transfer for Nium
const url = 'https://https/api/v1/payouts';
const options = {
  method: 'POST',
  headers: {
    'X-Mock-Scenario': 'finmo/retry-2fail-1success',
    'Content-Type': 'application/json'
  },
  body: undefined
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go 200: create with currency is SGD and SWIFT transfer for Nium
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://https/api/v1/payouts"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("X-Mock-Scenario", "finmo/retry-2fail-1success")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby 200: create with currency is SGD and SWIFT transfer for Nium
require 'uri'
require 'net/http'

url = URI("https://https/api/v1/payouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-Mock-Scenario"] = 'finmo/retry-2fail-1success'
request["Content-Type"] = 'application/json'

response = http.request(request)
puts response.read_body
```

```java 200: create with currency is SGD and SWIFT transfer for Nium
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/api/v1/payouts")
  .header("X-Mock-Scenario", "finmo/retry-2fail-1success")
  .header("Content-Type", "application/json")
  .asString();
```

```php 200: create with currency is SGD and SWIFT transfer for Nium
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/api/v1/payouts', [
  'headers' => [
    'Content-Type' => 'application/json',
    'X-Mock-Scenario' => 'finmo/retry-2fail-1success',
  ],
]);

echo $response->getBody();
```

```csharp 200: create with currency is SGD and SWIFT transfer for Nium
using RestSharp;

var client = new RestClient("https://https/api/v1/payouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-Mock-Scenario", "finmo/retry-2fail-1success");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift 200: create with currency is SGD and SWIFT transfer for Nium
import Foundation

let headers = [
  "X-Mock-Scenario": "finmo/retry-2fail-1success",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/api/v1/payouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

```python 200: Create with currency is SGD and Global transfer for Finmo
import requests

url = "https://https/api/v1/payouts"

headers = {
    "X-Mock-Scenario": "finmo/retry-2fail-1success",
    "Content-Type": "application/json"
}

response = requests.post(url, headers=headers)

print(response.json())
```

```javascript 200: Create with currency is SGD and Global transfer for Finmo
const url = 'https://https/api/v1/payouts';
const options = {
  method: 'POST',
  headers: {
    'X-Mock-Scenario': 'finmo/retry-2fail-1success',
    'Content-Type': 'application/json'
  },
  body: undefined
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go 200: Create with currency is SGD and Global transfer for Finmo
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://https/api/v1/payouts"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("X-Mock-Scenario", "finmo/retry-2fail-1success")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby 200: Create with currency is SGD and Global transfer for Finmo
require 'uri'
require 'net/http'

url = URI("https://https/api/v1/payouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-Mock-Scenario"] = 'finmo/retry-2fail-1success'
request["Content-Type"] = 'application/json'

response = http.request(request)
puts response.read_body
```

```java 200: Create with currency is SGD and Global transfer for Finmo
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/api/v1/payouts")
  .header("X-Mock-Scenario", "finmo/retry-2fail-1success")
  .header("Content-Type", "application/json")
  .asString();
```

```php 200: Create with currency is SGD and Global transfer for Finmo
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/api/v1/payouts', [
  'headers' => [
    'Content-Type' => 'application/json',
    'X-Mock-Scenario' => 'finmo/retry-2fail-1success',
  ],
]);

echo $response->getBody();
```

```csharp 200: Create with currency is SGD and Global transfer for Finmo
using RestSharp;

var client = new RestClient("https://https/api/v1/payouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-Mock-Scenario", "finmo/retry-2fail-1success");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift 200: Create with currency is SGD and Global transfer for Finmo
import Foundation

let headers = [
  "X-Mock-Scenario": "finmo/retry-2fail-1success",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://https/api/v1/payouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

```python Payout_Create payout_example
import requests

url = "https://https/api/v1/payouts"

payload = "{
    //Required params
    \"requestId\": \"{{$randomUUID}}\",
    \"paymentType\": \"LOCAL_TRANSFER_FAST\",
    \"manisPaymentMethodName\": \"Global Bank Tranfer\",
    \"amount\": \"1\",
    \"fundingCurrency\": \"SGD\",
    \"customerId\": \"cus-01k0s4dm5g62ts91et7gk59rbv\",
    \"beneficiaryId\": \"5d4ef78d-dcc7-489c-a91e-e6fbe20de254\",

    //Optional params
    \"pspId\": \"finmo\", //if not provided will trigger pspSelection logic
    \"beneficiaryAmount\": 2,
    \"sourceOfFunds\": \"\",
    \"description\": \"description\",
    \"purposeCode\": \"SELF\",
    \"walletType\": \"\",
    \"debitWalletId\": \"\",
    \"accountNumber\": \"\"
}
"
headers = {
    "X-Mock-Scenario": "finmo/retry-2fail-1success",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Payout_Create payout_example
const url = 'https://https/api/v1/payouts';
const options = {
  method: 'POST',
  headers: {
    'X-Mock-Scenario': 'finmo/retry-2fail-1success',
    'Content-Type': 'application/json'
  },
  body: '"{\r\n    //Required params\r\n    \"requestId\": \"{{$randomUUID}}\",\r\n    \"paymentType\": \"LOCAL_TRANSFER_FAST\",\r\n    \"manisPaymentMethodName\": \"Global Bank Tranfer\",\r\n    \"amount\": \"1\",\r\n    \"fundingCurrency\": \"SGD\",\r\n    \"customerId\": \"cus-01k0s4dm5g62ts91et7gk59rbv\",\r\n    \"beneficiaryId\": \"5d4ef78d-dcc7-489c-a91e-e6fbe20de254\",\r\n\r\n    //Optional params\r\n    \"pspId\": \"finmo\", //if not provided will trigger pspSelection logic\r\n    \"beneficiaryAmount\": 2,\r\n    \"sourceOfFunds\": \"\",\r\n    \"description\": \"description\",\r\n    \"purposeCode\": \"SELF\",\r\n    \"walletType\": \"\",\r\n    \"debitWalletId\": \"\",\r\n    \"accountNumber\": \"\"\r\n}\r\n"'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Payout_Create payout_example
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://https/api/v1/payouts"

	payload := strings.NewReader("\"{\\r\\n    //Required params\\r\\n    \\\"requestId\\\": \\\"{{$randomUUID}}\\\",\\r\\n    \\\"paymentType\\\": \\\"LOCAL_TRANSFER_FAST\\\",\\r\\n    \\\"manisPaymentMethodName\\\": \\\"Global Bank Tranfer\\\",\\r\\n    \\\"amount\\\": \\\"1\\\",\\r\\n    \\\"fundingCurrency\\\": \\\"SGD\\\",\\r\\n    \\\"customerId\\\": \\\"cus-01k0s4dm5g62ts91et7gk59rbv\\\",\\r\\n    \\\"beneficiaryId\\\": \\\"5d4ef78d-dcc7-489c-a91e-e6fbe20de254\\\",\\r\\n\\r\\n    //Optional params\\r\\n    \\\"pspId\\\": \\\"finmo\\\", //if not provided will trigger pspSelection logic\\r\\n    \\\"beneficiaryAmount\\\": 2,\\r\\n    \\\"sourceOfFunds\\\": \\\"\\\",\\r\\n    \\\"description\\\": \\\"description\\\",\\r\\n    \\\"purposeCode\\\": \\\"SELF\\\",\\r\\n    \\\"walletType\\\": \\\"\\\",\\r\\n    \\\"debitWalletId\\\": \\\"\\\",\\r\\n    \\\"accountNumber\\\": \\\"\\\"\\r\\n}\\r\\n\"")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-Mock-Scenario", "finmo/retry-2fail-1success")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Payout_Create payout_example
require 'uri'
require 'net/http'

url = URI("https://https/api/v1/payouts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-Mock-Scenario"] = 'finmo/retry-2fail-1success'
request["Content-Type"] = 'application/json'
request.body = "\"{\\r\\n    //Required params\\r\\n    \\\"requestId\\\": \\\"{{$randomUUID}}\\\",\\r\\n    \\\"paymentType\\\": \\\"LOCAL_TRANSFER_FAST\\\",\\r\\n    \\\"manisPaymentMethodName\\\": \\\"Global Bank Tranfer\\\",\\r\\n    \\\"amount\\\": \\\"1\\\",\\r\\n    \\\"fundingCurrency\\\": \\\"SGD\\\",\\r\\n    \\\"customerId\\\": \\\"cus-01k0s4dm5g62ts91et7gk59rbv\\\",\\r\\n    \\\"beneficiaryId\\\": \\\"5d4ef78d-dcc7-489c-a91e-e6fbe20de254\\\",\\r\\n\\r\\n    //Optional params\\r\\n    \\\"pspId\\\": \\\"finmo\\\", //if not provided will trigger pspSelection logic\\r\\n    \\\"beneficiaryAmount\\\": 2,\\r\\n    \\\"sourceOfFunds\\\": \\\"\\\",\\r\\n    \\\"description\\\": \\\"description\\\",\\r\\n    \\\"purposeCode\\\": \\\"SELF\\\",\\r\\n    \\\"walletType\\\": \\\"\\\",\\r\\n    \\\"debitWalletId\\\": \\\"\\\",\\r\\n    \\\"accountNumber\\\": \\\"\\\"\\r\\n}\\r\\n\""

response = http.request(request)
puts response.read_body
```

```java Payout_Create payout_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://https/api/v1/payouts")
  .header("X-Mock-Scenario", "finmo/retry-2fail-1success")
  .header("Content-Type", "application/json")
  .body("\"{\\r\\n    //Required params\\r\\n    \\\"requestId\\\": \\\"{{$randomUUID}}\\\",\\r\\n    \\\"paymentType\\\": \\\"LOCAL_TRANSFER_FAST\\\",\\r\\n    \\\"manisPaymentMethodName\\\": \\\"Global Bank Tranfer\\\",\\r\\n    \\\"amount\\\": \\\"1\\\",\\r\\n    \\\"fundingCurrency\\\": \\\"SGD\\\",\\r\\n    \\\"customerId\\\": \\\"cus-01k0s4dm5g62ts91et7gk59rbv\\\",\\r\\n    \\\"beneficiaryId\\\": \\\"5d4ef78d-dcc7-489c-a91e-e6fbe20de254\\\",\\r\\n\\r\\n    //Optional params\\r\\n    \\\"pspId\\\": \\\"finmo\\\", //if not provided will trigger pspSelection logic\\r\\n    \\\"beneficiaryAmount\\\": 2,\\r\\n    \\\"sourceOfFunds\\\": \\\"\\\",\\r\\n    \\\"description\\\": \\\"description\\\",\\r\\n    \\\"purposeCode\\\": \\\"SELF\\\",\\r\\n    \\\"walletType\\\": \\\"\\\",\\r\\n    \\\"debitWalletId\\\": \\\"\\\",\\r\\n    \\\"accountNumber\\\": \\\"\\\"\\r\\n}\\r\\n\"")
  .asString();
```

```php Payout_Create payout_example
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://https/api/v1/payouts', [
  'body' => '"{\\r\\n    //Required params\\r\\n    \\"requestId\\": \\"{{$randomUUID}}\\",\\r\\n    \\"paymentType\\": \\"LOCAL_TRANSFER_FAST\\",\\r\\n    \\"manisPaymentMethodName\\": \\"Global Bank Tranfer\\",\\r\\n    \\"amount\\": \\"1\\",\\r\\n    \\"fundingCurrency\\": \\"SGD\\",\\r\\n    \\"customerId\\": \\"cus-01k0s4dm5g62ts91et7gk59rbv\\",\\r\\n    \\"beneficiaryId\\": \\"5d4ef78d-dcc7-489c-a91e-e6fbe20de254\\",\\r\\n\\r\\n    //Optional params\\r\\n    \\"pspId\\": \\"finmo\\", //if not provided will trigger pspSelection logic\\r\\n    \\"beneficiaryAmount\\": 2,\\r\\n    \\"sourceOfFunds\\": \\"\\",\\r\\n    \\"description\\": \\"description\\",\\r\\n    \\"purposeCode\\": \\"SELF\\",\\r\\n    \\"walletType\\": \\"\\",\\r\\n    \\"debitWalletId\\": \\"\\",\\r\\n    \\"accountNumber\\": \\"\\"\\r\\n}\\r\\n"',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-Mock-Scenario' => 'finmo/retry-2fail-1success',
  ],
]);

echo $response->getBody();
```

```csharp Payout_Create payout_example
using RestSharp;

var client = new RestClient("https://https/api/v1/payouts");
var request = new RestRequest(Method.POST);
request.AddHeader("X-Mock-Scenario", "finmo/retry-2fail-1success");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "\"{\\r\\n    //Required params\\r\\n    \\\"requestId\\\": \\\"{{$randomUUID}}\\\",\\r\\n    \\\"paymentType\\\": \\\"LOCAL_TRANSFER_FAST\\\",\\r\\n    \\\"manisPaymentMethodName\\\": \\\"Global Bank Tranfer\\\",\\r\\n    \\\"amount\\\": \\\"1\\\",\\r\\n    \\\"fundingCurrency\\\": \\\"SGD\\\",\\r\\n    \\\"customerId\\\": \\\"cus-01k0s4dm5g62ts91et7gk59rbv\\\",\\r\\n    \\\"beneficiaryId\\\": \\\"5d4ef78d-dcc7-489c-a91e-e6fbe20de254\\\",\\r\\n\\r\\n    //Optional params\\r\\n    \\\"pspId\\\": \\\"finmo\\\", //if not provided will trigger pspSelection logic\\r\\n    \\\"beneficiaryAmount\\\": 2,\\r\\n    \\\"sourceOfFunds\\\": \\\"\\\",\\r\\n    \\\"description\\\": \\\"description\\\",\\r\\n    \\\"purposeCode\\\": \\\"SELF\\\",\\r\\n    \\\"walletType\\\": \\\"\\\",\\r\\n    \\\"debitWalletId\\\": \\\"\\\",\\r\\n    \\\"accountNumber\\\": \\\"\\\"\\r\\n}\\r\\n\"", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Payout_Create payout_example
import Foundation

let headers = [
  "X-Mock-Scenario": "finmo/retry-2fail-1success",
  "Content-Type": "application/json"
]
let parameters = "{
    //Required params
    \"requestId\": \"{{$randomUUID}}\",
    \"paymentType\": \"LOCAL_TRANSFER_FAST\",
    \"manisPaymentMethodName\": \"Global Bank Tranfer\",
    \"amount\": \"1\",
    \"fundingCurrency\": \"SGD\",
    \"customerId\": \"cus-01k0s4dm5g62ts91et7gk59rbv\",
    \"beneficiaryId\": \"5d4ef78d-dcc7-489c-a91e-e6fbe20de254\",

    //Optional params
    \"pspId\": \"finmo\", //if not provided will trigger pspSelection logic
    \"beneficiaryAmount\": 2,
    \"sourceOfFunds\": \"\",
    \"description\": \"description\",
    \"purposeCode\": \"SELF\",
    \"walletType\": \"\",
    \"debitWalletId\": \"\",
    \"accountNumber\": \"\"
}
" as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://https/api/v1/payouts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```